Handle has_one and has_many associations

Ecto.Repo.insert! only handles associations when changeset is passed as
argument. Prior to insertion, Ecto.Model is thus converted to
Ecto.Changeset.

Author: jesenko

lib/ex_machina/ecto.ex

@@ -103,17 +103,55 @@ defmodule ExMachina.Ecto do
     ExMachina.build(module, factory_name)
   end
 
+  defp get_assocs(%{__struct__: struct}) do
+    for a <- struct.__schema__(:associations) do
+      {a, struct.__schema__(:association, a)}
+    end
+  end
+
+  defp belongs_to_assocs(model) do
+    for {a, %Ecto.Association.BelongsTo{}} <- get_assocs(model), do: a
+  end
+
+  defp not_loaded_assocs(model) do
+    for {a, %Ecto.Association.Has{}} <- get_assocs(model),
+      !Ecto.Association.loaded?(Map.get(model, a)),
+      do: a
+  end
+
+  defp reset_associations(target, source) do
+    target
+      |> belongs_to_assocs
+      |> Enum.reduce(target, fn(a, target) -> Map.put(target, a, Map.get(source, a)) end)
+  end
+
+  defp convert_to_changes(record) do
+    record
+    |> Map.from_struct
+    |> Map.delete(:__meta__)
+    # drop fields for `belongs_to` assocs as they cannot be handled by changeset
+    |> Map.drop(belongs_to_assocs(record))
+    |> Map.drop(not_loaded_assocs(record))
+  end
+
   @doc """
   Saves a record and all associated records using `Repo.insert!`
   """
-  def save_record(module, repo, record) do
-    record
-    |> associate_records(module)
+  def save_record(module, repo, %{__struct__: model} = record) do
+    record = record |> associate_records(module)
+    changes = record |> convert_to_changes
+
+    struct(model)
+    |> Ecto.Changeset.change(changes)
     |> repo.insert!
+    |> reset_associations(record)
+  end
+  def save_record(_, _ , record) do
+    raise ArgumentError, "#{inspect record} is not Ecto model."
   end
 
-  defp associate_records(built_record = %{__struct__: struct}, module) do
-    association_names = struct.__schema__(:associations)
+  defp associate_records(built_record, module) do
+    association_names = belongs_to_assocs(built_record)
 
     Enum.reduce association_names, built_record, fn(association_name, record) ->
       case association = Map.get(record, association_name) do

priv/test_repo/migrations/20151016110321_create_packages_and_invoices.exs

@@ -0,0 +1,17 @@
+defmodule ExMachina.TestRepo.Migrations.CreatePackagesAndInvoices do
+  use Ecto.Migration
+
+  def change do
+    create table(:invoices) do
+      add :title, :string
+      add :package_id, :integer
+    end
+    create table(:package_statuses) do
+      add :status, :string
+      add :package_id, :integer
+    end
+    create table(:packages) do
+      add :description, :string
+    end
+  end
+end

test/ex_machina/ecto_has_many_test.exs

@@ -0,0 +1,105 @@
+defmodule ExMachina.EctoHasManyTest do
+  use ExUnit.Case, async: false
+  alias ExMachina.TestRepo
+
+  setup_all do
+    Ecto.Adapters.SQL.begin_test_transaction(TestRepo, [])
+    on_exit fn -> Ecto.Adapters.SQL.rollback_test_transaction(TestRepo, []) end
+    :ok
+  end
+
+  setup do
+    Ecto.Adapters.SQL.restart_test_transaction(TestRepo, [])
+    :ok
+  end
+
+  defmodule Package do
+    use Ecto.Model
+    schema "packages" do
+      field :description, :string
+      has_many :statuses, ExMachina.EctoHasManyTest.PackageStatus
+    end
+  end
+
+  defmodule PackageStatus do
+    use Ecto.Model
+    schema "package_statuses" do
+      field :status, :string
+      belongs_to :package, Package
+    end
+  end
+
+  defmodule Invoice do
+    use Ecto.Model
+    schema "invoices" do
+      field :title, :string
+      belongs_to :package, Package
+    end
+  end
+
+  defmodule Factory do
+    use ExMachina.Ecto, repo: TestRepo
+
+    factory(:invalid_package) do
+      %Package{
+        description: "Invalid package without any statuses"
+      }
+    end
+
+    factory(:package) do
+      %Package{
+        description: "Package that just got ordered",
+        statuses: [
+          %PackageStatus{status: "ordered"}
+        ]
+      }
+    end
+
+    factory(:shipped_package) do
+      %Package{
+        description: "Package that got shipped",
+        statuses: [
+          %PackageStatus{status: "ordered"},
+          %PackageStatus{status: "sent"},
+          %PackageStatus{status: "shipped"}
+        ]
+      }
+    end
+
+    factory(:invoice) do
+      %Invoice{
+        title: "Invoice for shipped package",
+        package: assoc(:package, factory: :shipped_package)
+      }
+    end
+  end
+
+  test "create/1 creates model with `has_many` associations" do
+    package = Factory.create(:package)
+
+    assert %{statuses: [%{status: "ordered"}]} = package
+  end
+
+  test "create/2 creates model with overriden `has_many` associations" do
+    statuses = [
+      %PackageStatus{status: "ordered"},
+      %PackageStatus{status: "delayed"}
+    ]
+    package = Factory.create :package,
+      description: "Delayed package",
+      statuses: statuses
+
+    assert %{statuses: [%{status: "ordered"}, %{status: "delayed"}]} = package
+  end
+
+  test "create/1 creates model without `has_many` association specified" do
+    package = Factory.create(:invalid_package)
+    assert package
+  end
+
+  test "create/1 creates model with `belongs_to` having `has_many` associations" do
+    invoice = Factory.create(:invoice)
+
+    assert %{title: "Invoice for shipped package", package_id: 1} = invoice
+  end
+end

test/ex_machina/ecto_test.exs

@@ -1,5 +1,5 @@
 defmodule ExMachina.EctoTest do
-  use ExUnit.Case, async: true
+  use ExUnit.Case, async: false
   alias ExMachina.TestRepo
 
   setup_all do
@@ -147,6 +147,12 @@ defmodule ExMachina.EctoTest do
     end
   end
 
+  test "save_record/1 raises unless Ecto.Model is passed" do
+    assert_raise ArgumentError, ~r"not Ecto model", fn ->
+      Factory.save_record(%{foo: "bar"})
+    end
+  end
+
   test "assoc/3 returns the passed in key if it exists" do
     existing_account = %{id: 1, plan_type: "free"}
     attrs = %{account: existing_account}