feat: autogenerate schema associations with factories

.tool-versions

@@ -0,0 +1,2 @@
+elixir 1.13
+erlang 24.2.2

README.md

@@ -117,3 +117,69 @@ $ mix factory_ex.gen --repo FactoryEx.Support.Repo FactoryEx.Support.{Accounts.{
 ```
 
 To read more info run `mix factory_ex.gen`
+
+### Build Relational Associations
+
+FactoryEx makes it possible to create associated records with your factories. This is
+similar to creating to creating records with Ecto.Changeset `cast_assoc` or `put_assoc`
+with the addition of using your factory to generate the parameters. To use this feature
+you must pass the `relational` option. The `relational` option accepts a list of keys
+that map to associations, for example if a Team has many users you would pass
+`[relational: [:users]]`:
+
+```elixir
+ FactoryEx.AssociationBuilder.build_params(
+ FactoryEx.Support.Factory.Accounts.Team,
+ %{},
+ relational: [:users]
+ )
+```
+
+The goal of this feature is to reduce boilerplate code in your test. In this example we
+create a team with 3 users that each have a label and a role:
+
+```elixir
+setup do
+ team = FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.Team)
+
+ user_one = FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.User, %{team_id: team.id})
+ FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.Label, %{user_id: user_one.id})
+ FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.Role, %{user_id: user_one.id})
+
+ user_two = FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.User, %{team_id: team.id})
+ FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.Label, %{user_id: user_two.id})
+ FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.Role, %{user_id: user_two.id})
+
+ user_three = FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.User, %{team_id: team.id})
+ FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.Label, %{user_id: user_three.id})
+ FactoryEx.insert!(FactoryEx.Support.Factory.Accounts.Role, %{user_id: user_three.id})
+end
+```
+
+With the relational feature this can be written as:
+
+```elixir
+setup do
+ team =
+ FactoryEx.insert!(
+ FactoryEx.Support.Factory.Accounts.Team,
+ %{users: {3, %{}}},
+ relational: [users: [:labels, :role]]
+ )
+end
+```
+
+You can create many associations by specifying a tuple of `{count, params}` which is expanded
+to a list of params before building the params with a factory. For example if you pass a
+tuple of `{2, %{name: "John"}}` it will be expanded to `[%{name: "John"}, %{name: "John"}]`.
+The count tuples can be added as elements inside a list or as values in the map of
+parameters. You can also manually add parameters which is useful for setting specific values
+while creating a specific amount. For example given three items if you wanted to customize
+the name for one you can do `[%{}, %{name: "custom"}, %{}]` or `[{2, %{}}, %{name: "custom"}]`.
+
+By default parameters are validated by Ecto.Changeset. If this behavior is not desired you can
+set the `validate` option to false which converts params to structs only.
+
+While this can simplify the amount of boilerplate you have to write it comes with a trade off
+of creating large complex objects that can hurt readability and/or make accessing specific
+data harder.

config/config.exs

@@ -1,9 +1,17 @@
 import Config
 
-config :factory_ex, FactoryExTest.MyRepo,
- username: System.get_env("POSTGRES_USER") || "postgres",
- password: System.get_env("POSTGRES_PASSWORD") || "postgres",
- database: "factory_ex_test",
- hostname: "localhost",
- pool: Ecto.Adapters.SQL.Sandbox,
- pool_size: String.to_integer(System.get_env("POSTGRES_POOL_SIZE", "10"))
+if Mix.env() == :test do
+ config :factory_ex, ecto_repos: [FactoryEx.Support.Repo]
+ config :factory_ex, repo: FactoryEx.Support.Repo
+ config :factory_ex, :sql_sandbox, true
+ config :factory_ex, FactoryEx.Support.Repo,
+ username: "postgres",
+ password: "postgres",
+ database: "factory_ex_test",
+ hostname: "localhost",
+ pool: Ecto.Adapters.SQL.Sandbox,
+ pool_size: 10,
+ show_sensitive_data_on_connection_error: true,
+ log: :debug,
+ stacktrace: true
+end

lib/factory_ex.ex

@@ -2,7 +2,12 @@ defmodule FactoryEx do
  @build_definition [
  keys: [
  type: {:in, [:atom, :string, :camel_string]},
- doc: "Sets the type of keys to have in the built object, can be one of `:atom`, `:string` or `:camel_string`"
+ doc:
+ "Sets the type of keys to have in the built object, can be one of `:atom`, `:string` or `:camel_string`"
+ ],
+ relational: [
+ type: {:or, [{:list, :any}, :keyword_list]},
+ doc: "Sets the ecto schema association fields to generate, can be a list of `:atom` or `:keyword_list`"
  ]
  ]
 
@@ -15,11 +20,11 @@ defmodule FactoryEx do
  #{NimbleOptions.docs(@build_definition)}
  """
 
- alias FactoryEx.Utils
+ alias FactoryEx.{AssociationBuilder, Utils}
 
  @type build_opts :: [
- keys: :atom | :string | :camel_string
- ]
+  keys: :atom | :string | :camel_string
+  ]
 
  @doc """
  Callback that returns the schema module.
@@ -72,7 +77,9 @@ defmodule FactoryEx do
  opts = NimbleOptions.validate!(opts, @build_definition)
 
  params
+ |> Utils.expand_count_tuples()
  |> module.build()
+ |> then(&AssociationBuilder.build_params(module, &1, opts))
  |> Utils.deep_struct_to_map()
  |> maybe_encode_keys(opts)
  end
@@ -94,18 +101,20 @@ defmodule FactoryEx do
  schema = module.schema()
  Code.ensure_loaded(schema)
 
- field = schema.__schema__(:fields)
+ field =
+ schema.__schema__(:fields)
  |> Kernel.--([:updated_at, :inserted_at, :id])
  |> Enum.reject(&(schema.__schema__(:type, &1) === :id))
- |> Enum.random
+ |> Enum.random()
 
  field_type = schema.__schema__(:type, field)
 
- field_value = case field_type do
- :integer -> "asdfd"
- :string -> 1239
- _ -> 4321
- end
+ field_value =
+ case field_type do
+ :integer -> "asdfd"
+ :string -> 1239
+ _ -> 4321
+ end
 
  Map.put(params, field, field_value)
  end
@@ -127,8 +136,10 @@ defmodule FactoryEx do
  validate = Keyword.get(options, :validate, true)
 
  params
+ |> Utils.expand_count_tuples()
  |> module.build()
- |> maybe_changeset(module, validate)
+ |> then(&AssociationBuilder.build_params(module, &1, options))
+ |> maybe_create_changeset(module, validate)
  |> case do
  %Ecto.Changeset{} = changeset -> Ecto.Changeset.apply_action!(changeset, :insert)
  struct when is_struct(struct) -> struct
@@ -149,11 +160,13 @@ defmodule FactoryEx do
 
  def insert!(module, params, options) do
  Code.ensure_loaded(module.schema())
- validate? = Keyword.get(options, :validate, true)
+ validate = Keyword.get(options, :validate, true)
 
  params
+ |> Utils.expand_count_tuples()
  |> module.build()
- |> maybe_changeset(module, validate?)
+ |> then(&AssociationBuilder.build_params(module, &1, options))
+ |> maybe_create_changeset(module, validate)
  |> module.repo().insert!(options)
  end
 
@@ -176,20 +189,61 @@ defmodule FactoryEx do
  module.repo().delete_all(module.schema(), options)
  end
 
- defp maybe_changeset(params, module, validate?) do
- if validate? && schema?(module) do
+ defp maybe_create_changeset(params, module, validate) do
+ if validate && schema?(module) do
  params = Utils.deep_struct_to_map(params)
 
  if create_changeset_defined?(module.schema()) do
- module.schema().create_changeset(params)
+ params
+ |> module.schema().create_changeset()
+ |> maybe_put_assocs(params)
  else
- module.schema().changeset(struct(module.schema(), %{}), params)
+ module.schema()
+ |> struct(%{})
+ |> module.schema().changeset(params)
+ |> maybe_put_assocs(params)
  end
  else
- struct!(module.schema, params)
+ deep_struct!(module.schema, params)
  end
  end
 
+ defp maybe_put_assocs(%{data: %module{}} = changeset, params) do
+ :associations
+ |> module.__schema__()
+ |> Enum.reduce(changeset, fn field, changeset ->
+ case Map.get(params, field) do
+ nil -> changeset
+ attrs -> Ecto.Changeset.put_assoc(changeset, field, attrs)
+ end
+ end)
+ end
+
+ defp deep_struct!(schema_module, params) when is_list(params) do
+ Enum.map(params, &deep_struct!(schema_module, &1))
+ end
+
+ defp deep_struct!(schema_module, params) do
+ Enum.reduce(params, struct!(schema_module, params), &convert_to_struct(&1, schema_module, &2))
+ end
+
+ defp convert_to_struct({field, attrs}, schema_module, acc) do
+ attrs =
+ case :associations
+ |> schema_module.__schema__()
+ |> Enum.find(&(&1 === field))
+ |> then(&schema_module.__schema__(:association, &1)) do
+ nil ->
+ attrs
+
+ ecto_assoc ->
+ deep_struct!(ecto_assoc.queryable, attrs)
+
+ end
+
+ Map.put(acc, field, attrs)
+ end
+
  defp create_changeset_defined?(module) do
  function_exported?(module, :create_changeset, 1)
  end