From bab2b26c13f2dfba3439086a48390aef857bc0de Mon Sep 17 00:00:00 2001 From: shibao Date: Tue, 28 Mar 2023 21:57:29 -0400 Subject: [PATCH] use atom keys in tests --- CHANGELOG.md | 3 + lib/cannery/ammo.ex | 36 ++- priv/gettext/de/LC_MESSAGES/errors.po | 2 +- priv/gettext/en/LC_MESSAGES/errors.po | 2 +- priv/gettext/errors.pot | 2 +- priv/gettext/es/LC_MESSAGES/errors.po | 2 +- priv/gettext/fr/LC_MESSAGES/errors.po | 2 +- priv/gettext/ga/LC_MESSAGES/errors.po | 2 +- test/cannery/accounts/invites_test.exs | 33 +- test/cannery/accounts_test.exs | 57 ++-- test/cannery/activity_log_test.exs | 79 +++-- test/cannery/ammo_test.exs | 283 +++++++++--------- test/cannery/containers_test.exs | 72 ++--- .../controllers/user_auth_test.exs | 3 +- .../user_confirmation_controller_test.exs | 44 +-- .../user_registration_controller_test.exs | 13 +- .../user_reset_password_controller_test.exs | 49 ++- .../user_session_controller_test.exs | 31 +- .../user_settings_controller_test.exs | 71 ++--- .../cannery_web/live/ammo_group_live_test.exs | 276 ++++++++--------- test/cannery_web/live/ammo_type_live_test.exs | 147 +++++---- test/cannery_web/live/container_live_test.exs | 138 ++++----- test/cannery_web/live/home_live_test.exs | 5 +- test/cannery_web/live/invite_live_test.exs | 48 ++- test/cannery_web/live/range_live_test.exs | 70 ++--- test/cannery_web/live/tag_live_test.exs | 72 ++--- test/cannery_web/views/error_view_test.exs | 7 +- test/support/fixtures.ex | 32 +- 28 files changed, 720 insertions(+), 861 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8005045b..a946c2b4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,6 @@ +# v0.9.1 +- Code quality improvements + # v0.9.0 - Add length limits to all string fields - Add selectable ammo types diff --git a/lib/cannery/ammo.ex b/lib/cannery/ammo.ex index 63868ad1..1ee65e09 100644 --- a/lib/cannery/ammo.ex +++ b/lib/cannery/ammo.ex @@ -1055,13 +1055,21 @@ defmodule Cannery.Ammo do @spec create_ammo_groups(attrs :: map(), multiplier :: non_neg_integer(), User.t()) :: {:ok, {count :: non_neg_integer(), [AmmoGroup.t()] | nil}} | {:error, AmmoGroup.changeset()} - def create_ammo_groups( - %{"ammo_type_id" => ammo_type_id, "container_id" => container_id} = attrs, - multiplier, - %User{} = user - ) - when multiplier >= 1 and multiplier <= @ammo_group_create_limit and - not (ammo_type_id |> is_nil()) and not (container_id |> is_nil()) do + def create_ammo_groups(attrs, multiplier, %User{} = user) do + attrs + |> Map.new(fn {k, v} -> {to_string(k), v} end) + |> do_create_ammo_groups(multiplier, user) + end + + defp do_create_ammo_groups( + %{"ammo_type_id" => ammo_type_id, "container_id" => container_id} = attrs, + multiplier, + user + ) + when multiplier >= 1 and + multiplier <= @ammo_group_create_limit and + ammo_type_id |> is_binary() and + container_id |> is_binary() do now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second) changesets = @@ -1097,12 +1105,12 @@ defmodule Cannery.Ammo do end end - def create_ammo_groups( - %{"ammo_type_id" => ammo_type_id, "container_id" => container_id} = attrs, - _multiplier, - user - ) - when is_binary(ammo_type_id) and is_binary(container_id) do + defp do_create_ammo_groups( + %{"ammo_type_id" => ammo_type_id, "container_id" => container_id} = attrs, + _multiplier, + user + ) + when is_binary(ammo_type_id) and is_binary(container_id) do changeset = %AmmoGroup{} |> AmmoGroup.create_changeset( @@ -1116,7 +1124,7 @@ defmodule Cannery.Ammo do {:error, changeset} end - def create_ammo_groups(invalid_attrs, _multiplier, user) do + defp do_create_ammo_groups(invalid_attrs, _multiplier, user) do {:error, %AmmoGroup{} |> AmmoGroup.create_changeset(nil, nil, user, invalid_attrs)} end diff --git a/priv/gettext/de/LC_MESSAGES/errors.po b/priv/gettext/de/LC_MESSAGES/errors.po index e5708973..12f7c0c1 100644 --- a/priv/gettext/de/LC_MESSAGES/errors.po +++ b/priv/gettext/de/LC_MESSAGES/errors.po @@ -173,7 +173,7 @@ msgstr "" "Ungültige Nummer an Kopien. Muss zwischen 1 and %{max} liegen. War " "%{multiplier}" -#: lib/cannery/ammo.ex:1114 +#: lib/cannery/ammo.ex:1122 #, elixir-autogen, elixir-format msgid "Invalid multiplier" msgstr "" diff --git a/priv/gettext/en/LC_MESSAGES/errors.po b/priv/gettext/en/LC_MESSAGES/errors.po index 1e52b747..75f6267b 100644 --- a/priv/gettext/en/LC_MESSAGES/errors.po +++ b/priv/gettext/en/LC_MESSAGES/errors.po @@ -156,7 +156,7 @@ msgstr "" msgid "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}" msgstr "" -#: lib/cannery/ammo.ex:1114 +#: lib/cannery/ammo.ex:1122 #, elixir-autogen, elixir-format msgid "Invalid multiplier" msgstr "" diff --git a/priv/gettext/errors.pot b/priv/gettext/errors.pot index a5d4148f..9dfd0766 100644 --- a/priv/gettext/errors.pot +++ b/priv/gettext/errors.pot @@ -155,7 +155,7 @@ msgstr "" msgid "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}" msgstr "" -#: lib/cannery/ammo.ex:1114 +#: lib/cannery/ammo.ex:1122 #, elixir-autogen, elixir-format msgid "Invalid multiplier" msgstr "" diff --git a/priv/gettext/es/LC_MESSAGES/errors.po b/priv/gettext/es/LC_MESSAGES/errors.po index c2246940..4fe04def 100644 --- a/priv/gettext/es/LC_MESSAGES/errors.po +++ b/priv/gettext/es/LC_MESSAGES/errors.po @@ -171,7 +171,7 @@ msgstr "No se ha podido procesar el número de copias" msgid "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}" msgstr "Número inválido de copias, debe ser entre 1 y %{max}. Fue %{multiplier" -#: lib/cannery/ammo.ex:1114 +#: lib/cannery/ammo.ex:1122 #, elixir-autogen, elixir-format msgid "Invalid multiplier" msgstr "Multiplicador inválido" diff --git a/priv/gettext/fr/LC_MESSAGES/errors.po b/priv/gettext/fr/LC_MESSAGES/errors.po index dade1975..294b690a 100644 --- a/priv/gettext/fr/LC_MESSAGES/errors.po +++ b/priv/gettext/fr/LC_MESSAGES/errors.po @@ -172,7 +172,7 @@ msgstr "Impossible d'analyser le nombre de copies" msgid "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}" msgstr "Nombre de copies invalide, doit être 1 et %{max}. Été %{multiplier}" -#: lib/cannery/ammo.ex:1114 +#: lib/cannery/ammo.ex:1122 #, elixir-autogen, elixir-format msgid "Invalid multiplier" msgstr "Multiplicateur invalide" diff --git a/priv/gettext/ga/LC_MESSAGES/errors.po b/priv/gettext/ga/LC_MESSAGES/errors.po index 9a661eaa..f53c65d6 100644 --- a/priv/gettext/ga/LC_MESSAGES/errors.po +++ b/priv/gettext/ga/LC_MESSAGES/errors.po @@ -171,7 +171,7 @@ msgstr "" msgid "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}" msgstr "" -#: lib/cannery/ammo.ex:1114 +#: lib/cannery/ammo.ex:1122 #, elixir-autogen, elixir-format msgid "Invalid multiplier" msgstr "" diff --git a/test/cannery/accounts/invites_test.exs b/test/cannery/accounts/invites_test.exs index b93fd7f7..2bdbd8be 100644 --- a/test/cannery/accounts/invites_test.exs +++ b/test/cannery/accounts/invites_test.exs @@ -11,11 +11,11 @@ defmodule Cannery.InvitesTest do @moduletag :invites_test @valid_attrs %{ - "name" => "some name" + name: "some name" } @invalid_attrs %{ - "name" => nil, - "token" => nil + name: nil, + token: nil } describe "invites" do @@ -57,7 +57,7 @@ defmodule Cannery.InvitesTest do assert {:ok, _user} = Accounts.register_user( - %{"email" => unique_user_email(), "password" => valid_user_password()}, + %{email: unique_user_email(), password: valid_user_password()}, token ) @@ -65,7 +65,7 @@ defmodule Cannery.InvitesTest do assert {:ok, _user} = Accounts.register_user( - %{"email" => unique_user_email(), "password" => valid_user_password()}, + %{email: unique_user_email(), password: valid_user_password()}, token ) @@ -81,13 +81,13 @@ defmodule Cannery.InvitesTest do assert {:ok, _user} = Accounts.register_user( - %{"email" => unique_user_email(), "password" => valid_user_password()}, + %{email: unique_user_email(), password: valid_user_password()}, token ) assert {:ok, _user} = Accounts.register_user( - %{"email" => unique_user_email(), "password" => valid_user_password()}, + %{email: unique_user_email(), password: valid_user_password()}, another_token ) @@ -97,7 +97,7 @@ defmodule Cannery.InvitesTest do assert {:ok, _user} = Accounts.register_user( - %{"email" => unique_user_email(), "password" => valid_user_password()}, + %{email: unique_user_email(), password: valid_user_password()}, token ) @@ -138,21 +138,14 @@ defmodule Cannery.InvitesTest do test "create_invite/1 with valid data creates an unlimited invite", %{current_user: current_user} do - assert {:ok, %Invite{} = invite} = - Invites.create_invite(current_user, %{ - "name" => "some name" - }) - + assert {:ok, %Invite{} = invite} = Invites.create_invite(current_user, %{name: "some name"}) assert invite.name == "some name" end test "create_invite/1 with valid data creates a limited invite", %{current_user: current_user} do assert {:ok, %Invite{} = invite} = - Invites.create_invite(current_user, %{ - "name" => "some name", - "uses_left" => 10 - }) + Invites.create_invite(current_user, %{name: "some name", uses_left: 10}) assert invite.name == "some name" assert invite.uses_left == 10 @@ -168,7 +161,7 @@ defmodule Cannery.InvitesTest do assert {:ok, %Invite{} = new_invite} = Invites.update_invite( invite, - %{"name" => "some updated name", "uses_left" => 5}, + %{name: "some updated name", uses_left: 5}, current_user ) @@ -178,12 +171,12 @@ defmodule Cannery.InvitesTest do test "update_invite/2 can set an invite to be unlimited", %{invite: invite, current_user: current_user} do - {:ok, invite} = Invites.update_invite(invite, %{"uses_left" => 5}, current_user) + {:ok, invite} = Invites.update_invite(invite, %{uses_left: 5}, current_user) assert {:ok, %Invite{} = new_invite} = Invites.update_invite( invite, - %{"name" => "some updated name", "uses_left" => nil}, + %{name: "some updated name", uses_left: nil}, current_user ) diff --git a/test/cannery/accounts_test.exs b/test/cannery/accounts_test.exs index 074a8b77..6fc82e62 100644 --- a/test/cannery/accounts_test.exs +++ b/test/cannery/accounts_test.exs @@ -63,8 +63,7 @@ defmodule Cannery.AccountsTest do end test "validates email and password when given" do - {:error, changeset} = - Accounts.register_user(%{"email" => "not valid", "password" => "not valid"}) + {:error, changeset} = Accounts.register_user(%{email: "not valid", password: "not valid"}) assert %{ email: ["must have the @ sign and no spaces"], @@ -74,26 +73,25 @@ defmodule Cannery.AccountsTest do test "validates maximum values for email and password for security" do too_long = String.duplicate("db", 100) - {:error, changeset} = Accounts.register_user(%{"email" => too_long, "password" => too_long}) + {:error, changeset} = Accounts.register_user(%{email: too_long, password: too_long}) assert "should be at most 160 character(s)" in errors_on(changeset).email assert "should be at most 80 character(s)" in errors_on(changeset).password end test "validates email uniqueness" do %{email: email} = user_fixture() - {:error, changeset} = Accounts.register_user(%{"email" => email}) + {:error, changeset} = Accounts.register_user(%{email: email}) assert "has already been taken" in errors_on(changeset).email # Now try with the upper cased email too, to check that email case is ignored. - {:error, changeset} = Accounts.register_user(%{"email" => String.upcase(email)}) + {:error, changeset} = Accounts.register_user(%{email: String.upcase(email)}) assert "has already been taken" in errors_on(changeset).email end test "registers users with a hashed password" do email = unique_user_email() - {:ok, user} = - Accounts.register_user(%{"email" => email, "password" => valid_user_password()}) + {:ok, user} = Accounts.register_user(%{email: email, password: valid_user_password()}) assert user.email == email assert is_binary(user.hashed_password) @@ -103,11 +101,11 @@ defmodule Cannery.AccountsTest do test "records used invite during registration" do {:ok, %{id: invite_id, token: token}} = - admin_fixture() |> Invites.create_invite(%{"name" => "my invite"}) + admin_fixture() |> Invites.create_invite(%{name: "my invite"}) assert {:ok, %{invite_id: ^invite_id}} = Accounts.register_user( - %{"email" => unique_user_email(), "password" => valid_user_password()}, + %{email: unique_user_email(), password: valid_user_password()}, token ) end @@ -123,7 +121,7 @@ defmodule Cannery.AccountsTest do email = unique_user_email() password = valid_user_password() - changeset = Accounts.change_user_registration(%{"email" => email, "password" => password}) + changeset = Accounts.change_user_registration(%{email: email, password: password}) assert changeset.valid? assert get_change(changeset, :email) == email @@ -151,7 +149,7 @@ defmodule Cannery.AccountsTest do test "validates email", %{user: user} do {:error, changeset} = - Accounts.apply_user_email(user, valid_user_password(), %{"email" => "not valid"}) + Accounts.apply_user_email(user, valid_user_password(), %{email: "not valid"}) assert %{email: ["must have the @ sign and no spaces"]} = errors_on(changeset) end @@ -160,7 +158,7 @@ defmodule Cannery.AccountsTest do too_long = String.duplicate("db", 100) {:error, changeset} = - Accounts.apply_user_email(user, valid_user_password(), %{"email" => too_long}) + Accounts.apply_user_email(user, valid_user_password(), %{email: too_long}) assert "should be at most 160 character(s)" in errors_on(changeset).email end @@ -169,21 +167,21 @@ defmodule Cannery.AccountsTest do %{email: email} = user_fixture() {:error, changeset} = - Accounts.apply_user_email(user, valid_user_password(), %{"email" => email}) + Accounts.apply_user_email(user, valid_user_password(), %{email: email}) assert "has already been taken" in errors_on(changeset).email end test "validates current password", %{user: user} do {:error, changeset} = - Accounts.apply_user_email(user, "invalid", %{"email" => unique_user_email()}) + Accounts.apply_user_email(user, "invalid", %{email: unique_user_email()}) assert %{current_password: ["is not valid"]} = errors_on(changeset) end test "applies the email without persisting it", %{user: user} do email = unique_user_email() - {:ok, user} = Accounts.apply_user_email(user, valid_user_password(), %{"email" => email}) + {:ok, user} = Accounts.apply_user_email(user, valid_user_password(), %{email: email}) assert user.email == email assert Accounts.get_user!(user.id).email != email end @@ -258,11 +256,7 @@ defmodule Cannery.AccountsTest do end test "allows fields to be set" do - changeset = - Accounts.change_user_password(%User{}, %{ - "password" => "new valid password" - }) - + changeset = Accounts.change_user_password(%User{}, %{password: "new valid password"}) assert changeset.valid? assert get_change(changeset, :password) == "new valid password" assert is_nil(get_change(changeset, :hashed_password)) @@ -277,8 +271,8 @@ defmodule Cannery.AccountsTest do test "validates password", %{user: user} do {:error, changeset} = Accounts.update_user_password(user, valid_user_password(), %{ - "password" => "not valid", - "password_confirmation" => "another" + password: "not valid", + password_confirmation: "another" }) assert %{ @@ -291,14 +285,14 @@ defmodule Cannery.AccountsTest do too_long = String.duplicate("db", 100) {:error, changeset} = - Accounts.update_user_password(user, valid_user_password(), %{"password" => too_long}) + Accounts.update_user_password(user, valid_user_password(), %{password: too_long}) assert "should be at most 80 character(s)" in errors_on(changeset).password end test "validates current password", %{user: user} do {:error, changeset} = - Accounts.update_user_password(user, "invalid", %{"password" => valid_user_password()}) + Accounts.update_user_password(user, "invalid", %{password: valid_user_password()}) assert %{current_password: ["is not valid"]} = errors_on(changeset) end @@ -306,7 +300,7 @@ defmodule Cannery.AccountsTest do test "updates the password", %{user: user} do {:ok, user} = Accounts.update_user_password(user, valid_user_password(), %{ - "password" => "new valid password" + password: "new valid password" }) assert is_nil(user.password) @@ -318,7 +312,7 @@ defmodule Cannery.AccountsTest do {:ok, _} = Accounts.update_user_password(user, valid_user_password(), %{ - "password" => "new valid password" + password: "new valid password" }) refute Repo.get_by(UserToken, user_id: user.id) @@ -486,8 +480,8 @@ defmodule Cannery.AccountsTest do test "validates password", %{user: user} do {:error, changeset} = Accounts.reset_user_password(user, %{ - "password" => "not valid", - "password_confirmation" => "another" + password: "not valid", + password_confirmation: "another" }) assert %{ @@ -498,13 +492,12 @@ defmodule Cannery.AccountsTest do test "validates maximum values for password for security", %{user: user} do too_long = String.duplicate("db", 100) - {:error, changeset} = Accounts.reset_user_password(user, %{"password" => too_long}) + {:error, changeset} = Accounts.reset_user_password(user, %{password: too_long}) assert "should be at most 80 character(s)" in errors_on(changeset).password end test "updates the password", %{user: user} do - {:ok, updated_user} = - Accounts.reset_user_password(user, %{"password" => "new valid password"}) + {:ok, updated_user} = Accounts.reset_user_password(user, %{password: "new valid password"}) assert is_nil(updated_user.password) assert Accounts.get_user_by_email_and_password(user.email, "new valid password") @@ -512,7 +505,7 @@ defmodule Cannery.AccountsTest do test "deletes all tokens for the given user", %{user: user} do _session_token = Accounts.generate_user_session_token(user) - {:ok, _user} = Accounts.reset_user_password(user, %{"password" => "new valid password"}) + {:ok, _user} = Accounts.reset_user_password(user, %{password: "new valid password"}) refute Repo.get_by(UserToken, user_id: user.id) end end diff --git a/test/cannery/activity_log_test.exs b/test/cannery/activity_log_test.exs index 333460be..6b2eebd3 100644 --- a/test/cannery/activity_log_test.exs +++ b/test/cannery/activity_log_test.exs @@ -5,12 +5,7 @@ defmodule Cannery.ActivityLogTest do use Cannery.DataCase import Cannery.Fixtures - - alias Cannery.{ - ActivityLog, - ActivityLog.ShotGroup, - Ammo - } + alias Cannery.{ActivityLog, ActivityLog.ShotGroup, Ammo} @moduletag :activity_log_test @@ -21,10 +16,10 @@ defmodule Cannery.ActivityLogTest do ammo_type = ammo_type_fixture(current_user) {1, [%{id: ammo_group_id} = ammo_group]} = - ammo_group_fixture(%{"count" => 25}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 25}, ammo_type, container, current_user) shot_group = - %{"count" => 5, "date" => ~N[2022-02-13 03:17:00], "notes" => "some notes"} + %{count: 5, date: ~N[2022-02-13 03:17:00], notes: "some notes"} |> shot_group_fixture(current_user, ammo_group) ammo_group = ammo_group_id |> Ammo.get_ammo_group!(current_user) @@ -54,7 +49,7 @@ defmodule Cannery.ActivityLogTest do test "create_shot_group/3 with valid data creates a shot_group", %{current_user: current_user, ammo_group: ammo_group} do - valid_attrs = %{"count" => 10, "date" => ~D[2022-02-13], "notes" => "some notes"} + valid_attrs = %{count: 10, date: ~D[2022-02-13], notes: "some notes"} assert {:ok, %ShotGroup{} = shot_group} = ActivityLog.create_shot_group(valid_attrs, current_user, ammo_group) @@ -69,7 +64,7 @@ defmodule Cannery.ActivityLogTest do current_user: current_user, ammo_group: %{id: ammo_group_id, count: org_count} = ammo_group } do - valid_attrs = %{"count" => 10, "date" => ~D[2022-02-13], "notes" => "some notes"} + valid_attrs = %{count: 10, date: ~D[2022-02-13], notes: "some notes"} assert {:ok, %ShotGroup{} = shot_group} = ActivityLog.create_shot_group(valid_attrs, current_user, ammo_group) @@ -82,7 +77,7 @@ defmodule Cannery.ActivityLogTest do test "create_shot_group/3 does not remove more than ammo group amount", %{current_user: current_user, ammo_group: %{id: ammo_group_id} = ammo_group} do - valid_attrs = %{"count" => 20, "date" => ~D[2022-02-13], "notes" => "some notes"} + valid_attrs = %{count: 20, date: ~D[2022-02-13], notes: "some notes"} assert {:ok, %ShotGroup{}} = ActivityLog.create_shot_group(valid_attrs, current_user, ammo_group) @@ -92,12 +87,12 @@ defmodule Cannery.ActivityLogTest do assert ammo_group.count == 0 assert {:error, %Ecto.Changeset{}} = - ActivityLog.create_shot_group(%{"count" => 1}, current_user, ammo_group) + ActivityLog.create_shot_group(%{count: 1}, current_user, ammo_group) end test "create_shot_group/3 with invalid data returns error changeset", %{current_user: current_user, ammo_group: ammo_group} do - invalid_params = %{"count" => nil, "date" => nil, "notes" => nil} + invalid_params = %{count: nil, date: nil, notes: nil} assert {:error, %Ecto.Changeset{}} = ActivityLog.create_shot_group(invalid_params, current_user, ammo_group) @@ -113,9 +108,9 @@ defmodule Cannery.ActivityLogTest do ActivityLog.update_shot_group( shot_group, %{ - "count" => 10, - "date" => ~D[2022-02-13], - "notes" => "some updated notes" + count: 10, + date: ~D[2022-02-13], + notes: "some updated notes" }, current_user ) @@ -131,9 +126,9 @@ defmodule Cannery.ActivityLogTest do ActivityLog.update_shot_group( shot_group, %{ - "count" => 25, - "date" => ~D[2022-02-13], - "notes" => "some updated notes" + count: 25, + date: ~D[2022-02-13], + notes: "some updated notes" }, current_user ) @@ -149,14 +144,14 @@ defmodule Cannery.ActivityLogTest do assert {:error, %Ecto.Changeset{}} = ActivityLog.update_shot_group( shot_group, - %{"count" => 26, "date" => nil, "notes" => nil}, + %{count: 26, date: nil, notes: nil}, current_user ) assert {:error, %Ecto.Changeset{}} = ActivityLog.update_shot_group( shot_group, - %{"count" => -1, "date" => nil, "notes" => nil}, + %{count: -1, date: nil, notes: nil}, current_user ) @@ -184,10 +179,10 @@ defmodule Cannery.ActivityLogTest do assert 0 = another_ammo_group |> ActivityLog.get_used_count(current_user) assert 5 = ammo_group |> ActivityLog.get_used_count(current_user) - shot_group_fixture(%{"count" => 15}, current_user, ammo_group) + shot_group_fixture(%{count: 15}, current_user, ammo_group) assert 20 = ammo_group |> ActivityLog.get_used_count(current_user) - shot_group_fixture(%{"count" => 10}, current_user, ammo_group) + shot_group_fixture(%{count: 10}, current_user, ammo_group) assert 30 = ammo_group |> ActivityLog.get_used_count(current_user) {1, [another_ammo_group]} = ammo_group_fixture(ammo_type, container, current_user) @@ -206,17 +201,17 @@ defmodule Cannery.ActivityLogTest do assert %{ammo_group_id => 5} == [ammo_group, another_ammo_group] |> ActivityLog.get_used_counts(current_user) - shot_group_fixture(%{"count" => 5}, current_user, another_ammo_group) + shot_group_fixture(%{count: 5}, current_user, another_ammo_group) used_counts = [ammo_group, another_ammo_group] |> ActivityLog.get_used_counts(current_user) assert %{^ammo_group_id => 5} = used_counts assert %{^another_ammo_group_id => 5} = used_counts - shot_group_fixture(%{"count" => 15}, current_user, ammo_group) + shot_group_fixture(%{count: 15}, current_user, ammo_group) used_counts = [ammo_group, another_ammo_group] |> ActivityLog.get_used_counts(current_user) assert %{^ammo_group_id => 20} = used_counts assert %{^another_ammo_group_id => 5} = used_counts - shot_group_fixture(%{"count" => 10}, current_user, ammo_group) + shot_group_fixture(%{count: 10}, current_user, ammo_group) used_counts = [ammo_group, another_ammo_group] |> ActivityLog.get_used_counts(current_user) assert %{^ammo_group_id => 30} = used_counts assert %{^another_ammo_group_id => 5} = used_counts @@ -233,10 +228,10 @@ defmodule Cannery.ActivityLogTest do assert another_ammo_group |> ActivityLog.get_last_used_date(current_user) |> is_nil() assert ^date = ammo_group |> ActivityLog.get_last_used_date(current_user) - %{date: date} = shot_group_fixture(%{"date" => ~D[2022-11-10]}, current_user, ammo_group) + %{date: date} = shot_group_fixture(%{date: ~D[2022-11-10]}, current_user, ammo_group) assert ^date = ammo_group |> ActivityLog.get_last_used_date(current_user) - %{date: date} = shot_group_fixture(%{"date" => ~D[2022-11-11]}, current_user, ammo_group) + %{date: date} = shot_group_fixture(%{date: ~D[2022-11-11]}, current_user, ammo_group) assert ^date = ammo_group |> ActivityLog.get_last_used_date(current_user) end @@ -254,7 +249,7 @@ defmodule Cannery.ActivityLogTest do assert %{ammo_group_id => date} == [ammo_group, another_ammo_group] |> ActivityLog.get_last_used_dates(current_user) - shot_group_fixture(%{"date" => ~D[2022-11-09]}, current_user, another_ammo_group) + shot_group_fixture(%{date: ~D[2022-11-09]}, current_user, another_ammo_group) # setting initial date last_used_shot_groups = @@ -264,7 +259,7 @@ defmodule Cannery.ActivityLogTest do assert %{^another_ammo_group_id => ~D[2022-11-09]} = last_used_shot_groups # setting another date - shot_group_fixture(%{"date" => ~D[2022-11-10]}, current_user, ammo_group) + shot_group_fixture(%{date: ~D[2022-11-10]}, current_user, ammo_group) last_used_shot_groups = [ammo_group, another_ammo_group] |> ActivityLog.get_last_used_dates(current_user) @@ -273,7 +268,7 @@ defmodule Cannery.ActivityLogTest do assert %{^another_ammo_group_id => ~D[2022-11-09]} = last_used_shot_groups # setting yet another date - shot_group_fixture(%{"date" => ~D[2022-11-11]}, current_user, ammo_group) + shot_group_fixture(%{date: ~D[2022-11-11]}, current_user, ammo_group) last_used_shot_groups = [ammo_group, another_ammo_group] |> ActivityLog.get_last_used_dates(current_user) @@ -288,10 +283,10 @@ defmodule Cannery.ActivityLogTest do assert 0 = another_ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user) assert 5 = ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user) - shot_group_fixture(%{"count" => 5}, current_user, ammo_group) + shot_group_fixture(%{count: 5}, current_user, ammo_group) assert 10 = ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user) - shot_group_fixture(%{"count" => 1}, current_user, ammo_group) + shot_group_fixture(%{count: 1}, current_user, ammo_group) assert 11 = ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user) end @@ -309,7 +304,7 @@ defmodule Cannery.ActivityLogTest do |> ActivityLog.get_used_count_for_ammo_types(current_user) # use generated ammo group - shot_group_fixture(%{"count" => 5}, current_user, ammo_group) + shot_group_fixture(%{count: 5}, current_user, ammo_group) used_counts = [ammo_type, another_ammo_type] |> ActivityLog.get_used_count_for_ammo_types(current_user) @@ -318,7 +313,7 @@ defmodule Cannery.ActivityLogTest do assert %{^another_ammo_type_id => 5} = used_counts # use generated ammo group again - shot_group_fixture(%{"count" => 1}, current_user, ammo_group) + shot_group_fixture(%{count: 1}, current_user, ammo_group) used_counts = [ammo_type, another_ammo_type] |> ActivityLog.get_used_count_for_ammo_types(current_user) @@ -349,20 +344,20 @@ defmodule Cannery.ActivityLogTest do other_container = container_fixture(other_user) for type <- ["rifle", "shotgun", "pistol"] do - other_ammo_type = ammo_type_fixture(%{"type" => type}, other_user) + other_ammo_type = ammo_type_fixture(%{type: type}, other_user) {1, [other_ammo_group]} = ammo_group_fixture(other_ammo_type, other_container, other_user) shot_group_fixture(other_user, other_ammo_group) end - rifle_ammo_type = ammo_type_fixture(%{"type" => "rifle"}, current_user) + rifle_ammo_type = ammo_type_fixture(%{type: "rifle"}, current_user) {1, [rifle_ammo_group]} = ammo_group_fixture(rifle_ammo_type, container, current_user) rifle_shot_group = shot_group_fixture(current_user, rifle_ammo_group) - shotgun_ammo_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user) + shotgun_ammo_type = ammo_type_fixture(%{type: "shotgun"}, current_user) {1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_ammo_type, container, current_user) shotgun_shot_group = shot_group_fixture(current_user, shotgun_ammo_group) - pistol_ammo_type = ammo_type_fixture(%{"type" => "pistol"}, current_user) + pistol_ammo_type = ammo_type_fixture(%{type: "pistol"}, current_user) {1, [pistol_ammo_group]} = ammo_group_fixture(pistol_ammo_type, container, current_user) pistol_shot_group = shot_group_fixture(current_user, pistol_ammo_group) @@ -389,14 +384,14 @@ defmodule Cannery.ActivityLogTest do container: container, current_user: current_user } do - shot_group_a = shot_group_fixture(%{"notes" => "amazing"}, current_user, ammo_group) + shot_group_a = shot_group_fixture(%{notes: "amazing"}, current_user, ammo_group) {1, [another_ammo_group]} = - ammo_group_fixture(%{"notes" => "stupendous"}, ammo_type, container, current_user) + ammo_group_fixture(%{notes: "stupendous"}, ammo_type, container, current_user) shot_group_b = shot_group_fixture(current_user, another_ammo_group) - another_ammo_type = ammo_type_fixture(%{"name" => "fabulous ammo"}, current_user) + another_ammo_type = ammo_type_fixture(%{name: "fabulous ammo"}, current_user) {1, [yet_another_ammo_group]} = ammo_group_fixture(another_ammo_type, container, current_user) diff --git a/test/cannery/ammo_test.exs b/test/cannery/ammo_test.exs index 6ed92034..9fd7bc15 100644 --- a/test/cannery/ammo_test.exs +++ b/test/cannery/ammo_test.exs @@ -10,28 +10,28 @@ defmodule Cannery.AmmoTest do @moduletag :ammo_test @valid_attrs %{ - "bullet_type" => "some bullet_type", - "case_material" => "some case_material", - "desc" => "some desc", - "manufacturer" => "some manufacturer", - "name" => "some name", - "grains" => 120 + bullet_type: "some bullet_type", + case_material: "some case_material", + desc: "some desc", + manufacturer: "some manufacturer", + name: "some name", + grains: 120 } @update_attrs %{ - "bullet_type" => "some updated bullet_type", - "case_material" => "some updated case_material", - "desc" => "some updated desc", - "manufacturer" => "some updated manufacturer", - "name" => "some updated name", - "grains" => 456 + bullet_type: "some updated bullet_type", + case_material: "some updated case_material", + desc: "some updated desc", + manufacturer: "some updated manufacturer", + name: "some updated name", + grains: 456 } @invalid_attrs %{ - "bullet_type" => nil, - "case_material" => nil, - "desc" => nil, - "manufacturer" => nil, - "name" => nil, - "grains" => nil + bullet_type: nil, + case_material: nil, + desc: nil, + manufacturer: nil, + name: nil, + grains: nil } describe "list_ammo_types/2" do @@ -40,34 +40,34 @@ defmodule Cannery.AmmoTest do rifle_ammo_type = %{ - "name" => "bullets", - "type" => "rifle", - "desc" => "has some pews in it", - "grains" => 5 + name: "bullets", + type: "rifle", + desc: "has some pews in it", + grains: 5 } |> ammo_type_fixture(current_user) shotgun_ammo_type = %{ - "name" => "hollows", - "type" => "shotgun", - "grains" => 3 + name: "hollows", + type: "shotgun", + grains: 3 } |> ammo_type_fixture(current_user) pistol_ammo_type = %{ - "type" => "pistol", - "name" => "jackets", - "desc" => "brass shell", - "tracer" => true + type: "pistol", + name: "jackets", + desc: "brass shell", + tracer: true } |> ammo_type_fixture(current_user) _shouldnt_return = %{ - "name" => "bullet", - "desc" => "pews brass shell" + name: "bullet", + desc: "pews brass shell" } |> ammo_type_fixture(user_fixture()) @@ -228,7 +228,7 @@ defmodule Cannery.AmmoTest do %{ammo_type: ammo_type, current_user: current_user, container: container} do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 25.00, "count" => 1}, + %{price_paid: 25.00, count: 1}, ammo_type, container, current_user @@ -238,7 +238,7 @@ defmodule Cannery.AmmoTest do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 25.00, "count" => 1}, + %{price_paid: 25.00, count: 1}, ammo_type, container, current_user @@ -248,7 +248,7 @@ defmodule Cannery.AmmoTest do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 70.00, "count" => 1}, + %{price_paid: 70.00, count: 1}, ammo_type, container, current_user @@ -258,7 +258,7 @@ defmodule Cannery.AmmoTest do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 30.00, "count" => 1}, + %{price_paid: 30.00, count: 1}, ammo_type, container, current_user @@ -282,7 +282,7 @@ defmodule Cannery.AmmoTest do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 25.00, "count" => 1}, + %{price_paid: 25.00, count: 1}, another_ammo_type, container, current_user @@ -294,7 +294,7 @@ defmodule Cannery.AmmoTest do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 25.00, "count" => 1}, + %{price_paid: 25.00, count: 1}, ammo_type, container, current_user @@ -308,7 +308,7 @@ defmodule Cannery.AmmoTest do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 25.00, "count" => 1}, + %{price_paid: 25.00, count: 1}, ammo_type, container, current_user @@ -322,7 +322,7 @@ defmodule Cannery.AmmoTest do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 70.00, "count" => 1}, + %{price_paid: 70.00, count: 1}, ammo_type, container, current_user @@ -336,7 +336,7 @@ defmodule Cannery.AmmoTest do {1, [_ammo_group]} = ammo_group_fixture( - %{"price_paid" => 30.00, "count" => 1}, + %{price_paid: 30.00, count: 1}, ammo_type, container, current_user @@ -355,18 +355,18 @@ defmodule Cannery.AmmoTest do assert 0 = Ammo.get_round_count_for_ammo_type(another_ammo_type, current_user) {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 1}, ammo_type, container, current_user) assert 1 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user) - {1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user) + {1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user) assert 51 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user) - shot_group_fixture(%{"count" => 26}, current_user, ammo_group) + shot_group_fixture(%{count: 26}, current_user, ammo_group) assert 25 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user) - shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group) + shot_group_fixture(%{count: 1}, current_user, first_ammo_group) assert 24 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user) end @@ -376,7 +376,7 @@ defmodule Cannery.AmmoTest do container: container } do {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 1}, ammo_type, container, current_user) assert %{ammo_type_id => 1} == [ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user) @@ -384,7 +384,7 @@ defmodule Cannery.AmmoTest do %{id: another_ammo_type_id} = another_ammo_type = ammo_type_fixture(current_user) {1, [_another_ammo_group]} = - ammo_group_fixture(%{"count" => 1}, another_ammo_type, container, current_user) + ammo_group_fixture(%{count: 1}, another_ammo_type, container, current_user) round_counts = [ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user) @@ -392,7 +392,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_type_id => 1} = round_counts assert %{^another_ammo_type_id => 1} = round_counts - {1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user) + {1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user) round_counts = [ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user) @@ -400,7 +400,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_type_id => 51} = round_counts assert %{^another_ammo_type_id => 1} = round_counts - shot_group_fixture(%{"count" => 26}, current_user, ammo_group) + shot_group_fixture(%{count: 26}, current_user, ammo_group) round_counts = [ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user) @@ -408,7 +408,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_type_id => 25} = round_counts assert %{^another_ammo_type_id => 1} = round_counts - shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group) + shot_group_fixture(%{count: 1}, current_user, first_ammo_group) round_counts = [ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user) @@ -422,18 +422,18 @@ defmodule Cannery.AmmoTest do assert 0 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user) {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 1}, ammo_type, container, current_user) assert 1 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user) - {1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user) + {1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user) assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user) - shot_group_fixture(%{"count" => 26}, current_user, ammo_group) + shot_group_fixture(%{count: 26}, current_user, ammo_group) assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user) - shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group) + shot_group_fixture(%{count: 1}, current_user, first_ammo_group) assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user) end @@ -446,7 +446,7 @@ defmodule Cannery.AmmoTest do assert %{} == [ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user) {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 1}, ammo_type, container, current_user) assert %{ammo_type_id => 1} == [ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user) @@ -454,7 +454,7 @@ defmodule Cannery.AmmoTest do %{id: another_ammo_type_id} = another_ammo_type = ammo_type_fixture(current_user) {1, [_ammo_group]} = - ammo_group_fixture(%{"count" => 1}, another_ammo_type, container, current_user) + ammo_group_fixture(%{count: 1}, another_ammo_type, container, current_user) historical_counts = [ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user) @@ -462,7 +462,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_type_id => 1} = historical_counts assert %{^another_ammo_type_id => 1} = historical_counts - {1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user) + {1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user) historical_counts = [ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user) @@ -470,7 +470,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_type_id => 51} = historical_counts assert %{^another_ammo_type_id => 1} = historical_counts - shot_group_fixture(%{"count" => 26}, current_user, ammo_group) + shot_group_fixture(%{count: 26}, current_user, ammo_group) historical_counts = [ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user) @@ -478,7 +478,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_type_id => 51} = historical_counts assert %{^another_ammo_type_id => 1} = historical_counts - shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group) + shot_group_fixture(%{count: 1}, current_user, first_ammo_group) historical_counts = [ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user) @@ -492,18 +492,18 @@ defmodule Cannery.AmmoTest do assert 0 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user) {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 1}, ammo_type, container, current_user) assert 0 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user) - {1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user) + {1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user) assert 0 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user) - shot_group_fixture(%{"count" => 50}, current_user, ammo_group) + shot_group_fixture(%{count: 50}, current_user, ammo_group) assert 1 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user) - shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group) + shot_group_fixture(%{count: 1}, current_user, first_ammo_group) assert 2 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user) end @@ -525,7 +525,7 @@ defmodule Cannery.AmmoTest do # testing ammo type with ammo group {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 1}, ammo_type, container, current_user) assert %{} == [ammo_type, another_ammo_type] @@ -533,17 +533,17 @@ defmodule Cannery.AmmoTest do # testing ammo type with used ammo group {1, [another_ammo_group]} = - ammo_group_fixture(%{"count" => 50}, another_ammo_type, container, current_user) + ammo_group_fixture(%{count: 50}, another_ammo_type, container, current_user) - shot_group_fixture(%{"count" => 50}, current_user, another_ammo_group) + shot_group_fixture(%{count: 50}, current_user, another_ammo_group) assert %{another_ammo_type_id => 1} == [ammo_type, another_ammo_type] |> Ammo.get_used_ammo_groups_count_for_types(current_user) # testing two ammo types with zero and one used ammo groups - {1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user) - shot_group_fixture(%{"count" => 50}, current_user, ammo_group) + {1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user) + shot_group_fixture(%{count: 50}, current_user, ammo_group) used_counts = [ammo_type, another_ammo_type] |> Ammo.get_used_ammo_groups_count_for_types(current_user) @@ -552,7 +552,7 @@ defmodule Cannery.AmmoTest do assert %{^another_ammo_type_id => 1} = used_counts # testing two ammo type with one and two used ammo groups - shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group) + shot_group_fixture(%{count: 1}, current_user, first_ammo_group) used_counts = [ammo_type, another_ammo_type] |> Ammo.get_used_ammo_groups_count_for_types(current_user) @@ -564,19 +564,18 @@ defmodule Cannery.AmmoTest do test "get_ammo_groups_count_for_container!/2 gets accurate ammo count for container", %{ammo_type: ammo_type, current_user: current_user, container: container} do {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 5}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 5}, ammo_type, container, current_user) assert 1 = Ammo.get_ammo_groups_count_for_container!(container, current_user) - {25, _ammo_groups} = - ammo_group_fixture(%{"count" => 5}, 25, ammo_type, container, current_user) + {25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user) assert 26 = Ammo.get_ammo_groups_count_for_container!(container, current_user) - shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group) + shot_group_fixture(%{count: 1}, current_user, first_ammo_group) assert 26 = Ammo.get_ammo_groups_count_for_container!(container, current_user) - shot_group_fixture(%{"count" => 4}, current_user, first_ammo_group) + shot_group_fixture(%{count: 4}, current_user, first_ammo_group) assert 25 = Ammo.get_ammo_groups_count_for_container!(container, current_user) end @@ -588,10 +587,10 @@ defmodule Cannery.AmmoTest do %{id: another_container_id} = another_container = container_fixture(current_user) {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 5}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 5}, ammo_type, container, current_user) {1, [_first_ammo_group]} = - ammo_group_fixture(%{"count" => 5}, ammo_type, another_container, current_user) + ammo_group_fixture(%{count: 5}, ammo_type, another_container, current_user) ammo_groups_count = [container, another_container] @@ -600,8 +599,7 @@ defmodule Cannery.AmmoTest do assert %{^container_id => 1} = ammo_groups_count assert %{^another_container_id => 1} = ammo_groups_count - {25, _ammo_groups} = - ammo_group_fixture(%{"count" => 5}, 25, ammo_type, container, current_user) + {25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user) ammo_groups_count = [container, another_container] @@ -610,7 +608,7 @@ defmodule Cannery.AmmoTest do assert %{^container_id => 26} = ammo_groups_count assert %{^another_container_id => 1} = ammo_groups_count - shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group) + shot_group_fixture(%{count: 1}, current_user, first_ammo_group) ammo_groups_count = [container, another_container] @@ -619,7 +617,7 @@ defmodule Cannery.AmmoTest do assert %{^container_id => 26} = ammo_groups_count assert %{^another_container_id => 1} = ammo_groups_count - shot_group_fixture(%{"count" => 4}, current_user, first_ammo_group) + shot_group_fixture(%{count: 4}, current_user, first_ammo_group) ammo_groups_count = [container, another_container] @@ -632,16 +630,15 @@ defmodule Cannery.AmmoTest do test "get_round_count_for_container!/2 gets accurate total round count for container", %{ammo_type: ammo_type, current_user: current_user, container: container} do {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 5}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 5}, ammo_type, container, current_user) assert 5 = Ammo.get_round_count_for_container!(container, current_user) - {25, _ammo_groups} = - ammo_group_fixture(%{"count" => 5}, 25, ammo_type, container, current_user) + {25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user) assert 130 = Ammo.get_round_count_for_container!(container, current_user) - shot_group_fixture(%{"count" => 5}, current_user, first_ammo_group) + shot_group_fixture(%{count: 5}, current_user, first_ammo_group) assert 125 = Ammo.get_round_count_for_container!(container, current_user) end @@ -654,10 +651,10 @@ defmodule Cannery.AmmoTest do %{id: another_container_id} = another_container = container_fixture(current_user) {1, [first_ammo_group]} = - ammo_group_fixture(%{"count" => 5}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 5}, ammo_type, container, current_user) {1, [_first_ammo_group]} = - ammo_group_fixture(%{"count" => 5}, ammo_type, another_container, current_user) + ammo_group_fixture(%{count: 5}, ammo_type, another_container, current_user) round_counts = [container, another_container] |> Ammo.get_round_count_for_containers(current_user) @@ -665,8 +662,7 @@ defmodule Cannery.AmmoTest do assert %{^container_id => 5} = round_counts assert %{^another_container_id => 5} = round_counts - {25, _ammo_groups} = - ammo_group_fixture(%{"count" => 5}, 25, ammo_type, container, current_user) + {25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user) round_counts = [container, another_container] |> Ammo.get_round_count_for_containers(current_user) @@ -674,7 +670,7 @@ defmodule Cannery.AmmoTest do assert %{^container_id => 130} = round_counts assert %{^another_container_id => 5} = round_counts - shot_group_fixture(%{"count" => 5}, current_user, first_ammo_group) + shot_group_fixture(%{count: 5}, current_user, first_ammo_group) round_counts = [container, another_container] |> Ammo.get_round_count_for_containers(current_user) @@ -686,20 +682,20 @@ defmodule Cannery.AmmoTest do describe "ammo_groups" do @valid_attrs %{ - "count" => 42, - "notes" => "some notes", - "price_paid" => 120.5, - "purchased_on" => ~D[2022-11-19] + count: 42, + notes: "some notes", + price_paid: 120.5, + purchased_on: ~D[2022-11-19] } @update_attrs %{ - "count" => 43, - "notes" => "some updated notes", - "price_paid" => 456.7 + count: 43, + notes: "some updated notes", + price_paid: 456.7 } @invalid_attrs %{ - "count" => nil, - "notes" => nil, - "price_paid" => nil + count: nil, + notes: nil, + price_paid: nil } setup do @@ -708,8 +704,7 @@ defmodule Cannery.AmmoTest do container = container_fixture(current_user) {1, [ammo_group]} = - %{"count" => 50, "price_paid" => 36.1} - |> ammo_group_fixture(ammo_type, container, current_user) + ammo_group_fixture(%{count: 50, price_paid: 36.1}, ammo_type, container, current_user) another_user = user_fixture() another_ammo_type = ammo_type_fixture(another_user) @@ -744,9 +739,9 @@ defmodule Cannery.AmmoTest do other_container = container_fixture(other_user) {1, [another_ammo_group]} = - ammo_group_fixture(%{"count" => 30}, other_ammo_type, other_container, other_user) + ammo_group_fixture(%{count: 30}, other_ammo_type, other_container, other_user) - shot_group_fixture(%{"count" => 30}, other_user, another_ammo_group) + shot_group_fixture(%{count: 30}, other_user, another_ammo_group) assert Ammo.get_ammo_groups_count!(other_user) == 0 assert Ammo.get_ammo_groups_count!(other_user, true) == 1 end @@ -755,11 +750,11 @@ defmodule Cannery.AmmoTest do current_user = user_fixture() container = container_fixture(current_user) - rifle_ammo_type = ammo_type_fixture(%{"type" => "rifle"}, current_user) + rifle_ammo_type = ammo_type_fixture(%{type: "rifle"}, current_user) {1, [rifle_ammo_group]} = ammo_group_fixture(rifle_ammo_type, container, current_user) - shotgun_ammo_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user) + shotgun_ammo_type = ammo_type_fixture(%{type: "shotgun"}, current_user) {1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_ammo_type, container, current_user) - pistol_ammo_type = ammo_type_fixture(%{"type" => "pistol"}, current_user) + pistol_ammo_type = ammo_type_fixture(%{type: "pistol"}, current_user) {1, [pistol_ammo_group]} = ammo_group_fixture(pistol_ammo_type, container, current_user) assert [^rifle_ammo_group] = Ammo.list_ammo_groups(nil, :rifle, current_user, false) @@ -786,9 +781,9 @@ defmodule Cannery.AmmoTest do current_user: current_user } do {1, [%{id: another_ammo_group_id} = another_ammo_group]} = - ammo_group_fixture(%{"count" => 30}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 30}, ammo_type, container, current_user) - shot_group_fixture(%{"count" => 30}, current_user, another_ammo_group) + shot_group_fixture(%{count: 30}, current_user, another_ammo_group) another_ammo_group = Ammo.get_ammo_group!(another_ammo_group_id, current_user) assert Ammo.list_ammo_groups(nil, :all, current_user, false) == [ammo_group] @@ -806,20 +801,20 @@ defmodule Cannery.AmmoTest do current_user: current_user } do {1, [another_ammo_group]} = - %{"count" => 49, "notes" => "cool ammo group"} + %{count: 49, notes: "cool ammo group"} |> ammo_group_fixture(ammo_type, container, current_user) - another_ammo_type = ammo_type_fixture(%{"name" => "amazing ammo"}, current_user) - another_container = container_fixture(%{"name" => "fantastic container"}, current_user) + another_ammo_type = ammo_type_fixture(%{name: "amazing ammo"}, current_user) + another_container = container_fixture(%{name: "fantastic container"}, current_user) - tag = tag_fixture(%{"name" => "stupendous tag"}, current_user) + tag = tag_fixture(%{name: "stupendous tag"}, current_user) Containers.add_tag!(another_container, tag, current_user) {1, [amazing_ammo_group]} = - ammo_group_fixture(%{"count" => 48}, another_ammo_type, container, current_user) + ammo_group_fixture(%{count: 48}, another_ammo_type, container, current_user) {1, [fantastic_ammo_group]} = - ammo_group_fixture(%{"count" => 47}, ammo_type, another_container, current_user) + ammo_group_fixture(%{count: 47}, ammo_type, another_container, current_user) ammo_groups = Ammo.list_ammo_groups(nil, :all, current_user, false) assert Enum.count(ammo_groups) == 4 @@ -863,11 +858,11 @@ defmodule Cannery.AmmoTest do current_user = user_fixture() container = container_fixture(current_user) - rifle_ammo_type = ammo_type_fixture(%{"type" => "rifle"}, current_user) + rifle_ammo_type = ammo_type_fixture(%{type: "rifle"}, current_user) {1, [rifle_ammo_group]} = ammo_group_fixture(rifle_ammo_type, container, current_user) - shotgun_ammo_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user) + shotgun_ammo_type = ammo_type_fixture(%{type: "shotgun"}, current_user) {1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_ammo_type, container, current_user) - pistol_ammo_type = ammo_type_fixture(%{"type" => "pistol"}, current_user) + pistol_ammo_type = ammo_type_fixture(%{type: "pistol"}, current_user) {1, [pistol_ammo_group]} = ammo_group_fixture(pistol_ammo_type, container, current_user) another_container = container_fixture(current_user) @@ -948,7 +943,7 @@ defmodule Cannery.AmmoTest do current_user: current_user } do {1, [another_ammo_group]} = - ammo_group_fixture(%{"staged" => true}, ammo_type, container, current_user) + ammo_group_fixture(%{staged: true}, ammo_type, container, current_user) assert Ammo.list_staged_ammo_groups(current_user) == [another_ammo_group] end @@ -979,7 +974,7 @@ defmodule Cannery.AmmoTest do } do assert {:ok, {1, [%AmmoGroup{} = ammo_group]}} = @valid_attrs - |> Map.merge(%{"ammo_type_id" => ammo_type.id, "container_id" => container.id}) + |> Map.merge(%{ammo_type_id: ammo_type.id, container_id: container.id}) |> Ammo.create_ammo_groups(1, current_user) assert ammo_group.count == 42 @@ -994,7 +989,7 @@ defmodule Cannery.AmmoTest do } do assert {:ok, {3, ammo_groups}} = @valid_attrs - |> Map.merge(%{"ammo_type_id" => ammo_type.id, "container_id" => container.id}) + |> Map.merge(%{ammo_type_id: ammo_type.id, container_id: container.id}) |> Ammo.create_ammo_groups(3, current_user) assert [%AmmoGroup{}, %AmmoGroup{}, %AmmoGroup{}] = ammo_groups @@ -1011,7 +1006,7 @@ defmodule Cannery.AmmoTest do %{ammo_type: ammo_type, container: container, current_user: current_user} do assert {:error, %Changeset{}} = @invalid_attrs - |> Map.merge(%{"ammo_type_id" => ammo_type.id, "container_id" => container.id}) + |> Map.merge(%{ammo_type_id: ammo_type.id, container_id: container.id}) |> Ammo.create_ammo_groups(1, current_user) end @@ -1043,15 +1038,15 @@ defmodule Cannery.AmmoTest do %{ammo_group: %{id: ammo_group_id} = ammo_group, current_user: current_user} do assert 100 = ammo_group |> Ammo.get_percentage_remaining(current_user) - shot_group_fixture(%{"count" => 14}, current_user, ammo_group) + shot_group_fixture(%{count: 14}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) assert 72 = ammo_group |> Ammo.get_percentage_remaining(current_user) - shot_group_fixture(%{"count" => 11}, current_user, ammo_group) + shot_group_fixture(%{count: 11}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) assert 50 = ammo_group |> Ammo.get_percentage_remaining(current_user) - shot_group_fixture(%{"count" => 25}, current_user, ammo_group) + shot_group_fixture(%{count: 25}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) assert 0 = ammo_group |> Ammo.get_percentage_remaining(current_user) end @@ -1066,7 +1061,7 @@ defmodule Cannery.AmmoTest do [ammo_group] |> Ammo.get_percentages_remaining(current_user) {1, [%{id: another_ammo_group_id} = another_ammo_group]} = - %{"count" => 50, "price_paid" => 36.1} + %{count: 50, price_paid: 36.1} |> ammo_group_fixture(ammo_type, container, current_user) percentages = @@ -1075,7 +1070,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_group_id => 100} = percentages assert %{^another_ammo_group_id => 100} = percentages - shot_group_fixture(%{"count" => 14}, current_user, ammo_group) + shot_group_fixture(%{count: 14}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) percentages = @@ -1084,7 +1079,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_group_id => 72} = percentages assert %{^another_ammo_group_id => 100} = percentages - shot_group_fixture(%{"count" => 11}, current_user, ammo_group) + shot_group_fixture(%{count: 11}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) percentages = @@ -1093,7 +1088,7 @@ defmodule Cannery.AmmoTest do assert %{^ammo_group_id => 50} = percentages assert %{^another_ammo_group_id => 100} = percentages - shot_group_fixture(%{"count" => 25}, current_user, ammo_group) + shot_group_fixture(%{count: 25}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) percentages = @@ -1105,12 +1100,12 @@ defmodule Cannery.AmmoTest do test "get_cpr/2 gets accurate cpr", %{ammo_type: ammo_type, container: container, current_user: current_user} do - {1, [ammo_group]} = ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user) + {1, [ammo_group]} = ammo_group_fixture(%{count: 1}, ammo_type, container, current_user) assert ammo_group |> Ammo.get_cpr(current_user) |> is_nil() {1, [ammo_group]} = ammo_group_fixture( - %{"count" => 1, "price_paid" => 1.0}, + %{count: 1, price_paid: 1.0}, ammo_type, container, current_user @@ -1120,7 +1115,7 @@ defmodule Cannery.AmmoTest do {1, [ammo_group]} = ammo_group_fixture( - %{"count" => 2, "price_paid" => 3.0}, + %{count: 2, price_paid: 3.0}, ammo_type, container, current_user @@ -1130,7 +1125,7 @@ defmodule Cannery.AmmoTest do {1, [ammo_group]} = ammo_group_fixture( - %{"count" => 50, "price_paid" => 36.1}, + %{count: 50, price_paid: 36.1}, ammo_type, container, current_user @@ -1139,19 +1134,19 @@ defmodule Cannery.AmmoTest do assert 0.722 = ammo_group |> Ammo.get_cpr(current_user) # with shot group, maintains total - shot_group_fixture(%{"count" => 14}, current_user, ammo_group) + shot_group_fixture(%{count: 14}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group.id, current_user) assert 0.722 = ammo_group |> Ammo.get_cpr(current_user) end test "get_cprs/2 gets accurate cprs", %{ammo_type: ammo_type, container: container, current_user: current_user} do - {1, [ammo_group]} = ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user) + {1, [ammo_group]} = ammo_group_fixture(%{count: 1}, ammo_type, container, current_user) assert %{} == [ammo_group] |> Ammo.get_cprs(current_user) {1, [%{id: ammo_group_id} = ammo_group]} = ammo_group_fixture( - %{"count" => 1, "price_paid" => 1.0}, + %{count: 1, price_paid: 1.0}, ammo_type, container, current_user @@ -1161,7 +1156,7 @@ defmodule Cannery.AmmoTest do {1, [%{id: another_ammo_group_id} = another_ammo_group]} = ammo_group_fixture( - %{"count" => 2, "price_paid" => 3.0}, + %{count: 2, price_paid: 3.0}, ammo_type, container, current_user @@ -1173,7 +1168,7 @@ defmodule Cannery.AmmoTest do {1, [%{id: yet_another_ammo_group_id} = yet_another_ammo_group]} = ammo_group_fixture( - %{"count" => 50, "price_paid" => 36.1}, + %{count: 50, price_paid: 36.1}, ammo_type, container, current_user @@ -1187,7 +1182,7 @@ defmodule Cannery.AmmoTest do assert %{^yet_another_ammo_group_id => 0.722} = cprs # with shot group, maintains total - shot_group_fixture(%{"count" => 14}, current_user, yet_another_ammo_group) + shot_group_fixture(%{count: 14}, current_user, yet_another_ammo_group) yet_another_ammo_group = Ammo.get_ammo_group!(yet_another_ammo_group.id, current_user) cprs = @@ -1202,15 +1197,15 @@ defmodule Cannery.AmmoTest do %{ammo_group: %{id: ammo_group_id} = ammo_group, current_user: current_user} do assert 50 = ammo_group |> Ammo.get_original_count(current_user) - shot_group_fixture(%{"count" => 14}, current_user, ammo_group) + shot_group_fixture(%{count: 14}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) assert 50 = ammo_group |> Ammo.get_original_count(current_user) - shot_group_fixture(%{"count" => 11}, current_user, ammo_group) + shot_group_fixture(%{count: 11}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) assert 50 = ammo_group |> Ammo.get_original_count(current_user) - shot_group_fixture(%{"count" => 25}, current_user, ammo_group) + shot_group_fixture(%{count: 25}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) assert 50 = ammo_group |> Ammo.get_original_count(current_user) end @@ -1222,25 +1217,25 @@ defmodule Cannery.AmmoTest do current_user: current_user } do {1, [%{id: another_ammo_group_id} = another_ammo_group]} = - ammo_group_fixture(%{"count" => 25}, ammo_type, container, current_user) + ammo_group_fixture(%{count: 25}, ammo_type, container, current_user) original_counts = [ammo_group, another_ammo_group] |> Ammo.get_original_counts(current_user) assert %{^ammo_group_id => 50} = original_counts assert %{^another_ammo_group_id => 25} = original_counts - shot_group_fixture(%{"count" => 14}, current_user, ammo_group) + shot_group_fixture(%{count: 14}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) original_counts = [ammo_group, another_ammo_group] |> Ammo.get_original_counts(current_user) assert %{^ammo_group_id => 50} = original_counts assert %{^another_ammo_group_id => 25} = original_counts - shot_group_fixture(%{"count" => 11}, current_user, ammo_group) + shot_group_fixture(%{count: 11}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) original_counts = [ammo_group, another_ammo_group] |> Ammo.get_original_counts(current_user) assert %{^ammo_group_id => 50} = original_counts assert %{^another_ammo_group_id => 25} = original_counts - shot_group_fixture(%{"count" => 25}, current_user, ammo_group) + shot_group_fixture(%{count: 25}, current_user, ammo_group) ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user) original_counts = [ammo_group, another_ammo_group] |> Ammo.get_original_counts(current_user) assert %{^ammo_group_id => 50} = original_counts diff --git a/test/cannery/containers_test.exs b/test/cannery/containers_test.exs index 9a5708a6..0819ae52 100644 --- a/test/cannery/containers_test.exs +++ b/test/cannery/containers_test.exs @@ -10,37 +10,37 @@ defmodule Cannery.ContainersTest do @moduletag :containers_test @valid_attrs %{ - "desc" => "some desc", - "location" => "some location", - "name" => "some name", - "type" => "some type" + desc: "some desc", + location: "some location", + name: "some name", + type: "some type" } @update_attrs %{ - "desc" => "some updated desc", - "location" => "some updated location", - "name" => "some updated name", - "type" => "some updated type" + desc: "some updated desc", + location: "some updated location", + name: "some updated name", + type: "some updated type" } @invalid_attrs %{ - "desc" => nil, - "location" => nil, - "name" => nil, - "type" => nil + desc: nil, + location: nil, + name: nil, + type: nil } @valid_tag_attrs %{ - "bg_color" => "#100000", - "name" => "some name", - "text_color" => "#000000" + bg_color: "#100000", + name: "some name", + text_color: "#000000" } @update_tag_attrs %{ - "bg_color" => "#100001", - "name" => "some updated name", - "text_color" => "#000001" + bg_color: "#100001", + name: "some updated name", + text_color: "#000001" } @invalid_tag_attrs %{ - "bg_color" => nil, - "name" => nil, - "text_color" => nil + bg_color: nil, + name: nil, + text_color: nil } describe "containers" do @@ -57,25 +57,24 @@ defmodule Cannery.ContainersTest do test "list_containers/2 returns relevant containers for a user", %{current_user: current_user} do - container_a = container_fixture(%{"name" => "my cool container"}, current_user) - container_b = container_fixture(%{"desc" => "a fascinating description"}, current_user) + container_a = container_fixture(%{name: "my cool container"}, current_user) + container_b = container_fixture(%{desc: "a fascinating description"}, current_user) %{id: container_c_id} = - container_c = container_fixture(%{"location" => "a secret place"}, current_user) + container_c = container_fixture(%{location: "a secret place"}, current_user) - tag = tag_fixture(%{"name" => "stupendous tag"}, current_user) + tag = tag_fixture(%{name: "stupendous tag"}, current_user) Containers.add_tag!(container_c, tag, current_user) container_c = container_c_id |> Containers.get_container!(current_user) %{id: container_d_id} = - container_d = container_fixture(%{"type" => "musty old box"}, current_user) + container_d = container_fixture(%{type: "musty old box"}, current_user) - tag = tag_fixture(%{"name" => "amazing tag"}, current_user) + tag = tag_fixture(%{name: "amazing tag"}, current_user) Containers.add_tag!(container_d, tag, current_user) container_d = container_d_id |> Containers.get_container!(current_user) - _shouldnt_return = - container_fixture(%{"name" => "another person's container"}, user_fixture()) + _shouldnt_return = container_fixture(%{name: "another person's container"}, user_fixture()) # attributes assert Containers.list_containers("cool", current_user) == [container_a] @@ -109,7 +108,7 @@ defmodule Cannery.ContainersTest do test "create_container/2 with valid data creates a container", %{current_user: current_user} do assert {:ok, %Container{} = container} = - @valid_attrs |> Containers.create_container(current_user) + Containers.create_container(@valid_attrs, current_user) assert container.desc == "some desc" assert container.location == "some location" @@ -120,7 +119,7 @@ defmodule Cannery.ContainersTest do test "create_container/2 with invalid data returns error changeset", %{current_user: current_user} do - assert {:error, %Changeset{}} = @invalid_attrs |> Containers.create_container(current_user) + assert {:error, %Changeset{}} = Containers.create_container(@invalid_attrs, current_user) end test "update_container/3 with valid data updates the container", @@ -163,15 +162,10 @@ defmodule Cannery.ContainersTest do end test "list_tags/2 returns relevant tags for a user", %{current_user: current_user} do - tag_a = tag_fixture(%{"name" => "bullets"}, current_user) - tag_b = tag_fixture(%{"name" => "hollows"}, current_user) + tag_a = tag_fixture(%{name: "bullets"}, current_user) + tag_b = tag_fixture(%{name: "hollows"}, current_user) - _shouldnt_return = - %{ - "name" => "bullet", - "desc" => "pews brass shell" - } - |> tag_fixture(user_fixture()) + tag_fixture(%{name: "bullet", desc: "pews brass shell"}, user_fixture()) # name assert Containers.list_tags("bullet", current_user) == [tag_a] diff --git a/test/cannery_web/controllers/user_auth_test.exs b/test/cannery_web/controllers/user_auth_test.exs index 32903204..f7cd5440 100644 --- a/test/cannery_web/controllers/user_auth_test.exs +++ b/test/cannery_web/controllers/user_auth_test.exs @@ -4,7 +4,6 @@ defmodule CanneryWeb.UserAuthTest do """ use CanneryWeb.ConnCase, async: true - import CanneryWeb.Gettext alias Cannery.Accounts alias CanneryWeb.UserAuth @@ -148,7 +147,7 @@ defmodule CanneryWeb.UserAuthTest do assert redirected_to(conn) == Routes.user_session_path(conn, :new) assert get_flash(conn, :error) == - dgettext("errors", "You must confirm your account and log in to access this page.") + "You must confirm your account and log in to access this page." end test "stores the path to redirect to on GET", %{conn: conn} do diff --git a/test/cannery_web/controllers/user_confirmation_controller_test.exs b/test/cannery_web/controllers/user_confirmation_controller_test.exs index 0d645b69..e104d6e1 100644 --- a/test/cannery_web/controllers/user_confirmation_controller_test.exs +++ b/test/cannery_web/controllers/user_confirmation_controller_test.exs @@ -4,7 +4,6 @@ defmodule CanneryWeb.UserConfirmationControllerTest do """ use CanneryWeb.ConnCase, async: true - import CanneryWeb.Gettext alias Cannery.{Accounts, Repo} @moduletag :user_confirmation_controller_test @@ -17,7 +16,7 @@ defmodule CanneryWeb.UserConfirmationControllerTest do test "renders the confirmation page", %{conn: conn} do conn = get(conn, Routes.user_confirmation_path(conn, :new)) response = html_response(conn, 200) - assert response =~ dgettext("actions", "Resend confirmation instructions") + assert response =~ "Resend confirmation instructions" end end @@ -25,18 +24,12 @@ defmodule CanneryWeb.UserConfirmationControllerTest do @tag :capture_log test "sends a new confirmation token", %{conn: conn, user: user} do conn = - post(conn, Routes.user_confirmation_path(conn, :create), %{ - "user" => %{"email" => user.email} - }) + post(conn, Routes.user_confirmation_path(conn, :create), %{user: %{email: user.email}}) assert redirected_to(conn) == "/" assert get_flash(conn, :info) =~ - dgettext( - "prompts", - "If your email is in our system and it has not been confirmed yet, " <> - "you will receive an email with instructions shortly." - ) + "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly." assert Repo.get_by!(Accounts.UserToken, user_id: user.id).context == "confirm" end @@ -45,34 +38,24 @@ defmodule CanneryWeb.UserConfirmationControllerTest do Repo.update!(Accounts.User.confirm_changeset(user)) conn = - post(conn, Routes.user_confirmation_path(conn, :create), %{ - "user" => %{"email" => user.email} - }) + post(conn, Routes.user_confirmation_path(conn, :create), %{user: %{email: user.email}}) assert redirected_to(conn) == "/" assert get_flash(conn, :info) =~ - dgettext( - "prompts", - "If your email is in our system and it has not been confirmed yet, " <> - "you will receive an email with instructions shortly." - ) + "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly." end test "does not send confirmation token if email is invalid", %{conn: conn} do conn = post(conn, Routes.user_confirmation_path(conn, :create), %{ - "user" => %{"email" => "unknown@example.com"} + user: %{email: "unknown@example.com"} }) assert redirected_to(conn) == "/" assert get_flash(conn, :info) =~ - dgettext( - "prompts", - "If your email is in our system and it has not been confirmed yet, " <> - "you will receive an email with instructions shortly." - ) + "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly." assert Repo.all(Accounts.UserToken) == [] end @@ -87,10 +70,7 @@ defmodule CanneryWeb.UserConfirmationControllerTest do conn = get(conn, Routes.user_confirmation_path(conn, :confirm, token)) assert redirected_to(conn) == "/" - - assert get_flash(conn, :info) =~ - dgettext("prompts", "%{email} confirmed successfully", email: user.email) - + assert get_flash(conn, :info) =~ "#{user.email} confirmed successfully" assert Accounts.get_user!(user.id).confirmed_at refute get_session(conn, :user_token) assert Repo.all(Accounts.UserToken) == [] @@ -99,8 +79,7 @@ defmodule CanneryWeb.UserConfirmationControllerTest do conn = get(conn, Routes.user_confirmation_path(conn, :confirm, token)) assert redirected_to(conn) == "/" - assert get_flash(conn, :error) =~ - dgettext("errors", "User confirmation link is invalid or it has expired") + assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired" # When logged in conn = @@ -115,10 +94,7 @@ defmodule CanneryWeb.UserConfirmationControllerTest do test "does not confirm email with invalid token", %{conn: conn, user: user} do conn = get(conn, Routes.user_confirmation_path(conn, :confirm, "oops")) assert redirected_to(conn) == "/" - - assert get_flash(conn, :error) =~ - dgettext("errors", "User confirmation link is invalid or it has expired") - + assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired" refute Accounts.get_user!(user.id).confirmed_at end end diff --git a/test/cannery_web/controllers/user_registration_controller_test.exs b/test/cannery_web/controllers/user_registration_controller_test.exs index 9a75847f..2f667884 100644 --- a/test/cannery_web/controllers/user_registration_controller_test.exs +++ b/test/cannery_web/controllers/user_registration_controller_test.exs @@ -4,7 +4,6 @@ defmodule CanneryWeb.UserRegistrationControllerTest do """ use CanneryWeb.ConnCase, async: true - import CanneryWeb.Gettext @moduletag :user_registration_controller_test @@ -12,8 +11,8 @@ defmodule CanneryWeb.UserRegistrationControllerTest do test "renders registration page", %{conn: conn} do conn = get(conn, Routes.user_registration_path(conn, :new)) response = html_response(conn, 200) - assert response =~ dgettext("actions", "Register") - assert response =~ dgettext("actions", "Log in") + assert response =~ "Register" + assert response =~ "Log in" end test "redirects if already logged in", %{conn: conn} do @@ -29,11 +28,11 @@ defmodule CanneryWeb.UserRegistrationControllerTest do conn = post(conn, Routes.user_registration_path(conn, :create), %{ - "user" => valid_user_attributes(email: email) + user: valid_user_attributes(email: email) }) assert get_session(conn, :phoenix_flash) == %{ - "info" => dgettext("prompts", "Please check your email to verify your account") + "info" => "Please check your email to verify your account" } assert redirected_to(conn) =~ "/" @@ -48,11 +47,11 @@ defmodule CanneryWeb.UserRegistrationControllerTest do test "render errors for invalid data", %{conn: conn} do conn = post(conn, Routes.user_registration_path(conn, :create), %{ - "user" => %{"email" => "with spaces", "password" => "too short"} + user: %{email: "with spaces", password: "too short"} }) response = html_response(conn, 200) - assert response =~ gettext("Register") + assert response =~ "Register" assert response =~ "must have the @ sign and no spaces" assert response =~ "should be at least 12 character" end diff --git a/test/cannery_web/controllers/user_reset_password_controller_test.exs b/test/cannery_web/controllers/user_reset_password_controller_test.exs index 2e546899..296a116c 100644 --- a/test/cannery_web/controllers/user_reset_password_controller_test.exs +++ b/test/cannery_web/controllers/user_reset_password_controller_test.exs @@ -4,7 +4,6 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do """ use CanneryWeb.ConnCase, async: true - import CanneryWeb.Gettext alias Cannery.{Accounts, Repo} @moduletag :user_reset_password_controller_test @@ -17,7 +16,7 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do test "renders the reset password page", %{conn: conn} do conn = get(conn, Routes.user_reset_password_path(conn, :new)) response = html_response(conn, 200) - assert response =~ dgettext("actions", "Forgot your password?") + assert response =~ "Forgot your password?" end end @@ -25,17 +24,12 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do @tag :capture_log test "sends a new reset password token", %{conn: conn, user: user} do conn = - post(conn, Routes.user_reset_password_path(conn, :create), %{ - "user" => %{"email" => user.email} - }) + post(conn, Routes.user_reset_password_path(conn, :create), %{user: %{email: user.email}}) assert redirected_to(conn) == "/" assert get_flash(conn, :info) =~ - dgettext( - "prompts", - "If your email is in our system, you will receive instructions to reset your password shortly." - ) + "If your email is in our system, you will receive instructions to reset your password shortly." assert Repo.get_by!(Accounts.UserToken, user_id: user.id).context == "reset_password" end @@ -43,16 +37,13 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do test "does not send reset password token if email is invalid", %{conn: conn} do conn = post(conn, Routes.user_reset_password_path(conn, :create), %{ - "user" => %{"email" => "unknown@example.com"} + user: %{email: "unknown@example.com"} }) assert redirected_to(conn) == "/" assert get_flash(conn, :info) =~ - dgettext( - "prompts", - "If your email is in our system, you will receive instructions to reset your password shortly." - ) + "If your email is in our system, you will receive instructions to reset your password shortly." assert Repo.all(Accounts.UserToken) == [] end @@ -70,15 +61,13 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do test "renders reset password", %{conn: conn, token: token} do conn = get(conn, Routes.user_reset_password_path(conn, :edit, token)) - assert html_response(conn, 200) =~ dgettext("actions", "Reset password") + assert html_response(conn, 200) =~ "Reset password" end test "does not render reset password with invalid token", %{conn: conn} do conn = get(conn, Routes.user_reset_password_path(conn, :edit, "oops")) assert redirected_to(conn) == "/" - - assert get_flash(conn, :error) =~ - dgettext("errors", "Reset password link is invalid or it has expired") + assert get_flash(conn, :error) =~ "Reset password link is invalid or it has expired" end end @@ -95,39 +84,37 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do test "resets password once", %{conn: conn, user: user, token: token} do conn = put(conn, Routes.user_reset_password_path(conn, :update, token), %{ - "user" => %{ - "password" => "new valid password", - "password_confirmation" => "new valid password" + user: %{ + password: "new valid password", + password_confirmation: "new valid password" } }) assert redirected_to(conn) == Routes.user_session_path(conn, :new) refute get_session(conn, :user_token) - assert get_flash(conn, :info) =~ dgettext("prompts", "Password reset successfully") + assert get_flash(conn, :info) =~ "Password reset successfully" assert Accounts.get_user_by_email_and_password(user.email, "new valid password") end test "does not reset password on invalid data", %{conn: conn, token: token} do conn = put(conn, Routes.user_reset_password_path(conn, :update, token), %{ - "user" => %{ - "password" => "too short", - "password_confirmation" => "does not match" + user: %{ + password: "too short", + password_confirmation: "does not match" } }) response = html_response(conn, 200) - assert response =~ gettext("Reset password") - assert response =~ dgettext("errors", "should be at least 12 character(s)") - assert response =~ dgettext("errors", "does not match password") + assert response =~ "Reset password" + assert response =~ "should be at least 12 character(s)" + assert response =~ "does not match password" end test "does not reset password with invalid token", %{conn: conn} do conn = put(conn, Routes.user_reset_password_path(conn, :update, "oops")) assert redirected_to(conn) == "/" - - assert get_flash(conn, :error) =~ - dgettext("errors", "Reset password link is invalid or it has expired") + assert get_flash(conn, :error) =~ "Reset password link is invalid or it has expired" end end end diff --git a/test/cannery_web/controllers/user_session_controller_test.exs b/test/cannery_web/controllers/user_session_controller_test.exs index 9541e0dc..5918b6f2 100644 --- a/test/cannery_web/controllers/user_session_controller_test.exs +++ b/test/cannery_web/controllers/user_session_controller_test.exs @@ -4,7 +4,6 @@ defmodule CanneryWeb.UserSessionControllerTest do """ use CanneryWeb.ConnCase, async: true - import CanneryWeb.Gettext @moduletag :user_session_controller_test @@ -16,7 +15,7 @@ defmodule CanneryWeb.UserSessionControllerTest do test "renders log in page", %{conn: conn} do conn = get(conn, Routes.user_session_path(conn, :new)) response = html_response(conn, 200) - assert response =~ dgettext("actions", "Log in") + assert response =~ "Log in" end test "redirects if already logged in", %{conn: conn, current_user: current_user} do @@ -29,7 +28,7 @@ defmodule CanneryWeb.UserSessionControllerTest do test "logs the user in", %{conn: conn, current_user: current_user} do conn = post(conn, Routes.user_session_path(conn, :create), %{ - "user" => %{"email" => current_user.email, "password" => valid_user_password()} + user: %{email: current_user.email, password: valid_user_password()} }) assert get_session(conn, :user_token) @@ -39,16 +38,16 @@ defmodule CanneryWeb.UserSessionControllerTest do conn = get(conn, "/") response = html_response(conn, 200) assert response =~ current_user.email - assert response =~ dgettext("prompts", "Are you sure you want to log out?") + assert response =~ "Are you sure you want to log out?" end test "logs the user in with remember me", %{conn: conn, current_user: current_user} do conn = post(conn, Routes.user_session_path(conn, :create), %{ - "user" => %{ - "email" => current_user.email, - "password" => valid_user_password(), - "remember_me" => "true" + user: %{ + email: current_user.email, + password: valid_user_password(), + remember_me: "true" } }) @@ -61,9 +60,9 @@ defmodule CanneryWeb.UserSessionControllerTest do conn |> init_test_session(user_return_to: "/foo/bar") |> post(Routes.user_session_path(conn, :create), %{ - "user" => %{ - "email" => current_user.email, - "password" => valid_user_password() + user: %{ + email: current_user.email, + password: valid_user_password() } }) @@ -74,12 +73,12 @@ defmodule CanneryWeb.UserSessionControllerTest do %{conn: conn, current_user: current_user} do conn = post(conn, Routes.user_session_path(conn, :create), %{ - "user" => %{"email" => current_user.email, "password" => "bad"} + user: %{email: current_user.email, password: "bad"} }) response = html_response(conn, 200) - assert response =~ dgettext("actions", "Log in") - assert response =~ dgettext("errors", "Invalid email or password") + assert response =~ "Log in" + assert response =~ "Invalid email or password" end end @@ -88,14 +87,14 @@ defmodule CanneryWeb.UserSessionControllerTest do conn = conn |> log_in_user(current_user) |> delete(Routes.user_session_path(conn, :delete)) assert redirected_to(conn) == "/" refute get_session(conn, :user_token) - assert get_flash(conn, :info) =~ gettext("Logged out successfully") + assert get_flash(conn, :info) =~ "Logged out successfully" end test "succeeds even if the user is not logged in", %{conn: conn} do conn = delete(conn, Routes.user_session_path(conn, :delete)) assert redirected_to(conn) == "/" refute get_session(conn, :user_token) - assert get_flash(conn, :info) =~ gettext("Logged out successfully") + assert get_flash(conn, :info) =~ "Logged out successfully" end end end diff --git a/test/cannery_web/controllers/user_settings_controller_test.exs b/test/cannery_web/controllers/user_settings_controller_test.exs index ba66cad7..35ab46c3 100644 --- a/test/cannery_web/controllers/user_settings_controller_test.exs +++ b/test/cannery_web/controllers/user_settings_controller_test.exs @@ -4,7 +4,6 @@ defmodule CanneryWeb.UserSettingsControllerTest do """ use CanneryWeb.ConnCase, async: true - import CanneryWeb.Gettext alias Cannery.Accounts @moduletag :user_settings_controller_test @@ -15,7 +14,7 @@ defmodule CanneryWeb.UserSettingsControllerTest do test "renders settings page", %{conn: conn} do conn = get(conn, Routes.user_settings_path(conn, :edit)) response = html_response(conn, 200) - assert response =~ gettext("Settings") + assert response =~ "Settings" end test "redirects if user is not logged in" do @@ -30,40 +29,36 @@ defmodule CanneryWeb.UserSettingsControllerTest do %{conn: conn, current_user: current_user} do new_password_conn = put(conn, Routes.user_settings_path(conn, :update), %{ - "action" => "update_password", - "current_password" => valid_user_password(), - "user" => %{ - "password" => "new valid password", - "password_confirmation" => "new valid password" + action: "update_password", + current_password: valid_user_password(), + user: %{ + password: "new valid password", + password_confirmation: "new valid password" } }) assert redirected_to(new_password_conn) == Routes.user_settings_path(conn, :edit) assert get_session(new_password_conn, :user_token) != get_session(conn, :user_token) - - assert get_flash(new_password_conn, :info) =~ - dgettext("actions", "Password updated successfully") - + assert get_flash(new_password_conn, :info) =~ "Password updated successfully" assert Accounts.get_user_by_email_and_password(current_user.email, "new valid password") end test "does not update password on invalid data", %{conn: conn} do old_password_conn = put(conn, Routes.user_settings_path(conn, :update), %{ - "action" => "update_password", - "current_password" => "invalid", - "user" => %{ - "password" => "too short", - "password_confirmation" => "does not match" + action: "update_password", + current_password: "invalid", + user: %{ + password: "too short", + password_confirmation: "does not match" } }) response = html_response(old_password_conn, 200) - assert response =~ gettext("Settings") - assert response =~ dgettext("errors", "should be at least 12 character(s)") - assert response =~ dgettext("errors", "does not match password") - assert response =~ dgettext("errors", "is not valid") - + assert response =~ "Settings" + assert response =~ "should be at least 12 character(s)" + assert response =~ "does not match password" + assert response =~ "is not valid" assert get_session(old_password_conn, :user_token) == get_session(conn, :user_token) end end @@ -73,18 +68,15 @@ defmodule CanneryWeb.UserSettingsControllerTest do test "updates the user email", %{conn: conn, current_user: current_user} do conn = put(conn, Routes.user_settings_path(conn, :update), %{ - "action" => "update_email", - "current_password" => valid_user_password(), - "user" => %{"email" => unique_user_email()} + action: "update_email", + current_password: valid_user_password(), + user: %{email: unique_user_email()} }) assert redirected_to(conn) == Routes.user_settings_path(conn, :edit) assert get_flash(conn, :info) =~ - dgettext( - "prompts", - "A link to confirm your email change has been sent to the new address." - ) + "A link to confirm your email change has been sent to the new address." assert Accounts.get_user_by_email(current_user.email) end @@ -92,15 +84,15 @@ defmodule CanneryWeb.UserSettingsControllerTest do test "does not update email on invalid data", %{conn: conn} do conn = put(conn, Routes.user_settings_path(conn, :update), %{ - "action" => "update_email", - "current_password" => "invalid", - "user" => %{"email" => "with spaces"} + action: "update_email", + current_password: "invalid", + user: %{email: "with spaces"} }) response = html_response(conn, 200) - assert response =~ gettext("Settings") - assert response =~ dgettext("errors", "must have the @ sign and no spaces") - assert response =~ dgettext("errors", "is not valid") + assert response =~ "Settings" + assert response =~ "must have the @ sign and no spaces" + assert response =~ "is not valid" end end @@ -124,24 +116,19 @@ defmodule CanneryWeb.UserSettingsControllerTest do %{conn: conn, current_user: current_user, token: token, email: email} do conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token)) assert redirected_to(conn) == Routes.user_settings_path(conn, :edit) - assert get_flash(conn, :info) =~ dgettext("prompts", "Email changed successfully") + assert get_flash(conn, :info) =~ "Email changed successfully" refute Accounts.get_user_by_email(current_user.email) assert Accounts.get_user_by_email(email) conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token)) assert redirected_to(conn) == Routes.user_settings_path(conn, :edit) - - assert get_flash(conn, :error) =~ - dgettext("errors", "Email change link is invalid or it has expired") + assert get_flash(conn, :error) =~ "Email change link is invalid or it has expired" end test "does not update email with invalid token", %{conn: conn, current_user: current_user} do conn = get(conn, Routes.user_settings_path(conn, :confirm_email, "oops")) assert redirected_to(conn) == Routes.user_settings_path(conn, :edit) - - assert get_flash(conn, :error) =~ - dgettext("errors", "Email change link is invalid or it has expired") - + assert get_flash(conn, :error) =~ "Email change link is invalid or it has expired" assert Accounts.get_user_by_email(current_user.email) end diff --git a/test/cannery_web/live/ammo_group_live_test.exs b/test/cannery_web/live/ammo_group_live_test.exs index 1d05dcac..6c0e8593 100644 --- a/test/cannery_web/live/ammo_group_live_test.exs +++ b/test/cannery_web/live/ammo_group_live_test.exs @@ -5,43 +5,40 @@ defmodule CanneryWeb.AmmoGroupLiveTest do use CanneryWeb.ConnCase import Phoenix.LiveViewTest - import CanneryWeb.Gettext alias Cannery.{Ammo, Repo} @moduletag :ammo_group_live_test - @shot_group_create_attrs %{"ammo_left" => 5, "notes" => "some notes"} - @shot_group_update_attrs %{ - "count" => 5, - "date" => ~N[2022-02-13 03:17:00], - "notes" => "some updated notes" - } - @create_attrs %{"count" => 42, "notes" => "some notes", "price_paid" => 120.5} - @update_attrs %{"count" => 43, "notes" => "some updated notes", "price_paid" => 456.7} + @create_attrs %{count: 42, notes: "some notes", price_paid: 120.5} + @update_attrs %{count: 43, notes: "some updated notes", price_paid: 456.7} + @invalid_attrs %{count: nil, notes: nil, price_paid: nil} @ammo_group_create_limit 10_000 + @shot_group_create_attrs %{ammo_left: 5, notes: "some notes"} + @shot_group_update_attrs %{ + count: 5, + date: ~N[2022-02-13 03:17:00], + notes: "some updated notes" + } + @shot_group_invalid_attrs %{ammo_left: nil, count: nil, notes: nil} @empty_attrs %{ - "price_paid" => 50, - "count" => 20 + price_paid: 50, + count: 20 } @shot_group_attrs %{ - "price_paid" => 50, - "count" => 20 + price_paid: 50, + count: 20 } - # @invalid_attrs %{count: -1, notes: nil, price_paid: nil} - defp create_ammo_group(%{current_user: current_user}) do ammo_type = ammo_type_fixture(current_user) container = container_fixture(current_user) {1, [ammo_group]} = ammo_group_fixture(@create_attrs, ammo_type, container, current_user) - - %{ammo_type: ammo_type, ammo_group: ammo_group, container: container} + [ammo_type: ammo_type, ammo_group: ammo_group, container: container] end defp create_shot_group(%{current_user: current_user, ammo_group: ammo_group}) do shot_group = shot_group_fixture(@shot_group_update_attrs, current_user, ammo_group) ammo_group = ammo_group |> Repo.reload!() - - %{ammo_group: ammo_group, shot_group: shot_group} + [ammo_group: ammo_group, shot_group: shot_group] end defp create_empty_ammo_group(%{ @@ -52,7 +49,7 @@ defmodule CanneryWeb.AmmoGroupLiveTest do {1, [ammo_group]} = ammo_group_fixture(@empty_attrs, ammo_type, container, current_user) shot_group = shot_group_fixture(@shot_group_attrs, current_user, ammo_group) ammo_group = ammo_group |> Repo.reload!() - %{empty_ammo_group: ammo_group, shot_group: shot_group} + [empty_ammo_group: ammo_group, shot_group: shot_group] end describe "Index of ammo group" do @@ -60,19 +57,18 @@ defmodule CanneryWeb.AmmoGroupLiveTest do test "lists all ammo_groups", %{conn: conn, ammo_group: ammo_group} do {:ok, _index_live, html} = live(conn, Routes.ammo_group_index_path(conn, :index)) - ammo_group = ammo_group |> Repo.preload(:ammo_type) - assert html =~ gettext("Ammo") + assert html =~ "Ammo" assert html =~ ammo_group.ammo_type.name end test "can sort by type", %{conn: conn, container: container, current_user: current_user} do - rifle_type = ammo_type_fixture(%{"type" => "rifle"}, current_user) + rifle_type = ammo_type_fixture(%{type: "rifle"}, current_user) {1, [rifle_ammo_group]} = ammo_group_fixture(rifle_type, container, current_user) - shotgun_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user) + shotgun_type = ammo_type_fixture(%{type: "shotgun"}, current_user) {1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_type, container, current_user) - pistol_type = ammo_type_fixture(%{"type" => "pistol"}, current_user) + pistol_type = ammo_type_fixture(%{type: "pistol"}, current_user) {1, [pistol_ammo_group]} = ammo_group_fixture(pistol_type, container, current_user) {:ok, index_live, html} = live(conn, Routes.ammo_group_index_path(conn, :index)) @@ -128,10 +124,9 @@ defmodule CanneryWeb.AmmoGroupLiveTest do assert html =~ ammo_group.ammo_type.name assert index_live - |> form(~s/form[phx-change="search"]/, - search: %{search_term: ammo_group.ammo_type.name} - ) - |> render_change() =~ ammo_group.ammo_type.name + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: ammo_group.ammo_type.name}) =~ + ammo_group.ammo_type.name assert_patch( index_live, @@ -139,14 +134,15 @@ defmodule CanneryWeb.AmmoGroupLiveTest do ) refute index_live - |> form(~s/form[phx-change="search"]/, search: %{search_term: "something_else"}) - |> render_change() =~ ammo_group.ammo_type.name + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: "something_else"}) =~ + ammo_group.ammo_type.name assert_patch(index_live, Routes.ammo_group_index_path(conn, :search, "something_else")) assert index_live - |> form(~s/form[phx-change="search"]/, search: %{search_term: ""}) - |> render_change() =~ ammo_group.ammo_type.name + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: ""}) =~ ammo_group.ammo_type.name assert_patch(index_live, Routes.ammo_group_index_path(conn, :index)) end @@ -154,85 +150,65 @@ defmodule CanneryWeb.AmmoGroupLiveTest do test "saves a single new ammo_group", %{conn: conn} do {:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "Add Ammo")) |> render_click() =~ - dgettext("actions", "Add Ammo") - + assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo" assert_patch(index_live, Routes.ammo_group_index_path(conn, :new)) - # assert index_live - # |> form("#ammo_group-form", ammo_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_group-form") + |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#ammo_group-form", ammo_group: @create_attrs) - |> render_submit() + |> form("#ammo_group-form") + |> render_submit(ammo_group: @create_attrs) |> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index)) - assert html =~ dgettext("prompts", "Ammo added successfully") + assert html =~ "Ammo added successfully" assert html =~ "\n42\n" end test "saves multiple new ammo_groups", %{conn: conn, current_user: current_user} do multiplier = 25 - {:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "Add Ammo")) |> render_click() =~ - dgettext("actions", "Add Ammo") - + assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo" assert_patch(index_live, Routes.ammo_group_index_path(conn, :new)) - # assert index_live - # |> form("#ammo_group-form", ammo_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_group-form") + |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#ammo_group-form", - ammo_group: @create_attrs |> Map.put("multiplier", to_string(multiplier)) - ) - |> render_submit() + |> form("#ammo_group-form") + |> render_submit(ammo_group: @create_attrs |> Map.put(:multiplier, multiplier)) |> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index)) - assert html =~ dgettext("prompts", "Ammo added successfully") + assert html =~ "Ammo added successfully" assert Ammo.list_ammo_groups(nil, :all, current_user) |> Enum.count() == multiplier + 1 end test "does not save invalid number of new ammo_groups", %{conn: conn} do {:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "Add Ammo")) |> render_click() =~ - dgettext("actions", "Add Ammo") - + assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo" assert_patch(index_live, Routes.ammo_group_index_path(conn, :new)) - # assert index_live - # |> form("#ammo_group-form", ammo_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_group-form") + |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank" assert index_live - |> form("#ammo_group-form", ammo_group: @create_attrs |> Map.put("multiplier", "0")) - |> render_submit() =~ - dgettext( - "errors", - "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}", - multiplier: 0, - max: @ammo_group_create_limit - ) + |> form("#ammo_group-form") + |> render_submit(ammo_group: @create_attrs |> Map.put(:multiplier, "0")) =~ + "Invalid number of copies, must be between 1 and #{@ammo_group_create_limit}. Was 0" assert index_live - |> form("#ammo_group-form", - ammo_group: - @create_attrs |> Map.put("multiplier", to_string(@ammo_group_create_limit + 1)) - ) - |> render_submit() =~ - dgettext( - "errors", - "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}", - multiplier: @ammo_group_create_limit + 1, - max: @ammo_group_create_limit - ) + |> form("#ammo_group-form") + |> render_submit( + ammo_group: @create_attrs |> Map.put(:multiplier, @ammo_group_create_limit + 1) + ) =~ + "Invalid number of copies, must be between 1 and #{@ammo_group_create_limit}. Was #{@ammo_group_create_limit + 1}" end test "updates ammo_group in listing", %{conn: conn, ammo_group: ammo_group} do @@ -240,22 +216,21 @@ defmodule CanneryWeb.AmmoGroupLiveTest do assert index_live |> element(~s/a[aria-label="Edit ammo group of #{ammo_group.count} bullets"]/) - |> render_click() =~ - gettext("Edit ammo") + |> render_click() =~ "Edit ammo" assert_patch(index_live, Routes.ammo_group_index_path(conn, :edit, ammo_group)) - # assert index_live - # |> form("#ammo_group-form", ammo_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_group-form") + |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#ammo_group-form", ammo_group: @update_attrs) - |> render_submit() + |> form("#ammo_group-form") + |> render_submit(ammo_group: @update_attrs) |> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index)) - assert html =~ dgettext("prompts", "Ammo updated successfully") + assert html =~ "Ammo updated successfully" assert html =~ "\n43\n" end @@ -267,24 +242,38 @@ defmodule CanneryWeb.AmmoGroupLiveTest do |> element(~s/a[aria-label="Clone ammo group of #{ammo_group.count} bullets"]/) |> render_click() - assert html =~ dgettext("actions", "Add Ammo") - assert html =~ gettext("$%{amount}", amount: display_currency(120.5)) + assert html =~ "Add Ammo" + assert html =~ "$#{display_currency(120.5)}" assert_patch(index_live, Routes.ammo_group_index_path(conn, :clone, ammo_group)) - # assert index_live - # |> form("#ammo_group-form", ammo_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") - - {:ok, _view, html} = + {:ok, _index_live, html} = index_live |> form("#ammo_group-form") |> render_submit() |> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index)) - assert html =~ dgettext("prompts", "Ammo added successfully") + assert html =~ "Ammo added successfully" assert html =~ "\n42\n" - assert html =~ gettext("$%{amount}", amount: display_currency(120.5)) + assert html =~ "$#{display_currency(120.5)}" + end + + test "checks validity when cloning", %{conn: conn, ammo_group: ammo_group} do + {:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index)) + + html = + index_live + |> element(~s/a[aria-label="Clone ammo group of #{ammo_group.count} bullets"]/) + |> render_click() + + assert html =~ "Add Ammo" + assert html =~ "$#{display_currency(120.5)}" + + assert_patch(index_live, Routes.ammo_group_index_path(conn, :clone, ammo_group)) + + assert index_live + |> form("#ammo_group-form") + |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank" end test "clones ammo_group in listing with updates", %{conn: conn, ammo_group: ammo_group} do @@ -295,24 +284,23 @@ defmodule CanneryWeb.AmmoGroupLiveTest do |> element(~s/a[aria-label="Clone ammo group of #{ammo_group.count} bullets"]/) |> render_click() - assert html =~ dgettext("actions", "Add Ammo") - assert html =~ gettext("$%{amount}", amount: display_currency(120.5)) - + assert html =~ "Add Ammo" + assert html =~ "$#{display_currency(120.5)}" assert_patch(index_live, Routes.ammo_group_index_path(conn, :clone, ammo_group)) - # assert index_live - # |> form("#ammo_group-form", ammo_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_group-form") + |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#ammo_group-form", ammo_group: Map.merge(@create_attrs, %{"count" => 43})) - |> render_submit() + |> form("#ammo_group-form") + |> render_submit(ammo_group: @create_attrs |> Map.put(:count, 43)) |> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index)) - assert html =~ dgettext("prompts", "Ammo added successfully") + assert html =~ "Ammo added successfully" assert html =~ "\n43\n" - assert html =~ gettext("$%{amount}", amount: display_currency(120.5)) + assert html =~ "$#{display_currency(120.5)}" end test "deletes ammo_group in listing", %{conn: conn, ammo_group: ammo_group} do @@ -328,22 +316,20 @@ defmodule CanneryWeb.AmmoGroupLiveTest do test "saves new shot_group", %{conn: conn, ammo_group: ammo_group} do {:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "Record shots")) |> render_click() =~ - gettext("Record shots") - + assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots" assert_patch(index_live, Routes.ammo_group_index_path(conn, :add_shot_group, ammo_group)) - # assert index_live - # |> form("#shot_group-form", shot_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "is invalid") + assert index_live + |> form("#shot-group-form") + |> render_change(shot_group: @shot_group_invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#shot-group-form", shot_group: @shot_group_create_attrs) - |> render_submit() + |> form("#shot-group-form") + |> render_submit(shot_group: @shot_group_create_attrs) |> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index)) - assert html =~ dgettext("prompts", "Shots recorded successfully") + assert html =~ "Shots recorded successfully" end @spec display_currency(float()) :: String.t() @@ -360,21 +346,20 @@ defmodule CanneryWeb.AmmoGroupLiveTest do } do {:ok, show_live, html} = live(conn, Routes.ammo_group_index_path(conn, :index)) - assert html =~ dgettext("actions", "Show used") - refute html =~ gettext("$%{amount}", amount: display_currency(50.00)) + assert html =~ "Show used" + refute html =~ "$#{display_currency(50.00)}" percentage = ammo_group |> Ammo.get_percentage_remaining(current_user) - refute html =~ "\n#{gettext("%{percentage}%", percentage: percentage)}\n" + refute html =~ "\n#{"#{percentage}%"}\n" html = show_live |> element(~s/input[type="checkbox"][aria-labelledby="toggle_show_used-label"}]/) |> render_click() - assert html =~ gettext("$%{amount}", amount: display_currency(50.00)) - + assert html =~ "$#{display_currency(50.00)}" percentage = ammo_group |> Ammo.get_percentage_remaining(current_user) - assert html =~ "\n#{gettext("%{percentage}%", percentage: percentage)}\n" + assert html =~ "\n#{"#{percentage}%"}\n" end end @@ -383,9 +368,8 @@ defmodule CanneryWeb.AmmoGroupLiveTest do test "displays ammo_group", %{conn: conn, ammo_group: ammo_group} do {:ok, _show_live, html} = live(conn, Routes.ammo_group_show_path(conn, :show, ammo_group)) - ammo_group = ammo_group |> Repo.preload(:ammo_type) - assert html =~ gettext("Show Ammo") + assert html =~ "Show Ammo" assert html =~ ammo_group.ammo_type.name end @@ -394,44 +378,41 @@ defmodule CanneryWeb.AmmoGroupLiveTest do assert show_live |> element(~s/a[aria-label="Edit ammo group of #{ammo_group.count} bullets"]/) - |> render_click() =~ - gettext("Edit Ammo") + |> render_click() =~ "Edit Ammo" assert_patch(show_live, Routes.ammo_group_show_path(conn, :edit, ammo_group)) - # assert show_live - # |> form("#ammo_group-form", ammo_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert show_live + |> form("#ammo_group-form") + |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = show_live - |> form("#ammo_group-form", ammo_group: @update_attrs) - |> render_submit() + |> form("#ammo_group-form") + |> render_submit(ammo_group: @update_attrs) |> follow_redirect(conn, Routes.ammo_group_show_path(conn, :show, ammo_group)) - assert html =~ dgettext("prompts", "Ammo updated successfully") + assert html =~ "Ammo updated successfully" assert html =~ "some updated notes" end test "saves new shot_group", %{conn: conn, ammo_group: ammo_group} do {:ok, index_live, _html} = live(conn, Routes.ammo_group_show_path(conn, :show, ammo_group)) - assert index_live |> element("a", dgettext("actions", "Record shots")) |> render_click() =~ - gettext("Record shots") - + assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots" assert_patch(index_live, Routes.ammo_group_show_path(conn, :add_shot_group, ammo_group)) - # assert index_live - # |> form("#shot_group-form", shot_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "is invalid") + assert index_live + |> form("#shot-group-form") + |> render_change(shot_group: @shot_group_invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#shot-group-form", shot_group: @shot_group_create_attrs) - |> render_submit() + |> form("#shot-group-form") + |> render_submit(shot_group: @shot_group_create_attrs) |> follow_redirect(conn, Routes.ammo_group_show_path(conn, :show, ammo_group)) - assert html =~ dgettext("prompts", "Shots recorded successfully") + assert html =~ "Shots recorded successfully" end end @@ -444,25 +425,24 @@ defmodule CanneryWeb.AmmoGroupLiveTest do assert index_live |> element(~s/a[aria-label="Edit shot group of #{shot_group.count} shots"]/) - |> render_click() =~ - gettext("Edit Shot Records") + |> render_click() =~ "Edit Shot Records" assert_patch( index_live, Routes.ammo_group_show_path(conn, :edit_shot_group, ammo_group, shot_group) ) - # assert index_live - # |> form("#shot_group-form", shot_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "is invalid") + assert index_live + |> form("#shot-group-form") + |> render_change(shot_group: @shot_group_invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#shot-group-form", shot_group: @shot_group_update_attrs) - |> render_submit() + |> form("#shot-group-form") + |> render_submit(shot_group: @shot_group_update_attrs) |> follow_redirect(conn, Routes.ammo_group_show_path(conn, :show, ammo_group)) - assert html =~ dgettext("actions", "Shot records updated successfully") + assert html =~ "Shot records updated successfully" assert html =~ "some updated notes" end diff --git a/test/cannery_web/live/ammo_type_live_test.exs b/test/cannery_web/live/ammo_type_live_test.exs index 7f8683f2..bde178af 100644 --- a/test/cannery_web/live/ammo_type_live_test.exs +++ b/test/cannery_web/live/ammo_type_live_test.exs @@ -5,54 +5,51 @@ defmodule CanneryWeb.AmmoTypeLiveTest do use CanneryWeb.ConnCase import Phoenix.LiveViewTest - import CanneryWeb.Gettext alias Cannery.{Ammo, Repo} @moduletag :ammo_type_live_test @create_attrs %{ - "bullet_type" => "some bullet_type", - "case_material" => "some case_material", - "desc" => "some desc", - "manufacturer" => "some manufacturer", - "name" => "some name", - "grains" => 120 + bullet_type: "some bullet_type", + case_material: "some case_material", + desc: "some desc", + manufacturer: "some manufacturer", + name: "some name", + grains: 120 } @update_attrs %{ - "bullet_type" => "some updated bullet_type", - "case_material" => "some updated case_material", - "desc" => "some updated desc", - "manufacturer" => "some updated manufacturer", - "name" => "some updated name", - "grains" => 456 + bullet_type: "some updated bullet_type", + case_material: "some updated case_material", + desc: "some updated desc", + manufacturer: "some updated manufacturer", + name: "some updated name", + grains: 456 + } + @invalid_attrs %{ + bullet_type: nil, + case_material: nil, + desc: nil, + manufacturer: nil, + name: nil, + grains: nil } @ammo_group_attrs %{ - "notes" => "some ammo group", - "count" => 20 + notes: "some ammo group", + count: 20 } @shot_group_attrs %{ - "notes" => "some shot group", - "count" => 20 + notes: "some shot group", + count: 20 } - # @invalid_attrs %{ - # "bullet_type" => nil, - # "case_material" => nil, - # "desc" => nil, - # "manufacturer" => nil, - # "name" => nil, - # "grains" => nil - # } - defp create_ammo_type(%{current_user: current_user}) do - %{ammo_type: ammo_type_fixture(@create_attrs, current_user)} + [ammo_type: ammo_type_fixture(@create_attrs, current_user)] end defp create_ammo_group(%{ammo_type: ammo_type, current_user: current_user}) do container = container_fixture(current_user) {1, [ammo_group]} = ammo_group_fixture(@ammo_group_attrs, ammo_type, container, current_user) - - %{ammo_group: ammo_group, container: container} + [ammo_group: ammo_group, container: container] end defp create_empty_ammo_group(%{ammo_type: ammo_type, current_user: current_user}) do @@ -60,8 +57,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do {1, [ammo_group]} = ammo_group_fixture(@ammo_group_attrs, ammo_type, container, current_user) shot_group = shot_group_fixture(@shot_group_attrs, current_user, ammo_group) ammo_group = ammo_group |> Repo.reload!() - - %{ammo_group: ammo_group, container: container, shot_group: shot_group} + [ammo_group: ammo_group, container: container, shot_group: shot_group] end describe "Index" do @@ -69,15 +65,14 @@ defmodule CanneryWeb.AmmoTypeLiveTest do test "lists all ammo_types", %{conn: conn, ammo_type: ammo_type} do {:ok, _index_live, html} = live(conn, Routes.ammo_type_index_path(conn, :index)) - - assert html =~ gettext("Catalog") + assert html =~ "Catalog" assert html =~ ammo_type.bullet_type end test "can sort by type", %{conn: conn, current_user: current_user} do - rifle_type = ammo_type_fixture(%{"type" => "rifle"}, current_user) - shotgun_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user) - pistol_type = ammo_type_fixture(%{"type" => "pistol"}, current_user) + rifle_type = ammo_type_fixture(%{type: "rifle"}, current_user) + shotgun_type = ammo_type_fixture(%{type: "shotgun"}, current_user) + pistol_type = ammo_type_fixture(%{type: "pistol"}, current_user) {:ok, index_live, html} = live(conn, Routes.ammo_type_index_path(conn, :index)) @@ -152,14 +147,12 @@ defmodule CanneryWeb.AmmoTypeLiveTest do test "saves new ammo_type", %{conn: conn, current_user: current_user, ammo_type: ammo_type} do {:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "New Ammo type")) |> render_click() =~ - gettext("New Ammo type") - + assert index_live |> element("a", "New Ammo type") |> render_click() =~ "New Ammo type" assert_patch(index_live, Routes.ammo_type_index_path(conn, :new)) - # assert index_live - # |> form("#ammo_type-form", ammo_type: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_type-form") + |> render_change(ammo_type: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live @@ -168,7 +161,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do |> follow_redirect(conn, Routes.ammo_type_index_path(conn, :index)) ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user) - assert html =~ dgettext("prompts", "%{name} created successfully", name: ammo_type.name) + assert html =~ "#{ammo_type.name} created successfully" assert html =~ "some bullet_type" end @@ -177,13 +170,13 @@ defmodule CanneryWeb.AmmoTypeLiveTest do {:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index)) assert index_live |> element(~s/a[aria-label="Edit #{ammo_type.name}"]/) |> render_click() =~ - gettext("Edit %{ammo_type_name}", ammo_type_name: ammo_type.name) + "Edit #{ammo_type.name}" assert_patch(index_live, Routes.ammo_type_index_path(conn, :edit, ammo_type)) - # assert index_live - # |> form("#ammo_type-form", ammo_type: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_type-form") + |> render_change(ammo_type: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live @@ -192,7 +185,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do |> follow_redirect(conn, Routes.ammo_type_index_path(conn, :index)) ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user) - assert html =~ dgettext("prompts", "%{name} updated successfully", name: ammo_type.name) + assert html =~ "#{ammo_type.name} updated successfully" assert html =~ "some updated bullet_type" end @@ -201,14 +194,14 @@ defmodule CanneryWeb.AmmoTypeLiveTest do {:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index)) html = index_live |> element(~s/a[aria-label="Clone #{ammo_type.name}"]/) |> render_click() - assert html =~ gettext("New Ammo type") + assert html =~ "New Ammo type" assert html =~ "some bullet_type" assert_patch(index_live, Routes.ammo_type_index_path(conn, :clone, ammo_type)) - # assert index_live - # |> form("#ammo_type-form", ammo_type: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_type-form") + |> render_change(ammo_type: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live @@ -217,7 +210,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do |> follow_redirect(conn, Routes.ammo_type_index_path(conn, :index)) ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user) - assert html =~ dgettext("prompts", "%{name} created successfully", name: ammo_type.name) + assert html =~ "#{ammo_type.name} created successfully" assert html =~ "some bullet_type" end @@ -226,31 +219,30 @@ defmodule CanneryWeb.AmmoTypeLiveTest do {:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index)) html = index_live |> element(~s/a[aria-label="Clone #{ammo_type.name}"]/) |> render_click() - assert html =~ gettext("New Ammo type") + assert html =~ "New Ammo type" assert html =~ "some bullet_type" assert_patch(index_live, Routes.ammo_type_index_path(conn, :clone, ammo_type)) - # assert index_live - # |> form("#ammo_type-form", ammo_type: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#ammo_type-form") + |> render_change(ammo_type: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live |> form("#ammo_type-form") |> render_submit( - ammo_type: Map.merge(@create_attrs, %{"bullet_type" => "some updated bullet_type"}) + ammo_type: Map.merge(@create_attrs, %{bullet_type: "some updated bullet_type"}) ) |> follow_redirect(conn, Routes.ammo_type_index_path(conn, :index)) ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user) - assert html =~ dgettext("prompts", "%{name} created successfully", name: ammo_type.name) + assert html =~ "#{ammo_type.name} created successfully" assert html =~ "some updated bullet_type" end test "deletes ammo_type in listing", %{conn: conn, ammo_type: ammo_type} do {:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index)) - assert index_live |> element(~s/a[aria-label="Delete #{ammo_type.name}"]/) |> render_click() refute has_element?(index_live, "#ammo_type-#{ammo_type.id}") end @@ -263,27 +255,27 @@ defmodule CanneryWeb.AmmoTypeLiveTest do %{conn: conn, ammo_group: ammo_group, current_user: current_user} do {:ok, index_live, html} = live(conn, Routes.ammo_type_index_path(conn, :index)) - assert html =~ dgettext("actions", "Show used") - refute html =~ gettext("Used rounds") - refute html =~ gettext("Total ever rounds") - refute html =~ gettext("Used packs") - refute html =~ gettext("Total ever packs") + assert html =~ "Show used" + refute html =~ "Used rounds" + refute html =~ "Total ever rounds" + refute html =~ "Used packs" + refute html =~ "Total ever packs" html = index_live |> element(~s/input[type="checkbox"][aria-labelledby="toggle_show_used-label"}]/) |> render_click() - assert html =~ gettext("Used rounds") - assert html =~ gettext("Total ever rounds") - assert html =~ gettext("Used packs") - assert html =~ gettext("Total ever packs") + assert html =~ "Used rounds" + assert html =~ "Total ever rounds" + assert html =~ "Used packs" + assert html =~ "Total ever packs" assert html =~ "\n20\n" assert html =~ "\n0\n" assert html =~ "\n1\n" - shot_group_fixture(%{"count" => 5}, current_user, ammo_group) + shot_group_fixture(%{count: 5}, current_user, ammo_group) {:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index)) @@ -315,13 +307,13 @@ defmodule CanneryWeb.AmmoTypeLiveTest do {:ok, show_live, _html} = live(conn, Routes.ammo_type_show_path(conn, :show, ammo_type)) assert show_live |> element(~s/a[aria-label="Edit #{ammo_type.name}"]/) |> render_click() =~ - gettext("Edit %{ammo_type_name}", ammo_type_name: name) + "Edit #{name}" assert_patch(show_live, Routes.ammo_type_show_path(conn, :edit, ammo_type)) - # assert show_live - # |> form("#ammo_type-form", ammo_type: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert show_live + |> form("#ammo_type-form") + |> render_change(ammo_type: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = show_live @@ -330,7 +322,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do |> follow_redirect(conn, Routes.ammo_type_show_path(conn, :show, ammo_type)) ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user) - assert html =~ dgettext("prompts", "%{name} updated successfully", name: ammo_type.name) + assert html =~ "#{ammo_type.name} updated successfully" assert html =~ "some updated bullet_type" end end @@ -370,8 +362,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do test "displays empty ammo groups on toggle", %{conn: conn, ammo_type: ammo_type, container: %{name: container_name}} do {:ok, show_live, html} = live(conn, Routes.ammo_type_show_path(conn, :show, ammo_type)) - - assert html =~ dgettext("actions", "Show used") + assert html =~ "Show used" refute html =~ "\n20\n" html = @@ -393,7 +384,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do |> element(~s/input[type="checkbox"][aria-labelledby="toggle_table-label"}]/) |> render_click() - assert html =~ dgettext("actions", "Show used") + assert html =~ "Show used" refute html =~ "\n20\n" html = diff --git a/test/cannery_web/live/container_live_test.exs b/test/cannery_web/live/container_live_test.exs index 567fb545..d23dafef 100644 --- a/test/cannery_web/live/container_live_test.exs +++ b/test/cannery_web/live/container_live_test.exs @@ -5,48 +5,46 @@ defmodule CanneryWeb.ContainerLiveTest do use CanneryWeb.ConnCase import Phoenix.LiveViewTest - import CanneryWeb.Gettext alias Cannery.Containers @moduletag :container_live_test @create_attrs %{ - "desc" => "some desc", - "location" => "some location", - "name" => "some name", - "type" => "some type" + desc: "some desc", + location: "some location", + name: "some name", + type: "some type" } @update_attrs %{ - "desc" => "some updated desc", - "location" => "some updated location", - "name" => "some updated name", - "type" => "some updated type" + desc: "some updated desc", + location: "some updated location", + name: "some updated name", + type: "some updated type" } + @invalid_attrs %{desc: nil, location: nil, name: nil, type: nil} @ammo_type_attrs %{ - "bullet_type" => "some bullet_type", - "case_material" => "some case_material", - "desc" => "some desc", - "manufacturer" => "some manufacturer", - "name" => "some name", - "grains" => 120 + bullet_type: "some bullet_type", + case_material: "some case_material", + desc: "some desc", + manufacturer: "some manufacturer", + name: "some name", + grains: 120 } @ammo_group_attrs %{ - "notes" => "some ammo group", - "count" => 20 + notes: "some ammo group", + count: 20 } - # @invalid_attrs %{desc: nil, location: nil, name: nil, type: nil} - defp create_container(%{current_user: current_user}) do container = container_fixture(@create_attrs, current_user) - %{container: container} + [container: container] end defp create_ammo_group(%{container: container, current_user: current_user}) do ammo_type = ammo_type_fixture(@ammo_type_attrs, current_user) {1, [ammo_group]} = ammo_group_fixture(@ammo_group_attrs, ammo_type, container, current_user) - %{ammo_type: ammo_type, ammo_group: ammo_group} + [ammo_type: ammo_type, ammo_group: ammo_group] end describe "Index" do @@ -55,7 +53,7 @@ defmodule CanneryWeb.ContainerLiveTest do test "lists all containers", %{conn: conn, container: container} do {:ok, _index_live, html} = live(conn, Routes.container_index_path(conn, :index)) - assert html =~ gettext("Containers") + assert html =~ "Containers" assert html =~ container.location end @@ -67,7 +65,7 @@ defmodule CanneryWeb.ContainerLiveTest do |> element(~s/input[type="checkbox"][aria-labelledby="toggle_table-label"}]/) |> render_click() - assert html =~ gettext("Containers") + assert html =~ "Containers" assert html =~ container.location end @@ -77,22 +75,20 @@ defmodule CanneryWeb.ContainerLiveTest do assert html =~ container.location assert index_live - |> form(~s/form[phx-change="search"]/, - search: %{search_term: container.location} - ) - |> render_change() =~ container.location + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: container.location}) =~ container.location assert_patch(index_live, Routes.container_index_path(conn, :search, container.location)) refute index_live - |> form(~s/form[phx-change="search"]/, search: %{search_term: "something_else"}) - |> render_change() =~ container.location + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: "something_else"}) =~ container.location assert_patch(index_live, Routes.container_index_path(conn, :search, "something_else")) assert index_live - |> form(~s/form[phx-change="search"]/, search: %{search_term: ""}) - |> render_change() =~ container.location + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: ""}) =~ container.location assert_patch(index_live, Routes.container_index_path(conn, :index)) end @@ -100,22 +96,20 @@ defmodule CanneryWeb.ContainerLiveTest do test "saves new container", %{conn: conn, container: container} do {:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "New Container")) |> render_click() =~ - gettext("New Container") - + assert index_live |> element("a", "New Container") |> render_click() =~ "New Container" assert_patch(index_live, Routes.container_index_path(conn, :new)) - # assert index_live - # |> form("#container-form", container: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#container-form") + |> render_change(container: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#container-form", container: @create_attrs) - |> render_submit() + |> form("#container-form") + |> render_submit(container: @create_attrs) |> follow_redirect(conn, Routes.container_index_path(conn, :index)) - assert html =~ dgettext("prompts", "%{name} created successfully", name: container.name) + assert html =~ "#{container.name} created successfully" assert html =~ "some location" end @@ -127,22 +121,22 @@ defmodule CanneryWeb.ContainerLiveTest do {:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index)) assert index_live |> element(~s/a[aria-label="Edit #{container.name}"]/) |> render_click() =~ - gettext("Edit %{name}", name: container.name) + "Edit #{container.name}" assert_patch(index_live, Routes.container_index_path(conn, :edit, container)) - # assert index_live - # |> form("#container-form", container: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#container-form") + |> render_change(container: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#container-form", container: @update_attrs) - |> render_submit() + |> form("#container-form") + |> render_submit(container: @update_attrs) |> follow_redirect(conn, Routes.container_index_path(conn, :index)) container = container.id |> Containers.get_container!(current_user) - assert html =~ dgettext("prompts", "%{name} updated successfully", name: container.name) + assert html =~ "#{container.name} updated successfully" assert html =~ "some updated location" end @@ -154,23 +148,23 @@ defmodule CanneryWeb.ContainerLiveTest do {:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index)) html = index_live |> element(~s/a[aria-label="Clone #{container.name}"]/) |> render_click() - assert html =~ gettext("New Container") + assert html =~ "New Container" assert html =~ "some location" assert_patch(index_live, Routes.container_index_path(conn, :clone, container)) - # assert index_live - # |> form("#container-form", container: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#container-form") + |> render_change(container: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#container-form", container: @create_attrs) - |> render_submit() + |> form("#container-form") + |> render_submit(container: @create_attrs) |> follow_redirect(conn, Routes.container_index_path(conn, :index)) container = container.id |> Containers.get_container!(current_user) - assert html =~ dgettext("prompts", "%{name} created successfully", name: container.name) + assert html =~ "#{container.name} created successfully" assert html =~ "some location" end @@ -182,30 +176,29 @@ defmodule CanneryWeb.ContainerLiveTest do {:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index)) assert index_live |> element(~s/a[aria-label="Clone #{container.name}"]/) |> render_click() =~ - gettext("New Container") + "New Container" assert_patch(index_live, Routes.container_index_path(conn, :clone, container)) - # assert index_live - # |> form("#container-form", container: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#container-form") + |> render_change(container: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#container-form", + |> form("#container-form") + |> render_submit( container: Map.merge(@create_attrs, %{location: "some updated location"}) ) - |> render_submit() |> follow_redirect(conn, Routes.container_index_path(conn, :index)) container = container.id |> Containers.get_container!(current_user) - assert html =~ dgettext("prompts", "%{name} created successfully", name: container.name) + assert html =~ "#{container.name} created successfully" assert html =~ "some updated location" end test "deletes container in listing", %{conn: conn, container: container} do {:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index)) - assert index_live |> element(~s/a[aria-label="Delete #{container.name}"]/) |> render_click() refute has_element?(index_live, "#container-#{container.id}") end @@ -219,7 +212,6 @@ defmodule CanneryWeb.ContainerLiveTest do container: %{name: name, location: location} = container } do {:ok, _show_live, html} = live(conn, Routes.container_show_path(conn, :show, container)) - assert html =~ name assert html =~ location end @@ -232,32 +224,32 @@ defmodule CanneryWeb.ContainerLiveTest do {:ok, show_live, _html} = live(conn, Routes.container_show_path(conn, :show, container)) assert show_live |> element(~s/a[aria-label="Edit #{container.name}"]/) |> render_click() =~ - gettext("Edit %{name}", name: container.name) + "Edit #{container.name}" assert_patch(show_live, Routes.container_show_path(conn, :edit, container)) - # assert show_live - # |> form("#container-form", container: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert show_live + |> form("#container-form") + |> render_change(container: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = show_live - |> form("#container-form", container: @update_attrs) - |> render_submit() + |> form("#container-form") + |> render_submit(container: @update_attrs) |> follow_redirect(conn, Routes.container_show_path(conn, :show, container)) container = container.id |> Containers.get_container!(current_user) - assert html =~ dgettext("prompts", "%{name} updated successfully", name: container.name) + assert html =~ "#{container.name} updated successfully" assert html =~ "some updated location" end test "can sort by type", %{conn: conn, container: container, current_user: current_user} do - rifle_type = ammo_type_fixture(%{"type" => "rifle"}, current_user) + rifle_type = ammo_type_fixture(%{type: "rifle"}, current_user) {1, [rifle_ammo_group]} = ammo_group_fixture(rifle_type, container, current_user) - shotgun_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user) + shotgun_type = ammo_type_fixture(%{type: "shotgun"}, current_user) {1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_type, container, current_user) - pistol_type = ammo_type_fixture(%{"type" => "pistol"}, current_user) + pistol_type = ammo_type_fixture(%{type: "pistol"}, current_user) {1, [pistol_ammo_group]} = ammo_group_fixture(pistol_type, container, current_user) {:ok, index_live, html} = live(conn, Routes.container_show_path(conn, :show, container)) diff --git a/test/cannery_web/live/home_live_test.exs b/test/cannery_web/live/home_live_test.exs index b228cedc..ed9757dd 100644 --- a/test/cannery_web/live/home_live_test.exs +++ b/test/cannery_web/live/home_live_test.exs @@ -5,14 +5,13 @@ defmodule CanneryWeb.HomeLiveTest do use CanneryWeb.ConnCase import Phoenix.LiveViewTest - import CanneryWeb.Gettext @moduletag :home_live_test test "disconnected and connected render", %{conn: conn} do {:ok, home_live, disconnected_html} = live(conn, "/") - assert disconnected_html =~ gettext("Welcome to %{name}", name: "Cannery") - assert render(home_live) =~ gettext("Welcome to %{name}", name: "Cannery") + assert disconnected_html =~ "Welcome to Cannery" + assert render(home_live) =~ "Welcome to Cannery" end test "displays version number", %{conn: conn} do diff --git a/test/cannery_web/live/invite_live_test.exs b/test/cannery_web/live/invite_live_test.exs index 9a03574f..71e23c4e 100644 --- a/test/cannery_web/live/invite_live_test.exs +++ b/test/cannery_web/live/invite_live_test.exs @@ -5,13 +5,12 @@ defmodule CanneryWeb.InviteLiveTest do use CanneryWeb.ConnCase import Phoenix.LiveViewTest - import CanneryWeb.Gettext alias Cannery.Accounts.Invites @moduletag :invite_live_test - @create_attrs %{"name" => "some name"} - @update_attrs %{"name" => "some updated name"} - # @invalid_attrs %{"name" => nil} + @create_attrs %{name: "some name"} + @update_attrs %{name: "some updated name"} + @invalid_attrs %{name: nil} describe "Index" do setup [:register_and_log_in_user] @@ -24,32 +23,27 @@ defmodule CanneryWeb.InviteLiveTest do test "lists all invites", %{conn: conn, invite: invite} do {:ok, _index_live, html} = live(conn, Routes.invite_index_path(conn, :index)) - assert html =~ gettext("Invites") + assert html =~ "Invites" assert html =~ invite.name end test "saves new invite", %{conn: conn} do {:ok, index_live, _html} = live(conn, Routes.invite_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "Create Invite")) |> render_click() =~ - gettext("New Invite") - + assert index_live |> element("a", "Create Invite") |> render_click() =~ "New Invite" assert_patch(index_live, Routes.invite_index_path(conn, :new)) - # assert index_live - # |> form("#invite-form", invite: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#invite-form") + |> render_change(invite: @invalid_attrs) =~ "can't be blank" {:ok, _live, html} = index_live - |> form("#invite-form", invite: @create_attrs) - |> render_submit() + |> form("#invite-form") + |> render_submit(invite: @create_attrs) |> follow_redirect(conn, Routes.invite_index_path(conn, :index)) - assert html =~ - dgettext("prompts", "%{invite_name} created successfully", invite_name: "some name") - - assert html =~ "some name" + assert html =~ "some name created successfully" end test "updates invite in listing", %{conn: conn, invite: invite} do @@ -57,27 +51,21 @@ defmodule CanneryWeb.InviteLiveTest do assert index_live |> element(~s/a[aria-label="Edit invite for #{invite.name}"]/) - |> render_click() =~ - gettext("Edit Invite") + |> render_click() =~ "Edit Invite" assert_patch(index_live, Routes.invite_index_path(conn, :edit, invite)) - # assert index_live - # |> form("#invite-form", invite: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#invite-form") + |> render_change(invite: @invalid_attrs) =~ "can't be blank" {:ok, _live, html} = index_live - |> form("#invite-form", invite: @update_attrs) - |> render_submit() + |> form("#invite-form") + |> render_submit(invite: @update_attrs) |> follow_redirect(conn, Routes.invite_index_path(conn, :index)) - assert html =~ - dgettext("prompts", "%{invite_name} updated successfully", - invite_name: "some updated name" - ) - - assert html =~ "some updated name" + assert html =~ "some updated name updated successfully" end test "deletes invite in listing", %{conn: conn, invite: invite} do diff --git a/test/cannery_web/live/range_live_test.exs b/test/cannery_web/live/range_live_test.exs index b0c8cdbf..f4611918 100644 --- a/test/cannery_web/live/range_live_test.exs +++ b/test/cannery_web/live/range_live_test.exs @@ -6,22 +6,20 @@ defmodule CanneryWeb.RangeLiveTest do use CanneryWeb.ConnCase import Phoenix.LiveViewTest import Cannery.Fixtures - import CanneryWeb.Gettext @moduletag :range_live_test - @create_attrs %{"ammo_left" => 5, "notes" => "some notes"} - @update_attrs %{"count" => 16, "notes" => "some updated notes"} - # @invalid_attrs %{"count" => nil, "notes" => nil} + @create_attrs %{ammo_left: 5, notes: "some notes"} + @update_attrs %{count: 16, notes: "some updated notes"} + @invalid_attrs %{count: nil, notes: nil} defp create_shot_group(%{current_user: current_user}) do - container = container_fixture(%{"staged" => true}, current_user) + container = container_fixture(%{staged: true}, current_user) ammo_type = ammo_type_fixture(current_user) - {1, [ammo_group]} = - ammo_group_fixture(%{"staged" => true}, ammo_type, container, current_user) + {1, [ammo_group]} = ammo_group_fixture(%{staged: true}, ammo_type, container, current_user) shot_group = - %{"count" => 5, "date" => ~N[2022-02-13 03:17:00], "notes" => "some notes"} + %{count: 5, date: ~N[2022-02-13 03:17:00], notes: "some notes"} |> shot_group_fixture(current_user, ammo_group) [ @@ -38,29 +36,28 @@ defmodule CanneryWeb.RangeLiveTest do test "lists all shot_groups", %{conn: conn, shot_group: shot_group} do {:ok, _index_live, html} = live(conn, Routes.range_index_path(conn, :index)) - assert html =~ gettext("Range day") + assert html =~ "Range day" assert html =~ shot_group.notes end test "can sort by type", %{conn: conn, container: container, current_user: current_user} do - rifle_ammo_type = ammo_type_fixture(%{"type" => "rifle"}, current_user) + rifle_ammo_type = ammo_type_fixture(%{type: "rifle"}, current_user) {1, [rifle_ammo_group]} = ammo_group_fixture(rifle_ammo_type, container, current_user) - rifle_shot_group = - shot_group_fixture(%{"notes" => "group_one"}, current_user, rifle_ammo_group) + rifle_shot_group = shot_group_fixture(%{notes: "group_one"}, current_user, rifle_ammo_group) - shotgun_ammo_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user) + shotgun_ammo_type = ammo_type_fixture(%{type: "shotgun"}, current_user) {1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_ammo_type, container, current_user) shotgun_shot_group = - shot_group_fixture(%{"notes" => "group_two"}, current_user, shotgun_ammo_group) + shot_group_fixture(%{notes: "group_two"}, current_user, shotgun_ammo_group) - pistol_ammo_type = ammo_type_fixture(%{"type" => "pistol"}, current_user) + pistol_ammo_type = ammo_type_fixture(%{type: "pistol"}, current_user) {1, [pistol_ammo_group]} = ammo_group_fixture(pistol_ammo_type, container, current_user) pistol_shot_group = - shot_group_fixture(%{"notes" => "group_three"}, current_user, pistol_ammo_group) + shot_group_fixture(%{notes: "group_three"}, current_user, pistol_ammo_group) {:ok, index_live, html} = live(conn, Routes.range_index_path(conn, :index)) @@ -113,22 +110,20 @@ defmodule CanneryWeb.RangeLiveTest do assert html =~ shot_group.notes assert index_live - |> form(~s/form[phx-change="search"]/, - search: %{search_term: shot_group.notes} - ) - |> render_change() =~ shot_group.notes + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: shot_group.notes}) =~ shot_group.notes assert_patch(index_live, Routes.range_index_path(conn, :search, shot_group.notes)) refute index_live - |> form(~s/form[phx-change="search"]/, search: %{search_term: "something_else"}) - |> render_change() =~ shot_group.notes + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: "something_else"}) =~ shot_group.notes assert_patch(index_live, Routes.range_index_path(conn, :search, "something_else")) assert index_live - |> form(~s/form[phx-change="search"]/, search: %{search_term: ""}) - |> render_change() =~ shot_group.notes + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: ""}) =~ shot_group.notes assert_patch(index_live, Routes.range_index_path(conn, :index)) end @@ -136,22 +131,20 @@ defmodule CanneryWeb.RangeLiveTest do test "saves new shot_group", %{conn: conn, ammo_group: ammo_group} do {:ok, index_live, _html} = live(conn, Routes.range_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "Record shots")) |> render_click() =~ - gettext("Record shots") - + assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots" assert_patch(index_live, Routes.range_index_path(conn, :add_shot_group, ammo_group)) - # assert index_live - # |> form("#shot_group-form", shot_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "is invalid") + assert index_live + |> form("#shot-group-form") + |> render_change(shot_group: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#shot-group-form", shot_group: @create_attrs) - |> render_submit() + |> form("#shot-group-form") + |> render_submit(shot_group: @create_attrs) |> follow_redirect(conn, Routes.range_index_path(conn, :index)) - assert html =~ dgettext("prompts", "Shots recorded successfully") + assert html =~ "Shots recorded successfully" assert html =~ "some notes" end @@ -160,14 +153,13 @@ defmodule CanneryWeb.RangeLiveTest do assert index_live |> element(~s/a[aria-label="Edit shot record of #{shot_group.count} shots"]/) - |> render_click() =~ - gettext("Edit Shot Records") + |> render_click() =~ "Edit Shot Records" assert_patch(index_live, Routes.range_index_path(conn, :edit, shot_group)) - # assert index_live - # |> form("#shot_group-form", shot_group: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "is invalid") + assert index_live + |> form("#shot-group-form") + |> render_change(shot_group: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live @@ -175,7 +167,7 @@ defmodule CanneryWeb.RangeLiveTest do |> render_submit() |> follow_redirect(conn, Routes.range_index_path(conn, :index)) - assert html =~ dgettext("actions", "Shot records updated successfully") + assert html =~ "Shot records updated successfully" assert html =~ "some updated notes" end diff --git a/test/cannery_web/live/tag_live_test.exs b/test/cannery_web/live/tag_live_test.exs index ad67fc06..f1ee6cd3 100644 --- a/test/cannery_web/live/tag_live_test.exs +++ b/test/cannery_web/live/tag_live_test.exs @@ -5,26 +5,24 @@ defmodule CanneryWeb.TagLiveTest do use CanneryWeb.ConnCase import Phoenix.LiveViewTest - import CanneryWeb.Gettext @moduletag :tag_live_test @create_attrs %{ - "bg_color" => "#100000", - "name" => "some name", - "text_color" => "#000000" + bg_color: "#100000", + name: "some name", + text_color: "#000000" } @update_attrs %{ - "bg_color" => "#100001", - "name" => "some updated name", - "text_color" => "#000001" + bg_color: "#100001", + name: "some updated name", + text_color: "#000001" + } + @invalid_attrs %{ + bg_color: nil, + name: nil, + text_color: nil } - - # @invalid_attrs %{ - # "bg_color" => nil, - # "name" => nil, - # "text_color" => nil - # } def create_tag(%{current_user: current_user}) do tag = tag_fixture(current_user) @@ -37,7 +35,7 @@ defmodule CanneryWeb.TagLiveTest do test "lists all tags", %{conn: conn, tag: tag} do {:ok, _index_live, html} = live(conn, Routes.tag_index_path(conn, :index)) - assert html =~ gettext("Tags") + assert html =~ "Tags" assert html =~ tag.bg_color end @@ -47,22 +45,20 @@ defmodule CanneryWeb.TagLiveTest do assert html =~ tag.name assert index_live - |> form(~s/form[phx-change="search"]/, - search: %{search_term: tag.name} - ) - |> render_change() =~ tag.name + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: tag.name}) =~ tag.name assert_patch(index_live, Routes.tag_index_path(conn, :search, tag.name)) refute index_live - |> form(~s/form[phx-change="search"]/, search: %{search_term: "something_else"}) - |> render_change() =~ tag.name + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: "something_else"}) =~ tag.name assert_patch(index_live, Routes.tag_index_path(conn, :search, "something_else")) assert index_live - |> form(~s/form[phx-change="search"]/, search: %{search_term: ""}) - |> render_change() =~ tag.name + |> form(~s/form[phx-change="search"]/) + |> render_change(search: %{search_term: ""}) =~ tag.name assert_patch(index_live, Routes.tag_index_path(conn, :index)) end @@ -70,22 +66,20 @@ defmodule CanneryWeb.TagLiveTest do test "saves new tag", %{conn: conn} do {:ok, index_live, _html} = live(conn, Routes.tag_index_path(conn, :index)) - assert index_live |> element("a", dgettext("actions", "New Tag")) |> render_click() =~ - dgettext("actions", "New Tag") - + assert index_live |> element("a", "New Tag") |> render_click() =~ "New Tag" assert_patch(index_live, Routes.tag_index_path(conn, :new)) - # assert index_live - # |> form("#tag-form", tag: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#tag-form") + |> render_change(tag: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#tag-form", tag: @create_attrs) - |> render_submit() + |> form("#tag-form") + |> render_submit(tag: @create_attrs) |> follow_redirect(conn, Routes.tag_index_path(conn, :index)) - assert html =~ dgettext("actions", "%{name} created successfully", name: "some name") + assert html =~ "some name created successfully" assert html =~ "#100000" end @@ -93,23 +87,21 @@ defmodule CanneryWeb.TagLiveTest do {:ok, index_live, _html} = live(conn, Routes.tag_index_path(conn, :index)) assert index_live |> element(~s/a[aria-label="Edit #{tag.name}"]/) |> render_click() =~ - dgettext("actions", "Edit Tag") + "Edit Tag" assert_patch(index_live, Routes.tag_index_path(conn, :edit, tag)) - # assert index_live - # |> form("#tag-form", tag: @invalid_attrs) - # |> render_change() =~ dgettext("errors", "can't be blank") + assert index_live + |> form("#tag-form") + |> render_change(tag: @invalid_attrs) =~ "can't be blank" {:ok, _view, html} = index_live - |> form("#tag-form", tag: @update_attrs) - |> render_submit() + |> form("#tag-form") + |> render_submit(tag: @update_attrs) |> follow_redirect(conn, Routes.tag_index_path(conn, :index)) - assert html =~ - dgettext("prompts", "%{name} updated successfully", name: "some updated name") - + assert html =~ "some updated name updated successfully" assert html =~ "#100001" end diff --git a/test/cannery_web/views/error_view_test.exs b/test/cannery_web/views/error_view_test.exs index 5cffbce8..32e9bebd 100644 --- a/test/cannery_web/views/error_view_test.exs +++ b/test/cannery_web/views/error_view_test.exs @@ -4,19 +4,16 @@ defmodule CanneryWeb.ErrorViewTest do """ use CanneryWeb.ConnCase, async: true - import CanneryWeb.Gettext # Bring render/3 and render_to_string/3 for testing custom views import Phoenix.View @moduletag :error_view_test test "renders 404.html" do - assert render_to_string(CanneryWeb.ErrorView, "404.html", []) =~ - dgettext("errors", "Not found") + assert render_to_string(CanneryWeb.ErrorView, "404.html", []) =~ "Not found" end test "renders 500.html" do - assert render_to_string(CanneryWeb.ErrorView, "500.html", []) =~ - dgettext("errors", "Internal Server Error") + assert render_to_string(CanneryWeb.ErrorView, "500.html", []) =~ "Internal Server Error" end end diff --git a/test/support/fixtures.ex b/test/support/fixtures.ex index f1418b9f..7d24dd88 100644 --- a/test/support/fixtures.ex +++ b/test/support/fixtures.ex @@ -24,8 +24,8 @@ defmodule Cannery.Fixtures do def user_fixture(attrs \\ %{}) do attrs |> Enum.into(%{ - "email" => unique_user_email(), - "password" => valid_user_password() + email: unique_user_email(), + password: valid_user_password() }) |> Accounts.register_user() |> unwrap_ok_tuple() @@ -36,8 +36,8 @@ defmodule Cannery.Fixtures do def admin_fixture(attrs \\ %{}) do attrs |> Enum.into(%{ - "email" => unique_user_email(), - "password" => valid_user_password() + email: unique_user_email(), + password: valid_user_password() }) |> Accounts.register_user() |> unwrap_ok_tuple() @@ -76,9 +76,9 @@ defmodule Cannery.Fixtures do def shot_group_fixture(attrs \\ %{}, %User{} = user, %AmmoGroup{} = ammo_group) do attrs |> Enum.into(%{ - "count" => 20, - "date" => ~N[2022-02-13 03:17:00], - "notes" => random_string() + count: 20, + date: ~N[2022-02-13 03:17:00], + notes: random_string() }) |> Cannery.ActivityLog.create_shot_group(user, ammo_group) |> unwrap_ok_tuple() @@ -91,7 +91,7 @@ defmodule Cannery.Fixtures do @spec container_fixture(attrs :: map(), User.t()) :: Container.t() def container_fixture(attrs \\ %{}, %User{} = user) do attrs - |> Enum.into(%{"name" => random_string(), "type" => "Ammo can"}) + |> Enum.into(%{name: random_string(), type: "Ammo can"}) |> Containers.create_container(user) |> unwrap_ok_tuple() end @@ -103,7 +103,7 @@ defmodule Cannery.Fixtures do @spec ammo_type_fixture(attrs :: map(), User.t()) :: AmmoType.t() def ammo_type_fixture(attrs \\ %{}, %User{} = user) do attrs - |> Enum.into(%{"name" => random_string(), "type" => "rifle"}) + |> Enum.into(%{name: random_string(), type: "rifle"}) |> Ammo.create_ammo_type(user) |> unwrap_ok_tuple() end @@ -131,10 +131,10 @@ defmodule Cannery.Fixtures do ) do attrs |> Enum.into(%{ - "ammo_type_id" => ammo_type_id, - "container_id" => container_id, - "count" => 20, - "purchased_on" => Date.utc_today() + ammo_type_id: ammo_type_id, + container_id: container_id, + count: 20, + purchased_on: Date.utc_today() }) |> Ammo.create_ammo_groups(multiplier, user) |> unwrap_ok_tuple() @@ -148,9 +148,9 @@ defmodule Cannery.Fixtures do def tag_fixture(attrs \\ %{}, %User{} = user) do attrs |> Enum.into(%{ - "bg_color" => "#100000", - "name" => random_string(), - "text_color" => "#000000" + bg_color: "#100000", + name: random_string(), + text_color: "#000000" }) |> Containers.create_tag(user) |> unwrap_ok_tuple()