use atom keys in tests

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

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(
+  def create_ammo_groups(attrs, multiplier, %User{} = user) do
-        %{"ammo_type_id" => ammo_type_id, "container_id" => container_id} = attrs,
+    attrs
-        multiplier,
+    |> Map.new(fn {k, v} -> {to_string(k), v} end)
-        %User{} = user
+    |> do_create_ammo_groups(multiplier, user)
-      )
+  end
-      when multiplier >= 1 and multiplier <= @ammo_group_create_limit and
+
-             not (ammo_type_id |> is_nil()) and not (container_id |> is_nil()) do
+  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(
+  defp do_create_ammo_groups(
-        %{"ammo_type_id" => ammo_type_id, "container_id" => container_id} = attrs,
+         %{"ammo_type_id" => ammo_type_id, "container_id" => container_id} = attrs,
-        _multiplier,
+         _multiplier,
-        user
+         user
-      )
+       )
-      when is_binary(ammo_type_id) and is_binary(container_id) do
+       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
 

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 ""

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 ""

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 ""

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"

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"

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 ""

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,
+    name: nil,
-    "token" => 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} =
+      assert {:ok, %Invite{} = invite} = Invites.create_invite(current_user, %{name: "some name"})
-               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, %{
+               Invites.create_invite(current_user, %{name: "some name", uses_left: 10})
-                 "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
                )
 

test/cannery/accounts_test.exs

@@ -63,8 +63,7 @@ defmodule Cannery.AccountsTest do
     end
 
     test "validates email and password when given" do
-      {:error, changeset} =
+      {:error, changeset} = Accounts.register_user(%{email: "not valid", password: "not valid"})
-        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} =
+      {:ok, user} = Accounts.register_user(%{email: email, password: valid_user_password()})
-        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 =
+      changeset = Accounts.change_user_password(%User{}, %{password: "new valid password"})
-        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: "not valid",
-          "password_confirmation" => "another"
+          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: "not valid",
-          "password_confirmation" => "another"
+          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} =
+      {:ok, updated_user} = Accounts.reset_user_password(user, %{password: "new valid password"})
-        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

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,
+                   count: 10,
-                   "date" => ~D[2022-02-13],
+                   date: ~D[2022-02-13],
-                   "notes" => "some updated notes"
+                   notes: "some updated notes"
                  },
                  current_user
                )
@@ -131,9 +126,9 @@ defmodule Cannery.ActivityLogTest do
                ActivityLog.update_shot_group(
                  shot_group,
                  %{
-                   "count" => 25,
+                   count: 25,
-                   "date" => ~D[2022-02-13],
+                   date: ~D[2022-02-13],
-                   "notes" => "some updated notes"
+                   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)

test/cannery/ammo_test.exs

@@ -10,28 +10,28 @@ defmodule Cannery.AmmoTest do
   @moduletag :ammo_test
 
   @valid_attrs %{
-    "bullet_type" => "some bullet_type",
+    bullet_type: "some bullet_type",
-    "case_material" => "some case_material",
+    case_material: "some case_material",
-    "desc" => "some desc",
+    desc: "some desc",
-    "manufacturer" => "some manufacturer",
+    manufacturer: "some manufacturer",
-    "name" => "some name",
+    name: "some name",
-    "grains" => 120
+    grains: 120
   }
   @update_attrs %{
-    "bullet_type" => "some updated bullet_type",
+    bullet_type: "some updated bullet_type",
-    "case_material" => "some updated case_material",
+    case_material: "some updated case_material",
-    "desc" => "some updated desc",
+    desc: "some updated desc",
-    "manufacturer" => "some updated manufacturer",
+    manufacturer: "some updated manufacturer",
-    "name" => "some updated name",
+    name: "some updated name",
-    "grains" => 456
+    grains: 456
   }
   @invalid_attrs %{
-    "bullet_type" => nil,
+    bullet_type: nil,
-    "case_material" => nil,
+    case_material: nil,
-    "desc" => nil,
+    desc: nil,
-    "manufacturer" => nil,
+    manufacturer: nil,
-    "name" => nil,
+    name: nil,
-    "grains" => nil
+    grains: nil
   }
 
   describe "list_ammo_types/2" do
@@ -40,34 +40,34 @@ defmodule Cannery.AmmoTest do
 
       rifle_ammo_type =
         %{
-          "name" => "bullets",
+          name: "bullets",
-          "type" => "rifle",
+          type: "rifle",
-          "desc" => "has some pews in it",
+          desc: "has some pews in it",
-          "grains" => 5
+          grains: 5
         }
         |> ammo_type_fixture(current_user)
 
       shotgun_ammo_type =
         %{
-          "name" => "hollows",
+          name: "hollows",
-          "type" => "shotgun",
+          type: "shotgun",
-          "grains" => 3
+          grains: 3
         }
         |> ammo_type_fixture(current_user)
 
       pistol_ammo_type =
         %{
-          "type" => "pistol",
+          type: "pistol",
-          "name" => "jackets",
+          name: "jackets",
-          "desc" => "brass shell",
+          desc: "brass shell",
-          "tracer" => true
+          tracer: true
         }
         |> ammo_type_fixture(current_user)
 
       _shouldnt_return =
         %{
-          "name" => "bullet",
+          name: "bullet",
-          "desc" => "pews brass shell"
+          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)
+      {1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user)
-      shot_group_fixture(%{"count" => 50}, current_user, ammo_group)
+      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} =
+      {25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user)
-        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} =
+      {25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user)
-        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} =
+      {25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user)
-        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} =
+      {25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user)
-        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,
+      count: 42,
-      "notes" => "some notes",
+      notes: "some notes",
-      "price_paid" => 120.5,
+      price_paid: 120.5,
-      "purchased_on" => ~D[2022-11-19]
+      purchased_on: ~D[2022-11-19]
     }
     @update_attrs %{
-      "count" => 43,
+      count: 43,
-      "notes" => "some updated notes",
+      notes: "some updated notes",
-      "price_paid" => 456.7
+      price_paid: 456.7
     }
     @invalid_attrs %{
-      "count" => nil,
+      count: nil,
-      "notes" => nil,
+      notes: nil,
-      "price_paid" => 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(%{count: 50, price_paid: 36.1}, ammo_type, container, current_user)
-        |> ammo_group_fixture(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_ammo_type = ammo_type_fixture(%{name: "amazing ammo"}, current_user)
-      another_container = container_fixture(%{"name" => "fantastic container"}, 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

test/cannery/containers_test.exs

@@ -10,37 +10,37 @@ defmodule Cannery.ContainersTest do
   @moduletag :containers_test
 
   @valid_attrs %{
-    "desc" => "some desc",
+    desc: "some desc",
-    "location" => "some location",
+    location: "some location",
-    "name" => "some name",
+    name: "some name",
-    "type" => "some type"
+    type: "some type"
   }
   @update_attrs %{
-    "desc" => "some updated desc",
+    desc: "some updated desc",
-    "location" => "some updated location",
+    location: "some updated location",
-    "name" => "some updated name",
+    name: "some updated name",
-    "type" => "some updated type"
+    type: "some updated type"
   }
   @invalid_attrs %{
-    "desc" => nil,
+    desc: nil,
-    "location" => nil,
+    location: nil,
-    "name" => nil,
+    name: nil,
-    "type" => nil
+    type: nil
   }
   @valid_tag_attrs %{
-    "bg_color" => "#100000",
+    bg_color: "#100000",
-    "name" => "some name",
+    name: "some name",
-    "text_color" => "#000000"
+    text_color: "#000000"
   }
   @update_tag_attrs %{
-    "bg_color" => "#100001",
+    bg_color: "#100001",
-    "name" => "some updated name",
+    name: "some updated name",
-    "text_color" => "#000001"
+    text_color: "#000001"
   }
   @invalid_tag_attrs %{
-    "bg_color" => nil,
+    bg_color: nil,
-    "name" => nil,
+    name: nil,
-    "text_color" => 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_a = container_fixture(%{name: "my cool container"}, current_user)
-      container_b = container_fixture(%{"desc" => "a fascinating description"}, 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 =
+      _shouldnt_return = container_fixture(%{name: "another person's container"}, user_fixture())
-        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_a = tag_fixture(%{name: "bullets"}, current_user)
-      tag_b = tag_fixture(%{"name" => "hollows"}, current_user)
+      tag_b = tag_fixture(%{name: "hollows"}, current_user)
 
-      _shouldnt_return =
+      tag_fixture(%{name: "bullet", desc: "pews brass shell"}, user_fixture())
-        %{
-          "name" => "bullet",
-          "desc" => "pews brass shell"
-        }
-        |> tag_fixture(user_fixture())
 
       # name
       assert Containers.list_tags("bullet", current_user) == [tag_a]

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

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), %{
+        post(conn, Routes.user_confirmation_path(conn, :create), %{user: %{email: user.email}})
-          "user" => %{"email" => user.email}
-        })
 
       assert redirected_to(conn) == "/"
 
       assert get_flash(conn, :info) =~
-               dgettext(
+               "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
-                 "prompts",
-                 "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), %{
+        post(conn, Routes.user_confirmation_path(conn, :create), %{user: %{email: user.email}})
-          "user" => %{"email" => user.email}
-        })
 
       assert redirected_to(conn) == "/"
 
       assert get_flash(conn, :info) =~
-               dgettext(
+               "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
-                 "prompts",
-                 "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(
+               "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
-                 "prompts",
-                 "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) =~ "#{user.email} confirmed successfully"
-      assert get_flash(conn, :info) =~
-               dgettext("prompts", "%{email} confirmed successfully", email: user.email)
-
       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) =~
+      assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired"
-               dgettext("errors", "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) =~ "User confirmation link is invalid or it has expired"
-      assert get_flash(conn, :error) =~
-               dgettext("errors", "User confirmation link is invalid or it has expired")
-
       refute Accounts.get_user!(user.id).confirmed_at
     end
   end

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 =~ "Register"
-      assert response =~ dgettext("actions", "Log in")
+      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

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), %{
+        post(conn, Routes.user_reset_password_path(conn, :create), %{user: %{email: user.email}})
-          "user" => %{"email" => user.email}
-        })
 
       assert redirected_to(conn) == "/"
 
       assert get_flash(conn, :info) =~
-               dgettext(
+               "If your email is in our system, you will receive instructions to reset your password shortly."
-                 "prompts",
-                 "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(
+               "If your email is in our system, you will receive instructions to reset your password shortly."
-                 "prompts",
-                 "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) =~ "Reset password link is invalid or it has expired"
-      assert get_flash(conn, :error) =~
-               dgettext("errors", "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" => %{
+          user: %{
-            "password" => "new valid password",
+            password: "new valid password",
-            "password_confirmation" => "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" => %{
+          user: %{
-            "password" => "too short",
+            password: "too short",
-            "password_confirmation" => "does not match"
+            password_confirmation: "does not match"
           }
         })
 
       response = html_response(conn, 200)
-      assert response =~ gettext("Reset password")
+      assert response =~ "Reset password"
-      assert response =~ dgettext("errors", "should be at least 12 character(s)")
+      assert response =~ "should be at least 12 character(s)"
-      assert response =~ dgettext("errors", "does not match password")
+      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) =~ "Reset password link is invalid or it has expired"
-      assert get_flash(conn, :error) =~
-               dgettext("errors", "Reset password link is invalid or it has expired")
     end
   end
 end

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" => %{
+          user: %{
-            "email" => current_user.email,
+            email: current_user.email,
-            "password" => valid_user_password(),
+            password: valid_user_password(),
-            "remember_me" => "true"
+            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" => %{
+          user: %{
-            "email" => current_user.email,
+            email: current_user.email,
-            "password" => valid_user_password()
+            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 =~ "Log in"
-      assert response =~ dgettext("errors", "Invalid email or password")
+      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

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",
+          action: "update_password",
-          "current_password" => valid_user_password(),
+          current_password: valid_user_password(),
-          "user" => %{
+          user: %{
-            "password" => "new valid password",
+            password: "new valid password",
-            "password_confirmation" => "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) =~ "Password updated successfully"
-      assert get_flash(new_password_conn, :info) =~
-               dgettext("actions", "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",
+          action: "update_password",
-          "current_password" => "invalid",
+          current_password: "invalid",
-          "user" => %{
+          user: %{
-            "password" => "too short",
+            password: "too short",
-            "password_confirmation" => "does not match"
+            password_confirmation: "does not match"
           }
         })
 
       response = html_response(old_password_conn, 200)
-      assert response =~ gettext("Settings")
+      assert response =~ "Settings"
-      assert response =~ dgettext("errors", "should be at least 12 character(s)")
+      assert response =~ "should be at least 12 character(s)"
-      assert response =~ dgettext("errors", "does not match password")
+      assert response =~ "does not match password"
-      assert response =~ dgettext("errors", "is not valid")
+      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",
+          action: "update_email",
-          "current_password" => valid_user_password(),
+          current_password: valid_user_password(),
-          "user" => %{"email" => unique_user_email()}
+          user: %{email: unique_user_email()}
         })
 
       assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
 
       assert get_flash(conn, :info) =~
-               dgettext(
+               "A link to confirm your email change has been sent to the new address."
-                 "prompts",
-                 "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",
+          action: "update_email",
-          "current_password" => "invalid",
+          current_password: "invalid",
-          "user" => %{"email" => "with spaces"}
+          user: %{email: "with spaces"}
         })
 
       response = html_response(conn, 200)
-      assert response =~ gettext("Settings")
+      assert response =~ "Settings"
-      assert response =~ dgettext("errors", "must have the @ sign and no spaces")
+      assert response =~ "must have the @ sign and no spaces"
-      assert response =~ dgettext("errors", "is not valid")
+      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) =~ "Email change link is invalid or it has expired"
-      assert get_flash(conn, :error) =~
-               dgettext("errors", "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) =~ "Email change link is invalid or it has expired"
-      assert get_flash(conn, :error) =~
-               dgettext("errors", "Email change link is invalid or it has expired")
-
       assert Accounts.get_user_by_email(current_user.email)
     end
 

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"}
+  @create_attrs %{count: 42, notes: "some notes", price_paid: 120.5}
-  @shot_group_update_attrs %{
+  @update_attrs %{count: 43, notes: "some updated notes", price_paid: 456.7}
-    "count" => 5,
+  @invalid_attrs %{count: nil, notes: nil, price_paid: nil}
-    "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}
   @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,
+    price_paid: 50,
-    "count" => 20
+    count: 20
   }
   @shot_group_attrs %{
-    "price_paid" => 50,
+    price_paid: 50,
-    "count" => 20
+    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"]/,
+             |> form(~s/form[phx-change="search"]/)
-               search: %{search_term: ammo_group.ammo_type.name}
+             |> render_change(search: %{search_term: ammo_group.ammo_type.name}) =~
-             )
+               ammo_group.ammo_type.name
-             |> render_change() =~ 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"})
+             |> form(~s/form[phx-change="search"]/)
-             |> render_change() =~ ammo_group.ammo_type.name
+             |> 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: ""})
+             |> form(~s/form[phx-change="search"]/)
-             |> render_change() =~ ammo_group.ammo_type.name
+             |> 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() =~
+      assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo"
-               dgettext("actions", "Add Ammo")
-
       assert_patch(index_live, Routes.ammo_group_index_path(conn, :new))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#ammo_group-form", ammo_group: @invalid_attrs)
+             |> form("#ammo_group-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#ammo_group-form", ammo_group: @create_attrs)
+        |> form("#ammo_group-form")
-        |> render_submit()
+        |> 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() =~
+      assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo"
-               dgettext("actions", "Add Ammo")
-
       assert_patch(index_live, Routes.ammo_group_index_path(conn, :new))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#ammo_group-form", ammo_group: @invalid_attrs)
+             |> form("#ammo_group-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#ammo_group-form",
+        |> form("#ammo_group-form")
-          ammo_group: @create_attrs |> Map.put("multiplier", to_string(multiplier))
+        |> render_submit(ammo_group: @create_attrs |> Map.put(:multiplier, multiplier))
-        )
-        |> 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 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() =~
+      assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo"
-               dgettext("actions", "Add Ammo")
-
       assert_patch(index_live, Routes.ammo_group_index_path(conn, :new))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#ammo_group-form", ammo_group: @invalid_attrs)
+             |> form("#ammo_group-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> 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"))
+             |> form("#ammo_group-form")
-             |> render_submit() =~
+             |> render_submit(ammo_group: @create_attrs |> Map.put(:multiplier, "0")) =~
-               dgettext(
+               "Invalid number of copies, must be between 1 and #{@ammo_group_create_limit}. Was 0"
-                 "errors",
-                 "Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}",
-                 multiplier: 0,
-                 max: @ammo_group_create_limit
-               )
 
       assert index_live
-             |> form("#ammo_group-form",
+             |> form("#ammo_group-form")
-               ammo_group:
+             |> render_submit(
-                 @create_attrs |> Map.put("multiplier", to_string(@ammo_group_create_limit + 1))
+               ammo_group: @create_attrs |> Map.put(:multiplier, @ammo_group_create_limit + 1)
-             )
+             ) =~
-             |> render_submit() =~
+               "Invalid number of copies, must be between 1 and #{@ammo_group_create_limit}. Was #{@ammo_group_create_limit + 1}"
-               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
-               )
     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() =~
+             |> render_click() =~ "Edit ammo"
-               gettext("Edit ammo")
 
       assert_patch(index_live, Routes.ammo_group_index_path(conn, :edit, ammo_group))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#ammo_group-form", ammo_group: @invalid_attrs)
+             |> form("#ammo_group-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#ammo_group-form", ammo_group: @update_attrs)
+        |> form("#ammo_group-form")
-        |> render_submit()
+        |> 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 =~ "Add Ammo"
-      assert html =~ gettext("$%{amount}", amount: display_currency(120.5))
+      assert html =~ "$#{display_currency(120.5)}"
 
       assert_patch(index_live, Routes.ammo_group_index_path(conn, :clone, ammo_group))
 
-      # assert index_live
+      {:ok, _index_live, html} =
-      #        |> form("#ammo_group-form", ammo_group: @invalid_attrs)
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
-
-      {:ok, _view, 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 =~ "Add Ammo"
-      assert html =~ gettext("$%{amount}", amount: display_currency(120.5))
+      assert html =~ "$#{display_currency(120.5)}"
-
       assert_patch(index_live, Routes.ammo_group_index_path(conn, :clone, ammo_group))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#ammo_group-form", ammo_group: @invalid_attrs)
+             |> form("#ammo_group-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> 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}))
+        |> form("#ammo_group-form")
-        |> render_submit()
+        |> 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() =~
+      assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots"
-               gettext("Record shots")
-
       assert_patch(index_live, Routes.ammo_group_index_path(conn, :add_shot_group, ammo_group))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#shot_group-form", shot_group: @invalid_attrs)
+             |> form("#shot-group-form")
-      #        |> render_change() =~ dgettext("errors", "is invalid")
+             |> 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)
+        |> form("#shot-group-form")
-        |> render_submit()
+        |> 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")
+      assert html =~ "Show used"
-      refute html =~ gettext("$%{amount}", amount: display_currency(50.00))
+      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() =~
+             |> render_click() =~ "Edit Ammo"
-               gettext("Edit Ammo")
 
       assert_patch(show_live, Routes.ammo_group_show_path(conn, :edit, ammo_group))
 
-      # assert show_live
+      assert show_live
-      #        |> form("#ammo_group-form", ammo_group: @invalid_attrs)
+             |> form("#ammo_group-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(ammo_group: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         show_live
-        |> form("#ammo_group-form", ammo_group: @update_attrs)
+        |> form("#ammo_group-form")
-        |> render_submit()
+        |> 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() =~
+      assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots"
-               gettext("Record shots")
-
       assert_patch(index_live, Routes.ammo_group_show_path(conn, :add_shot_group, ammo_group))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#shot_group-form", shot_group: @invalid_attrs)
+             |> form("#shot-group-form")
-      #        |> render_change() =~ dgettext("errors", "is invalid")
+             |> 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)
+        |> form("#shot-group-form")
-        |> render_submit()
+        |> 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() =~
+             |> render_click() =~ "Edit Shot Records"
-               gettext("Edit Shot Records")
 
       assert_patch(
         index_live,
         Routes.ammo_group_show_path(conn, :edit_shot_group, ammo_group, shot_group)
       )
 
-      # assert index_live
+      assert index_live
-      #        |> form("#shot_group-form", shot_group: @invalid_attrs)
+             |> form("#shot-group-form")
-      #        |> render_change() =~ dgettext("errors", "is invalid")
+             |> 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)
+        |> form("#shot-group-form")
-        |> render_submit()
+        |> 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
 

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",
+    bullet_type: "some bullet_type",
-    "case_material" => "some case_material",
+    case_material: "some case_material",
-    "desc" => "some desc",
+    desc: "some desc",
-    "manufacturer" => "some manufacturer",
+    manufacturer: "some manufacturer",
-    "name" => "some name",
+    name: "some name",
-    "grains" => 120
+    grains: 120
   }
   @update_attrs %{
-    "bullet_type" => "some updated bullet_type",
+    bullet_type: "some updated bullet_type",
-    "case_material" => "some updated case_material",
+    case_material: "some updated case_material",
-    "desc" => "some updated desc",
+    desc: "some updated desc",
-    "manufacturer" => "some updated manufacturer",
+    manufacturer: "some updated manufacturer",
-    "name" => "some updated name",
+    name: "some updated name",
-    "grains" => 456
+    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",
+    notes: "some ammo group",
-    "count" => 20
+    count: 20
   }
   @shot_group_attrs %{
-    "notes" => "some shot group",
+    notes: "some shot group",
-    "count" => 20
+    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 =~ "Catalog"
-      assert html =~ gettext("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)
+      rifle_type = ammo_type_fixture(%{type: "rifle"}, current_user)
-      shotgun_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user)
+      shotgun_type = ammo_type_fixture(%{type: "shotgun"}, current_user)
-      pistol_type = ammo_type_fixture(%{"type" => "pistol"}, 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() =~
+      assert index_live |> element("a", "New Ammo type") |> render_click() =~ "New Ammo type"
-               gettext("New Ammo type")
-
       assert_patch(index_live, Routes.ammo_type_index_path(conn, :new))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#ammo_type-form", ammo_type: @invalid_attrs)
+             |> form("#ammo_type-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> 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
+      assert index_live
-      #        |> form("#ammo_type-form", ammo_type: @invalid_attrs)
+             |> form("#ammo_type-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> 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
+      assert index_live
-      #        |> form("#ammo_type-form", ammo_type: @invalid_attrs)
+             |> form("#ammo_type-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> 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
+      assert index_live
-      #        |> form("#ammo_type-form", ammo_type: @invalid_attrs)
+             |> form("#ammo_type-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> 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")
+      assert html =~ "Show used"
-      refute html =~ gettext("Used rounds")
+      refute html =~ "Used rounds"
-      refute html =~ gettext("Total ever rounds")
+      refute html =~ "Total ever rounds"
-      refute html =~ gettext("Used packs")
+      refute html =~ "Used packs"
-      refute html =~ gettext("Total ever 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 =~ "Used rounds"
-      assert html =~ gettext("Total ever rounds")
+      assert html =~ "Total ever rounds"
-      assert html =~ gettext("Used packs")
+      assert html =~ "Used packs"
-      assert html =~ gettext("Total ever 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
+      assert show_live
-      #        |> form("#ammo_type-form", ammo_type: @invalid_attrs)
+             |> form("#ammo_type-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> 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 =~ "Show used"
-      assert html =~ dgettext("actions", "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 =

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",
+    desc: "some desc",
-    "location" => "some location",
+    location: "some location",
-    "name" => "some name",
+    name: "some name",
-    "type" => "some type"
+    type: "some type"
   }
   @update_attrs %{
-    "desc" => "some updated desc",
+    desc: "some updated desc",
-    "location" => "some updated location",
+    location: "some updated location",
-    "name" => "some updated name",
+    name: "some updated name",
-    "type" => "some updated type"
+    type: "some updated type"
   }
+  @invalid_attrs %{desc: nil, location: nil, name: nil, type: nil}
   @ammo_type_attrs %{
-    "bullet_type" => "some bullet_type",
+    bullet_type: "some bullet_type",
-    "case_material" => "some case_material",
+    case_material: "some case_material",
-    "desc" => "some desc",
+    desc: "some desc",
-    "manufacturer" => "some manufacturer",
+    manufacturer: "some manufacturer",
-    "name" => "some name",
+    name: "some name",
-    "grains" => 120
+    grains: 120
   }
   @ammo_group_attrs %{
-    "notes" => "some ammo group",
+    notes: "some ammo group",
-    "count" => 20
+    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"]/,
+             |> form(~s/form[phx-change="search"]/)
-               search: %{search_term: container.location}
+             |> render_change(search: %{search_term: container.location}) =~ container.location
-             )
-             |> render_change() =~ 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"})
+             |> form(~s/form[phx-change="search"]/)
-             |> render_change() =~ container.location
+             |> 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: ""})
+             |> form(~s/form[phx-change="search"]/)
-             |> render_change() =~ container.location
+             |> 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() =~
+      assert index_live |> element("a", "New Container") |> render_click() =~ "New Container"
-               gettext("New Container")
-
       assert_patch(index_live, Routes.container_index_path(conn, :new))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#container-form", container: @invalid_attrs)
+             |> form("#container-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(container: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#container-form", container: @create_attrs)
+        |> form("#container-form")
-        |> render_submit()
+        |> 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
+      assert index_live
-      #        |> form("#container-form", container: @invalid_attrs)
+             |> form("#container-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(container: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#container-form", container: @update_attrs)
+        |> form("#container-form")
-        |> render_submit()
+        |> 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
+      assert index_live
-      #        |> form("#container-form", container: @invalid_attrs)
+             |> form("#container-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(container: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#container-form", container: @create_attrs)
+        |> form("#container-form")
-        |> render_submit()
+        |> 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
+      assert index_live
-      #        |> form("#container-form", container: @invalid_attrs)
+             |> form("#container-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> 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
+      assert show_live
-      #        |> form("#container-form", container: @invalid_attrs)
+             |> form("#container-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(container: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         show_live
-        |> form("#container-form", container: @update_attrs)
+        |> form("#container-form")
-        |> render_submit()
+        |> 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))

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 disconnected_html =~ "Welcome to Cannery"
-    assert render(home_live) =~ gettext("Welcome to %{name}", name: "Cannery")
+    assert render(home_live) =~ "Welcome to Cannery"
   end
 
   test "displays version number", %{conn: conn} do

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"}
+  @create_attrs %{name: "some name"}
-  @update_attrs %{"name" => "some updated name"}
+  @update_attrs %{name: "some updated name"}
-  # @invalid_attrs %{"name" => nil}
+  @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() =~
+      assert index_live |> element("a", "Create Invite") |> render_click() =~ "New Invite"
-               gettext("New Invite")
-
       assert_patch(index_live, Routes.invite_index_path(conn, :new))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#invite-form", invite: @invalid_attrs)
+             |> form("#invite-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(invite: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _live, html} =
         index_live
-        |> form("#invite-form", invite: @create_attrs)
+        |> form("#invite-form")
-        |> render_submit()
+        |> render_submit(invite: @create_attrs)
         |> follow_redirect(conn, Routes.invite_index_path(conn, :index))
 
-      assert html =~
+      assert html =~ "some name created successfully"
-               dgettext("prompts", "%{invite_name} created successfully", invite_name: "some name")
-
-      assert html =~ "some name"
     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() =~
+             |> render_click() =~ "Edit Invite"
-               gettext("Edit Invite")
 
       assert_patch(index_live, Routes.invite_index_path(conn, :edit, invite))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#invite-form", invite: @invalid_attrs)
+             |> form("#invite-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(invite: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _live, html} =
         index_live
-        |> form("#invite-form", invite: @update_attrs)
+        |> form("#invite-form")
-        |> render_submit()
+        |> render_submit(invite: @update_attrs)
         |> follow_redirect(conn, Routes.invite_index_path(conn, :index))
 
-      assert html =~
+      assert html =~ "some updated name updated successfully"
-               dgettext("prompts", "%{invite_name} updated successfully",
-                 invite_name: "some updated name"
-               )
-
-      assert html =~ "some updated name"
     end
 
     test "deletes invite in listing", %{conn: conn, invite: invite} do

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"}
+  @create_attrs %{ammo_left: 5, notes: "some notes"}
-  @update_attrs %{"count" => 16, "notes" => "some updated notes"}
+  @update_attrs %{count: 16, notes: "some updated notes"}
-  # @invalid_attrs %{"count" => nil, "notes" => nil}
+  @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]} =
+    {1, [ammo_group]} = ammo_group_fixture(%{staged: true}, ammo_type, container, current_user)
-      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 =
+      rifle_shot_group = shot_group_fixture(%{notes: "group_one"}, current_user, rifle_ammo_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"]/,
+             |> form(~s/form[phx-change="search"]/)
-               search: %{search_term: shot_group.notes}
+             |> render_change(search: %{search_term: shot_group.notes}) =~ shot_group.notes
-             )
-             |> render_change() =~ 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"})
+             |> form(~s/form[phx-change="search"]/)
-             |> render_change() =~ shot_group.notes
+             |> 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: ""})
+             |> form(~s/form[phx-change="search"]/)
-             |> render_change() =~ shot_group.notes
+             |> 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() =~
+      assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots"
-               gettext("Record shots")
-
       assert_patch(index_live, Routes.range_index_path(conn, :add_shot_group, ammo_group))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#shot_group-form", shot_group: @invalid_attrs)
+             |> form("#shot-group-form")
-      #        |> render_change() =~ dgettext("errors", "is invalid")
+             |> render_change(shot_group: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#shot-group-form", shot_group: @create_attrs)
+        |> form("#shot-group-form")
-        |> render_submit()
+        |> 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() =~
+             |> render_click() =~ "Edit Shot Records"
-               gettext("Edit Shot Records")
 
       assert_patch(index_live, Routes.range_index_path(conn, :edit, shot_group))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#shot_group-form", shot_group: @invalid_attrs)
+             |> form("#shot-group-form")
-      #        |> render_change() =~ dgettext("errors", "is invalid")
+             |> 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
 

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",
+    bg_color: "#100000",
-    "name" => "some name",
+    name: "some name",
-    "text_color" => "#000000"
+    text_color: "#000000"
   }
   @update_attrs %{
-    "bg_color" => "#100001",
+    bg_color: "#100001",
-    "name" => "some updated name",
+    name: "some updated name",
-    "text_color" => "#000001"
+    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"]/,
+             |> form(~s/form[phx-change="search"]/)
-               search: %{search_term: tag.name}
+             |> render_change(search: %{search_term: tag.name}) =~ tag.name
-             )
-             |> render_change() =~ 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"})
+             |> form(~s/form[phx-change="search"]/)
-             |> render_change() =~ tag.name
+             |> 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: ""})
+             |> form(~s/form[phx-change="search"]/)
-             |> render_change() =~ tag.name
+             |> 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() =~
+      assert index_live |> element("a", "New Tag") |> render_click() =~ "New Tag"
-               dgettext("actions", "New Tag")
-
       assert_patch(index_live, Routes.tag_index_path(conn, :new))
 
-      # assert index_live
+      assert index_live
-      #        |> form("#tag-form", tag: @invalid_attrs)
+             |> form("#tag-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(tag: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#tag-form", tag: @create_attrs)
+        |> form("#tag-form")
-        |> render_submit()
+        |> 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
+      assert index_live
-      #        |> form("#tag-form", tag: @invalid_attrs)
+             |> form("#tag-form")
-      #        |> render_change() =~ dgettext("errors", "can't be blank")
+             |> render_change(tag: @invalid_attrs) =~ "can't be blank"
 
       {:ok, _view, html} =
         index_live
-        |> form("#tag-form", tag: @update_attrs)
+        |> form("#tag-form")
-        |> render_submit()
+        |> render_submit(tag: @update_attrs)
         |> follow_redirect(conn, Routes.tag_index_path(conn, :index))
 
-      assert html =~
+      assert html =~ "some updated name updated successfully"
-               dgettext("prompts", "%{name} updated successfully", name: "some updated name")
-
       assert html =~ "#100001"
     end
 

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", []) =~
+    assert render_to_string(CanneryWeb.ErrorView, "404.html", []) =~ "Not found"
-             dgettext("errors", "Not found")
   end
 
   test "renders 500.html" do
-    assert render_to_string(CanneryWeb.ErrorView, "500.html", []) =~
+    assert render_to_string(CanneryWeb.ErrorView, "500.html", []) =~ "Internal Server Error"
-             dgettext("errors", "Internal Server Error")
   end
 end

test/support/fixtures.ex

@@ -24,8 +24,8 @@ defmodule Cannery.Fixtures do
   def user_fixture(attrs \\ %{}) do
     attrs
     |> Enum.into(%{
-      "email" => unique_user_email(),
+      email: unique_user_email(),
-      "password" => valid_user_password()
+      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(),
+      email: unique_user_email(),
-      "password" => valid_user_password()
+      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,
+      count: 20,
-      "date" => ~N[2022-02-13 03:17:00],
+      date: ~N[2022-02-13 03:17:00],
-      "notes" => random_string()
+      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,
+      ammo_type_id: ammo_type_id,
-      "container_id" => container_id,
+      container_id: container_id,
-      "count" => 20,
+      count: 20,
-      "purchased_on" => Date.utc_today()
+      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",
+      bg_color: "#100000",
-      "name" => random_string(),
+      name: random_string(),
-      "text_color" => "#000000"
+      text_color: "#000000"
     })
     |> Containers.create_tag(user)
     |> unwrap_ok_tuple()