test: add unit tests for TypeMapper, ChangesetExtractor, and has_one through override

Cover all TypeMapper branches: association types, embed types,
parameterized type variants, enum value extraction paths, custom
type override, and edge cases. Add ChangesetExtractor unit tests
including error path. Add has_one through with type override test.
Brings coverage from 86.13% to 91.18%.

Author: fahchen

test/ecto_typed_schema/changeset_extractor_test.exs

@@ -0,0 +1,46 @@
+defmodule EctoTypedSchema.ChangesetExtractorTest do
+  use ExUnit.Case, async: true
+  alias EctoTypedSchema.ChangesetExtractor
+
+  describe "extract/1" do
+    test "extracts primitive field types" do
+      body = [do: {:%{}, [], [name: :string, age: :integer]}]
+      assert ChangesetExtractor.extract(body) == [name: :string, age: :integer]
+    end
+
+    test "extracts parameterized types" do
+      body = [do: {:%{}, [], [status: {:parameterized, {Ecto.Enum, %{values: [:a]}}}]}]
+
+      assert [{:status, {:parameterized, {Ecto.Enum, %{values: [:a]}}}}] =
+               ChangesetExtractor.extract(body)
+    end
+
+    test "extracts association types" do
+      assoc_args = [
+        field: :user,
+        owner: MyApp.Post,
+        related: MyApp.User,
+        cardinality: :one
+      ]
+
+      body = [do: {:%{}, [], [user: {:assoc, {:%{}, [], assoc_args}}]}]
+      [{:user, {:assoc, result}}] = ChangesetExtractor.extract(body)
+      assert is_map(result)
+      assert result.related == MyApp.User
+    end
+
+    test "extracts embed types" do
+      embed_args = [related: MyApp.Address, cardinality: :one]
+      body = [do: {:%{}, [], [address: {:embed, {:%{}, [], embed_args}}]}]
+      [{:address, {:embed, result}}] = ChangesetExtractor.extract(body)
+      assert is_map(result)
+      assert result.related == MyApp.Address
+    end
+
+    test "raises on unexpected body shape" do
+      assert_raise ArgumentError, ~r/unexpected __changeset__\/0 body shape/, fn ->
+        ChangesetExtractor.extract(do: :unexpected)
+      end
+    end
+  end
+end

test/ecto_typed_schema/type_mapper_test.exs

@@ -105,6 +105,276 @@ defmodule EctoTypedSchema.TypeMapperTest do
     end
   end
 
+  describe "to_elixir_type/2 - custom type override" do
+    test "returns custom type when :type option is provided" do
+      custom = quote(do: MyApp.Status.t())
+      assert TypeMapper.to_elixir_type(:string, type: custom) == custom
+    end
+  end
+
+  describe "to_elixir_type/1 - :any type" do
+    test "maps :any to term()" do
+      assert infer_type_string(:any) == "term()"
+    end
+  end
+
+  describe "to_elixir_type/1 - bare :array type" do
+    test "maps :array to list()" do
+      assert infer_type_string(:array) == "list()"
+    end
+  end
+
+  describe "to_elixir_type/1 - association types" do
+    test "belongs_to" do
+      assoc = %Ecto.Association.BelongsTo{
+        field: :user,
+        owner: MyApp.Post,
+        related: MyApp.User,
+        owner_key: :user_id,
+        related_key: :id,
+        queryable: MyApp.User,
+        cardinality: :one,
+        relationship: :parent,
+        on_replace: :raise,
+        defaults: [],
+        on_cast: nil,
+        where: [],
+        unique: true,
+        ordered: false
+      }
+
+      assert infer_type_string({:assoc, assoc}) ==
+               "Ecto.Schema.belongs_to(MyApp.User.t())"
+    end
+
+    test "has_one" do
+      assoc = %Ecto.Association.Has{
+        field: :profile,
+        owner: MyApp.User,
+        related: MyApp.Profile,
+        owner_key: :id,
+        related_key: :user_id,
+        queryable: MyApp.Profile,
+        cardinality: :one,
+        relationship: :child,
+        on_delete: :nothing,
+        on_replace: :raise,
+        defaults: [],
+        where: [],
+        unique: true,
+        ordered: false,
+        preload_order: []
+      }
+
+      assert infer_type_string({:assoc, assoc}) ==
+               "Ecto.Schema.has_one(MyApp.Profile.t())"
+    end
+
+    test "has_many" do
+      assoc = %Ecto.Association.Has{
+        field: :posts,
+        owner: MyApp.User,
+        related: MyApp.Post,
+        owner_key: :id,
+        related_key: :user_id,
+        queryable: MyApp.Post,
+        cardinality: :many,
+        relationship: :child,
+        on_delete: :nothing,
+        on_replace: :raise,
+        defaults: [],
+        where: [],
+        unique: true,
+        ordered: false,
+        preload_order: []
+      }
+
+      assert infer_type_string({:assoc, assoc}) ==
+               "Ecto.Schema.has_many(MyApp.Post.t())"
+    end
+
+    test "many_to_many" do
+      assoc = %Ecto.Association.ManyToMany{
+        field: :tags,
+        owner: MyApp.Post,
+        related: MyApp.Tag,
+        owner_key: :id,
+        queryable: MyApp.Tag,
+        cardinality: :many,
+        relationship: :child,
+        on_delete: :nothing,
+        on_replace: :raise,
+        defaults: [],
+        join_keys: [{:post_id, :id}, {:tag_id, :id}],
+        join_through: "posts_tags",
+        join_where: [],
+        join_defaults: [],
+        where: [],
+        unique: false,
+        ordered: false,
+        preload_order: []
+      }
+
+      assert infer_type_string({:assoc, assoc}) ==
+               "Ecto.Schema.many_to_many(MyApp.Tag.t())"
+    end
+  end
+
+  describe "to_elixir_type/1 - embed types" do
+    test "embeds_one" do
+      embed = %{related: MyApp.Address, cardinality: :one}
+
+      assert infer_type_string({:embed, embed}) ==
+               "Ecto.Schema.embeds_one(MyApp.Address.t())"
+    end
+
+    test "embeds_many" do
+      embed = %{related: MyApp.Address, cardinality: :many}
+
+      assert infer_type_string({:embed, embed}) ==
+               "Ecto.Schema.embeds_many(MyApp.Address.t())"
+    end
+  end
+
+  describe "to_elixir_type/1 - parameterized types" do
+    test "{:parameterized, {Ecto.Enum, params}} with enum_values typed opt" do
+      params = %{values: [:active, :inactive]}
+
+      result =
+        {:parameterized, {Ecto.Enum, params}}
+        |> TypeMapper.to_elixir_type(enum_values: [:on, :off])
+        |> Macro.to_string()
+
+      assert result == ":on | :off"
+    end
+
+    test "{:parameterized, Ecto.Enum, params} 3-tuple form" do
+      params = %{values: [:active, :inactive]}
+
+      result =
+        {:parameterized, Ecto.Enum, params}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == ":active | :inactive"
+    end
+
+    test "{:parameterized, Ecto.Enum} bare form falls back to atom()" do
+      result =
+        {:parameterized, Ecto.Enum}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == "atom()"
+    end
+
+    test "{:parameterized, {CustomModule, _}} non-Enum" do
+      result =
+        {:parameterized, {MyApp.Money, %{}}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == "MyApp.Money.t()"
+    end
+
+    test "{:parameterized, CustomModule} bare module" do
+      result =
+        {:parameterized, MyApp.Money}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == "MyApp.Money.t()"
+    end
+
+    test "{:parameterized, CustomModule, _} 3-tuple non-Enum" do
+      result =
+        {:parameterized, MyApp.Money, %{}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == "MyApp.Money.t()"
+    end
+  end
+
+  describe "to_elixir_type/1 - enum value extraction" do
+    test "extracts values from %{values: [...]}" do
+      params = %{values: [:draft, :published]}
+
+      result =
+        {:parameterized, {Ecto.Enum, params}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == ":draft | :published"
+    end
+
+    test "extracts keys from %{mappings: [...]}" do
+      params = %{mappings: [admin: "ADMIN", user: "USER"]}
+
+      result =
+        {:parameterized, {Ecto.Enum, params}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == ":admin | :user"
+    end
+
+    test "falls back to atom() when params have no values or mappings" do
+      params = %{something_else: true}
+
+      result =
+        {:parameterized, {Ecto.Enum, params}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == "atom()"
+    end
+
+    test "single enum value" do
+      params = %{values: [:only_one]}
+
+      result =
+        {:parameterized, {Ecto.Enum, params}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == ":only_one"
+    end
+
+    test "extracts values from AST map with :values key" do
+      params = {:%{}, [], [values: [:a, :b]]}
+
+      result =
+        {:parameterized, {Ecto.Enum, params}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == ":a | :b"
+    end
+
+    test "extracts keys from AST map with :mappings key" do
+      params = {:%{}, [], [mappings: [x: "X", y: "Y"]]}
+
+      result =
+        {:parameterized, {Ecto.Enum, params}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == ":x | :y"
+    end
+
+    test "AST map with neither values nor mappings falls back to atom()" do
+      params = {:%{}, [], [other: true]}
+
+      result =
+        {:parameterized, {Ecto.Enum, params}}
+        |> TypeMapper.to_elixir_type([])
+        |> Macro.to_string()
+
+      assert result == "atom()"
+    end
+  end
+
   defp infer_type_string(ecto_type) do
     ecto_type
     |> TypeMapper.to_elixir_type()

test/ecto_typed_schema/types/has_one_test.exs

@@ -280,6 +280,43 @@ defmodule EctoTypedSchema.Types.HasOneTest do
     end
   end
 
+  describe "through association with type override" do
+    test "uses custom type for has_one through", ctx do
+      expected_types =
+        with_tmpmodule Schema, ctx do
+          use Ecto.Schema
+
+          schema "users" do
+            has_one :account, Account, foreign_key: :user_id
+            has_one :account_profile, through: [:account, :profile]
+          end
+
+          @type t() :: %__MODULE__{
+                  __meta__: Ecto.Schema.Metadata.t(__MODULE__),
+                  id: integer(),
+                  account: Ecto.Schema.has_one(Account.t()) | nil,
+                  account_profile: Profile.t() | nil
+                }
+        after
+          fetch_types!(Schema)
+        end
+
+      generated_types =
+        with_tmpmodule Schema, ctx do
+          use EctoTypedSchema
+
+          typed_schema "users" do
+            has_one :account, Account, foreign_key: :user_id
+            has_one :account_profile, through: [:account, :profile], typed: [type: Profile.t()]
+          end
+        after
+          fetch_types!(Schema)
+        end
+
+      assert_type(expected_types, generated_types)
+    end
+  end
+
   describe "through association fallback warning" do
     test "emits warning when through chain cannot be resolved", ctx do
       warnings =