From ea407dc2228941e6502af5be1a63b59498827199 Mon Sep 17 00:00:00 2001 From: Izel Nakri Date: Thu, 15 Feb 2018 21:13:22 +0100 Subject: [PATCH 1/3] 0.7.8 release elixir formatter --- .formatter.exs | 4 + config/config.exs | 2 +- lib/mix/tasks/papertrail/install.ex | 10 +- lib/paper_trail.ex | 318 +++-- lib/paper_trail/version_queries.ex | 39 +- lib/version.ex | 34 +- mix.exs | 17 +- .../bang_functions_simple_mode_test.exs | 995 +++++++++------- .../bang_functions_strict_mode_test.exs | 1044 ++++++++++------- test/paper_trail/paper_trail_version_test.exs | 128 +- test/paper_trail/uuid_test.exs | 4 +- test/paper_trail/version_queries_test.exs | 95 +- test/paper_trail_strict_mode_test.exs | 517 ++++---- test/paper_trail_test.exs | 496 ++++---- test/support/repos.ex | 4 +- test/support/simple_models.exs | 40 +- test/support/strict_models.exs | 48 +- test/support/uuid_models.exs | 4 +- test/test_helper.exs | 10 +- 19 files changed, 2239 insertions(+), 1570 deletions(-) create mode 100644 .formatter.exs diff --git a/.formatter.exs b/.formatter.exs new file mode 100644 index 00000000..525446d4 --- /dev/null +++ b/.formatter.exs @@ -0,0 +1,4 @@ +# Used by "mix format" +[ + inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"] +] diff --git a/config/config.exs b/config/config.exs index 3024fce1..42848738 100644 --- a/config/config.exs +++ b/config/config.exs @@ -29,4 +29,4 @@ use Mix.Config # here (which is why it is important to import them last). # -import_config "#{Mix.env}.exs" +import_config "#{Mix.env()}.exs" diff --git a/lib/mix/tasks/papertrail/install.ex b/lib/mix/tasks/papertrail/install.ex index 8b7a2691..b05abef8 100644 --- a/lib/mix/tasks/papertrail/install.ex +++ b/lib/mix/tasks/papertrail/install.ex @@ -7,11 +7,11 @@ defmodule Mix.Tasks.Papertrail.Install do import Mix.Generator def run(_args) do - path = Path.relative_to("priv/repo/migrations", Mix.Project.app_path) + path = Path.relative_to("priv/repo/migrations", Mix.Project.app_path()) file = Path.join(path, "#{timestamp()}_#{underscore(AddVersions)}.exs") - create_directory path + create_directory(path) - create_file file, """ + create_file(file, """ defmodule Repo.Migrations.AddVersions do use Ecto.Migration @@ -35,7 +35,7 @@ defmodule Mix.Tasks.Papertrail.Install do # create index(:versions, [:item_type, :inserted_at]) end end - """ + """) end defp timestamp do @@ -43,6 +43,6 @@ defmodule Mix.Tasks.Papertrail.Install do "#{y}#{pad(m)}#{pad(d)}#{pad(hh)}#{pad(mm)}#{pad(ss)}" end - defp pad(i) when i < 10, do: << ?0, ?0 + i >> + defp pad(i) when i < 10, do: <> defp pad(i), do: to_string(i) end diff --git a/lib/paper_trail.ex b/lib/paper_trail.ex index 741ea1dd..513c8be4 100644 --- a/lib/paper_trail.ex +++ b/lib/paper_trail.ex @@ -18,44 +18,61 @@ defmodule PaperTrail do """ def insert(changeset, options \\ [origin: nil, meta: nil, originator: nil, prefix: nil]) do repo = RepoClient.repo() - transaction_order = case RepoClient.strict_mode() do - true -> - Multi.new - |> Multi.run(:initial_version, fn %{} -> - version_id = get_sequence_id("versions") + 1 - changeset_data = case Map.get(changeset, :data) do - nil -> changeset |> Map.merge(%{ - id: get_sequence_from_model(changeset) + 1, - first_version_id: version_id, - current_version_id: version_id - }) - _ -> changeset.data |> Map.merge(%{ - id: get_sequence_from_model(changeset) + 1, - first_version_id: version_id, - current_version_id: version_id - }) - end - initial_version = make_version_struct(%{event: "insert"}, changeset_data, options) - repo.insert(initial_version) - end) - |> Multi.run(:model, fn %{initial_version: initial_version} -> - updated_changeset = changeset |> change(%{ - first_version_id: initial_version.id, current_version_id: initial_version.id - }) - repo.insert(updated_changeset) - end) - |> Multi.run(:version, fn %{initial_version: initial_version, model: model} -> - target_version = make_version_struct(%{event: "insert"}, model, options) |> serialize() - Version.changeset(initial_version, target_version) |> repo.update - end) - _ -> - Multi.new - |> Multi.insert(:model, changeset) - |> Multi.run(:version, fn %{model: model} -> - version = make_version_struct(%{event: "insert"}, model, options) - repo.insert(version) - end) - end + + transaction_order = + case RepoClient.strict_mode() do + true -> + Multi.new() + |> Multi.run(:initial_version, fn %{} -> + version_id = get_sequence_id("versions") + 1 + + changeset_data = + case Map.get(changeset, :data) do + nil -> + changeset + |> Map.merge(%{ + id: get_sequence_from_model(changeset) + 1, + first_version_id: version_id, + current_version_id: version_id + }) + + _ -> + changeset.data + |> Map.merge(%{ + id: get_sequence_from_model(changeset) + 1, + first_version_id: version_id, + current_version_id: version_id + }) + end + + initial_version = make_version_struct(%{event: "insert"}, changeset_data, options) + repo.insert(initial_version) + end) + |> Multi.run(:model, fn %{initial_version: initial_version} -> + updated_changeset = + changeset + |> change(%{ + first_version_id: initial_version.id, + current_version_id: initial_version.id + }) + + repo.insert(updated_changeset) + end) + |> Multi.run(:version, fn %{initial_version: initial_version, model: model} -> + target_version = + make_version_struct(%{event: "insert"}, model, options) |> serialize() + + Version.changeset(initial_version, target_version) |> repo.update + end) + + _ -> + Multi.new() + |> Multi.insert(:model, changeset) + |> Multi.run(:version, fn %{model: model} -> + version = make_version_struct(%{event: "insert"}, model, options) + repo.insert(version) + end) + end transaction = repo.transaction(transaction_order) @@ -63,10 +80,15 @@ defmodule PaperTrail do true -> case transaction do {:error, :model, changeset, %{}} -> - filtered_changes = Map.drop(changeset.changes, [:current_version_id, :first_version_id]) + filtered_changes = + Map.drop(changeset.changes, [:current_version_id, :first_version_id]) + {:error, Map.merge(changeset, %{repo: repo, changes: filtered_changes})} - {:ok, map} -> {:ok, Map.drop(map, [:initial_version])} + + {:ok, map} -> + {:ok, Map.drop(map, [:initial_version])} end + _ -> case transaction do {:error, :model, changeset, %{}} -> {:error, Map.merge(changeset, %{repo: repo})} @@ -80,37 +102,54 @@ defmodule PaperTrail do """ def insert!(changeset, options \\ [origin: nil, meta: nil, originator: nil, prefix: nil]) do repo = RepoClient.repo() + repo.transaction(fn -> case RepoClient.strict_mode() do true -> version_id = get_sequence_id("versions") + 1 - changeset_data = case Map.get(changeset, :data) do - nil -> changeset |> Map.merge(%{ - id: get_sequence_from_model(changeset) + 1, - first_version_id: version_id, - current_version_id: version_id - }) - _ -> changeset.data |> Map.merge(%{ - id: get_sequence_from_model(changeset) + 1, - first_version_id: version_id, - current_version_id: version_id - }) - end - initial_version = make_version_struct(%{event: "insert"}, changeset_data, options) + + changeset_data = + case Map.get(changeset, :data) do + nil -> + changeset + |> Map.merge(%{ + id: get_sequence_from_model(changeset) + 1, + first_version_id: version_id, + current_version_id: version_id + }) + + _ -> + changeset.data + |> Map.merge(%{ + id: get_sequence_from_model(changeset) + 1, + first_version_id: version_id, + current_version_id: version_id + }) + end + + initial_version = + make_version_struct(%{event: "insert"}, changeset_data, options) |> repo.insert! - updated_changeset = changeset |> change(%{ - first_version_id: initial_version.id, current_version_id: initial_version.id - }) + + updated_changeset = + changeset + |> change(%{ + first_version_id: initial_version.id, + current_version_id: initial_version.id + }) + model = repo.insert!(updated_changeset) target_version = make_version_struct(%{event: "insert"}, model, options) |> serialize() Version.changeset(initial_version, target_version) |> repo.update! model + _ -> model = repo.insert!(changeset) make_version_struct(%{event: "insert"}, model, options) |> repo.insert! model end - end) |> elem(1) + end) + |> elem(1) end @doc """ @@ -119,35 +158,44 @@ defmodule PaperTrail do def update(changeset, options \\ [origin: nil, meta: nil, originator: nil, prefix: nil]) do repo = PaperTrail.RepoClient.repo() client = PaperTrail.RepoClient - transaction_order = case client.strict_mode() do - true -> - Multi.new - |> Multi.run(:initial_version, fn %{} -> - version_data = changeset.data |> Map.merge(%{ - current_version_id: get_sequence_id("versions") - }) - target_changeset = changeset |> Map.merge(%{data: version_data}) - target_version = make_version_struct(%{event: "update"}, target_changeset, options) - repo.insert(target_version) - end) - |> Multi.run(:model, fn %{initial_version: initial_version} -> - updated_changeset = changeset |> change(%{current_version_id: initial_version.id}) - repo.update(updated_changeset) - end) - |> Multi.run(:version, fn %{initial_version: initial_version} -> - new_item_changes = initial_version.item_changes |> Map.merge(%{ - current_version_id: initial_version.id - }) - initial_version |> change(%{item_changes: new_item_changes}) |> repo.update - end) - _ -> - Multi.new - |> Multi.update(:model, changeset) - |> Multi.run(:version, fn %{model: _model} -> - version = make_version_struct(%{event: "update"}, changeset, options) - repo.insert(version) - end) - end + + transaction_order = + case client.strict_mode() do + true -> + Multi.new() + |> Multi.run(:initial_version, fn %{} -> + version_data = + changeset.data + |> Map.merge(%{ + current_version_id: get_sequence_id("versions") + }) + + target_changeset = changeset |> Map.merge(%{data: version_data}) + target_version = make_version_struct(%{event: "update"}, target_changeset, options) + repo.insert(target_version) + end) + |> Multi.run(:model, fn %{initial_version: initial_version} -> + updated_changeset = changeset |> change(%{current_version_id: initial_version.id}) + repo.update(updated_changeset) + end) + |> Multi.run(:version, fn %{initial_version: initial_version} -> + new_item_changes = + initial_version.item_changes + |> Map.merge(%{ + current_version_id: initial_version.id + }) + + initial_version |> change(%{item_changes: new_item_changes}) |> repo.update + end) + + _ -> + Multi.new() + |> Multi.update(:model, changeset) + |> Multi.run(:version, fn %{model: _model} -> + version = make_version_struct(%{event: "update"}, changeset, options) + repo.insert(version) + end) + end transaction = repo.transaction(transaction_order) @@ -157,8 +205,11 @@ defmodule PaperTrail do {:error, :model, changeset, %{}} -> filtered_changes = Map.drop(changeset.changes, [:current_version_id]) {:error, Map.merge(changeset, %{repo: repo, changes: filtered_changes})} - {:ok, map} -> {:ok, Map.delete(map, :initial_version)} + + {:ok, map} -> + {:ok, Map.delete(map, :initial_version)} end + _ -> case transaction do {:error, :model, changeset, %{}} -> {:error, Map.merge(changeset, %{repo: repo})} @@ -173,29 +224,39 @@ defmodule PaperTrail do def update!(changeset, options \\ [origin: nil, meta: nil, originator: nil, prefix: nil]) do repo = PaperTrail.RepoClient.repo() client = PaperTrail.RepoClient + repo.transaction(fn -> case client.strict_mode() do true -> - version_data = changeset.data |> Map.merge(%{ - current_version_id: get_sequence_id("versions") - }) + version_data = + changeset.data + |> Map.merge(%{ + current_version_id: get_sequence_id("versions") + }) + target_changeset = changeset |> Map.merge(%{data: version_data}) target_version = make_version_struct(%{event: "update"}, target_changeset, options) initial_version = repo.insert!(target_version) updated_changeset = changeset |> change(%{current_version_id: initial_version.id}) model = repo.update!(updated_changeset) - new_item_changes = initial_version.item_changes |> Map.merge(%{ - current_version_id: initial_version.id - }) + + new_item_changes = + initial_version.item_changes + |> Map.merge(%{ + current_version_id: initial_version.id + }) + initial_version |> change(%{item_changes: new_item_changes}) |> repo.update! model + _ -> model = repo.update!(changeset) version_struct = make_version_struct(%{event: "update"}, changeset, options) repo.insert!(version_struct) model end - end) |> elem(1) + end) + |> elem(1) end @doc """ @@ -203,7 +264,9 @@ defmodule PaperTrail do """ def delete(struct, options \\ [origin: nil, meta: nil, originator: nil, prefix: nil]) do repo = PaperTrail.RepoClient.repo() - transaction = Multi.new + + transaction = + Multi.new() |> Multi.delete(:model, struct, options) |> Multi.run(:version, fn %{} -> version = make_version_struct(%{event: "delete"}, struct, options) @@ -222,75 +285,90 @@ defmodule PaperTrail do """ def delete!(struct, options \\ [origin: nil, meta: nil, originator: nil, prefix: nil]) do repo = PaperTrail.RepoClient.repo() + repo.transaction(fn -> model = repo.delete!(struct, options) version_struct = make_version_struct(%{event: "delete"}, struct, options) repo.insert!(version_struct, options) model - end) |> elem(1) + end) + |> elem(1) end defp make_version_struct(%{event: "insert"}, model, options) do originator = PaperTrail.RepoClient.originator() originator_ref = options[originator[:name]] || options[:originator] + %Version{ event: "insert", - item_type: model.__struct__ |> Module.split |> List.last, + item_type: model.__struct__ |> Module.split() |> List.last(), item_id: model.id, item_changes: serialize(model), - originator_id: case originator_ref do - nil -> nil - _ -> originator_ref |> Map.get(:id) - end, + originator_id: + case originator_ref do + nil -> nil + _ -> originator_ref |> Map.get(:id) + end, origin: options[:origin], meta: options[:meta] - } |> add_prefix(options[:prefix]) + } + |> add_prefix(options[:prefix]) end + defp make_version_struct(%{event: "update"}, changeset, options) do originator = PaperTrail.RepoClient.originator() originator_ref = options[originator[:name]] || options[:originator] + %Version{ event: "update", - item_type: changeset.data.__struct__ |> Module.split |> List.last, + item_type: changeset.data.__struct__ |> Module.split() |> List.last(), item_id: changeset.data.id, item_changes: changeset.changes, - originator_id: case originator_ref do - nil -> nil - _ -> originator_ref |> Map.get(:id) - end, + originator_id: + case originator_ref do + nil -> nil + _ -> originator_ref |> Map.get(:id) + end, origin: options[:origin], meta: options[:meta] - } |> add_prefix(options[:prefix]) + } + |> add_prefix(options[:prefix]) end + defp make_version_struct(%{event: "delete"}, model, options) do originator = PaperTrail.RepoClient.originator() originator_ref = options[originator[:name]] || options[:originator] + %Version{ event: "delete", - item_type: model.__struct__ |> Module.split |> List.last, + item_type: model.__struct__ |> Module.split() |> List.last(), item_id: model.id, item_changes: serialize(model), - originator_id: case originator_ref do - nil -> nil - _ -> originator_ref |> Map.get(:id) - end, + originator_id: + case originator_ref do + nil -> nil + _ -> originator_ref |> Map.get(:id) + end, origin: options[:origin], meta: options[:meta] - } |> add_prefix(options[:prefix]) + } + |> add_prefix(options[:prefix]) end defp get_sequence_from_model(changeset) do - table_name = case Map.get(changeset, :data) do - nil -> changeset.__struct__.__schema__(:source) - _ -> changeset.data.__struct__.__schema__(:source) - end + table_name = + case Map.get(changeset, :data) do + nil -> changeset.__struct__.__schema__(:source) + _ -> changeset.data.__struct__.__schema__(:source) + end + get_sequence_id(table_name) end defp get_sequence_id(table_name) do Ecto.Adapters.SQL.query!(RepoClient.repo(), "select last_value FROM #{table_name}_id_seq").rows - |> List.first - |> List.first + |> List.first() + |> List.first() end defp serialize(model) do diff --git a/lib/paper_trail/version_queries.ex b/lib/paper_trail/version_queries.ex index d55054f0..22a4cd74 100644 --- a/lib/paper_trail/version_queries.ex +++ b/lib/paper_trail/version_queries.ex @@ -2,18 +2,21 @@ defmodule PaperTrail.VersionQueries do import Ecto.Query alias PaperTrail.Version - @repo PaperTrail.RepoClient.repo + @repo PaperTrail.RepoClient.repo() @doc """ Gets all the versions of a record. """ - @spec get_versions(record :: Ecto.Schema.t) :: Ecto.Query.t + @spec get_versions(record :: Ecto.Schema.t()) :: Ecto.Query.t() def get_versions(record), do: get_versions(record, []) + @doc """ Gets all the versions of a record given a module and its id """ - @spec get_versions(model :: module, id :: pos_integer) :: Ecto.Query.t - def get_versions(model, id) when is_atom(model) and is_integer(id), do: get_versions(model, id, []) + @spec get_versions(model :: module, id :: pos_integer) :: Ecto.Query.t() + def get_versions(model, id) when is_atom(model) and is_integer(id), + do: get_versions(model, id, []) + @doc """ Gets all the versions of a record. @@ -24,9 +27,9 @@ defmodule PaperTrail.VersionQueries do iex(1)> PaperTrail.VersionQueries.get_versions(record, [prefix: "tenant_id"]) """ - @spec get_versions(record :: Ecto.Schema.t, options :: []) :: Ecto.Query.t + @spec get_versions(record :: Ecto.Schema.t(), options :: []) :: Ecto.Query.t() def get_versions(record, options) when is_map(record) do - item_type = record.__struct__ |> Module.split |> List.last + item_type = record.__struct__ |> Module.split() |> List.last() version_query(item_type, record.id, options) |> @repo.all end @@ -40,23 +43,24 @@ defmodule PaperTrail.VersionQueries do iex(1)> PaperTrail.VersionQueries.get_versions(ModelName, id, [prefix: "tenant_id"]) """ - @spec get_versions(model :: module, id :: pos_integer, options :: []) :: Ecto.Query.t + @spec get_versions(model :: module, id :: pos_integer, options :: []) :: Ecto.Query.t() def get_versions(model, id, options) do - item_type = model |> Module.split |> List.last + item_type = model |> Module.split() |> List.last() version_query(item_type, id, options) |> @repo.all end @doc """ Gets the last version of a record. """ - @spec get_version(record :: Ecto.Schema.t) :: Ecto.Query.t + @spec get_version(record :: Ecto.Schema.t()) :: Ecto.Query.t() def get_version(record), do: get_version(record, []) @doc """ Gets the last version of a record given its module reference and its id. """ - @spec get_version(model :: module, id :: pos_integer) :: Ecto.Query.t - def get_version(model, id) when is_atom(model) and is_integer(id), do: get_version(model, id, []) + @spec get_version(model :: module, id :: pos_integer) :: Ecto.Query.t() + def get_version(model, id) when is_atom(model) and is_integer(id), + do: get_version(model, id, []) @doc """ Gets the last version of a record. @@ -68,9 +72,9 @@ defmodule PaperTrail.VersionQueries do iex(1)> PaperTrail.VersionQueries.get_version(record, [prefix: "tenant_id"]) """ - @spec get_version(record :: Ecto.Schema.t, options :: []) :: Ecto.Query.t + @spec get_version(record :: Ecto.Schema.t(), options :: []) :: Ecto.Query.t() def get_version(record, options) when is_map(record) do - item_type = record.__struct__ |> Module.split |> List.last + item_type = record.__struct__ |> Module.split() |> List.last() last(version_query(item_type, record.id, options)) |> @repo.one end @@ -84,9 +88,9 @@ defmodule PaperTrail.VersionQueries do iex(1)> PaperTrail.VersionQueries.get_version(ModelName, id, [prefix: "tenant_id"]) """ - @spec get_version(model :: module, id :: pos_integer, options :: []) :: Ecto.Query.t + @spec get_version(model :: module, id :: pos_integer, options :: []) :: Ecto.Query.t() def get_version(model, id, options) do - item_type = model |> Module.split |> List.last + item_type = model |> Module.split() |> List.last() last(version_query(item_type, id, options)) |> @repo.one end @@ -94,12 +98,13 @@ defmodule PaperTrail.VersionQueries do Gets the current model record/struct of a version """ def get_current_model(version) do - @repo.get("Elixir." <> version.item_type |> String.to_existing_atom, version.item_id) + @repo.get(("Elixir." <> version.item_type) |> String.to_existing_atom(), version.item_id) end defp version_query(item_type, id) do - from v in Version, where: v.item_type == ^item_type and v.item_id == ^id + from(v in Version, where: v.item_type == ^item_type and v.item_id == ^id) end + defp version_query(item_type, id, options) do with opts <- Enum.into(options, %{}) do version_query(item_type, id) diff --git a/lib/version.ex b/lib/version.ex index 0fb06af3..56c99f4b 100644 --- a/lib/version.ex +++ b/lib/version.ex @@ -9,21 +9,22 @@ defmodule PaperTrail.Version do # @originator_type Application.get_env(:paper_trail, :originator_type, :integer) schema "versions" do - - field :event, :string - field :item_type, :string - field :item_id, Application.get_env(:paper_trail, :item_type, :integer) - field :item_changes, :map - field :originator_id, Application.get_env(:paper_trail, :originator_type, :integer) - field :origin, :string, read_after_writes: true - field :meta, :map + field(:event, :string) + field(:item_type, :string) + field(:item_id, Application.get_env(:paper_trail, :item_type, :integer)) + field(:item_changes, :map) + field(:originator_id, Application.get_env(:paper_trail, :originator_type, :integer)) + field(:origin, :string, read_after_writes: true) + field(:meta, :map) if PaperTrail.RepoClient.originator() do - belongs_to PaperTrail.RepoClient.originator()[:name], + belongs_to( + PaperTrail.RepoClient.originator()[:name], PaperTrail.RepoClient.originator()[:model], define_field: false, foreign_key: :originator_id, type: Application.get_env(:paper_trail, :originator_type, :integer) + ) end timestamps(updated_at: false) @@ -39,13 +40,14 @@ defmodule PaperTrail.Version do Returns the count of all version records in the database """ def count do - from(version in __MODULE__, select: count(version.id)) |> PaperTrail.RepoClient.repo.one() + from(version in __MODULE__, select: count(version.id)) |> PaperTrail.RepoClient.repo().one() end + def count(options) do from(version in __MODULE__, select: count(version.id)) |> Ecto.Queryable.to_query() |> Map.put(:prefix, options[:prefix]) - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end @doc """ @@ -53,13 +55,14 @@ defmodule PaperTrail.Version do """ def first do from(record in __MODULE__, limit: 1, order_by: [asc: :inserted_at]) - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end + def first(options) do from(record in __MODULE__, limit: 1, order_by: [asc: :inserted_at]) |> Ecto.Queryable.to_query() |> Map.put(:prefix, options[:prefix]) - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end @doc """ @@ -67,12 +70,13 @@ defmodule PaperTrail.Version do """ def last do from(record in __MODULE__, limit: 1, order_by: [desc: :inserted_at]) - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end + def last(options) do from(record in __MODULE__, limit: 1, order_by: [desc: :inserted_at]) |> Ecto.Queryable.to_query() |> Map.put(:prefix, options[:prefix]) - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end end diff --git a/mix.exs b/mix.exs index 65d98fc5..e2874964 100644 --- a/mix.exs +++ b/mix.exs @@ -4,12 +4,12 @@ defmodule PaperTrail.Mixfile do def project do [ app: :paper_trail, - version: "0.7.7", - elixir: "~> 1.4", + version: "0.7.8", + elixir: "~> 1.6", description: description(), - build_embedded: Mix.env == :prod, - start_permanent: Mix.env == :prod, - elixirc_paths: elixirc_paths(Mix.env), + build_embedded: Mix.env() == :prod, + start_permanent: Mix.env() == :prod, + elixirc_paths: elixirc_paths(Mix.env()), package: package(), deps: deps() ] @@ -34,9 +34,9 @@ defmodule PaperTrail.Mixfile do end defp description do - """ - Track and record all the changes in your database. Revert back to anytime in history. - """ + """ + Track and record all the changes in your database. Revert back to anytime in history. + """ end defp package do @@ -51,6 +51,7 @@ defmodule PaperTrail.Mixfile do } ] end + defp elixirc_paths(:test), do: ["lib", "test/support"] defp elixirc_paths(_), do: ["lib"] end diff --git a/test/paper_trail/bang_functions_simple_mode_test.exs b/test/paper_trail/bang_functions_simple_mode_test.exs index 39a1ee79..7416f960 100644 --- a/test/paper_trail/bang_functions_simple_mode_test.exs +++ b/test/paper_trail/bang_functions_simple_mode_test.exs @@ -8,9 +8,13 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do alias SimplePerson, as: Person alias PaperTrailTest.MultiTenantHelper, as: MultiTenant - @repo PaperTrail.RepoClient.repo + @repo PaperTrail.RepoClient.repo() @create_company_params %{name: "Acme LLC", is_active: true, city: "Greenwich"} - @update_company_params %{city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc"} + @update_company_params %{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + } doctest PaperTrail @@ -25,9 +29,11 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do setup do reset_all_data() - on_exit fn -> + + on_exit(fn -> reset_all_data() - end + end) + :ok end @@ -42,25 +48,28 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert company_count == 1 assert version_count == 1 + assert company |> serialize |> Map.drop([:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Greenwich", - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Greenwich", + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: company |> serialize |> convert_to_string_map, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "insert", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: company |> serialize |> convert_to_string_map, + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one end @@ -73,9 +82,13 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do test "updating a company with originator creates a correct company version" do user = create_user() inserted_company = create_company_with_version() - updated_company = update_company_with_version( - inserted_company, @update_company_params, user: user - ) + + updated_company = + update_company_with_version( + inserted_company, + @update_company_params, + user: user + ) company_count = Company.count() version_count = Version.count() @@ -85,74 +98,94 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: convert_to_string_map(%{ - city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: + convert_to_string_map(%{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end test "updating a company with originator[user] creates a correct company version" do user = create_user() inserted_company = create_company_with_version() - updated_company = update_company_with_version( - inserted_company, @update_company_params, user: user - ) + + updated_company = + update_company_with_version( + inserted_company, + @update_company_params, + user: user + ) company_count = Company.count() version_count = Version.count() company = updated_company |> serialize - version = PaperTrail.get_version(updated_company) |> serialize + version = PaperTrail.get_version(updated_company) |> serialize assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: convert_to_string_map(%{ - city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: + convert_to_string_map(%{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end test "PaperTrail.update!/2 with an error raises Ecto.InvalidChangesetError" do assert_raise(Ecto.InvalidChangesetError, fn -> inserted_company = create_company_with_version() + update_company_with_version(inserted_company, %{ - name: nil, city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" + name: nil, + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" }) end) end @@ -172,66 +205,79 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert company_count == 0 assert version_count == 3 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: convert_to_string_map(%{ - id: company.id, - inserted_at: company.inserted_at, - updated_at: company.updated_at, - name: "Acme LLC", - is_active: true, - website: "http://www.acme.com", - city: "Hong Kong", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "delete", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: + convert_to_string_map(%{ + id: company.id, + inserted_at: company.inserted_at, + updated_at: company.updated_at, + name: "Acme LLC", + is_active: true, + website: "http://www.acme.com", + city: "Hong Kong", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == company_before_deletion end test "PaperTrail.delete!/2 with an error raises Ecto.InvalidChangesetError" do assert_raise(Ecto.InvalidChangesetError, fn -> inserted_company = create_company_with_version() + Person.changeset(%Person{}, %{ first_name: "Izel", last_name: "Nakri", gender: true, company_id: inserted_company.id - }) |> PaperTrail.insert! - inserted_company |> Company.changeset |> PaperTrail.delete! + }) + |> PaperTrail.insert!() + + inserted_company |> Company.changeset() |> PaperTrail.delete!() end) end test "creating a person with meta tag creates a person version with correct attributes" do create_company_with_version() - second_company = Company.changeset(%Company{}, %{ - name: "Another Company Corp.", - is_active: true, - address: "Sesame street 100/3, 101010" - }) |> PaperTrail.insert! - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: second_company.id - }) |> PaperTrail.insert!(origin: "admin", meta: %{linkname: "izelnakri"}) + + second_company = + Company.changeset(%Company{}, %{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + |> PaperTrail.insert!() + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: second_company.id + }) + |> PaperTrail.insert!(origin: "admin", meta: %{linkname: "izelnakri"}) person_count = Person.count() company_count = Company.count() @@ -243,45 +289,60 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert person_count == 1 assert company_count == 2 assert version_count == 3 - assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - visit_count: nil, - birthdate: nil, - company_id: second_company.id - } + + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + visit_count: nil, + birthdate: nil, + company_id: second_company.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "SimplePerson", - item_id: person.id, - item_changes: convert_to_string_map(person), - originator_id: nil, - origin: "admin", - meta: %{"linkname" => "izelnakri"} - } + event: "insert", + item_type: "SimplePerson", + item_id: person.id, + item_changes: convert_to_string_map(person), + originator_id: nil, + origin: "admin", + meta: %{"linkname" => "izelnakri"} + } + assert person == first(Person, :id) |> @repo.one |> serialize end test "updating a person creates a person version with correct attributes" do - inserted_initial_company = create_company_with_version(%{ - name: "Acme LLC", website: "http://www.acme.com" - }) - inserted_target_company = create_company_with_version(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_target_company.id - }) |> PaperTrail.insert!(origin: "admin") - updated_person = Person.changeset(inserted_person, %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: inserted_initial_company.id - }) |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}) + inserted_initial_company = + create_company_with_version(%{ + name: "Acme LLC", + website: "http://www.acme.com" + }) + + inserted_target_company = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_target_company.id + }) + |> PaperTrail.insert!(origin: "admin") + + updated_person = + Person.changeset(inserted_person, %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: inserted_initial_company.id + }) + |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}) person_count = Person.count() company_count = Company.count() @@ -293,52 +354,71 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert person_count == 1 assert company_count == 2 assert version_count == 4 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - company_id: inserted_initial_company.id, - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - last_name: "Nakri", - gender: true - } + company_id: inserted_initial_company.id, + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + last_name: "Nakri", + gender: true + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimplePerson", - item_id: person.id, - item_changes: convert_to_string_map(%{ - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: inserted_initial_company.id - }), - originator_id: nil, - origin: "scraper", - meta: %{"linkname" => "izelnakri"} - } + event: "update", + item_type: "SimplePerson", + item_id: person.id, + item_changes: + convert_to_string_map(%{ + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: inserted_initial_company.id + }), + originator_id: nil, + origin: "scraper", + meta: %{"linkname" => "izelnakri"} + } + assert person == first(Person, :id) |> @repo.one |> serialize end test "deleting a person creates a person version with correct attributes" do create_company_with_version(%{name: "Acme LLC", website: "http://www.acme.com"}) - inserted_target_company = create_company_with_version(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_target_company.id - }) |> PaperTrail.insert!(origin: "admin") - updated_person = Person.changeset(inserted_person, %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: inserted_target_company.id - }) |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}) + + inserted_target_company = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_target_company.id + }) + |> PaperTrail.insert!(origin: "admin") + + updated_person = + Person.changeset(inserted_person, %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: inserted_target_company.id + }) + |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}) + person_before_deletion = first(Person, :id) |> @repo.one |> serialize - deleted_person = PaperTrail.delete!( - updated_person, origin: "admin", meta: %{linkname: "izelnakri"} - ) + + deleted_person = + PaperTrail.delete!( + updated_person, + origin: "admin", + meta: %{linkname: "izelnakri"} + ) person_count = Person.count() company_count = Company.count() @@ -350,25 +430,28 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert person_count == 0 assert company_count == 2 assert version_count == 5 + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "SimplePerson", - item_id: old_person.id, - item_changes: convert_to_string_map(%{ - id: old_person.id, - inserted_at: old_person.inserted_at, - updated_at: old_person.updated_at, - first_name: "Isaac", - last_name: "Nakri", - gender: true, - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: inserted_target_company.id - }), - originator_id: nil, - origin: "admin", - meta: %{"linkname" => "izelnakri"} - } + event: "delete", + item_type: "SimplePerson", + item_id: old_person.id, + item_changes: + convert_to_string_map(%{ + id: old_person.id, + inserted_at: old_person.inserted_at, + updated_at: old_person.updated_at, + first_name: "Isaac", + last_name: "Nakri", + gender: true, + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: inserted_target_company.id + }), + originator_id: nil, + origin: "admin", + meta: %{"linkname" => "izelnakri"} + } + assert old_person == person_before_deletion end @@ -381,32 +464,36 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do company_count = Company.count(:multitenant) version_count = Version.count(prefix: tenant) - version = PaperTrail.get_version(company, prefix: tenant) + version = + PaperTrail.get_version(company, prefix: tenant) |> serialize assert Company.count() == 0 assert Version.count() == 0 assert company_count == 1 assert version_count == 1 + assert company |> serialize |> Map.drop([:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Greenwich", - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Greenwich", + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: company |> serialize |> convert_to_string_map, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "insert", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: company |> serialize |> convert_to_string_map, + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first_company(:multitenant) end @@ -420,42 +507,54 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do tenant = MultiTenant.tenant() user = create_user(:multitenant) inserted_company = create_company_with_version_multi() - updated_company = update_company_with_version_multi( - inserted_company, @update_company_params, user: user - ) + + updated_company = + update_company_with_version_multi( + inserted_company, + @update_company_params, + user: user + ) company_count = Company.count(:multitenant) version_count = Version.count(prefix: tenant) company = updated_company |> serialize - version = PaperTrail.get_version(updated_company, prefix: tenant) + + version = + PaperTrail.get_version(updated_company, prefix: tenant) |> serialize assert Company.count() == 0 assert Version.count() == 0 assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: convert_to_string_map(%{ - city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: + convert_to_string_map(%{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first_company(:multitenant) |> serialize end @@ -464,50 +563,66 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do user = create_user(:multitenant) inserted_company = create_company_with_version_multi() - updated_company = update_company_with_version_multi( - inserted_company, @update_company_params, user: user - ) + + updated_company = + update_company_with_version_multi( + inserted_company, + @update_company_params, + user: user + ) company_count = Company.count(:multitenant) version_count = Version.count(prefix: tenant) company = updated_company |> serialize - version = PaperTrail.get_version(updated_company, prefix: tenant) + + version = + PaperTrail.get_version(updated_company, prefix: tenant) |> serialize assert Company.count() == 0 assert Version.count() == 0 assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: convert_to_string_map(%{ - city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: + convert_to_string_map(%{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first_company(:multitenant) |> serialize end test "[multi tenant] PaperTrail.update!/2 with an error raises Ecto.InvalidChangesetError" do assert_raise(Ecto.InvalidChangesetError, fn -> inserted_company = create_company_with_version_multi() + update_company_with_version_multi(inserted_company, %{ - name: nil, city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" + name: nil, + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" }) end) end @@ -519,8 +634,13 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do inserted_company = create_company_with_version_multi() updated_company = update_company_with_version_multi(inserted_company) company_before_deletion = first_company(:multitenant) |> serialize - deleted_company = PaperTrail.delete!(updated_company, originator: user, - prefix: tenant) + + deleted_company = + PaperTrail.delete!( + updated_company, + originator: user, + prefix: tenant + ) company_count = Company.count(:multitenant) version_count = Version.count(prefix: tenant) @@ -532,37 +652,41 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert Version.count() == 0 assert company_count == 0 assert version_count == 3 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: convert_to_string_map(%{ - id: company.id, - inserted_at: company.inserted_at, - updated_at: company.updated_at, - name: "Acme LLC", - is_active: true, - website: "http://www.acme.com", - city: "Hong Kong", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "delete", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: + convert_to_string_map(%{ + id: company.id, + inserted_at: company.inserted_at, + updated_at: company.updated_at, + name: "Acme LLC", + is_active: true, + website: "http://www.acme.com", + city: "Hong Kong", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == company_before_deletion end @@ -571,6 +695,7 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert_raise(Ecto.InvalidChangesetError, fn -> inserted_company = create_company_with_version_multi() + Person.changeset(%Person{}, %{ first_name: "Izel", last_name: "Nakri", @@ -581,7 +706,7 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do |> PaperTrail.insert!(prefix: tenant) inserted_company - |> Company.changeset + |> Company.changeset() |> MultiTenant.add_prefix_to_changeset() |> PaperTrail.delete!(prefix: tenant) end) @@ -591,22 +716,25 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do tenant = MultiTenant.tenant() create_company_with_version_multi() - second_company = Company.changeset(%Company{}, %{ - name: "Another Company Corp.", - is_active: true, - address: "Sesame street 100/3, 101010" - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.insert!(prefix: tenant) - - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: second_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.insert!(origin: "admin", meta: %{linkname: "izelnakri"}, prefix: tenant) + + second_company = + Company.changeset(%Company{}, %{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.insert!(prefix: tenant) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: second_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.insert!(origin: "admin", meta: %{linkname: "izelnakri"}, prefix: tenant) assert Person.count() == 0 assert Company.count() == 0 @@ -621,52 +749,64 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert person_count == 1 assert company_count == 2 assert version_count == 3 - assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - visit_count: nil, - birthdate: nil, - company_id: second_company.id - } + + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + visit_count: nil, + birthdate: nil, + company_id: second_company.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "SimplePerson", - item_id: person.id, - item_changes: convert_to_string_map(person), - originator_id: nil, - origin: "admin", - meta: %{"linkname" => "izelnakri"} - } + event: "insert", + item_type: "SimplePerson", + item_id: person.id, + item_changes: convert_to_string_map(person), + originator_id: nil, + origin: "admin", + meta: %{"linkname" => "izelnakri"} + } + assert person == first_person(:multitenant) |> serialize end test "[multi tenant] updating a person creates a person version with correct attributes" do tenant = MultiTenant.tenant() - inserted_initial_company = create_company_with_version_multi(%{ - name: "Acme LLC", website: "http://www.acme.com" - }) - inserted_target_company = create_company_with_version_multi(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_target_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.insert!(origin: "admin", prefix: tenant) - - updated_person = Person.changeset(inserted_person, %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: inserted_initial_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}, prefix: tenant) + inserted_initial_company = + create_company_with_version_multi(%{ + name: "Acme LLC", + website: "http://www.acme.com" + }) + + inserted_target_company = + create_company_with_version_multi(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_target_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.insert!(origin: "admin", prefix: tenant) + + updated_person = + Person.changeset(inserted_person, %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: inserted_initial_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}, prefix: tenant) person_count = Person.count(:multitenant) company_count = Company.count(:multitenant) @@ -681,28 +821,32 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert person_count == 1 assert company_count == 2 assert version_count == 4 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - company_id: inserted_initial_company.id, - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - last_name: "Nakri", - gender: true - } + company_id: inserted_initial_company.id, + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + last_name: "Nakri", + gender: true + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimplePerson", - item_id: person.id, - item_changes: convert_to_string_map(%{ - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: inserted_initial_company.id - }), - originator_id: nil, - origin: "scraper", - meta: %{"linkname" => "izelnakri"} - } + event: "update", + item_type: "SimplePerson", + item_id: person.id, + item_changes: + convert_to_string_map(%{ + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: inserted_initial_company.id + }), + originator_id: nil, + origin: "scraper", + meta: %{"linkname" => "izelnakri"} + } + assert person == first_person(:multitenant) |> serialize end @@ -710,31 +854,43 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do tenant = MultiTenant.tenant() create_company_with_version_multi(%{name: "Acme LLC", website: "http://www.acme.com"}) - inserted_target_company = create_company_with_version_multi(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_target_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.insert!(origin: "admin", prefix: tenant) - - updated_person = Person.changeset(inserted_person, %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: inserted_target_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}, prefix: tenant) + + inserted_target_company = + create_company_with_version_multi(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_target_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.insert!(origin: "admin", prefix: tenant) + + updated_person = + Person.changeset(inserted_person, %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: inserted_target_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}, prefix: tenant) person_before_deletion = first_person(:multitenant) |> serialize - deleted_person = PaperTrail.delete!( - updated_person, origin: "admin", meta: %{linkname: "izelnakri"}, prefix: tenant - ) + + deleted_person = + PaperTrail.delete!( + updated_person, + origin: "admin", + meta: %{linkname: "izelnakri"}, + prefix: tenant + ) person_count = Person.count(:multitenant) company_count = Company.count(:multitenant) @@ -749,25 +905,28 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do assert person_count == 0 assert company_count == 2 assert version_count == 5 + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "SimplePerson", - item_id: old_person.id, - item_changes: convert_to_string_map(%{ - id: old_person.id, - inserted_at: old_person.inserted_at, - updated_at: old_person.updated_at, - first_name: "Isaac", - last_name: "Nakri", - gender: true, - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: inserted_target_company.id - }), - originator_id: nil, - origin: "admin", - meta: %{"linkname" => "izelnakri"} - } + event: "delete", + item_type: "SimplePerson", + item_id: old_person.id, + item_changes: + convert_to_string_map(%{ + id: old_person.id, + inserted_at: old_person.inserted_at, + updated_at: old_person.updated_at, + first_name: "Isaac", + last_name: "Nakri", + gender: true, + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: inserted_target_company.id + }), + originator_id: nil, + origin: "admin", + meta: %{"linkname" => "izelnakri"} + } + assert old_person == person_before_deletion end @@ -776,6 +935,7 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do User.changeset(%User{}, %{token: "fake-token", username: "izelnakri"}) |> @repo.insert! end + defp create_user(:multitenant) do User.changeset(%User{}, %{token: "fake-token", username: "izelnakri"}) |> MultiTenant.add_prefix_to_changeset() @@ -785,6 +945,7 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do defp create_company_with_version(params \\ @create_company_params, options \\ nil) do Company.changeset(%Company{}, params) |> PaperTrail.insert!(options) end + defp create_company_with_version_multi(params \\ @create_company_params, options \\ nil) do opts_with_prefix = Keyword.put(options || [], :prefix, MultiTenant.tenant()) @@ -796,7 +957,12 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do defp update_company_with_version(company, params \\ @update_company_params, options \\ nil) do Company.changeset(company, params) |> PaperTrail.update!(options) end - defp update_company_with_version_multi(company, params \\ @update_company_params, options \\ nil) do + + defp update_company_with_version_multi( + company, + params \\ @update_company_params, + options \\ nil + ) do opts_with_prefix = Keyword.put(options || [], :prefix, MultiTenant.tenant()) Company.changeset(company, params) @@ -807,6 +973,7 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do defp first_company(:multitenant) do first(Company, :id) |> MultiTenant.add_prefix_to_query() |> @repo.one() end + defp first_person(:multitenant) do first(Person, :id) |> MultiTenant.add_prefix_to_query() |> @repo.one() end @@ -835,6 +1002,6 @@ defmodule PaperTrailTest.SimpleModeBangFunctions do end defp convert_to_string_map(map) do - map |> Poison.encode! |> Poison.decode! + map |> Poison.encode!() |> Poison.decode!() end end diff --git a/test/paper_trail/bang_functions_strict_mode_test.exs b/test/paper_trail/bang_functions_strict_mode_test.exs index a430cdf0..3fd792e7 100644 --- a/test/paper_trail/bang_functions_strict_mode_test.exs +++ b/test/paper_trail/bang_functions_strict_mode_test.exs @@ -8,9 +8,13 @@ defmodule PaperTrailTest.StrictModeBangFunctions do alias StrictPerson, as: Person alias PaperTrailTest.MultiTenantHelper, as: MultiTenant - @repo PaperTrail.RepoClient.repo + @repo PaperTrail.RepoClient.repo() @create_company_params %{name: "Acme LLC", is_active: true, city: "Greenwich"} - @update_company_params %{city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc"} + @update_company_params %{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + } doctest PaperTrail @@ -25,9 +29,11 @@ defmodule PaperTrailTest.StrictModeBangFunctions do setup do reset_all_data() - on_exit fn -> + + on_exit(fn -> reset_all_data() - end + end) + :ok end @@ -43,27 +49,30 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert company_count == 1 assert version_count == 1 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Greenwich", - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil, - first_version_id: version.id, - current_version_id: version.id - } + name: "Acme LLC", + is_active: true, + city: "Greenwich", + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil, + first_version_id: version.id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictCompany", - item_id: company.id, - item_changes: convert_to_string_map(company), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "insert", + item_type: "StrictCompany", + item_id: company.id, + item_changes: convert_to_string_map(company), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end @@ -77,27 +86,29 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert company_count == 1 assert version_count == 1 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: nil, - city: nil, - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil, - first_version_id: version.id, - current_version_id: version.id - } + name: "Acme LLC", + is_active: nil, + city: nil, + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil, + first_version_id: version.id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictCompany", - item_id: company.id, - item_changes: convert_to_string_map(company), - originator_id: nil, - origin: nil, - meta: nil - } + event: "insert", + item_type: "StrictCompany", + item_id: company.id, + item_changes: convert_to_string_map(company), + originator_id: nil, + origin: nil, + meta: nil + } end test "PaperTrail.insert!/2 with an error raises Ecto.InvalidChangesetError" do @@ -110,9 +121,13 @@ defmodule PaperTrailTest.StrictModeBangFunctions do user = create_user() inserted_company = create_company_with_version() inserted_company_version = PaperTrail.get_version(inserted_company) |> serialize - updated_company = update_company_with_version( - inserted_company, @update_company_params, originator: user - ) + + updated_company = + update_company_with_version( + inserted_company, + @update_company_params, + originator: user + ) company_count = Company.count() version_count = Version.count() @@ -122,40 +137,48 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: inserted_company_version.id, - current_version_id: updated_company_version.id - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: inserted_company_version.id, + current_version_id: updated_company_version.id + } + assert Map.drop(updated_company_version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "StrictCompany", - item_id: company.id, - item_changes: convert_to_string_map(%{ - city: "Hong Kong", - website: "http://www.acme.com", - facebook: "acme.llc", - current_version_id: updated_company_version.id - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "StrictCompany", + item_id: company.id, + item_changes: + convert_to_string_map(%{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc", + current_version_id: updated_company_version.id + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end test "PaperTrail.update!/2 with an error raises Ecto.InvalidChangesetError" do assert_raise(Ecto.InvalidChangesetError, fn -> inserted_company = create_company_with_version() + update_company_with_version(inserted_company, %{ - name: nil, city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" + name: nil, + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" }) end) end @@ -177,70 +200,82 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert company_count == 0 assert version_count == 3 + assert Map.drop(old_company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: inserted_company_version.id, - current_version_id: updated_company_version.id - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: inserted_company_version.id, + current_version_id: updated_company_version.id + } + assert Map.drop(deleted_company_version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "StrictCompany", - item_id: old_company.id, - item_changes: convert_to_string_map(%{ - id: old_company.id, - inserted_at: old_company.inserted_at, - updated_at: old_company.updated_at, - name: "Acme LLC", - is_active: true, - website: "http://www.acme.com", - city: "Hong Kong", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: inserted_company_version.id, - current_version_id: updated_company_version.id - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "delete", + item_type: "StrictCompany", + item_id: old_company.id, + item_changes: + convert_to_string_map(%{ + id: old_company.id, + inserted_at: old_company.inserted_at, + updated_at: old_company.updated_at, + name: "Acme LLC", + is_active: true, + website: "http://www.acme.com", + city: "Hong Kong", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: inserted_company_version.id, + current_version_id: updated_company_version.id + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert old_company == company_before_deletion end test "PaperTrail.delete!/2 with an error raises Ecto.InvalidChangesetError" do assert_raise(Ecto.InvalidChangesetError, fn -> inserted_company = create_company_with_version() + Person.changeset(%Person{}, %{ first_name: "Izel", last_name: "Nakri", gender: true, company_id: inserted_company.id - }) |> PaperTrail.insert! - inserted_company |> Company.changeset |> PaperTrail.delete! + }) + |> PaperTrail.insert!() + + inserted_company |> Company.changeset() |> PaperTrail.delete!() end) end test "creating a person with meta tag creates a person version with correct attributes" do create_company_with_version(%{name: "Acme LLC", website: "http://www.acme.com"}) - inserted_company = create_company_with_version(%{ - name: "Another Company Corp.", - is_active: true, - address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_company.id - }) |> PaperTrail.insert!(origin: "admin", meta: %{linkname: "izelnakri"}) + + inserted_company = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_company.id + }) + |> PaperTrail.insert!(origin: "admin", meta: %{linkname: "izelnakri"}) person_count = Person.count() version_count = Version.count() @@ -250,48 +285,64 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert person_count == 1 assert version_count == 3 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - visit_count: nil, - birthdate: nil, - company_id: inserted_company.id, - first_version_id: version.id, - current_version_id: version.id - } + first_name: "Izel", + last_name: "Nakri", + gender: true, + visit_count: nil, + birthdate: nil, + company_id: inserted_company.id, + first_version_id: version.id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictPerson", - item_id: person.id, - item_changes: convert_to_string_map(person), - originator_id: nil, - origin: "admin", - meta: %{"linkname" => "izelnakri"} - } + event: "insert", + item_type: "StrictPerson", + item_id: person.id, + item_changes: convert_to_string_map(person), + originator_id: nil, + origin: "admin", + meta: %{"linkname" => "izelnakri"} + } + assert person == first(Person, :id) |> @repo.one |> serialize end test "updating a person creates a person version with correct attributes" do - inserted_initial_company = create_company_with_version(%{ - name: "Acme LLC", website: "http://www.acme.com" - }) - inserted_target_company = create_company_with_version(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_target_company.id - }) |> PaperTrail.insert!(origin: "admin") + inserted_initial_company = + create_company_with_version(%{ + name: "Acme LLC", + website: "http://www.acme.com" + }) + + inserted_target_company = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_target_company.id + }) + |> PaperTrail.insert!(origin: "admin") + inserted_person_version = PaperTrail.get_version(inserted_person) |> serialize - updated_person = Person.changeset(inserted_person, %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: inserted_initial_company.id - }) |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}) + + updated_person = + Person.changeset(inserted_person, %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: inserted_initial_company.id + }) + |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}) person_count = Person.count() company_count = Company.count() @@ -303,56 +354,78 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert person_count == 1 assert company_count == 2 assert version_count == 4 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - company_id: inserted_initial_company.id, - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), # this is the only problem - last_name: "Nakri", - gender: true, - first_version_id: inserted_person_version.id, - current_version_id: updated_person_version.id - } + company_id: inserted_initial_company.id, + first_name: "Isaac", + visit_count: 10, + # this is the only problem + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + last_name: "Nakri", + gender: true, + first_version_id: inserted_person_version.id, + current_version_id: updated_person_version.id + } + assert Map.drop(updated_person_version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "StrictPerson", - item_id: person.id, - item_changes: convert_to_string_map(%{ - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - current_version_id: updated_person_version.id, - company_id: inserted_initial_company.id - }), - originator_id: nil, - origin: "scraper", - meta: %{"linkname" => "izelnakri"} - } + event: "update", + item_type: "StrictPerson", + item_id: person.id, + item_changes: + convert_to_string_map(%{ + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + current_version_id: updated_person_version.id, + company_id: inserted_initial_company.id + }), + originator_id: nil, + origin: "scraper", + meta: %{"linkname" => "izelnakri"} + } + assert person == first(Person, :id) |> @repo.one |> serialize end test "deleting a person creates a person version with correct attributes" do create_company_with_version(%{name: "Acme LLC", website: "http://www.acme.com"}) - inserted_company = create_company_with_version(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_company.id - }) |> PaperTrail.insert!(origin: "admin") + + inserted_company = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_company.id + }) + |> PaperTrail.insert!(origin: "admin") + inserted_person_version = PaperTrail.get_version(inserted_person) |> serialize - updated_person = Person.changeset(inserted_person, %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01] - }) |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}) + + updated_person = + Person.changeset(inserted_person, %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01] + }) + |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}) + updated_person_version = PaperTrail.get_version(updated_person) |> serialize person_before_deletion = first(Person, :id) |> @repo.one - deleted_person = PaperTrail.delete!( - updated_person, origin: "admin", meta: %{linkname: "izelnakri"} - ) + + deleted_person = + PaperTrail.delete!( + updated_person, + origin: "admin", + meta: %{linkname: "izelnakri"} + ) + deleted_person_version = PaperTrail.get_version(deleted_person) |> serialize person_count = Person.count() @@ -362,27 +435,30 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert person_count == 0 assert company_count == 2 assert version_count == 5 + assert Map.drop(deleted_person_version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "StrictPerson", - item_id: deleted_person.id, - item_changes: convert_to_string_map(%{ - id: deleted_person.id, - inserted_at: deleted_person.inserted_at, - updated_at: deleted_person.updated_at, - first_name: "Isaac", - last_name: "Nakri", - gender: true, - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: inserted_company.id, - first_version_id: inserted_person_version.id, - current_version_id: updated_person_version.id - }), - originator_id: nil, - origin: "admin", - meta: %{"linkname" => "izelnakri"} - } + event: "delete", + item_type: "StrictPerson", + item_id: deleted_person.id, + item_changes: + convert_to_string_map(%{ + id: deleted_person.id, + inserted_at: deleted_person.inserted_at, + updated_at: deleted_person.updated_at, + first_name: "Isaac", + last_name: "Nakri", + gender: true, + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: inserted_company.id, + first_version_id: inserted_person_version.id, + current_version_id: updated_person_version.id + }), + originator_id: nil, + origin: "admin", + meta: %{"linkname" => "izelnakri"} + } + assert deleted_person |> serialize == person_before_deletion |> serialize end @@ -396,73 +472,84 @@ defmodule PaperTrailTest.StrictModeBangFunctions do version_count = Version.count(prefix: tenant) company = inserted_company |> serialize() - version = PaperTrail.get_version(inserted_company, prefix: tenant) + + version = + PaperTrail.get_version(inserted_company, prefix: tenant) |> serialize() assert Company.count() == 0 assert Version.count() == 0 assert company_count == 1 assert version_count == 1 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Greenwich", - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil, - first_version_id: version.id, - current_version_id: version.id - } + name: "Acme LLC", + is_active: true, + city: "Greenwich", + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil, + first_version_id: version.id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictCompany", - item_id: company.id, - item_changes: convert_to_string_map(company), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "insert", + item_type: "StrictCompany", + item_id: company.id, + item_changes: convert_to_string_map(company), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first_company(:multitenant) |> serialize end test "[multi tenant] creating a company without changeset creates a company version with correct attributes" do tenant = MultiTenant.tenant() - inserted_company = create_company_with_version_multi(%{name: "Acme LLC"}, prefix: MultiTenant.tenant()) + inserted_company = + create_company_with_version_multi(%{name: "Acme LLC"}, prefix: MultiTenant.tenant()) + company_count = Company.count(:multitenant) version_count = Version.count(prefix: tenant) company = inserted_company |> serialize - version = PaperTrail.get_version(inserted_company, prefix: tenant) + + version = + PaperTrail.get_version(inserted_company, prefix: tenant) |> serialize assert Company.count() == 0 assert Version.count() == 0 assert company_count == 1 assert version_count == 1 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: nil, - city: nil, - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil, - first_version_id: version.id, - current_version_id: version.id - } + name: "Acme LLC", + is_active: nil, + city: nil, + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil, + first_version_id: version.id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictCompany", - item_id: company.id, - item_changes: convert_to_string_map(company), - originator_id: nil, - origin: nil, - meta: nil - } + event: "insert", + item_type: "StrictCompany", + item_id: company.id, + item_changes: convert_to_string_map(company), + originator_id: nil, + origin: nil, + meta: nil + } end test "[multi tenant] PaperTrail.insert!/2 with an error raises Ecto.InvalidChangesetError" do @@ -476,57 +563,73 @@ defmodule PaperTrailTest.StrictModeBangFunctions do user = create_user(:multitenant) inserted_company = create_company_with_version_multi() - inserted_company_version = PaperTrail.get_version(inserted_company, prefix: tenant) + + inserted_company_version = + PaperTrail.get_version(inserted_company, prefix: tenant) |> serialize - updated_company = update_company_with_version_multi( - inserted_company, @update_company_params, originator: user - ) + + updated_company = + update_company_with_version_multi( + inserted_company, + @update_company_params, + originator: user + ) company_count = Company.count(:multitenant) version_count = Version.count(prefix: tenant) company = updated_company |> serialize - updated_company_version = PaperTrail.get_version(updated_company, prefix: tenant) + + updated_company_version = + PaperTrail.get_version(updated_company, prefix: tenant) |> serialize assert Company.count() == 0 assert Version.count() == 0 assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: inserted_company_version.id, - current_version_id: updated_company_version.id - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: inserted_company_version.id, + current_version_id: updated_company_version.id + } + assert Map.drop(updated_company_version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "StrictCompany", - item_id: company.id, - item_changes: convert_to_string_map(%{ - city: "Hong Kong", - website: "http://www.acme.com", - facebook: "acme.llc", - current_version_id: updated_company_version.id - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "StrictCompany", + item_id: company.id, + item_changes: + convert_to_string_map(%{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc", + current_version_id: updated_company_version.id + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first_company(:multitenant) |> serialize end test "[multi tenant] PaperTrail.update!/2 with an error raises Ecto.InvalidChangesetError" do assert_raise(Ecto.InvalidChangesetError, fn -> inserted_company = create_company_with_version_multi() + update_company_with_version_multi(inserted_company, %{ - name: nil, city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" + name: nil, + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" }) end) end @@ -546,48 +649,54 @@ defmodule PaperTrailTest.StrictModeBangFunctions do version_count = Version.count(prefix: tenant) old_company = deleted_company |> serialize - deleted_company_version = PaperTrail.get_version(deleted_company, prefix: tenant) + + deleted_company_version = + PaperTrail.get_version(deleted_company, prefix: tenant) |> serialize assert Company.count() == 0 assert Version.count() == 0 assert company_count == 0 assert version_count == 3 + assert Map.drop(old_company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: inserted_company_version.id, - current_version_id: updated_company_version.id - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: inserted_company_version.id, + current_version_id: updated_company_version.id + } + assert Map.drop(deleted_company_version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "StrictCompany", - item_id: old_company.id, - item_changes: convert_to_string_map(%{ - id: old_company.id, - inserted_at: old_company.inserted_at, - updated_at: old_company.updated_at, - name: "Acme LLC", - is_active: true, - website: "http://www.acme.com", - city: "Hong Kong", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: inserted_company_version.id, - current_version_id: updated_company_version.id - }), - originator_id: user.id, - origin: nil, - meta: nil - } + event: "delete", + item_type: "StrictCompany", + item_id: old_company.id, + item_changes: + convert_to_string_map(%{ + id: old_company.id, + inserted_at: old_company.inserted_at, + updated_at: old_company.updated_at, + name: "Acme LLC", + is_active: true, + website: "http://www.acme.com", + city: "Hong Kong", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: inserted_company_version.id, + current_version_id: updated_company_version.id + }), + originator_id: user.id, + origin: nil, + meta: nil + } + assert old_company == company_before_deletion end @@ -596,6 +705,7 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert_raise(Ecto.InvalidChangesetError, fn -> inserted_company = create_company_with_version_multi() + Person.changeset(%Person{}, %{ first_name: "Izel", last_name: "Nakri", @@ -606,7 +716,7 @@ defmodule PaperTrailTest.StrictModeBangFunctions do |> PaperTrail.insert!(prefix: tenant) inserted_company - |> Company.changeset + |> Company.changeset() |> MultiTenant.add_prefix_to_changeset() |> PaperTrail.delete!(prefix: tenant) end) @@ -616,19 +726,23 @@ defmodule PaperTrailTest.StrictModeBangFunctions do tenant = MultiTenant.tenant() create_company_with_version_multi(%{name: "Acme LLC", website: "http://www.acme.com"}) - inserted_company = create_company_with_version_multi(%{ - name: "Another Company Corp.", - is_active: true, - address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.insert!(origin: "admin", meta: %{linkname: "izelnakri"}, prefix: tenant) + + inserted_company = + create_company_with_version_multi(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.insert!(origin: "admin", meta: %{linkname: "izelnakri"}, prefix: tenant) person_count = Person.count(:multitenant) version_count = Version.count(prefix: tenant) @@ -640,63 +754,79 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert Version.count() == 0 assert person_count == 1 assert version_count == 3 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - visit_count: nil, - birthdate: nil, - company_id: inserted_company.id, - first_version_id: version.id, - current_version_id: version.id - } + first_name: "Izel", + last_name: "Nakri", + gender: true, + visit_count: nil, + birthdate: nil, + company_id: inserted_company.id, + first_version_id: version.id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictPerson", - item_id: person.id, - item_changes: convert_to_string_map(person), - originator_id: nil, - origin: "admin", - meta: %{"linkname" => "izelnakri"} - } + event: "insert", + item_type: "StrictPerson", + item_id: person.id, + item_changes: convert_to_string_map(person), + originator_id: nil, + origin: "admin", + meta: %{"linkname" => "izelnakri"} + } + assert person == first_person(:multitenant) |> serialize end test "[multi tenant] updating a person creates a person version with correct attributes" do tenant = MultiTenant.tenant() - inserted_initial_company = create_company_with_version_multi(%{ - name: "Acme LLC", website: "http://www.acme.com" - }) - inserted_target_company = create_company_with_version_multi(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_target_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.insert!(origin: "admin", prefix: tenant) + inserted_initial_company = + create_company_with_version_multi(%{ + name: "Acme LLC", + website: "http://www.acme.com" + }) + + inserted_target_company = + create_company_with_version_multi(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) - inserted_person_version = PaperTrail.get_version(inserted_person, prefix: tenant) + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_target_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.insert!(origin: "admin", prefix: tenant) + + inserted_person_version = + PaperTrail.get_version(inserted_person, prefix: tenant) |> serialize - updated_person = Person.changeset(inserted_person, %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: inserted_initial_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}, prefix: tenant) + + updated_person = + Person.changeset(inserted_person, %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: inserted_initial_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}, prefix: tenant) person_count = Person.count(:multitenant) company_count = Company.count(:multitenant) version_count = Version.count(prefix: tenant) person = updated_person |> serialize - updated_person_version = PaperTrail.get_version(updated_person, prefix: tenant) + + updated_person_version = + PaperTrail.get_version(updated_person, prefix: tenant) |> serialize assert Person.count() == 0 @@ -704,31 +834,36 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert person_count == 1 assert company_count == 2 assert version_count == 4 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - company_id: inserted_initial_company.id, - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), # this is the only problem - last_name: "Nakri", - gender: true, - first_version_id: inserted_person_version.id, - current_version_id: updated_person_version.id - } + company_id: inserted_initial_company.id, + first_name: "Isaac", + visit_count: 10, + # this is the only problem + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + last_name: "Nakri", + gender: true, + first_version_id: inserted_person_version.id, + current_version_id: updated_person_version.id + } + assert Map.drop(updated_person_version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "StrictPerson", - item_id: person.id, - item_changes: convert_to_string_map(%{ - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - current_version_id: updated_person_version.id, - company_id: inserted_initial_company.id - }), - originator_id: nil, - origin: "scraper", - meta: %{"linkname" => "izelnakri"} - } + event: "update", + item_type: "StrictPerson", + item_id: person.id, + item_changes: + convert_to_string_map(%{ + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + current_version_id: updated_person_version.id, + company_id: inserted_initial_company.id + }), + originator_id: nil, + origin: "scraper", + meta: %{"linkname" => "izelnakri"} + } + assert person == first_person(:multitenant) |> serialize end @@ -736,35 +871,53 @@ defmodule PaperTrailTest.StrictModeBangFunctions do tenant = MultiTenant.tenant() create_company_with_version_multi(%{name: "Acme LLC", website: "http://www.acme.com"}) - inserted_company = create_company_with_version_multi(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - inserted_person = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: inserted_company.id - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.insert!(origin: "admin", prefix: tenant) - inserted_person_version = PaperTrail.get_version(inserted_person, prefix: tenant) + inserted_company = + create_company_with_version_multi(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + inserted_person = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: inserted_company.id + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.insert!(origin: "admin", prefix: tenant) + + inserted_person_version = + PaperTrail.get_version(inserted_person, prefix: tenant) |> serialize - updated_person = Person.changeset(inserted_person, %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01] - }) - |> MultiTenant.add_prefix_to_changeset() - |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}, prefix: tenant) - updated_person_version = PaperTrail.get_version(updated_person, prefix: tenant) + updated_person = + Person.changeset(inserted_person, %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01] + }) + |> MultiTenant.add_prefix_to_changeset() + |> PaperTrail.update!(origin: "scraper", meta: %{linkname: "izelnakri"}, prefix: tenant) + + updated_person_version = + PaperTrail.get_version(updated_person, prefix: tenant) |> serialize + person_before_deletion = first_person(:multitenant) - deleted_person = PaperTrail.delete!( - updated_person, origin: "admin", meta: %{linkname: "izelnakri"}, prefix: tenant - ) - deleted_person_version = PaperTrail.get_version(deleted_person, prefix: tenant) + + deleted_person = + PaperTrail.delete!( + updated_person, + origin: "admin", + meta: %{linkname: "izelnakri"}, + prefix: tenant + ) + + deleted_person_version = + PaperTrail.get_version(deleted_person, prefix: tenant) |> serialize person_count = Person.count(:multitenant) @@ -777,27 +930,30 @@ defmodule PaperTrailTest.StrictModeBangFunctions do assert person_count == 0 assert company_count == 2 assert version_count == 5 + assert Map.drop(deleted_person_version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "StrictPerson", - item_id: deleted_person.id, - item_changes: convert_to_string_map(%{ - id: deleted_person.id, - inserted_at: deleted_person.inserted_at, - updated_at: deleted_person.updated_at, - first_name: "Isaac", - last_name: "Nakri", - gender: true, - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: inserted_company.id, - first_version_id: inserted_person_version.id, - current_version_id: updated_person_version.id - }), - originator_id: nil, - origin: "admin", - meta: %{"linkname" => "izelnakri"} - } + event: "delete", + item_type: "StrictPerson", + item_id: deleted_person.id, + item_changes: + convert_to_string_map(%{ + id: deleted_person.id, + inserted_at: deleted_person.inserted_at, + updated_at: deleted_person.updated_at, + first_name: "Isaac", + last_name: "Nakri", + gender: true, + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: inserted_company.id, + first_version_id: inserted_person_version.id, + current_version_id: updated_person_version.id + }), + originator_id: nil, + origin: "admin", + meta: %{"linkname" => "izelnakri"} + } + assert deleted_person |> serialize == person_before_deletion |> serialize end @@ -806,6 +962,7 @@ defmodule PaperTrailTest.StrictModeBangFunctions do User.changeset(%User{}, %{token: "fake-token", username: "izelnakri"}) |> @repo.insert! end + defp create_user(:multitenant) do User.changeset(%User{}, %{token: "fake-token", username: "izelnakri"}) |> MultiTenant.add_prefix_to_changeset() @@ -815,6 +972,7 @@ defmodule PaperTrailTest.StrictModeBangFunctions do defp create_company_with_version(params \\ @create_company_params, options \\ nil) do Company.changeset(%Company{}, params) |> PaperTrail.insert!(options) end + defp create_company_with_version_multi(params \\ @create_company_params, options \\ nil) do opts_with_prefix = Keyword.put(options || [], :prefix, MultiTenant.tenant()) @@ -826,7 +984,12 @@ defmodule PaperTrailTest.StrictModeBangFunctions do defp update_company_with_version(company, params \\ @update_company_params, options \\ nil) do Company.changeset(company, params) |> PaperTrail.update!(options) end - defp update_company_with_version_multi(company, params \\ @update_company_params, options \\ nil) do + + defp update_company_with_version_multi( + company, + params \\ @update_company_params, + options \\ nil + ) do opts_with_prefix = Keyword.put(options || [], :prefix, MultiTenant.tenant()) Company.changeset(company, params) @@ -837,6 +1000,7 @@ defmodule PaperTrailTest.StrictModeBangFunctions do defp first_company(:multitenant) do first(Company, :id) |> MultiTenant.add_prefix_to_query() |> @repo.one() end + defp first_person(:multitenant) do first(Person, :id) |> MultiTenant.add_prefix_to_query() |> @repo.one() end @@ -865,6 +1029,6 @@ defmodule PaperTrailTest.StrictModeBangFunctions do end defp convert_to_string_map(map) do - map |> Poison.encode! |> Poison.decode! + map |> Poison.encode!() |> Poison.decode!() end end diff --git a/test/paper_trail/paper_trail_version_test.exs b/test/paper_trail/paper_trail_version_test.exs index 299dcdc4..6a9bf9a5 100644 --- a/test/paper_trail/paper_trail_version_test.exs +++ b/test/paper_trail/paper_trail_version_test.exs @@ -14,7 +14,7 @@ defmodule PaperTrailTest.Version do } @invalid_attrs %{} - @repo PaperTrail.RepoClient.repo + @repo PaperTrail.RepoClient.repo() setup_all do Application.put_env(:paper_trail, :strict_mode, false) @@ -27,15 +27,19 @@ defmodule PaperTrailTest.Version do setup do @repo.delete_all(Version) + Version |> MultiTenant.add_prefix_to_query() |> @repo.delete_all() - on_exit fn -> + + on_exit(fn -> @repo.delete_all(Version) + Version |> MultiTenant.add_prefix_to_query() |> @repo.delete_all() - end + end) + :ok end @@ -56,26 +60,36 @@ defmodule PaperTrailTest.Version do test "first works" do add_three_versions() - target_model = @valid_attrs |> Map.delete(:inserted_at) |> Map.merge(%{ - item_changes: %{"first_name" => "Izel", "last_name" => "Nakri"} - }) - target_version = Version.first() |> serialize |> Map.drop([ - :id, :meta, :originator_id, :inserted_at - ]) + + target_model = + @valid_attrs |> Map.delete(:inserted_at) + |> Map.merge(%{ + item_changes: %{"first_name" => "Izel", "last_name" => "Nakri"} + }) + + target_version = + Version.first() |> serialize + |> Map.drop([ + :id, + :meta, + :originator_id, + :inserted_at + ]) assert target_version == target_model end test "last works" do add_three_versions() + assert Version.last() |> serialize != %{ - event: "insert", - item_type: "Person", - item_id: 3, - item_changes: %{first_name: "Yukihiro", last_name: "Matsumoto"}, - origin: "test", - inserted_at: DateTime.from_naive!(~N[1965-04-14 01:00:00.000], "Etc/UTC") - } + event: "insert", + item_type: "Person", + item_id: 3, + item_changes: %{first_name: "Yukihiro", last_name: "Matsumoto"}, + origin: "test", + inserted_at: DateTime.from_naive!(~N[1965-04-14 01:00:00.000], "Etc/UTC") + } end # Multi tenant tests @@ -87,12 +101,21 @@ defmodule PaperTrailTest.Version do test "[multi tenant] first works" do add_three_versions(MultiTenant.tenant()) - target_version = Version.first(prefix: MultiTenant.tenant()) |> serialize |> Map.drop([ - :id, :meta, :originator_id, :inserted_at - ]) - target_model = @valid_attrs |> Map.delete(:inserted_at) |> Map.merge(%{ - item_changes: %{"first_name" => "Izel", "last_name" => "Nakri"} - }) + + target_version = + Version.first(prefix: MultiTenant.tenant()) |> serialize + |> Map.drop([ + :id, + :meta, + :originator_id, + :inserted_at + ]) + + target_model = + @valid_attrs |> Map.delete(:inserted_at) + |> Map.merge(%{ + item_changes: %{"first_name" => "Izel", "last_name" => "Nakri"} + }) assert target_version == target_model assert Version.first() == nil @@ -100,40 +123,49 @@ defmodule PaperTrailTest.Version do test "[multi tenant] last works" do add_three_versions(MultiTenant.tenant()) + assert Version.last(prefix: MultiTenant.tenant()) |> serialize != %{ - event: "insert", - item_type: "Person", - item_id: 3, - item_changes: %{first_name: "Yukihiro", last_name: "Matsumoto"}, - origin: "test", - inserted_at: DateTime.from_naive!(~N[1965-04-14 01:00:00.000], "Etc/UTC") - } + event: "insert", + item_type: "Person", + item_id: 3, + item_changes: %{first_name: "Yukihiro", last_name: "Matsumoto"}, + origin: "test", + inserted_at: DateTime.from_naive!(~N[1965-04-14 01:00:00.000], "Etc/UTC") + } + assert Version.last() == nil end def add_three_versions(prefix \\ nil) do - @repo.insert_all(Version, [ - @valid_attrs, - %{ - event: "insert", - item_type: "Person", - item_id: 2, - item_changes: %{first_name: "Brendan", last_name: "Eich"}, - origin: "test", - inserted_at: DateTime.from_naive!(~N[1961-07-04 01:00:00.000], "Etc/UTC") - }, - %{ - event: "insert", - item_type: "Person", - item_id: 3, - item_changes: %{first_name: "Yukihiro", last_name: "Matsumoto"}, - origin: "test", - inserted_at: DateTime.from_naive!(~N[1965-04-14 01:00:00.000], "Etc/UTC") - } - ], returning: true, prefix: prefix) |> elem(1) + @repo.insert_all( + Version, + [ + @valid_attrs, + %{ + event: "insert", + item_type: "Person", + item_id: 2, + item_changes: %{first_name: "Brendan", last_name: "Eich"}, + origin: "test", + inserted_at: DateTime.from_naive!(~N[1961-07-04 01:00:00.000], "Etc/UTC") + }, + %{ + event: "insert", + item_type: "Person", + item_id: 3, + item_changes: %{first_name: "Yukihiro", last_name: "Matsumoto"}, + origin: "test", + inserted_at: DateTime.from_naive!(~N[1965-04-14 01:00:00.000], "Etc/UTC") + } + ], + returning: true, + prefix: prefix + ) + |> elem(1) end def serialize(nil), do: nil + def serialize(resource) do relationships = resource.__struct__.__schema__(:associations) Map.drop(resource, [:__meta__, :__struct__] ++ relationships) diff --git a/test/paper_trail/uuid_test.exs b/test/paper_trail/uuid_test.exs index f871e7ad..a4f67f65 100644 --- a/test/paper_trail/uuid_test.exs +++ b/test/paper_trail/uuid_test.exs @@ -6,7 +6,7 @@ defmodule PaperTrailTest.UUIDTest do setup_all do Application.put_env(:paper_trail, :repo, PaperTrail.UUIDRepo) - Application.put_env(:paper_trail, :originator, [name: :admin, model: Admin]) + Application.put_env(:paper_trail, :originator, name: :admin, model: Admin) Application.put_env(:paper_trail, :originator_type, Ecto.UUID) Application.put_env(:paper_trail, :item_type, Ecto.UUID) Code.eval_file("lib/paper_trail.ex") @@ -21,7 +21,7 @@ defmodule PaperTrailTest.UUIDTest do product = %Product{} |> Product.changeset(%{name: "Hair Cream"}) - |> PaperTrail.insert! + |> PaperTrail.insert!() version = Version |> last |> repo().one diff --git a/test/paper_trail/version_queries_test.exs b/test/paper_trail/version_queries_test.exs index 37b52ed9..f2b825c2 100644 --- a/test/paper_trail/version_queries_test.exs +++ b/test/paper_trail/version_queries_test.exs @@ -8,15 +8,18 @@ defmodule PaperTrailTest.VersionQueries do import Ecto.Query - @repo PaperTrail.RepoClient.repo + @repo PaperTrail.RepoClient.repo() setup_all do MultiTenant.setup_tenant(@repo) reset_all_data() Company.changeset(%Company{}, %{ - name: "Acme LLC", is_active: true, city: "Greenwich" - }) |> PaperTrail.insert + name: "Acme LLC", + is_active: true, + city: "Greenwich" + }) + |> PaperTrail.insert() old_company = first(Company, :id) |> @repo.one @@ -24,51 +27,63 @@ defmodule PaperTrailTest.VersionQueries do city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }) |> PaperTrail.update + }) + |> PaperTrail.update() - first(Company, :id) |> @repo.one |> PaperTrail.delete + first(Company, :id) |> @repo.one |> PaperTrail.delete() Company.changeset(%Company{}, %{ name: "Acme LLC", website: "http://www.acme.com" - }) |> PaperTrail.insert + }) + |> PaperTrail.insert() Company.changeset(%Company{}, %{ name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) |> PaperTrail.insert + }) + |> PaperTrail.insert() company = first(Company, :id) |> @repo.one + # add link name later on Person.changeset(%Person{}, %{ first_name: "Izel", last_name: "Nakri", gender: true, company_id: company.id - }) |> PaperTrail.insert(set_by: "admin") # add link name later on + }) + |> PaperTrail.insert(set_by: "admin") - another_company = @repo.one( - from c in Company, - where: c.name == "Another Company Corp.", - limit: 1 - ) + another_company = + @repo.one( + from( + c in Company, + where: c.name == "Another Company Corp.", + limit: 1 + ) + ) Person.changeset(first(Person, :id) |> @repo.one, %{ first_name: "Isaac", visit_count: 10, birthdate: ~D[1992-04-01], company_id: another_company.id - }) |> PaperTrail.update(set_by: "user:1", meta: %{linkname: "izelnakri"}) + }) + |> PaperTrail.update(set_by: "user:1", meta: %{linkname: "izelnakri"}) # Multi tenant Company.changeset(%Company{}, %{ - name: "Acme LLC", is_active: true, city: "Greenwich" + name: "Acme LLC", + is_active: true, + city: "Greenwich" }) |> MultiTenant.add_prefix_to_changeset() |> PaperTrail.insert(prefix: MultiTenant.tenant()) - company_multi = first(Company, :id) + company_multi = + first(Company, :id) |> MultiTenant.add_prefix_to_query() |> @repo.one @@ -88,48 +103,72 @@ defmodule PaperTrailTest.VersionQueries do tenant = MultiTenant.tenant() last_person = last(Person, :id) |> @repo.one target_version = last(Version, :id) |> @repo.one - last_person_multi = last(Person, :id) + + last_person_multi = + last(Person, :id) |> MultiTenant.add_prefix_to_query() |> @repo.one - target_version_multi = last(Version, :id) + + target_version_multi = + last(Version, :id) |> MultiTenant.add_prefix_to_query() |> @repo.one assert PaperTrail.get_version(last_person) == target_version assert PaperTrail.get_version(Person, last_person.id) == target_version assert PaperTrail.get_version(last_person_multi, prefix: tenant) == target_version_multi - assert PaperTrail.get_version(Person, last_person_multi.id, prefix: tenant) == target_version_multi + + assert PaperTrail.get_version(Person, last_person_multi.id, prefix: tenant) == + target_version_multi + assert target_version != target_version_multi end test "get_versions gives us the right versions" do tenant = MultiTenant.tenant() last_person = last(Person, :id) |> @repo.one - target_versions = @repo.all( - from version in Version, - where: version.item_type == "SimplePerson" and version.item_id == ^last_person.id - ) - last_person_multi = last(Person, :id) + + target_versions = + @repo.all( + from( + version in Version, + where: version.item_type == "SimplePerson" and version.item_id == ^last_person.id + ) + ) + + last_person_multi = + last(Person, :id) |> MultiTenant.add_prefix_to_query() |> @repo.one - target_versions_multi = from(version in Version, - where: version.item_type == "SimplePerson" and version.item_id == ^last_person_multi.id) + + target_versions_multi = + from( + version in Version, + where: version.item_type == "SimplePerson" and version.item_id == ^last_person_multi.id + ) |> MultiTenant.add_prefix_to_query() |> @repo.all assert PaperTrail.get_versions(last_person) == target_versions assert PaperTrail.get_versions(Person, last_person.id) == target_versions assert PaperTrail.get_versions(last_person_multi, prefix: tenant) == target_versions_multi - assert PaperTrail.get_versions(Person, last_person_multi.id, prefix: tenant) == target_versions_multi + + assert PaperTrail.get_versions(Person, last_person_multi.id, prefix: tenant) == + target_versions_multi + assert target_versions != target_versions_multi end test "get_current_model/1 gives us the current record of a version" do person = first(Person, :id) |> @repo.one - first_version = Version |> where([v], v.item_type == "SimplePerson" and v.item_id == ^person.id) |> first |> @repo.one + + first_version = + Version |> where([v], v.item_type == "SimplePerson" and v.item_id == ^person.id) |> first + |> @repo.one assert PaperTrail.get_current_model(first_version) == person end + # query meta data!! # Functions diff --git a/test/paper_trail_strict_mode_test.exs b/test/paper_trail_strict_mode_test.exs index 5a65139c..bcecfb69 100644 --- a/test/paper_trail_strict_mode_test.exs +++ b/test/paper_trail_strict_mode_test.exs @@ -8,9 +8,13 @@ defmodule PaperTrailStrictModeTest do alias StrictCompany, as: Company alias StrictPerson, as: Person - @repo PaperTrail.RepoClient.repo + @repo PaperTrail.RepoClient.repo() @create_company_params %{name: "Acme LLC", is_active: true, city: "Greenwich"} - @update_company_params %{city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc"} + @update_company_params %{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + } doctest PaperTrail @@ -26,11 +30,13 @@ defmodule PaperTrailStrictModeTest do @repo.delete_all(Person) @repo.delete_all(Company) @repo.delete_all(Version) - on_exit fn -> + + on_exit(fn -> @repo.delete_all(Person) @repo.delete_all(Company) @repo.delete_all(Version) - end + end) + :ok end @@ -47,27 +53,30 @@ defmodule PaperTrailStrictModeTest do assert Map.keys(result) == [:model, :version] assert company_count == 1 assert version_count == 1 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Greenwich", - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil, - first_version_id: version.id, - current_version_id: version.id - } + name: "Acme LLC", + is_active: true, + city: "Greenwich", + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil, + first_version_id: version.id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictCompany", - item_id: company.id, - item_changes: company, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "insert", + item_type: "StrictCompany", + item_id: company.id, + item_changes: company, + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end @@ -82,42 +91,51 @@ defmodule PaperTrailStrictModeTest do assert Map.keys(result) == [:model, :version] assert company_count == 1 assert version_count == 1 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: nil, - city: nil, - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil, - first_version_id: version.id, - current_version_id: version.id - } + name: "Acme LLC", + is_active: nil, + city: nil, + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil, + first_version_id: version.id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictCompany", - item_id: company.id, - item_changes: company, - originator_id: nil, - origin: nil, - meta: nil - } + event: "insert", + item_type: "StrictCompany", + item_id: company.id, + item_changes: company, + originator_id: nil, + origin: nil, + meta: nil + } end test "PaperTrail.insert/2 with an error returns and error tuple like Repo.insert/2" do result = create_company_with_version(%{name: nil, is_active: true, city: "Greenwich"}) - ecto_result = Company.changeset(%Company{}, %{name: nil, is_active: true, city: "Greenwich"}) + + ecto_result = + Company.changeset(%Company{}, %{name: nil, is_active: true, city: "Greenwich"}) |> @repo.insert + assert result == ecto_result end test "updating a company creates a company version with correct item_changes" do user = create_user() {:ok, insert_company_result} = create_company_with_version() - {:ok, result} = update_company_with_version( - insert_company_result[:model], @update_company_params, originator: user - ) + + {:ok, result} = + update_company_with_version( + insert_company_result[:model], + @update_company_params, + originator: user + ) company_count = Company.count() version_count = Version.count() @@ -128,44 +146,58 @@ defmodule PaperTrailStrictModeTest do assert Map.keys(result) == [:model, :version] assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: insert_company_result[:version].id, - current_version_id: version.id - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: insert_company_result[:version].id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "StrictCompany", - item_id: company.id, - item_changes: %{ - city: "Hong Kong", - website: "http://www.acme.com", - facebook: "acme.llc", - current_version_id: version.id - }, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "StrictCompany", + item_id: company.id, + item_changes: %{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc", + current_version_id: version.id + }, + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end test "PaperTrail.update/2 with an error returns and error tuple like Repo.update/2" do {:ok, insert_result} = create_company_with_version() company = insert_result[:model] - result = update_company_with_version(company, %{ - name: nil, city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }) - ecto_result = Company.changeset(company, %{ - name: nil, city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }) |> @repo.update + + result = + update_company_with_version(company, %{ + name: nil, + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }) + + ecto_result = + Company.changeset(company, %{ + name: nil, + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }) + |> @repo.update assert result == ecto_result end @@ -186,71 +218,82 @@ defmodule PaperTrailStrictModeTest do assert Map.keys(result) == [:model, :version] assert company_count == 0 assert version_count == 3 + assert Map.drop(old_company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: insert_company_result[:version].id, - current_version_id: update_company_result[:version].id - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: insert_company_result[:version].id, + current_version_id: update_company_result[:version].id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "StrictCompany", - item_id: old_company.id, - item_changes: %{ - id: old_company.id, - inserted_at: old_company.inserted_at, - updated_at: old_company.updated_at, - name: "Acme LLC", - is_active: true, - website: "http://www.acme.com", - city: "Hong Kong", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil, - first_version_id: insert_company_result[:version].id, - current_version_id: update_company_result[:version].id - }, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "delete", + item_type: "StrictCompany", + item_id: old_company.id, + item_changes: %{ + id: old_company.id, + inserted_at: old_company.inserted_at, + updated_at: old_company.updated_at, + name: "Acme LLC", + is_active: true, + website: "http://www.acme.com", + city: "Hong Kong", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil, + first_version_id: insert_company_result[:version].id, + current_version_id: update_company_result[:version].id + }, + originator_id: user.id, + origin: nil, + meta: nil + } + assert old_company == company_before_deletion end test "PaperTrail.delete/2 with an error returns and error tuple like Repo.delete/2" do {:ok, insert_company_result} = create_company_with_version() + Person.changeset(%Person{}, %{ first_name: "Izel", last_name: "Nakri", gender: true, company_id: insert_company_result[:model].id - }) |> PaperTrail.insert - ecto_result = insert_company_result[:model] |> Company.changeset |> @repo.delete - result = insert_company_result[:model] |> Company.changeset |> PaperTrail.delete + }) + |> PaperTrail.insert() + + ecto_result = insert_company_result[:model] |> Company.changeset() |> @repo.delete + result = insert_company_result[:model] |> Company.changeset() |> PaperTrail.delete() assert result == ecto_result end test "creating a person with meta tag creates a person version with correct attributes" do create_company_with_version(%{name: "Acme LLC", website: "http://www.acme.com"}) - {:ok, insert_company_result} = create_company_with_version(%{ - name: "Another Company Corp.", - is_active: true, - address: "Sesame street 100/3, 101010" - }) - {:ok, result} = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: insert_company_result[:model].id - }) |> PaperTrail.insert(origin: "admin", meta: %{linkname: "izelnakri"}) + + {:ok, insert_company_result} = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + {:ok, result} = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: insert_company_result[:model].id + }) + |> PaperTrail.insert(origin: "admin", meta: %{linkname: "izelnakri"}) person_count = Person.count() version_count = Version.count() @@ -261,47 +304,62 @@ defmodule PaperTrailStrictModeTest do assert Map.keys(result) == [:model, :version] assert person_count == 1 assert version_count == 3 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - visit_count: nil, - birthdate: nil, - company_id: insert_company_result[:model].id, - first_version_id: result[:version].id, - current_version_id: result[:version].id - } + first_name: "Izel", + last_name: "Nakri", + gender: true, + visit_count: nil, + birthdate: nil, + company_id: insert_company_result[:model].id, + first_version_id: result[:version].id, + current_version_id: result[:version].id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "StrictPerson", - item_id: person.id, - item_changes: person, - originator_id: nil, - origin: "admin", - meta: %{linkname: "izelnakri"} - } + event: "insert", + item_type: "StrictPerson", + item_id: person.id, + item_changes: person, + originator_id: nil, + origin: "admin", + meta: %{linkname: "izelnakri"} + } + assert person == first(Person, :id) |> @repo.one |> serialize end test "updating a person creates a person version with correct attributes" do - {:ok, insert_company_result} = create_company_with_version(%{ - name: "Acme LLC", website: "http://www.acme.com" - }) - {:ok, target_company_insertion} = create_company_with_version(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - {:ok, insert_person_result} = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: target_company_insertion[:model].id - }) |> PaperTrail.insert(origin: "admin") - {:ok, result} = Person.changeset(insert_person_result[:model], %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: insert_company_result[:model].id - }) |> PaperTrail.update(origin: "scraper", meta: %{linkname: "izelnakri"}) + {:ok, insert_company_result} = + create_company_with_version(%{ + name: "Acme LLC", + website: "http://www.acme.com" + }) + + {:ok, target_company_insertion} = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + {:ok, insert_person_result} = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: target_company_insertion[:model].id + }) + |> PaperTrail.insert(origin: "admin") + + {:ok, result} = + Person.changeset(insert_person_result[:model], %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: insert_company_result[:model].id + }) + |> PaperTrail.update(origin: "scraper", meta: %{linkname: "izelnakri"}) person_count = Person.count() version_count = Version.count() @@ -312,54 +370,73 @@ defmodule PaperTrailStrictModeTest do assert Map.keys(result) == [:model, :version] assert person_count == 1 assert version_count == 4 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - company_id: insert_company_result[:model].id, - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), # this is the only problem - last_name: "Nakri", - gender: true, - first_version_id: insert_person_result[:version].id, - current_version_id: version.id - } + company_id: insert_company_result[:model].id, + first_name: "Isaac", + visit_count: 10, + # this is the only problem + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + last_name: "Nakri", + gender: true, + first_version_id: insert_person_result[:version].id, + current_version_id: version.id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "StrictPerson", - item_id: person.id, - item_changes: %{ - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - current_version_id: version.id, - company_id: insert_company_result[:model].id - }, - originator_id: nil, - origin: "scraper", - meta: %{linkname: "izelnakri"} - } + event: "update", + item_type: "StrictPerson", + item_id: person.id, + item_changes: %{ + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + current_version_id: version.id, + company_id: insert_company_result[:model].id + }, + originator_id: nil, + origin: "scraper", + meta: %{linkname: "izelnakri"} + } + assert person == first(Person, :id) |> @repo.one |> serialize end test "deleting a person creates a person version with correct attributes" do create_company_with_version(%{name: "Acme LLC", website: "http://www.acme.com"}) - {:ok, target_company_insertion} = create_company_with_version(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - {:ok, insert_person_result} = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: target_company_insertion[:model].id - }) |> PaperTrail.insert(origin: "admin") - {:ok, update_person_result} = Person.changeset(insert_person_result[:model], %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01] - }) |> PaperTrail.update(origin: "scraper", meta: %{linkname: "izelnakri"}) + + {:ok, target_company_insertion} = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + {:ok, insert_person_result} = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: target_company_insertion[:model].id + }) + |> PaperTrail.insert(origin: "admin") + + {:ok, update_person_result} = + Person.changeset(insert_person_result[:model], %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01] + }) + |> PaperTrail.update(origin: "scraper", meta: %{linkname: "izelnakri"}) + person_before_deletion = first(Person, :id) |> @repo.one |> serialize - {:ok, result} = PaperTrail.delete( - update_person_result[:model], origin: "admin", meta: %{linkname: "izelnakri"} - ) + + {:ok, result} = + PaperTrail.delete( + update_person_result[:model], + origin: "admin", + meta: %{linkname: "izelnakri"} + ) person_count = Person.count() version_count = Version.count() @@ -370,27 +447,29 @@ defmodule PaperTrailStrictModeTest do assert Map.keys(result) == [:model, :version] assert person_count == 0 assert version_count == 5 + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "StrictPerson", - item_id: old_person.id, - item_changes: %{ - id: old_person.id, - inserted_at: old_person.inserted_at, - updated_at: old_person.updated_at, - first_name: "Isaac", - last_name: "Nakri", - gender: true, - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: target_company_insertion[:model].id, - first_version_id: insert_person_result[:version].id, - current_version_id: update_person_result[:version].id - }, - originator_id: nil, - origin: "admin", - meta: %{linkname: "izelnakri"} - } + event: "delete", + item_type: "StrictPerson", + item_id: old_person.id, + item_changes: %{ + id: old_person.id, + inserted_at: old_person.inserted_at, + updated_at: old_person.updated_at, + first_name: "Isaac", + last_name: "Nakri", + gender: true, + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: target_company_insertion[:model].id, + first_version_id: insert_person_result[:version].id, + current_version_id: update_person_result[:version].id + }, + originator_id: nil, + origin: "admin", + meta: %{linkname: "izelnakri"} + } + assert old_person == person_before_deletion end @@ -402,7 +481,7 @@ defmodule PaperTrailStrictModeTest do Company.changeset(%Company{}, params) |> PaperTrail.insert(options) end - defp update_company_with_version(company, params \\ @update_company_params , options \\ nil) do + defp update_company_with_version(company, params \\ @update_company_params, options \\ nil) do Company.changeset(company, params) |> PaperTrail.update(options) end diff --git a/test/paper_trail_test.exs b/test/paper_trail_test.exs index 116a167b..56afeb64 100644 --- a/test/paper_trail_test.exs +++ b/test/paper_trail_test.exs @@ -7,9 +7,13 @@ defmodule PaperTrailTest do alias SimpleCompany, as: Company alias SimplePerson, as: Person - @repo PaperTrail.RepoClient.repo + @repo PaperTrail.RepoClient.repo() @create_company_params %{name: "Acme LLC", is_active: true, city: "Greenwich"} - @update_company_params %{city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc"} + @update_company_params %{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + } doctest PaperTrail @@ -25,11 +29,13 @@ defmodule PaperTrailTest do @repo.delete_all(Person) @repo.delete_all(Company) @repo.delete_all(Version) - on_exit fn -> + + on_exit(fn -> @repo.delete_all(Person) @repo.delete_all(Company) @repo.delete_all(Version) - end + end) + :ok end @@ -46,41 +52,51 @@ defmodule PaperTrailTest do assert Map.keys(result) == [:model, :version] assert company_count == 1 assert version_count == 1 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Greenwich", - website: nil, - address: nil, - facebook: nil, - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Greenwich", + website: nil, + address: nil, + facebook: nil, + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: company, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "insert", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: company, + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end test "PaperTrail.insert/2 with an error returns and error tuple like Repo.insert/2" do result = create_company_with_version(%{name: nil, is_active: true, city: "Greenwich"}) - ecto_result = Company.changeset(%Company{}, %{name: nil, is_active: true, city: "Greenwich"}) + + ecto_result = + Company.changeset(%Company{}, %{name: nil, is_active: true, city: "Greenwich"}) |> @repo.insert + assert result == ecto_result end test "updating a company with originator creates a correct company version" do user = create_user() {:ok, insert_result} = create_company_with_version() - {:ok, result} = update_company_with_version( - insert_result[:model], @update_company_params, user: user - ) + + {:ok, result} = + update_company_with_version( + insert_result[:model], + @update_company_params, + user: user + ) company_count = Company.count() version_count = Version.count() @@ -91,35 +107,45 @@ defmodule PaperTrailTest do assert Map.keys(result) == [:model, :version] assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: %{city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc"}, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: %{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }, + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end - test "updating a company with originator[user] creates a correct company version" do user = create_user() {:ok, insert_result} = create_company_with_version() - {:ok, result} = update_company_with_version( - insert_result[:model], @update_company_params, user: user - ) + + {:ok, result} = + update_company_with_version( + insert_result[:model], + @update_company_params, + user: user + ) company_count = Company.count() version_count = Version.count() @@ -130,37 +156,55 @@ defmodule PaperTrailTest do assert Map.keys(result) == [:model, :version] assert company_count == 1 assert version_count == 2 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: %{city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc"}, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "update", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: %{ + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }, + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == first(Company, :id) |> @repo.one |> serialize end test "PaperTrail.update/2 with an error returns and error tuple like Repo.update/2" do {:ok, insert_result} = create_company_with_version() company = insert_result[:model] - result = update_company_with_version(company, %{ - name: nil, city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }) - ecto_result = Company.changeset(company, %{ - name: nil, city: "Hong Kong", website: "http://www.acme.com", facebook: "acme.llc" - }) |> @repo.update + + result = + update_company_with_version(company, %{ + name: nil, + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }) + + ecto_result = + Company.changeset(company, %{ + name: nil, + city: "Hong Kong", + website: "http://www.acme.com", + facebook: "acme.llc" + }) + |> @repo.update assert result == ecto_result end @@ -181,67 +225,79 @@ defmodule PaperTrailTest do assert Map.keys(result) == [:model, :version] assert company_count == 0 assert version_count == 3 + assert Map.drop(company, [:id, :inserted_at, :updated_at]) == %{ - name: "Acme LLC", - is_active: true, - city: "Hong Kong", - website: "http://www.acme.com", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - } + name: "Acme LLC", + is_active: true, + city: "Hong Kong", + website: "http://www.acme.com", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "SimpleCompany", - item_id: company.id, - item_changes: %{ - id: company.id, - inserted_at: company.inserted_at, - updated_at: company.updated_at, - name: "Acme LLC", - is_active: true, - website: "http://www.acme.com", - city: "Hong Kong", - address: nil, - facebook: "acme.llc", - twitter: nil, - founded_in: nil - }, - originator_id: user.id, - origin: nil, - meta: nil - } + event: "delete", + item_type: "SimpleCompany", + item_id: company.id, + item_changes: %{ + id: company.id, + inserted_at: company.inserted_at, + updated_at: company.updated_at, + name: "Acme LLC", + is_active: true, + website: "http://www.acme.com", + city: "Hong Kong", + address: nil, + facebook: "acme.llc", + twitter: nil, + founded_in: nil + }, + originator_id: user.id, + origin: nil, + meta: nil + } + assert company == company_before_deletion end test "PaperTrail.delete/2 with an error returns and error tuple like Repo.delete/2" do {:ok, insert_company_result} = create_company_with_version() + Person.changeset(%Person{}, %{ first_name: "Izel", last_name: "Nakri", gender: true, company_id: insert_company_result[:model].id - }) |> PaperTrail.insert - ecto_result = insert_company_result[:model] |> Company.changeset |> @repo.delete - result = insert_company_result[:model] |> Company.changeset |> PaperTrail.delete + }) + |> PaperTrail.insert() + + ecto_result = insert_company_result[:model] |> Company.changeset() |> @repo.delete + result = insert_company_result[:model] |> Company.changeset() |> PaperTrail.delete() assert result == ecto_result end test "creating a person with meta tag creates a person version with correct attributes" do create_company_with_version() - {:ok, new_company_result} = Company.changeset(%Company{}, %{ - name: "Another Company Corp.", - is_active: true, - address: "Sesame street 100/3, 101010" - }) |> PaperTrail.insert - {:ok, result} = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: new_company_result[:model].id - }) |> PaperTrail.insert(origin: "admin", meta: %{linkname: "izelnakri"}) + + {:ok, new_company_result} = + Company.changeset(%Company{}, %{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + |> PaperTrail.insert() + + {:ok, result} = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: new_company_result[:model].id + }) + |> PaperTrail.insert(origin: "admin", meta: %{linkname: "izelnakri"}) person_count = Person.count() version_count = Version.count() @@ -252,45 +308,60 @@ defmodule PaperTrailTest do assert Map.keys(result) == [:model, :version] assert person_count == 1 assert version_count == 3 - assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - visit_count: nil, - birthdate: nil, - company_id: new_company_result[:model].id - } + + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + visit_count: nil, + birthdate: nil, + company_id: new_company_result[:model].id + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "insert", - item_type: "SimplePerson", - item_id: person.id, - item_changes: person, - originator_id: nil, - origin: "admin", - meta: %{linkname: "izelnakri"} - } + event: "insert", + item_type: "SimplePerson", + item_id: person.id, + item_changes: person, + originator_id: nil, + origin: "admin", + meta: %{linkname: "izelnakri"} + } + assert person == first(Person, :id) |> @repo.one |> serialize end test "updating a person creates a person version with correct attributes" do - {:ok, initial_company_insertion} = create_company_with_version(%{ - name: "Acme LLC", website: "http://www.acme.com" - }) - {:ok, target_company_insertion} = create_company_with_version(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - {:ok, insert_person_result} = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: target_company_insertion[:model].id - }) |> PaperTrail.insert(origin: "admin") - {:ok, result} = Person.changeset(insert_person_result[:model], %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: initial_company_insertion[:model].id - }) |> PaperTrail.update(origin: "scraper", meta: %{linkname: "izelnakri"}) + {:ok, initial_company_insertion} = + create_company_with_version(%{ + name: "Acme LLC", + website: "http://www.acme.com" + }) + + {:ok, target_company_insertion} = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + {:ok, insert_person_result} = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: target_company_insertion[:model].id + }) + |> PaperTrail.insert(origin: "admin") + + {:ok, result} = + Person.changeset(insert_person_result[:model], %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: initial_company_insertion[:model].id + }) + |> PaperTrail.update(origin: "scraper", meta: %{linkname: "izelnakri"}) person_count = Person.count() version_count = Version.count() @@ -301,52 +372,71 @@ defmodule PaperTrailTest do assert Map.keys(result) == [:model, :version] assert person_count == 1 assert version_count == 4 + assert Map.drop(person, [:id, :inserted_at, :updated_at]) == %{ - company_id: initial_company_insertion[:model].id, - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - last_name: "Nakri", - gender: true - } + company_id: initial_company_insertion[:model].id, + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + last_name: "Nakri", + gender: true + } + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "update", - item_type: "SimplePerson", - item_id: person.id, - item_changes: %{ - first_name: "Isaac", - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: initial_company_insertion[:model].id - }, - originator_id: nil, - origin: "scraper", - meta: %{linkname: "izelnakri"} - } + event: "update", + item_type: "SimplePerson", + item_id: person.id, + item_changes: %{ + first_name: "Isaac", + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: initial_company_insertion[:model].id + }, + originator_id: nil, + origin: "scraper", + meta: %{linkname: "izelnakri"} + } + assert person == first(Person, :id) |> @repo.one |> serialize end test "deleting a person creates a person version with correct attributes" do create_company_with_version(%{name: "Acme LLC", website: "http://www.acme.com"}) - {:ok, target_company_insertion} = create_company_with_version(%{ - name: "Another Company Corp.", is_active: true, address: "Sesame street 100/3, 101010" - }) - {:ok, insert_person_result} = Person.changeset(%Person{}, %{ - first_name: "Izel", - last_name: "Nakri", - gender: true, - company_id: target_company_insertion[:model].id - }) |> PaperTrail.insert(origin: "admin") # add link name later on - {:ok, update_result} = Person.changeset(insert_person_result[:model], %{ - first_name: "Isaac", - visit_count: 10, - birthdate: ~D[1992-04-01], - company_id: target_company_insertion[:model].id - }) |> PaperTrail.update(origin: "scraper", meta: %{linkname: "izelnakri"}) + + {:ok, target_company_insertion} = + create_company_with_version(%{ + name: "Another Company Corp.", + is_active: true, + address: "Sesame street 100/3, 101010" + }) + + # add link name later on + {:ok, insert_person_result} = + Person.changeset(%Person{}, %{ + first_name: "Izel", + last_name: "Nakri", + gender: true, + company_id: target_company_insertion[:model].id + }) + |> PaperTrail.insert(origin: "admin") + + {:ok, update_result} = + Person.changeset(insert_person_result[:model], %{ + first_name: "Isaac", + visit_count: 10, + birthdate: ~D[1992-04-01], + company_id: target_company_insertion[:model].id + }) + |> PaperTrail.update(origin: "scraper", meta: %{linkname: "izelnakri"}) + person_before_deletion = first(Person, :id) |> @repo.one |> serialize - {:ok, result} = PaperTrail.delete( - update_result[:model], origin: "admin", meta: %{linkname: "izelnakri"} - ) + + {:ok, result} = + PaperTrail.delete( + update_result[:model], + origin: "admin", + meta: %{linkname: "izelnakri"} + ) person_count = Person.count() version_count = Version.count() @@ -357,25 +447,27 @@ defmodule PaperTrailTest do assert person_count == 0 assert version_count == 5 + assert Map.drop(version, [:id, :inserted_at]) == %{ - event: "delete", - item_type: "SimplePerson", - item_id: old_person.id, - item_changes: %{ - id: old_person.id, - inserted_at: old_person.inserted_at, - updated_at: old_person.updated_at, - first_name: "Isaac", - last_name: "Nakri", - gender: true, - visit_count: 10, - birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), - company_id: target_company_insertion[:model].id - }, - originator_id: nil, - origin: "admin", - meta: %{linkname: "izelnakri"} - } + event: "delete", + item_type: "SimplePerson", + item_id: old_person.id, + item_changes: %{ + id: old_person.id, + inserted_at: old_person.inserted_at, + updated_at: old_person.updated_at, + first_name: "Isaac", + last_name: "Nakri", + gender: true, + visit_count: 10, + birthdate: elem(Ecto.Date.cast(~D[1992-04-01]), 1), + company_id: target_company_insertion[:model].id + }, + originator_id: nil, + origin: "admin", + meta: %{linkname: "izelnakri"} + } + assert old_person == person_before_deletion end diff --git a/test/support/repos.ex b/test/support/repos.ex index af70cb12..ad83afa2 100644 --- a/test/support/repos.ex +++ b/test/support/repos.ex @@ -12,8 +12,8 @@ defmodule User do import Ecto.Changeset schema "users" do - field :token, :string - field :username, :string + field(:token, :string) + field(:username, :string) timestamps() end diff --git a/test/support/simple_models.exs b/test/support/simple_models.exs index c9846008..db962564 100644 --- a/test/support/simple_models.exs +++ b/test/support/simple_models.exs @@ -7,16 +7,16 @@ defmodule SimpleCompany do import Ecto.Query schema "simple_companies" do - field :name, :string - field :is_active, :boolean - field :website, :string - field :city, :string - field :address, :string - field :facebook, :string - field :twitter, :string - field :founded_in, :string + field(:name, :string) + field(:is_active, :boolean) + field(:website, :string) + field(:city, :string) + field(:address, :string) + field(:facebook, :string) + field(:twitter, :string) + field(:founded_in, :string) - has_many :people, SimplePerson, foreign_key: :company_id + has_many(:people, SimplePerson, foreign_key: :company_id) timestamps() end @@ -31,12 +31,13 @@ defmodule SimpleCompany do end def count do - from(record in __MODULE__, select: count(record.id)) |> PaperTrail.RepoClient.repo.one + from(record in __MODULE__, select: count(record.id)) |> PaperTrail.RepoClient.repo().one end + def count(:multitenant) do from(record in __MODULE__, select: count(record.id)) |> MultiTenant.add_prefix_to_query() - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end end @@ -49,13 +50,13 @@ defmodule SimplePerson do import Ecto.Query schema "simple_people" do - field :first_name, :string - field :last_name, :string - field :visit_count, :integer - field :gender, :boolean - field :birthdate, Ecto.Date + field(:first_name, :string) + field(:last_name, :string) + field(:visit_count, :integer) + field(:gender, :boolean) + field(:birthdate, Ecto.Date) - belongs_to :company, SimpleCompany, foreign_key: :company_id + belongs_to(:company, SimpleCompany, foreign_key: :company_id) timestamps() end @@ -69,11 +70,12 @@ defmodule SimplePerson do end def count do - from(record in __MODULE__, select: count(record.id)) |> PaperTrail.RepoClient.repo.one + from(record in __MODULE__, select: count(record.id)) |> PaperTrail.RepoClient.repo().one end + def count(:multitenant) do from(record in __MODULE__, select: count(record.id)) |> MultiTenant.add_prefix_to_query() - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end end diff --git a/test/support/strict_models.exs b/test/support/strict_models.exs index 2217b994..39e1918b 100644 --- a/test/support/strict_models.exs +++ b/test/support/strict_models.exs @@ -7,19 +7,19 @@ defmodule StrictCompany do import Ecto.Query schema "strict_companies" do - field :name, :string - field :is_active, :boolean - field :website, :string - field :city, :string - field :address, :string - field :facebook, :string - field :twitter, :string - field :founded_in, :string + field(:name, :string) + field(:is_active, :boolean) + field(:website, :string) + field(:city, :string) + field(:address, :string) + field(:facebook, :string) + field(:twitter, :string) + field(:founded_in, :string) - belongs_to :first_version, PaperTrail.Version - belongs_to :current_version, PaperTrail.Version, on_replace: :update + belongs_to(:first_version, PaperTrail.Version) + belongs_to(:current_version, PaperTrail.Version, on_replace: :update) - has_many :people, StrictPerson, foreign_key: :company_id + has_many(:people, StrictPerson, foreign_key: :company_id) timestamps() end @@ -34,12 +34,13 @@ defmodule StrictCompany do end def count do - from(record in __MODULE__, select: count(record.id)) |> PaperTrail.RepoClient.repo.one + from(record in __MODULE__, select: count(record.id)) |> PaperTrail.RepoClient.repo().one end + def count(:multitenant) do from(record in __MODULE__, select: count(record.id)) |> MultiTenant.add_prefix_to_query() - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end end @@ -52,15 +53,15 @@ defmodule StrictPerson do import Ecto.Query schema "strict_people" do - field :first_name, :string - field :last_name, :string - field :visit_count, :integer - field :gender, :boolean - field :birthdate, Ecto.Date + field(:first_name, :string) + field(:last_name, :string) + field(:visit_count, :integer) + field(:gender, :boolean) + field(:birthdate, Ecto.Date) - belongs_to :first_version, PaperTrail.Version - belongs_to :current_version, PaperTrail.Version, on_replace: :update - belongs_to :company, StrictCompany, foreign_key: :company_id + belongs_to(:first_version, PaperTrail.Version) + belongs_to(:current_version, PaperTrail.Version, on_replace: :update) + belongs_to(:company, StrictCompany, foreign_key: :company_id) timestamps() end @@ -74,11 +75,12 @@ defmodule StrictPerson do end def count do - from(record in __MODULE__, select: count(record.id)) |> PaperTrail.RepoClient.repo.one + from(record in __MODULE__, select: count(record.id)) |> PaperTrail.RepoClient.repo().one end + def count(:multitenant) do from(record in __MODULE__, select: count(record.id)) |> MultiTenant.add_prefix_to_query() - |> PaperTrail.RepoClient.repo.one + |> PaperTrail.RepoClient.repo().one end end diff --git a/test/support/uuid_models.exs b/test/support/uuid_models.exs index e58ac793..635ce457 100644 --- a/test/support/uuid_models.exs +++ b/test/support/uuid_models.exs @@ -5,7 +5,7 @@ defmodule Product do @primary_key {:id, :binary_id, autogenerate: true} schema "products" do - field :name, :string + field(:name, :string) timestamps() end @@ -23,7 +23,7 @@ defmodule Admin do @primary_key {:id, :binary_id, autogenerate: true} schema "admins" do - field :email, :string + field(:email, :string) timestamps() end diff --git a/test/test_helper.exs b/test/test_helper.exs index badc1e80..3a451e9a 100644 --- a/test/test_helper.exs +++ b/test/test_helper.exs @@ -1,14 +1,14 @@ -Mix.Task.run "ecto.create" -Mix.Task.run "ecto.migrate" +Mix.Task.run("ecto.create") +Mix.Task.run("ecto.migrate") -PaperTrail.Repo.start_link -PaperTrail.UUIDRepo.start_link +PaperTrail.Repo.start_link() +PaperTrail.UUIDRepo.start_link() Code.require_file("test/support/simple_models.exs") Code.require_file("test/support/strict_models.exs") Code.require_file("test/support/uuid_models.exs") Code.require_file("test/support/multi_tenant_helper.exs") -ExUnit.configure seed: 0 +ExUnit.configure(seed: 0) ExUnit.start() From a0f5dbf7668f0146a473d1700331f6f3b45258d4 Mon Sep 17 00:00:00 2001 From: devvit Date: Fri, 16 Feb 2018 17:06:26 +0800 Subject: [PATCH 2/3] fixed for non-regular primary key --- lib/paper_trail.ex | 14 +++++++++++--- lib/paper_trail/version_queries.ex | 4 ++-- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/lib/paper_trail.ex b/lib/paper_trail.ex index 513c8be4..d07d60ec 100644 --- a/lib/paper_trail.ex +++ b/lib/paper_trail.ex @@ -302,7 +302,7 @@ defmodule PaperTrail do %Version{ event: "insert", item_type: model.__struct__ |> Module.split() |> List.last(), - item_id: model.id, + item_id: get_model_id(model), item_changes: serialize(model), originator_id: case originator_ref do @@ -322,7 +322,7 @@ defmodule PaperTrail do %Version{ event: "update", item_type: changeset.data.__struct__ |> Module.split() |> List.last(), - item_id: changeset.data.id, + item_id: get_model_id_from_changeset(changeset), item_changes: changeset.changes, originator_id: case originator_ref do @@ -342,7 +342,7 @@ defmodule PaperTrail do %Version{ event: "delete", item_type: model.__struct__ |> Module.split() |> List.last(), - item_id: model.id, + item_id: get_model_id(model), item_changes: serialize(model), originator_id: case originator_ref do @@ -378,4 +378,12 @@ defmodule PaperTrail do defp add_prefix(changeset, nil), do: changeset defp add_prefix(changeset, prefix), do: Ecto.put_meta(changeset, prefix: prefix) + + def get_model_id(model) do + Map.get(model, List.first(model.__struct__.__schema__(:primary_key))) + end + + def get_model_id_from_changeset(changeset) do + get_model_id(changeset.data) + end end diff --git a/lib/paper_trail/version_queries.ex b/lib/paper_trail/version_queries.ex index 22a4cd74..d755a9e7 100644 --- a/lib/paper_trail/version_queries.ex +++ b/lib/paper_trail/version_queries.ex @@ -30,7 +30,7 @@ defmodule PaperTrail.VersionQueries do @spec get_versions(record :: Ecto.Schema.t(), options :: []) :: Ecto.Query.t() def get_versions(record, options) when is_map(record) do item_type = record.__struct__ |> Module.split() |> List.last() - version_query(item_type, record.id, options) |> @repo.all + version_query(item_type, PaperTrail.get_model_id(record), options) |> @repo.all end @doc """ @@ -75,7 +75,7 @@ defmodule PaperTrail.VersionQueries do @spec get_version(record :: Ecto.Schema.t(), options :: []) :: Ecto.Query.t() def get_version(record, options) when is_map(record) do item_type = record.__struct__ |> Module.split() |> List.last() - last(version_query(item_type, record.id, options)) |> @repo.one + last(version_query(item_type, PaperTrail.get_model_id(record), options)) |> @repo.one end @doc """ From 2ced4a299577531363a880be40bcdee16ab08959 Mon Sep 17 00:00:00 2001 From: devvit Date: Sat, 17 Feb 2018 02:52:59 +0800 Subject: [PATCH 3/3] fixed for non-regular primary key with test --- lib/paper_trail.ex | 6 +----- .../20170525133833_create_uuid_products.exs | 7 +++++++ test/paper_trail/uuid_test.exs | 11 +++++++++++ test/support/uuid_models.exs | 18 ++++++++++++++++++ 4 files changed, 37 insertions(+), 5 deletions(-) diff --git a/lib/paper_trail.ex b/lib/paper_trail.ex index d07d60ec..ee099e97 100644 --- a/lib/paper_trail.ex +++ b/lib/paper_trail.ex @@ -322,7 +322,7 @@ defmodule PaperTrail do %Version{ event: "update", item_type: changeset.data.__struct__ |> Module.split() |> List.last(), - item_id: get_model_id_from_changeset(changeset), + item_id: get_model_id(changeset.data), item_changes: changeset.changes, originator_id: case originator_ref do @@ -382,8 +382,4 @@ defmodule PaperTrail do def get_model_id(model) do Map.get(model, List.first(model.__struct__.__schema__(:primary_key))) end - - def get_model_id_from_changeset(changeset) do - get_model_id(changeset.data) - end end diff --git a/priv/uuid_repo/migrations/20170525133833_create_uuid_products.exs b/priv/uuid_repo/migrations/20170525133833_create_uuid_products.exs index f14a5820..579685ba 100644 --- a/priv/uuid_repo/migrations/20170525133833_create_uuid_products.exs +++ b/priv/uuid_repo/migrations/20170525133833_create_uuid_products.exs @@ -8,5 +8,12 @@ defmodule PaperTrail.UUIDRepo.Migrations.CreateUuidProducts do timestamps() end + + create table(:items, primary_key: false) do + add :item_id, :binary_id, primary_key: true + add :title, :string, null: false + + timestamps() + end end end diff --git a/test/paper_trail/uuid_test.exs b/test/paper_trail/uuid_test.exs index a4f67f65..8947680e 100644 --- a/test/paper_trail/uuid_test.exs +++ b/test/paper_trail/uuid_test.exs @@ -14,6 +14,7 @@ defmodule PaperTrailTest.UUIDTest do repo().delete_all(Version) repo().delete_all(Admin) repo().delete_all(Product) + repo().delete_all(Item) :ok end @@ -47,4 +48,14 @@ defmodule PaperTrailTest.UUIDTest do assert version.admin == admin end + + test "versioning models that have a non-regular primary key" do + item = + %Item{} + |> Item.changeset(%{title: "hello"}) + |> PaperTrail.insert!() + + version = Version |> last |> repo().one + assert version.item_id == item.item_id + end end diff --git a/test/support/uuid_models.exs b/test/support/uuid_models.exs index 635ce457..92d09373 100644 --- a/test/support/uuid_models.exs +++ b/test/support/uuid_models.exs @@ -34,3 +34,21 @@ defmodule Admin do |> validate_required([:email]) end end + +defmodule Item do + use Ecto.Schema + import Ecto.Changeset + + @primary_key {:item_id, :binary_id, autogenerate: true} + schema "items" do + field(:title, :string) + + timestamps() + end + + def changeset(model, params \\ %{}) do + model + |> cast(params, [:title]) + |> validate_required(:title) + end +end