shibao/cannery
shibao
/
cannery
1
2
Fork 1
Code Issues 11 Pull Requests Projects 1 Releases 33 Wiki Activity

use atom keys in tests
continuous-integration/drone/push Build is passing Details

This commit is contained in:
shibao 2023-03-28 21:57:29 -04:00
parent 8c95536ffd
commit bab2b26c13
28 changed files with 720 additions and 861 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -1,3 +1,6 @@
# v0.9.1
- Code quality improvements
# v0.9.0
- Add length limits to all string fields
- Add selectable ammo types

20
lib/cannery/ammo.ex
View File

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

2
priv/gettext/de/LC_MESSAGES/errors.po
View File

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

2
priv/gettext/en/LC_MESSAGES/errors.po
View File

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

2
priv/gettext/errors.pot
View File

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

2
priv/gettext/es/LC_MESSAGES/errors.po
View File

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

2
priv/gettext/fr/LC_MESSAGES/errors.po
View File

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

2
priv/gettext/ga/LC_MESSAGES/errors.po
View File

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

33
test/cannery/accounts/invites_test.exs
View File

@ -11,11 +11,11 @@ defmodule Cannery.InvitesTest do
@moduletag :invites_test
@valid_attrs %{
"name" => "some name"
name: "some name"
}
@invalid_attrs %{
"name" => nil,
"token" => nil
name: nil,
token: nil
}
describe "invites" do
@ -57,7 +57,7 @@ defmodule Cannery.InvitesTest do
assert {:ok, _user} =
Accounts.register_user(
%{"email" => unique_user_email(), "password" => valid_user_password()},
%{email: unique_user_email(), password: valid_user_password()},
token
)
@ -65,7 +65,7 @@ defmodule Cannery.InvitesTest do
assert {:ok, _user} =
Accounts.register_user(
%{"email" => unique_user_email(), "password" => valid_user_password()},
%{email: unique_user_email(), password: valid_user_password()},
token
)
@ -81,13 +81,13 @@ defmodule Cannery.InvitesTest do
assert {:ok, _user} =
Accounts.register_user(
%{"email" => unique_user_email(), "password" => valid_user_password()},
%{email: unique_user_email(), password: valid_user_password()},
token
)
assert {:ok, _user} =
Accounts.register_user(
%{"email" => unique_user_email(), "password" => valid_user_password()},
%{email: unique_user_email(), password: valid_user_password()},
another_token
)
@ -97,7 +97,7 @@ defmodule Cannery.InvitesTest do
assert {:ok, _user} =
Accounts.register_user(
%{"email" => unique_user_email(), "password" => valid_user_password()},
%{email: unique_user_email(), password: valid_user_password()},
token
)
@ -138,21 +138,14 @@ defmodule Cannery.InvitesTest do
test "create_invite/1 with valid data creates an unlimited invite",
%{current_user: current_user} do
assert {:ok, %Invite{} = invite} =
Invites.create_invite(current_user, %{
"name" => "some name"
})
assert {:ok, %Invite{} = invite} = Invites.create_invite(current_user, %{name: "some name"})
assert invite.name == "some name"
end
test "create_invite/1 with valid data creates a limited invite",
%{current_user: current_user} do
assert {:ok, %Invite{} = invite} =
Invites.create_invite(current_user, %{
"name" => "some name",
"uses_left" => 10
})
Invites.create_invite(current_user, %{name: "some name", uses_left: 10})
assert invite.name == "some name"
assert invite.uses_left == 10
@ -168,7 +161,7 @@ defmodule Cannery.InvitesTest do
assert {:ok, %Invite{} = new_invite} =
Invites.update_invite(
invite,
%{"name" => "some updated name", "uses_left" => 5},
%{name: "some updated name", uses_left: 5},
current_user
)
@ -178,12 +171,12 @@ defmodule Cannery.InvitesTest do
test "update_invite/2 can set an invite to be unlimited",
%{invite: invite, current_user: current_user} do
{:ok, invite} = Invites.update_invite(invite, %{"uses_left" => 5}, current_user)
{:ok, invite} = Invites.update_invite(invite, %{uses_left: 5}, current_user)
assert {:ok, %Invite{} = new_invite} =
Invites.update_invite(
invite,
%{"name" => "some updated name", "uses_left" => nil},
%{name: "some updated name", uses_left: nil},
current_user
)

57
test/cannery/accounts_test.exs
View File

@ -63,8 +63,7 @@ defmodule Cannery.AccountsTest do
end
test "validates email and password when given" do
{:error, changeset} =
Accounts.register_user(%{"email" => "not valid", "password" => "not valid"})
{:error, changeset} = Accounts.register_user(%{email: "not valid", password: "not valid"})
assert %{
email: ["must have the @ sign and no spaces"],
@ -74,26 +73,25 @@ defmodule Cannery.AccountsTest do
test "validates maximum values for email and password for security" do
too_long = String.duplicate("db", 100)
{:error, changeset} = Accounts.register_user(%{"email" => too_long, "password" => too_long})
{:error, changeset} = Accounts.register_user(%{email: too_long, password: too_long})
assert "should be at most 160 character(s)" in errors_on(changeset).email
assert "should be at most 80 character(s)" in errors_on(changeset).password
end
test "validates email uniqueness" do
%{email: email} = user_fixture()
{:error, changeset} = Accounts.register_user(%{"email" => email})
{:error, changeset} = Accounts.register_user(%{email: email})
assert "has already been taken" in errors_on(changeset).email
# Now try with the upper cased email too, to check that email case is ignored.
{:error, changeset} = Accounts.register_user(%{"email" => String.upcase(email)})
{:error, changeset} = Accounts.register_user(%{email: String.upcase(email)})
assert "has already been taken" in errors_on(changeset).email
end
test "registers users with a hashed password" do
email = unique_user_email()
{:ok, user} =
Accounts.register_user(%{"email" => email, "password" => valid_user_password()})
{:ok, user} = Accounts.register_user(%{email: email, password: valid_user_password()})
assert user.email == email
assert is_binary(user.hashed_password)
@ -103,11 +101,11 @@ defmodule Cannery.AccountsTest do
test "records used invite during registration" do
{:ok, %{id: invite_id, token: token}} =
admin_fixture() |> Invites.create_invite(%{"name" => "my invite"})
admin_fixture() |> Invites.create_invite(%{name: "my invite"})
assert {:ok, %{invite_id: ^invite_id}} =
Accounts.register_user(
%{"email" => unique_user_email(), "password" => valid_user_password()},
%{email: unique_user_email(), password: valid_user_password()},
token
)
end
@ -123,7 +121,7 @@ defmodule Cannery.AccountsTest do
email = unique_user_email()
password = valid_user_password()
changeset = Accounts.change_user_registration(%{"email" => email, "password" => password})
changeset = Accounts.change_user_registration(%{email: email, password: password})
assert changeset.valid?
assert get_change(changeset, :email) == email
@ -151,7 +149,7 @@ defmodule Cannery.AccountsTest do
test "validates email", %{user: user} do
{:error, changeset} =
Accounts.apply_user_email(user, valid_user_password(), %{"email" => "not valid"})
Accounts.apply_user_email(user, valid_user_password(), %{email: "not valid"})
assert %{email: ["must have the @ sign and no spaces"]} = errors_on(changeset)
end
@ -160,7 +158,7 @@ defmodule Cannery.AccountsTest do
too_long = String.duplicate("db", 100)
{:error, changeset} =
Accounts.apply_user_email(user, valid_user_password(), %{"email" => too_long})
Accounts.apply_user_email(user, valid_user_password(), %{email: too_long})
assert "should be at most 160 character(s)" in errors_on(changeset).email
end
@ -169,21 +167,21 @@ defmodule Cannery.AccountsTest do
%{email: email} = user_fixture()
{:error, changeset} =
Accounts.apply_user_email(user, valid_user_password(), %{"email" => email})
Accounts.apply_user_email(user, valid_user_password(), %{email: email})
assert "has already been taken" in errors_on(changeset).email
end
test "validates current password", %{user: user} do
{:error, changeset} =
Accounts.apply_user_email(user, "invalid", %{"email" => unique_user_email()})
Accounts.apply_user_email(user, "invalid", %{email: unique_user_email()})
assert %{current_password: ["is not valid"]} = errors_on(changeset)
end
test "applies the email without persisting it", %{user: user} do
email = unique_user_email()
{:ok, user} = Accounts.apply_user_email(user, valid_user_password(), %{"email" => email})
{:ok, user} = Accounts.apply_user_email(user, valid_user_password(), %{email: email})
assert user.email == email
assert Accounts.get_user!(user.id).email != email
end
@ -258,11 +256,7 @@ defmodule Cannery.AccountsTest do
end
test "allows fields to be set" do
changeset =
Accounts.change_user_password(%User{}, %{
"password" => "new valid password"
})
changeset = Accounts.change_user_password(%User{}, %{password: "new valid password"})
assert changeset.valid?
assert get_change(changeset, :password) == "new valid password"
assert is_nil(get_change(changeset, :hashed_password))
@ -277,8 +271,8 @@ defmodule Cannery.AccountsTest do
test "validates password", %{user: user} do
{:error, changeset} =
Accounts.update_user_password(user, valid_user_password(), %{
"password" => "not valid",
"password_confirmation" => "another"
password: "not valid",
password_confirmation: "another"
})
assert %{
@ -291,14 +285,14 @@ defmodule Cannery.AccountsTest do
too_long = String.duplicate("db", 100)
{:error, changeset} =
Accounts.update_user_password(user, valid_user_password(), %{"password" => too_long})
Accounts.update_user_password(user, valid_user_password(), %{password: too_long})
assert "should be at most 80 character(s)" in errors_on(changeset).password
end
test "validates current password", %{user: user} do
{:error, changeset} =
Accounts.update_user_password(user, "invalid", %{"password" => valid_user_password()})
Accounts.update_user_password(user, "invalid", %{password: valid_user_password()})
assert %{current_password: ["is not valid"]} = errors_on(changeset)
end
@ -306,7 +300,7 @@ defmodule Cannery.AccountsTest do
test "updates the password", %{user: user} do
{:ok, user} =
Accounts.update_user_password(user, valid_user_password(), %{
"password" => "new valid password"
password: "new valid password"
})
assert is_nil(user.password)
@ -318,7 +312,7 @@ defmodule Cannery.AccountsTest do
{:ok, _} =
Accounts.update_user_password(user, valid_user_password(), %{
"password" => "new valid password"
password: "new valid password"
})
refute Repo.get_by(UserToken, user_id: user.id)
@ -486,8 +480,8 @@ defmodule Cannery.AccountsTest do
test "validates password", %{user: user} do
{:error, changeset} =
Accounts.reset_user_password(user, %{
"password" => "not valid",
"password_confirmation" => "another"
password: "not valid",
password_confirmation: "another"
})
assert %{
@ -498,13 +492,12 @@ defmodule Cannery.AccountsTest do
test "validates maximum values for password for security", %{user: user} do
too_long = String.duplicate("db", 100)
{:error, changeset} = Accounts.reset_user_password(user, %{"password" => too_long})
{:error, changeset} = Accounts.reset_user_password(user, %{password: too_long})
assert "should be at most 80 character(s)" in errors_on(changeset).password
end
test "updates the password", %{user: user} do
{:ok, updated_user} =
Accounts.reset_user_password(user, %{"password" => "new valid password"})
{:ok, updated_user} = Accounts.reset_user_password(user, %{password: "new valid password"})
assert is_nil(updated_user.password)
assert Accounts.get_user_by_email_and_password(user.email, "new valid password")
@ -512,7 +505,7 @@ defmodule Cannery.AccountsTest do
test "deletes all tokens for the given user", %{user: user} do
_session_token = Accounts.generate_user_session_token(user)
{:ok, _user} = Accounts.reset_user_password(user, %{"password" => "new valid password"})
{:ok, _user} = Accounts.reset_user_password(user, %{password: "new valid password"})
refute Repo.get_by(UserToken, user_id: user.id)
end
end

79
test/cannery/activity_log_test.exs
View File

@ -5,12 +5,7 @@ defmodule Cannery.ActivityLogTest do
use Cannery.DataCase
import Cannery.Fixtures
alias Cannery.{
ActivityLog,
ActivityLog.ShotGroup,
Ammo
}
alias Cannery.{ActivityLog, ActivityLog.ShotGroup, Ammo}
@moduletag :activity_log_test
@ -21,10 +16,10 @@ defmodule Cannery.ActivityLogTest do
ammo_type = ammo_type_fixture(current_user)
{1, [%{id: ammo_group_id} = ammo_group]} =
ammo_group_fixture(%{"count" => 25}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 25}, ammo_type, container, current_user)
shot_group =
%{"count" => 5, "date" => ~N[2022-02-13 03:17:00], "notes" => "some notes"}
%{count: 5, date: ~N[2022-02-13 03:17:00], notes: "some notes"}
|> shot_group_fixture(current_user, ammo_group)
ammo_group = ammo_group_id |> Ammo.get_ammo_group!(current_user)
@ -54,7 +49,7 @@ defmodule Cannery.ActivityLogTest do
test "create_shot_group/3 with valid data creates a shot_group",
%{current_user: current_user, ammo_group: ammo_group} do
valid_attrs = %{"count" => 10, "date" => ~D[2022-02-13], "notes" => "some notes"}
valid_attrs = %{count: 10, date: ~D[2022-02-13], notes: "some notes"}
assert {:ok, %ShotGroup{} = shot_group} =
ActivityLog.create_shot_group(valid_attrs, current_user, ammo_group)
@ -69,7 +64,7 @@ defmodule Cannery.ActivityLogTest do
current_user: current_user,
ammo_group: %{id: ammo_group_id, count: org_count} = ammo_group
} do
valid_attrs = %{"count" => 10, "date" => ~D[2022-02-13], "notes" => "some notes"}
valid_attrs = %{count: 10, date: ~D[2022-02-13], notes: "some notes"}
assert {:ok, %ShotGroup{} = shot_group} =
ActivityLog.create_shot_group(valid_attrs, current_user, ammo_group)
@ -82,7 +77,7 @@ defmodule Cannery.ActivityLogTest do
test "create_shot_group/3 does not remove more than ammo group amount",
%{current_user: current_user, ammo_group: %{id: ammo_group_id} = ammo_group} do
valid_attrs = %{"count" => 20, "date" => ~D[2022-02-13], "notes" => "some notes"}
valid_attrs = %{count: 20, date: ~D[2022-02-13], notes: "some notes"}
assert {:ok, %ShotGroup{}} =
ActivityLog.create_shot_group(valid_attrs, current_user, ammo_group)
@ -92,12 +87,12 @@ defmodule Cannery.ActivityLogTest do
assert ammo_group.count == 0
assert {:error, %Ecto.Changeset{}} =
ActivityLog.create_shot_group(%{"count" => 1}, current_user, ammo_group)
ActivityLog.create_shot_group(%{count: 1}, current_user, ammo_group)
end
test "create_shot_group/3 with invalid data returns error changeset",
%{current_user: current_user, ammo_group: ammo_group} do
invalid_params = %{"count" => nil, "date" => nil, "notes" => nil}
invalid_params = %{count: nil, date: nil, notes: nil}
assert {:error, %Ecto.Changeset{}} =
ActivityLog.create_shot_group(invalid_params, current_user, ammo_group)
@ -113,9 +108,9 @@ defmodule Cannery.ActivityLogTest do
ActivityLog.update_shot_group(
shot_group,
%{
"count" => 10,
"date" => ~D[2022-02-13],
"notes" => "some updated notes"
count: 10,
date: ~D[2022-02-13],
notes: "some updated notes"
},
current_user
)
@ -131,9 +126,9 @@ defmodule Cannery.ActivityLogTest do
ActivityLog.update_shot_group(
shot_group,
%{
"count" => 25,
"date" => ~D[2022-02-13],
"notes" => "some updated notes"
count: 25,
date: ~D[2022-02-13],
notes: "some updated notes"
},
current_user
)
@ -149,14 +144,14 @@ defmodule Cannery.ActivityLogTest do
assert {:error, %Ecto.Changeset{}} =
ActivityLog.update_shot_group(
shot_group,
%{"count" => 26, "date" => nil, "notes" => nil},
%{count: 26, date: nil, notes: nil},
current_user
)
assert {:error, %Ecto.Changeset{}} =
ActivityLog.update_shot_group(
shot_group,
%{"count" => -1, "date" => nil, "notes" => nil},
%{count: -1, date: nil, notes: nil},
current_user
)
@ -184,10 +179,10 @@ defmodule Cannery.ActivityLogTest do
assert 0 = another_ammo_group |> ActivityLog.get_used_count(current_user)
assert 5 = ammo_group |> ActivityLog.get_used_count(current_user)
shot_group_fixture(%{"count" => 15}, current_user, ammo_group)
shot_group_fixture(%{count: 15}, current_user, ammo_group)
assert 20 = ammo_group |> ActivityLog.get_used_count(current_user)
shot_group_fixture(%{"count" => 10}, current_user, ammo_group)
shot_group_fixture(%{count: 10}, current_user, ammo_group)
assert 30 = ammo_group |> ActivityLog.get_used_count(current_user)
{1, [another_ammo_group]} = ammo_group_fixture(ammo_type, container, current_user)
@ -206,17 +201,17 @@ defmodule Cannery.ActivityLogTest do
assert %{ammo_group_id => 5} ==
[ammo_group, another_ammo_group] |> ActivityLog.get_used_counts(current_user)
shot_group_fixture(%{"count" => 5}, current_user, another_ammo_group)
shot_group_fixture(%{count: 5}, current_user, another_ammo_group)
used_counts = [ammo_group, another_ammo_group] |> ActivityLog.get_used_counts(current_user)
assert %{^ammo_group_id => 5} = used_counts
assert %{^another_ammo_group_id => 5} = used_counts
shot_group_fixture(%{"count" => 15}, current_user, ammo_group)
shot_group_fixture(%{count: 15}, current_user, ammo_group)
used_counts = [ammo_group, another_ammo_group] |> ActivityLog.get_used_counts(current_user)
assert %{^ammo_group_id => 20} = used_counts
assert %{^another_ammo_group_id => 5} = used_counts
shot_group_fixture(%{"count" => 10}, current_user, ammo_group)
shot_group_fixture(%{count: 10}, current_user, ammo_group)
used_counts = [ammo_group, another_ammo_group] |> ActivityLog.get_used_counts(current_user)
assert %{^ammo_group_id => 30} = used_counts
assert %{^another_ammo_group_id => 5} = used_counts
@ -233,10 +228,10 @@ defmodule Cannery.ActivityLogTest do
assert another_ammo_group |> ActivityLog.get_last_used_date(current_user) |> is_nil()
assert ^date = ammo_group |> ActivityLog.get_last_used_date(current_user)
%{date: date} = shot_group_fixture(%{"date" => ~D[2022-11-10]}, current_user, ammo_group)
%{date: date} = shot_group_fixture(%{date: ~D[2022-11-10]}, current_user, ammo_group)
assert ^date = ammo_group |> ActivityLog.get_last_used_date(current_user)
%{date: date} = shot_group_fixture(%{"date" => ~D[2022-11-11]}, current_user, ammo_group)
%{date: date} = shot_group_fixture(%{date: ~D[2022-11-11]}, current_user, ammo_group)
assert ^date = ammo_group |> ActivityLog.get_last_used_date(current_user)
end
@ -254,7 +249,7 @@ defmodule Cannery.ActivityLogTest do
assert %{ammo_group_id => date} ==
[ammo_group, another_ammo_group] |> ActivityLog.get_last_used_dates(current_user)
shot_group_fixture(%{"date" => ~D[2022-11-09]}, current_user, another_ammo_group)
shot_group_fixture(%{date: ~D[2022-11-09]}, current_user, another_ammo_group)
# setting initial date
last_used_shot_groups =
@ -264,7 +259,7 @@ defmodule Cannery.ActivityLogTest do
assert %{^another_ammo_group_id => ~D[2022-11-09]} = last_used_shot_groups
# setting another date
shot_group_fixture(%{"date" => ~D[2022-11-10]}, current_user, ammo_group)
shot_group_fixture(%{date: ~D[2022-11-10]}, current_user, ammo_group)
last_used_shot_groups =
[ammo_group, another_ammo_group] |> ActivityLog.get_last_used_dates(current_user)
@ -273,7 +268,7 @@ defmodule Cannery.ActivityLogTest do
assert %{^another_ammo_group_id => ~D[2022-11-09]} = last_used_shot_groups
# setting yet another date
shot_group_fixture(%{"date" => ~D[2022-11-11]}, current_user, ammo_group)
shot_group_fixture(%{date: ~D[2022-11-11]}, current_user, ammo_group)
last_used_shot_groups =
[ammo_group, another_ammo_group] |> ActivityLog.get_last_used_dates(current_user)
@ -288,10 +283,10 @@ defmodule Cannery.ActivityLogTest do
assert 0 = another_ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user)
assert 5 = ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user)
shot_group_fixture(%{"count" => 5}, current_user, ammo_group)
shot_group_fixture(%{count: 5}, current_user, ammo_group)
assert 10 = ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user)
shot_group_fixture(%{"count" => 1}, current_user, ammo_group)
shot_group_fixture(%{count: 1}, current_user, ammo_group)
assert 11 = ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user)
end
@ -309,7 +304,7 @@ defmodule Cannery.ActivityLogTest do
|> ActivityLog.get_used_count_for_ammo_types(current_user)
# use generated ammo group
shot_group_fixture(%{"count" => 5}, current_user, ammo_group)
shot_group_fixture(%{count: 5}, current_user, ammo_group)
used_counts =
[ammo_type, another_ammo_type] |> ActivityLog.get_used_count_for_ammo_types(current_user)
@ -318,7 +313,7 @@ defmodule Cannery.ActivityLogTest do
assert %{^another_ammo_type_id => 5} = used_counts
# use generated ammo group again
shot_group_fixture(%{"count" => 1}, current_user, ammo_group)
shot_group_fixture(%{count: 1}, current_user, ammo_group)
used_counts =
[ammo_type, another_ammo_type] |> ActivityLog.get_used_count_for_ammo_types(current_user)
@ -349,20 +344,20 @@ defmodule Cannery.ActivityLogTest do
other_container = container_fixture(other_user)
for type <- ["rifle", "shotgun", "pistol"] do
other_ammo_type = ammo_type_fixture(%{"type" => type}, other_user)
other_ammo_type = ammo_type_fixture(%{type: type}, other_user)
{1, [other_ammo_group]} = ammo_group_fixture(other_ammo_type, other_container, other_user)
shot_group_fixture(other_user, other_ammo_group)
end
rifle_ammo_type = ammo_type_fixture(%{"type" => "rifle"}, current_user)
rifle_ammo_type = ammo_type_fixture(%{type: "rifle"}, current_user)
{1, [rifle_ammo_group]} = ammo_group_fixture(rifle_ammo_type, container, current_user)
rifle_shot_group = shot_group_fixture(current_user, rifle_ammo_group)
shotgun_ammo_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user)
shotgun_ammo_type = ammo_type_fixture(%{type: "shotgun"}, current_user)
{1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_ammo_type, container, current_user)
shotgun_shot_group = shot_group_fixture(current_user, shotgun_ammo_group)
pistol_ammo_type = ammo_type_fixture(%{"type" => "pistol"}, current_user)
pistol_ammo_type = ammo_type_fixture(%{type: "pistol"}, current_user)
{1, [pistol_ammo_group]} = ammo_group_fixture(pistol_ammo_type, container, current_user)
pistol_shot_group = shot_group_fixture(current_user, pistol_ammo_group)
@ -389,14 +384,14 @@ defmodule Cannery.ActivityLogTest do
container: container,
current_user: current_user
} do
shot_group_a = shot_group_fixture(%{"notes" => "amazing"}, current_user, ammo_group)
shot_group_a = shot_group_fixture(%{notes: "amazing"}, current_user, ammo_group)
{1, [another_ammo_group]} =
ammo_group_fixture(%{"notes" => "stupendous"}, ammo_type, container, current_user)
ammo_group_fixture(%{notes: "stupendous"}, ammo_type, container, current_user)
shot_group_b = shot_group_fixture(current_user, another_ammo_group)
another_ammo_type = ammo_type_fixture(%{"name" => "fabulous ammo"}, current_user)
another_ammo_type = ammo_type_fixture(%{name: "fabulous ammo"}, current_user)
{1, [yet_another_ammo_group]} =
ammo_group_fixture(another_ammo_type, container, current_user)

283
test/cannery/ammo_test.exs
View File

@ -10,28 +10,28 @@ defmodule Cannery.AmmoTest do
@moduletag :ammo_test
@valid_attrs %{
"bullet_type" => "some bullet_type",
"case_material" => "some case_material",
"desc" => "some desc",
"manufacturer" => "some manufacturer",
"name" => "some name",
"grains" => 120
bullet_type: "some bullet_type",
case_material: "some case_material",
desc: "some desc",
manufacturer: "some manufacturer",
name: "some name",
grains: 120
}
@update_attrs %{
"bullet_type" => "some updated bullet_type",
"case_material" => "some updated case_material",
"desc" => "some updated desc",
"manufacturer" => "some updated manufacturer",
"name" => "some updated name",
"grains" => 456
bullet_type: "some updated bullet_type",
case_material: "some updated case_material",
desc: "some updated desc",
manufacturer: "some updated manufacturer",
name: "some updated name",
grains: 456
}
@invalid_attrs %{
"bullet_type" => nil,
"case_material" => nil,
"desc" => nil,
"manufacturer" => nil,
"name" => nil,
"grains" => nil
bullet_type: nil,
case_material: nil,
desc: nil,
manufacturer: nil,
name: nil,
grains: nil
}
describe "list_ammo_types/2" do
@ -40,34 +40,34 @@ defmodule Cannery.AmmoTest do
rifle_ammo_type =
%{
"name" => "bullets",
"type" => "rifle",
"desc" => "has some pews in it",
"grains" => 5
name: "bullets",
type: "rifle",
desc: "has some pews in it",
grains: 5
}
|> ammo_type_fixture(current_user)
shotgun_ammo_type =
%{
"name" => "hollows",
"type" => "shotgun",
"grains" => 3
name: "hollows",
type: "shotgun",
grains: 3
}
|> ammo_type_fixture(current_user)
pistol_ammo_type =
%{
"type" => "pistol",
"name" => "jackets",
"desc" => "brass shell",
"tracer" => true
type: "pistol",
name: "jackets",
desc: "brass shell",
tracer: true
}
|> ammo_type_fixture(current_user)
_shouldnt_return =
%{
"name" => "bullet",
"desc" => "pews brass shell"
name: "bullet",
desc: "pews brass shell"
}
|> ammo_type_fixture(user_fixture())
@ -228,7 +228,7 @@ defmodule Cannery.AmmoTest do
%{ammo_type: ammo_type, current_user: current_user, container: container} do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 25.00, "count" => 1},
%{price_paid: 25.00, count: 1},
ammo_type,
container,
current_user
@ -238,7 +238,7 @@ defmodule Cannery.AmmoTest do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 25.00, "count" => 1},
%{price_paid: 25.00, count: 1},
ammo_type,
container,
current_user
@ -248,7 +248,7 @@ defmodule Cannery.AmmoTest do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 70.00, "count" => 1},
%{price_paid: 70.00, count: 1},
ammo_type,
container,
current_user
@ -258,7 +258,7 @@ defmodule Cannery.AmmoTest do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 30.00, "count" => 1},
%{price_paid: 30.00, count: 1},
ammo_type,
container,
current_user
@ -282,7 +282,7 @@ defmodule Cannery.AmmoTest do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 25.00, "count" => 1},
%{price_paid: 25.00, count: 1},
another_ammo_type,
container,
current_user
@ -294,7 +294,7 @@ defmodule Cannery.AmmoTest do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 25.00, "count" => 1},
%{price_paid: 25.00, count: 1},
ammo_type,
container,
current_user
@ -308,7 +308,7 @@ defmodule Cannery.AmmoTest do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 25.00, "count" => 1},
%{price_paid: 25.00, count: 1},
ammo_type,
container,
current_user
@ -322,7 +322,7 @@ defmodule Cannery.AmmoTest do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 70.00, "count" => 1},
%{price_paid: 70.00, count: 1},
ammo_type,
container,
current_user
@ -336,7 +336,7 @@ defmodule Cannery.AmmoTest do
{1, [_ammo_group]} =
ammo_group_fixture(
%{"price_paid" => 30.00, "count" => 1},
%{price_paid: 30.00, count: 1},
ammo_type,
container,
current_user
@ -355,18 +355,18 @@ defmodule Cannery.AmmoTest do
assert 0 = Ammo.get_round_count_for_ammo_type(another_ammo_type, current_user)
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 1}, ammo_type, container, current_user)
assert 1 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user)
assert 51 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user)
shot_group_fixture(%{"count" => 26}, current_user, ammo_group)
shot_group_fixture(%{count: 26}, current_user, ammo_group)
assert 25 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user)
shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group)
shot_group_fixture(%{count: 1}, current_user, first_ammo_group)
assert 24 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user)
end
@ -376,7 +376,7 @@ defmodule Cannery.AmmoTest do
container: container
} do
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 1}, ammo_type, container, current_user)
assert %{ammo_type_id => 1} ==
[ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user)
@ -384,7 +384,7 @@ defmodule Cannery.AmmoTest do
%{id: another_ammo_type_id} = another_ammo_type = ammo_type_fixture(current_user)
{1, [_another_ammo_group]} =
ammo_group_fixture(%{"count" => 1}, another_ammo_type, container, current_user)
ammo_group_fixture(%{count: 1}, another_ammo_type, container, current_user)
round_counts =
[ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user)
@ -392,7 +392,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_type_id => 1} = round_counts
assert %{^another_ammo_type_id => 1} = round_counts
{1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user)
round_counts =
[ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user)
@ -400,7 +400,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_type_id => 51} = round_counts
assert %{^another_ammo_type_id => 1} = round_counts
shot_group_fixture(%{"count" => 26}, current_user, ammo_group)
shot_group_fixture(%{count: 26}, current_user, ammo_group)
round_counts =
[ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user)
@ -408,7 +408,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_type_id => 25} = round_counts
assert %{^another_ammo_type_id => 1} = round_counts
shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group)
shot_group_fixture(%{count: 1}, current_user, first_ammo_group)
round_counts =
[ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user)
@ -422,18 +422,18 @@ defmodule Cannery.AmmoTest do
assert 0 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user)
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 1}, ammo_type, container, current_user)
assert 1 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user)
assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user)
shot_group_fixture(%{"count" => 26}, current_user, ammo_group)
shot_group_fixture(%{count: 26}, current_user, ammo_group)
assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user)
shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group)
shot_group_fixture(%{count: 1}, current_user, first_ammo_group)
assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user)
end
@ -446,7 +446,7 @@ defmodule Cannery.AmmoTest do
assert %{} == [ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user)
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 1}, ammo_type, container, current_user)
assert %{ammo_type_id => 1} ==
[ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user)
@ -454,7 +454,7 @@ defmodule Cannery.AmmoTest do
%{id: another_ammo_type_id} = another_ammo_type = ammo_type_fixture(current_user)
{1, [_ammo_group]} =
ammo_group_fixture(%{"count" => 1}, another_ammo_type, container, current_user)
ammo_group_fixture(%{count: 1}, another_ammo_type, container, current_user)
historical_counts =
[ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user)
@ -462,7 +462,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_type_id => 1} = historical_counts
assert %{^another_ammo_type_id => 1} = historical_counts
{1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user)
historical_counts =
[ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user)
@ -470,7 +470,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_type_id => 51} = historical_counts
assert %{^another_ammo_type_id => 1} = historical_counts
shot_group_fixture(%{"count" => 26}, current_user, ammo_group)
shot_group_fixture(%{count: 26}, current_user, ammo_group)
historical_counts =
[ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user)
@ -478,7 +478,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_type_id => 51} = historical_counts
assert %{^another_ammo_type_id => 1} = historical_counts
shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group)
shot_group_fixture(%{count: 1}, current_user, first_ammo_group)
historical_counts =
[ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user)
@ -492,18 +492,18 @@ defmodule Cannery.AmmoTest do
assert 0 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user)
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 1}, ammo_type, container, current_user)
assert 0 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user)
assert 0 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user)
shot_group_fixture(%{"count" => 50}, current_user, ammo_group)
shot_group_fixture(%{count: 50}, current_user, ammo_group)
assert 1 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user)
shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group)
shot_group_fixture(%{count: 1}, current_user, first_ammo_group)
assert 2 = Ammo.get_used_ammo_groups_count_for_type(ammo_type, current_user)
end
@ -525,7 +525,7 @@ defmodule Cannery.AmmoTest do
# testing ammo type with ammo group
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 1}, ammo_type, container, current_user)
assert %{} ==
[ammo_type, another_ammo_type]
@ -533,17 +533,17 @@ defmodule Cannery.AmmoTest do
# testing ammo type with used ammo group
{1, [another_ammo_group]} =
ammo_group_fixture(%{"count" => 50}, another_ammo_type, container, current_user)
ammo_group_fixture(%{count: 50}, another_ammo_type, container, current_user)
shot_group_fixture(%{"count" => 50}, current_user, another_ammo_group)
shot_group_fixture(%{count: 50}, current_user, another_ammo_group)
assert %{another_ammo_type_id => 1} ==
[ammo_type, another_ammo_type]
|> Ammo.get_used_ammo_groups_count_for_types(current_user)
# testing two ammo types with zero and one used ammo groups
{1, [ammo_group]} = ammo_group_fixture(%{"count" => 50}, ammo_type, container, current_user)
shot_group_fixture(%{"count" => 50}, current_user, ammo_group)
{1, [ammo_group]} = ammo_group_fixture(%{count: 50}, ammo_type, container, current_user)
shot_group_fixture(%{count: 50}, current_user, ammo_group)
used_counts =
[ammo_type, another_ammo_type] |> Ammo.get_used_ammo_groups_count_for_types(current_user)
@ -552,7 +552,7 @@ defmodule Cannery.AmmoTest do
assert %{^another_ammo_type_id => 1} = used_counts
# testing two ammo type with one and two used ammo groups
shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group)
shot_group_fixture(%{count: 1}, current_user, first_ammo_group)
used_counts =
[ammo_type, another_ammo_type] |> Ammo.get_used_ammo_groups_count_for_types(current_user)
@ -564,19 +564,18 @@ defmodule Cannery.AmmoTest do
test "get_ammo_groups_count_for_container!/2 gets accurate ammo count for container",
%{ammo_type: ammo_type, current_user: current_user, container: container} do
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 5}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 5}, ammo_type, container, current_user)
assert 1 = Ammo.get_ammo_groups_count_for_container!(container, current_user)
{25, _ammo_groups} =
ammo_group_fixture(%{"count" => 5}, 25, ammo_type, container, current_user)
{25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user)
assert 26 = Ammo.get_ammo_groups_count_for_container!(container, current_user)
shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group)
shot_group_fixture(%{count: 1}, current_user, first_ammo_group)
assert 26 = Ammo.get_ammo_groups_count_for_container!(container, current_user)
shot_group_fixture(%{"count" => 4}, current_user, first_ammo_group)
shot_group_fixture(%{count: 4}, current_user, first_ammo_group)
assert 25 = Ammo.get_ammo_groups_count_for_container!(container, current_user)
end
@ -588,10 +587,10 @@ defmodule Cannery.AmmoTest do
%{id: another_container_id} = another_container = container_fixture(current_user)
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 5}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 5}, ammo_type, container, current_user)
{1, [_first_ammo_group]} =
ammo_group_fixture(%{"count" => 5}, ammo_type, another_container, current_user)
ammo_group_fixture(%{count: 5}, ammo_type, another_container, current_user)
ammo_groups_count =
[container, another_container]
@ -600,8 +599,7 @@ defmodule Cannery.AmmoTest do
assert %{^container_id => 1} = ammo_groups_count
assert %{^another_container_id => 1} = ammo_groups_count
{25, _ammo_groups} =
ammo_group_fixture(%{"count" => 5}, 25, ammo_type, container, current_user)
{25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user)
ammo_groups_count =
[container, another_container]
@ -610,7 +608,7 @@ defmodule Cannery.AmmoTest do
assert %{^container_id => 26} = ammo_groups_count
assert %{^another_container_id => 1} = ammo_groups_count
shot_group_fixture(%{"count" => 1}, current_user, first_ammo_group)
shot_group_fixture(%{count: 1}, current_user, first_ammo_group)
ammo_groups_count =
[container, another_container]
@ -619,7 +617,7 @@ defmodule Cannery.AmmoTest do
assert %{^container_id => 26} = ammo_groups_count
assert %{^another_container_id => 1} = ammo_groups_count
shot_group_fixture(%{"count" => 4}, current_user, first_ammo_group)
shot_group_fixture(%{count: 4}, current_user, first_ammo_group)
ammo_groups_count =
[container, another_container]
@ -632,16 +630,15 @@ defmodule Cannery.AmmoTest do
test "get_round_count_for_container!/2 gets accurate total round count for container",
%{ammo_type: ammo_type, current_user: current_user, container: container} do
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 5}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 5}, ammo_type, container, current_user)
assert 5 = Ammo.get_round_count_for_container!(container, current_user)
{25, _ammo_groups} =
ammo_group_fixture(%{"count" => 5}, 25, ammo_type, container, current_user)
{25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user)
assert 130 = Ammo.get_round_count_for_container!(container, current_user)
shot_group_fixture(%{"count" => 5}, current_user, first_ammo_group)
shot_group_fixture(%{count: 5}, current_user, first_ammo_group)
assert 125 = Ammo.get_round_count_for_container!(container, current_user)
end
@ -654,10 +651,10 @@ defmodule Cannery.AmmoTest do
%{id: another_container_id} = another_container = container_fixture(current_user)
{1, [first_ammo_group]} =
ammo_group_fixture(%{"count" => 5}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 5}, ammo_type, container, current_user)
{1, [_first_ammo_group]} =
ammo_group_fixture(%{"count" => 5}, ammo_type, another_container, current_user)
ammo_group_fixture(%{count: 5}, ammo_type, another_container, current_user)
round_counts =
[container, another_container] |> Ammo.get_round_count_for_containers(current_user)
@ -665,8 +662,7 @@ defmodule Cannery.AmmoTest do
assert %{^container_id => 5} = round_counts
assert %{^another_container_id => 5} = round_counts
{25, _ammo_groups} =
ammo_group_fixture(%{"count" => 5}, 25, ammo_type, container, current_user)
{25, _ammo_groups} = ammo_group_fixture(%{count: 5}, 25, ammo_type, container, current_user)
round_counts =
[container, another_container] |> Ammo.get_round_count_for_containers(current_user)
@ -674,7 +670,7 @@ defmodule Cannery.AmmoTest do
assert %{^container_id => 130} = round_counts
assert %{^another_container_id => 5} = round_counts
shot_group_fixture(%{"count" => 5}, current_user, first_ammo_group)
shot_group_fixture(%{count: 5}, current_user, first_ammo_group)
round_counts =
[container, another_container] |> Ammo.get_round_count_for_containers(current_user)
@ -686,20 +682,20 @@ defmodule Cannery.AmmoTest do
describe "ammo_groups" do
@valid_attrs %{
"count" => 42,
"notes" => "some notes",
"price_paid" => 120.5,
"purchased_on" => ~D[2022-11-19]
count: 42,
notes: "some notes",
price_paid: 120.5,
purchased_on: ~D[2022-11-19]
}
@update_attrs %{
"count" => 43,
"notes" => "some updated notes",
"price_paid" => 456.7
count: 43,
notes: "some updated notes",
price_paid: 456.7
}
@invalid_attrs %{
"count" => nil,
"notes" => nil,
"price_paid" => nil
count: nil,
notes: nil,
price_paid: nil
}
setup do
@ -708,8 +704,7 @@ defmodule Cannery.AmmoTest do
container = container_fixture(current_user)
{1, [ammo_group]} =
%{"count" => 50, "price_paid" => 36.1}
|> ammo_group_fixture(ammo_type, container, current_user)
ammo_group_fixture(%{count: 50, price_paid: 36.1}, ammo_type, container, current_user)
another_user = user_fixture()
another_ammo_type = ammo_type_fixture(another_user)
@ -744,9 +739,9 @@ defmodule Cannery.AmmoTest do
other_container = container_fixture(other_user)
{1, [another_ammo_group]} =
ammo_group_fixture(%{"count" => 30}, other_ammo_type, other_container, other_user)
ammo_group_fixture(%{count: 30}, other_ammo_type, other_container, other_user)
shot_group_fixture(%{"count" => 30}, other_user, another_ammo_group)
shot_group_fixture(%{count: 30}, other_user, another_ammo_group)
assert Ammo.get_ammo_groups_count!(other_user) == 0
assert Ammo.get_ammo_groups_count!(other_user, true) == 1
end
@ -755,11 +750,11 @@ defmodule Cannery.AmmoTest do
current_user = user_fixture()
container = container_fixture(current_user)
rifle_ammo_type = ammo_type_fixture(%{"type" => "rifle"}, current_user)
rifle_ammo_type = ammo_type_fixture(%{type: "rifle"}, current_user)
{1, [rifle_ammo_group]} = ammo_group_fixture(rifle_ammo_type, container, current_user)
shotgun_ammo_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user)
shotgun_ammo_type = ammo_type_fixture(%{type: "shotgun"}, current_user)
{1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_ammo_type, container, current_user)
pistol_ammo_type = ammo_type_fixture(%{"type" => "pistol"}, current_user)
pistol_ammo_type = ammo_type_fixture(%{type: "pistol"}, current_user)
{1, [pistol_ammo_group]} = ammo_group_fixture(pistol_ammo_type, container, current_user)
assert [^rifle_ammo_group] = Ammo.list_ammo_groups(nil, :rifle, current_user, false)
@ -786,9 +781,9 @@ defmodule Cannery.AmmoTest do
current_user: current_user
} do
{1, [%{id: another_ammo_group_id} = another_ammo_group]} =
ammo_group_fixture(%{"count" => 30}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 30}, ammo_type, container, current_user)
shot_group_fixture(%{"count" => 30}, current_user, another_ammo_group)
shot_group_fixture(%{count: 30}, current_user, another_ammo_group)
another_ammo_group = Ammo.get_ammo_group!(another_ammo_group_id, current_user)
assert Ammo.list_ammo_groups(nil, :all, current_user, false) == [ammo_group]
@ -806,20 +801,20 @@ defmodule Cannery.AmmoTest do
current_user: current_user
} do
{1, [another_ammo_group]} =
%{"count" => 49, "notes" => "cool ammo group"}
%{count: 49, notes: "cool ammo group"}
|> ammo_group_fixture(ammo_type, container, current_user)
another_ammo_type = ammo_type_fixture(%{"name" => "amazing ammo"}, current_user)
another_container = container_fixture(%{"name" => "fantastic container"}, current_user)
another_ammo_type = ammo_type_fixture(%{name: "amazing ammo"}, current_user)
another_container = container_fixture(%{name: "fantastic container"}, current_user)
tag = tag_fixture(%{"name" => "stupendous tag"}, current_user)
tag = tag_fixture(%{name: "stupendous tag"}, current_user)
Containers.add_tag!(another_container, tag, current_user)
{1, [amazing_ammo_group]} =
ammo_group_fixture(%{"count" => 48}, another_ammo_type, container, current_user)
ammo_group_fixture(%{count: 48}, another_ammo_type, container, current_user)
{1, [fantastic_ammo_group]} =
ammo_group_fixture(%{"count" => 47}, ammo_type, another_container, current_user)
ammo_group_fixture(%{count: 47}, ammo_type, another_container, current_user)
ammo_groups = Ammo.list_ammo_groups(nil, :all, current_user, false)
assert Enum.count(ammo_groups) == 4
@ -863,11 +858,11 @@ defmodule Cannery.AmmoTest do
current_user = user_fixture()
container = container_fixture(current_user)
rifle_ammo_type = ammo_type_fixture(%{"type" => "rifle"}, current_user)
rifle_ammo_type = ammo_type_fixture(%{type: "rifle"}, current_user)
{1, [rifle_ammo_group]} = ammo_group_fixture(rifle_ammo_type, container, current_user)
shotgun_ammo_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user)
shotgun_ammo_type = ammo_type_fixture(%{type: "shotgun"}, current_user)
{1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_ammo_type, container, current_user)
pistol_ammo_type = ammo_type_fixture(%{"type" => "pistol"}, current_user)
pistol_ammo_type = ammo_type_fixture(%{type: "pistol"}, current_user)
{1, [pistol_ammo_group]} = ammo_group_fixture(pistol_ammo_type, container, current_user)
another_container = container_fixture(current_user)
@ -948,7 +943,7 @@ defmodule Cannery.AmmoTest do
current_user: current_user
} do
{1, [another_ammo_group]} =
ammo_group_fixture(%{"staged" => true}, ammo_type, container, current_user)
ammo_group_fixture(%{staged: true}, ammo_type, container, current_user)
assert Ammo.list_staged_ammo_groups(current_user) == [another_ammo_group]
end
@ -979,7 +974,7 @@ defmodule Cannery.AmmoTest do
} do
assert {:ok, {1, [%AmmoGroup{} = ammo_group]}} =
@valid_attrs
|> Map.merge(%{"ammo_type_id" => ammo_type.id, "container_id" => container.id})
|> Map.merge(%{ammo_type_id: ammo_type.id, container_id: container.id})
|> Ammo.create_ammo_groups(1, current_user)
assert ammo_group.count == 42
@ -994,7 +989,7 @@ defmodule Cannery.AmmoTest do
} do
assert {:ok, {3, ammo_groups}} =
@valid_attrs
|> Map.merge(%{"ammo_type_id" => ammo_type.id, "container_id" => container.id})
|> Map.merge(%{ammo_type_id: ammo_type.id, container_id: container.id})
|> Ammo.create_ammo_groups(3, current_user)
assert [%AmmoGroup{}, %AmmoGroup{}, %AmmoGroup{}] = ammo_groups
@ -1011,7 +1006,7 @@ defmodule Cannery.AmmoTest do
%{ammo_type: ammo_type, container: container, current_user: current_user} do
assert {:error, %Changeset{}} =
@invalid_attrs
|> Map.merge(%{"ammo_type_id" => ammo_type.id, "container_id" => container.id})
|> Map.merge(%{ammo_type_id: ammo_type.id, container_id: container.id})
|> Ammo.create_ammo_groups(1, current_user)
end
@ -1043,15 +1038,15 @@ defmodule Cannery.AmmoTest do
%{ammo_group: %{id: ammo_group_id} = ammo_group, current_user: current_user} do
assert 100 = ammo_group |> Ammo.get_percentage_remaining(current_user)
shot_group_fixture(%{"count" => 14}, current_user, ammo_group)
shot_group_fixture(%{count: 14}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
assert 72 = ammo_group |> Ammo.get_percentage_remaining(current_user)
shot_group_fixture(%{"count" => 11}, current_user, ammo_group)
shot_group_fixture(%{count: 11}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
assert 50 = ammo_group |> Ammo.get_percentage_remaining(current_user)
shot_group_fixture(%{"count" => 25}, current_user, ammo_group)
shot_group_fixture(%{count: 25}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
assert 0 = ammo_group |> Ammo.get_percentage_remaining(current_user)
end
@ -1066,7 +1061,7 @@ defmodule Cannery.AmmoTest do
[ammo_group] |> Ammo.get_percentages_remaining(current_user)
{1, [%{id: another_ammo_group_id} = another_ammo_group]} =
%{"count" => 50, "price_paid" => 36.1}
%{count: 50, price_paid: 36.1}
|> ammo_group_fixture(ammo_type, container, current_user)
percentages =
@ -1075,7 +1070,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_group_id => 100} = percentages
assert %{^another_ammo_group_id => 100} = percentages
shot_group_fixture(%{"count" => 14}, current_user, ammo_group)
shot_group_fixture(%{count: 14}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
percentages =
@ -1084,7 +1079,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_group_id => 72} = percentages
assert %{^another_ammo_group_id => 100} = percentages
shot_group_fixture(%{"count" => 11}, current_user, ammo_group)
shot_group_fixture(%{count: 11}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
percentages =
@ -1093,7 +1088,7 @@ defmodule Cannery.AmmoTest do
assert %{^ammo_group_id => 50} = percentages
assert %{^another_ammo_group_id => 100} = percentages
shot_group_fixture(%{"count" => 25}, current_user, ammo_group)
shot_group_fixture(%{count: 25}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
percentages =
@ -1105,12 +1100,12 @@ defmodule Cannery.AmmoTest do
test "get_cpr/2 gets accurate cpr",
%{ammo_type: ammo_type, container: container, current_user: current_user} do
{1, [ammo_group]} = ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{count: 1}, ammo_type, container, current_user)
assert ammo_group |> Ammo.get_cpr(current_user) |> is_nil()
{1, [ammo_group]} =
ammo_group_fixture(
%{"count" => 1, "price_paid" => 1.0},
%{count: 1, price_paid: 1.0},
ammo_type,
container,
current_user
@ -1120,7 +1115,7 @@ defmodule Cannery.AmmoTest do
{1, [ammo_group]} =
ammo_group_fixture(
%{"count" => 2, "price_paid" => 3.0},
%{count: 2, price_paid: 3.0},
ammo_type,
container,
current_user
@ -1130,7 +1125,7 @@ defmodule Cannery.AmmoTest do
{1, [ammo_group]} =
ammo_group_fixture(
%{"count" => 50, "price_paid" => 36.1},
%{count: 50, price_paid: 36.1},
ammo_type,
container,
current_user
@ -1139,19 +1134,19 @@ defmodule Cannery.AmmoTest do
assert 0.722 = ammo_group |> Ammo.get_cpr(current_user)
# with shot group, maintains total
shot_group_fixture(%{"count" => 14}, current_user, ammo_group)
shot_group_fixture(%{count: 14}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group.id, current_user)
assert 0.722 = ammo_group |> Ammo.get_cpr(current_user)
end
test "get_cprs/2 gets accurate cprs",
%{ammo_type: ammo_type, container: container, current_user: current_user} do
{1, [ammo_group]} = ammo_group_fixture(%{"count" => 1}, ammo_type, container, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{count: 1}, ammo_type, container, current_user)
assert %{} == [ammo_group] |> Ammo.get_cprs(current_user)
{1, [%{id: ammo_group_id} = ammo_group]} =
ammo_group_fixture(
%{"count" => 1, "price_paid" => 1.0},
%{count: 1, price_paid: 1.0},
ammo_type,
container,
current_user
@ -1161,7 +1156,7 @@ defmodule Cannery.AmmoTest do
{1, [%{id: another_ammo_group_id} = another_ammo_group]} =
ammo_group_fixture(
%{"count" => 2, "price_paid" => 3.0},
%{count: 2, price_paid: 3.0},
ammo_type,
container,
current_user
@ -1173,7 +1168,7 @@ defmodule Cannery.AmmoTest do
{1, [%{id: yet_another_ammo_group_id} = yet_another_ammo_group]} =
ammo_group_fixture(
%{"count" => 50, "price_paid" => 36.1},
%{count: 50, price_paid: 36.1},
ammo_type,
container,
current_user
@ -1187,7 +1182,7 @@ defmodule Cannery.AmmoTest do
assert %{^yet_another_ammo_group_id => 0.722} = cprs
# with shot group, maintains total
shot_group_fixture(%{"count" => 14}, current_user, yet_another_ammo_group)
shot_group_fixture(%{count: 14}, current_user, yet_another_ammo_group)
yet_another_ammo_group = Ammo.get_ammo_group!(yet_another_ammo_group.id, current_user)
cprs =
@ -1202,15 +1197,15 @@ defmodule Cannery.AmmoTest do
%{ammo_group: %{id: ammo_group_id} = ammo_group, current_user: current_user} do
assert 50 = ammo_group |> Ammo.get_original_count(current_user)
shot_group_fixture(%{"count" => 14}, current_user, ammo_group)
shot_group_fixture(%{count: 14}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
assert 50 = ammo_group |> Ammo.get_original_count(current_user)
shot_group_fixture(%{"count" => 11}, current_user, ammo_group)
shot_group_fixture(%{count: 11}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
assert 50 = ammo_group |> Ammo.get_original_count(current_user)
shot_group_fixture(%{"count" => 25}, current_user, ammo_group)
shot_group_fixture(%{count: 25}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
assert 50 = ammo_group |> Ammo.get_original_count(current_user)
end
@ -1222,25 +1217,25 @@ defmodule Cannery.AmmoTest do
current_user: current_user
} do
{1, [%{id: another_ammo_group_id} = another_ammo_group]} =
ammo_group_fixture(%{"count" => 25}, ammo_type, container, current_user)
ammo_group_fixture(%{count: 25}, ammo_type, container, current_user)
original_counts = [ammo_group, another_ammo_group] |> Ammo.get_original_counts(current_user)
assert %{^ammo_group_id => 50} = original_counts
assert %{^another_ammo_group_id => 25} = original_counts
shot_group_fixture(%{"count" => 14}, current_user, ammo_group)
shot_group_fixture(%{count: 14}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
original_counts = [ammo_group, another_ammo_group] |> Ammo.get_original_counts(current_user)
assert %{^ammo_group_id => 50} = original_counts
assert %{^another_ammo_group_id => 25} = original_counts
shot_group_fixture(%{"count" => 11}, current_user, ammo_group)
shot_group_fixture(%{count: 11}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
original_counts = [ammo_group, another_ammo_group] |> Ammo.get_original_counts(current_user)
assert %{^ammo_group_id => 50} = original_counts
assert %{^another_ammo_group_id => 25} = original_counts
shot_group_fixture(%{"count" => 25}, current_user, ammo_group)
shot_group_fixture(%{count: 25}, current_user, ammo_group)
ammo_group = Ammo.get_ammo_group!(ammo_group_id, current_user)
original_counts = [ammo_group, another_ammo_group] |> Ammo.get_original_counts(current_user)
assert %{^ammo_group_id => 50} = original_counts

72
test/cannery/containers_test.exs
View File

@ -10,37 +10,37 @@ defmodule Cannery.ContainersTest do
@moduletag :containers_test
@valid_attrs %{
"desc" => "some desc",
"location" => "some location",
"name" => "some name",
"type" => "some type"
desc: "some desc",
location: "some location",
name: "some name",
type: "some type"
}
@update_attrs %{
"desc" => "some updated desc",
"location" => "some updated location",
"name" => "some updated name",
"type" => "some updated type"
desc: "some updated desc",
location: "some updated location",
name: "some updated name",
type: "some updated type"
}
@invalid_attrs %{
"desc" => nil,
"location" => nil,
"name" => nil,
"type" => nil
desc: nil,
location: nil,
name: nil,
type: nil
}
@valid_tag_attrs %{
"bg_color" => "#100000",
"name" => "some name",
"text_color" => "#000000"
bg_color: "#100000",
name: "some name",
text_color: "#000000"
}
@update_tag_attrs %{
"bg_color" => "#100001",
"name" => "some updated name",
"text_color" => "#000001"
bg_color: "#100001",
name: "some updated name",
text_color: "#000001"
}
@invalid_tag_attrs %{
"bg_color" => nil,
"name" => nil,
"text_color" => nil
bg_color: nil,
name: nil,
text_color: nil
}
describe "containers" do
@ -57,25 +57,24 @@ defmodule Cannery.ContainersTest do
test "list_containers/2 returns relevant containers for a user",
%{current_user: current_user} do
container_a = container_fixture(%{"name" => "my cool container"}, current_user)
container_b = container_fixture(%{"desc" => "a fascinating description"}, current_user)
container_a = container_fixture(%{name: "my cool container"}, current_user)
container_b = container_fixture(%{desc: "a fascinating description"}, current_user)
%{id: container_c_id} =
container_c = container_fixture(%{"location" => "a secret place"}, current_user)
container_c = container_fixture(%{location: "a secret place"}, current_user)
tag = tag_fixture(%{"name" => "stupendous tag"}, current_user)
tag = tag_fixture(%{name: "stupendous tag"}, current_user)
Containers.add_tag!(container_c, tag, current_user)
container_c = container_c_id |> Containers.get_container!(current_user)
%{id: container_d_id} =
container_d = container_fixture(%{"type" => "musty old box"}, current_user)
container_d = container_fixture(%{type: "musty old box"}, current_user)
tag = tag_fixture(%{"name" => "amazing tag"}, current_user)
tag = tag_fixture(%{name: "amazing tag"}, current_user)
Containers.add_tag!(container_d, tag, current_user)
container_d = container_d_id |> Containers.get_container!(current_user)
_shouldnt_return =
container_fixture(%{"name" => "another person's container"}, user_fixture())
_shouldnt_return = container_fixture(%{name: "another person's container"}, user_fixture())
# attributes
assert Containers.list_containers("cool", current_user) == [container_a]
@ -109,7 +108,7 @@ defmodule Cannery.ContainersTest do
test "create_container/2 with valid data creates a container", %{current_user: current_user} do
assert {:ok, %Container{} = container} =
@valid_attrs |> Containers.create_container(current_user)
Containers.create_container(@valid_attrs, current_user)
assert container.desc == "some desc"
assert container.location == "some location"
@ -120,7 +119,7 @@ defmodule Cannery.ContainersTest do
test "create_container/2 with invalid data returns error changeset",
%{current_user: current_user} do
assert {:error, %Changeset{}} = @invalid_attrs |> Containers.create_container(current_user)
assert {:error, %Changeset{}} = Containers.create_container(@invalid_attrs, current_user)
end
test "update_container/3 with valid data updates the container",
@ -163,15 +162,10 @@ defmodule Cannery.ContainersTest do
end
test "list_tags/2 returns relevant tags for a user", %{current_user: current_user} do
tag_a = tag_fixture(%{"name" => "bullets"}, current_user)
tag_b = tag_fixture(%{"name" => "hollows"}, current_user)
tag_a = tag_fixture(%{name: "bullets"}, current_user)
tag_b = tag_fixture(%{name: "hollows"}, current_user)
_shouldnt_return =
%{
"name" => "bullet",
"desc" => "pews brass shell"
}
|> tag_fixture(user_fixture())
tag_fixture(%{name: "bullet", desc: "pews brass shell"}, user_fixture())
# name
assert Containers.list_tags("bullet", current_user) == [tag_a]

3
test/cannery_web/controllers/user_auth_test.exs
View File

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

44
test/cannery_web/controllers/user_confirmation_controller_test.exs
View File

@ -4,7 +4,6 @@ defmodule CanneryWeb.UserConfirmationControllerTest do
"""
use CanneryWeb.ConnCase, async: true
import CanneryWeb.Gettext
alias Cannery.{Accounts, Repo}
@moduletag :user_confirmation_controller_test
@ -17,7 +16,7 @@ defmodule CanneryWeb.UserConfirmationControllerTest do
test "renders the confirmation page", %{conn: conn} do
conn = get(conn, Routes.user_confirmation_path(conn, :new))
response = html_response(conn, 200)
assert response =~ dgettext("actions", "Resend confirmation instructions")
assert response =~ "Resend confirmation instructions"
end
end
@ -25,18 +24,12 @@ defmodule CanneryWeb.UserConfirmationControllerTest do
@tag :capture_log
test "sends a new confirmation token", %{conn: conn, user: user} do
conn =
post(conn, Routes.user_confirmation_path(conn, :create), %{
"user" => %{"email" => user.email}
})
post(conn, Routes.user_confirmation_path(conn, :create), %{user: %{email: user.email}})
assert redirected_to(conn) == "/"
assert get_flash(conn, :info) =~
dgettext(
"prompts",
"If your email is in our system and it has not been confirmed yet, " <>
"you will receive an email with instructions shortly."
)
"If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
assert Repo.get_by!(Accounts.UserToken, user_id: user.id).context == "confirm"
end
@ -45,34 +38,24 @@ defmodule CanneryWeb.UserConfirmationControllerTest do
Repo.update!(Accounts.User.confirm_changeset(user))
conn =
post(conn, Routes.user_confirmation_path(conn, :create), %{
"user" => %{"email" => user.email}
})
post(conn, Routes.user_confirmation_path(conn, :create), %{user: %{email: user.email}})
assert redirected_to(conn) == "/"
assert get_flash(conn, :info) =~
dgettext(
"prompts",
"If your email is in our system and it has not been confirmed yet, " <>
"you will receive an email with instructions shortly."
)
"If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
end
test "does not send confirmation token if email is invalid", %{conn: conn} do
conn =
post(conn, Routes.user_confirmation_path(conn, :create), %{
"user" => %{"email" => "unknown@example.com"}
user: %{email: "unknown@example.com"}
})
assert redirected_to(conn) == "/"
assert get_flash(conn, :info) =~
dgettext(
"prompts",
"If your email is in our system and it has not been confirmed yet, " <>
"you will receive an email with instructions shortly."
)
"If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
assert Repo.all(Accounts.UserToken) == []
end
@ -87,10 +70,7 @@ defmodule CanneryWeb.UserConfirmationControllerTest do
conn = get(conn, Routes.user_confirmation_path(conn, :confirm, token))
assert redirected_to(conn) == "/"
assert get_flash(conn, :info) =~
dgettext("prompts", "%{email} confirmed successfully", email: user.email)
assert get_flash(conn, :info) =~ "#{user.email} confirmed successfully"
assert Accounts.get_user!(user.id).confirmed_at
refute get_session(conn, :user_token)
assert Repo.all(Accounts.UserToken) == []
@ -99,8 +79,7 @@ defmodule CanneryWeb.UserConfirmationControllerTest do
conn = get(conn, Routes.user_confirmation_path(conn, :confirm, token))
assert redirected_to(conn) == "/"
assert get_flash(conn, :error) =~
dgettext("errors", "User confirmation link is invalid or it has expired")
assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired"
# When logged in
conn =
@ -115,10 +94,7 @@ defmodule CanneryWeb.UserConfirmationControllerTest do
test "does not confirm email with invalid token", %{conn: conn, user: user} do
conn = get(conn, Routes.user_confirmation_path(conn, :confirm, "oops"))
assert redirected_to(conn) == "/"
assert get_flash(conn, :error) =~
dgettext("errors", "User confirmation link is invalid or it has expired")
assert get_flash(conn, :error) =~ "User confirmation link is invalid or it has expired"
refute Accounts.get_user!(user.id).confirmed_at
end
end

13
test/cannery_web/controllers/user_registration_controller_test.exs
View File

@ -4,7 +4,6 @@ defmodule CanneryWeb.UserRegistrationControllerTest do
"""
use CanneryWeb.ConnCase, async: true
import CanneryWeb.Gettext
@moduletag :user_registration_controller_test
@ -12,8 +11,8 @@ defmodule CanneryWeb.UserRegistrationControllerTest do
test "renders registration page", %{conn: conn} do
conn = get(conn, Routes.user_registration_path(conn, :new))
response = html_response(conn, 200)
assert response =~ dgettext("actions", "Register")
assert response =~ dgettext("actions", "Log in")
assert response =~ "Register"
assert response =~ "Log in"
end
test "redirects if already logged in", %{conn: conn} do
@ -29,11 +28,11 @@ defmodule CanneryWeb.UserRegistrationControllerTest do
conn =
post(conn, Routes.user_registration_path(conn, :create), %{
"user" => valid_user_attributes(email: email)
user: valid_user_attributes(email: email)
})
assert get_session(conn, :phoenix_flash) == %{
"info" => dgettext("prompts", "Please check your email to verify your account")
"info" => "Please check your email to verify your account"
}
assert redirected_to(conn) =~ "/"
@ -48,11 +47,11 @@ defmodule CanneryWeb.UserRegistrationControllerTest do
test "render errors for invalid data", %{conn: conn} do
conn =
post(conn, Routes.user_registration_path(conn, :create), %{
"user" => %{"email" => "with spaces", "password" => "too short"}
user: %{email: "with spaces", password: "too short"}
})
response = html_response(conn, 200)
assert response =~ gettext("Register")
assert response =~ "Register"
assert response =~ "must have the @ sign and no spaces"
assert response =~ "should be at least 12 character"
end

45
test/cannery_web/controllers/user_reset_password_controller_test.exs
View File

@ -4,7 +4,6 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do
"""
use CanneryWeb.ConnCase, async: true
import CanneryWeb.Gettext
alias Cannery.{Accounts, Repo}
@moduletag :user_reset_password_controller_test
@ -17,7 +16,7 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do
test "renders the reset password page", %{conn: conn} do
conn = get(conn, Routes.user_reset_password_path(conn, :new))
response = html_response(conn, 200)
assert response =~ dgettext("actions", "Forgot your password?")
assert response =~ "Forgot your password?"
end
end
@ -25,17 +24,12 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do
@tag :capture_log
test "sends a new reset password token", %{conn: conn, user: user} do
conn =
post(conn, Routes.user_reset_password_path(conn, :create), %{
"user" => %{"email" => user.email}
})
post(conn, Routes.user_reset_password_path(conn, :create), %{user: %{email: user.email}})
assert redirected_to(conn) == "/"
assert get_flash(conn, :info) =~
dgettext(
"prompts",
"If your email is in our system, you will receive instructions to reset your password shortly."
)
assert Repo.get_by!(Accounts.UserToken, user_id: user.id).context == "reset_password"
end
@ -43,16 +37,13 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do
test "does not send reset password token if email is invalid", %{conn: conn} do
conn =
post(conn, Routes.user_reset_password_path(conn, :create), %{
"user" => %{"email" => "unknown@example.com"}
user: %{email: "unknown@example.com"}
})
assert redirected_to(conn) == "/"
assert get_flash(conn, :info) =~
dgettext(
"prompts",
"If your email is in our system, you will receive instructions to reset your password shortly."
)
assert Repo.all(Accounts.UserToken) == []
end
@ -70,15 +61,13 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do
test "renders reset password", %{conn: conn, token: token} do
conn = get(conn, Routes.user_reset_password_path(conn, :edit, token))
assert html_response(conn, 200) =~ dgettext("actions", "Reset password")
assert html_response(conn, 200) =~ "Reset password"
end
test "does not render reset password with invalid token", %{conn: conn} do
conn = get(conn, Routes.user_reset_password_path(conn, :edit, "oops"))
assert redirected_to(conn) == "/"
assert get_flash(conn, :error) =~
dgettext("errors", "Reset password link is invalid or it has expired")
assert get_flash(conn, :error) =~ "Reset password link is invalid or it has expired"
end
end
@ -95,39 +84,37 @@ defmodule CanneryWeb.UserResetPasswordControllerTest do
test "resets password once", %{conn: conn, user: user, token: token} do
conn =
put(conn, Routes.user_reset_password_path(conn, :update, token), %{
"user" => %{
"password" => "new valid password",
"password_confirmation" => "new valid password"
user: %{
password: "new valid password",
password_confirmation: "new valid password"
}
})
assert redirected_to(conn) == Routes.user_session_path(conn, :new)
refute get_session(conn, :user_token)
assert get_flash(conn, :info) =~ dgettext("prompts", "Password reset successfully")
assert get_flash(conn, :info) =~ "Password reset successfully"
assert Accounts.get_user_by_email_and_password(user.email, "new valid password")
end
test "does not reset password on invalid data", %{conn: conn, token: token} do
conn =
put(conn, Routes.user_reset_password_path(conn, :update, token), %{
"user" => %{
"password" => "too short",
"password_confirmation" => "does not match"
user: %{
password: "too short",
password_confirmation: "does not match"
}
})
response = html_response(conn, 200)
assert response =~ gettext("Reset password")
assert response =~ dgettext("errors", "should be at least 12 character(s)")
assert response =~ dgettext("errors", "does not match password")
assert response =~ "Reset password"
assert response =~ "should be at least 12 character(s)"
assert response =~ "does not match password"
end
test "does not reset password with invalid token", %{conn: conn} do
conn = put(conn, Routes.user_reset_password_path(conn, :update, "oops"))
assert redirected_to(conn) == "/"
assert get_flash(conn, :error) =~
dgettext("errors", "Reset password link is invalid or it has expired")
assert get_flash(conn, :error) =~ "Reset password link is invalid or it has expired"
end
end
end

31
test/cannery_web/controllers/user_session_controller_test.exs
View File

@ -4,7 +4,6 @@ defmodule CanneryWeb.UserSessionControllerTest do
"""
use CanneryWeb.ConnCase, async: true
import CanneryWeb.Gettext
@moduletag :user_session_controller_test
@ -16,7 +15,7 @@ defmodule CanneryWeb.UserSessionControllerTest do
test "renders log in page", %{conn: conn} do
conn = get(conn, Routes.user_session_path(conn, :new))
response = html_response(conn, 200)
assert response =~ dgettext("actions", "Log in")
assert response =~ "Log in"
end
test "redirects if already logged in", %{conn: conn, current_user: current_user} do
@ -29,7 +28,7 @@ defmodule CanneryWeb.UserSessionControllerTest do
test "logs the user in", %{conn: conn, current_user: current_user} do
conn =
post(conn, Routes.user_session_path(conn, :create), %{
"user" => %{"email" => current_user.email, "password" => valid_user_password()}
user: %{email: current_user.email, password: valid_user_password()}
})
assert get_session(conn, :user_token)
@ -39,16 +38,16 @@ defmodule CanneryWeb.UserSessionControllerTest do
conn = get(conn, "/")
response = html_response(conn, 200)
assert response =~ current_user.email
assert response =~ dgettext("prompts", "Are you sure you want to log out?")
assert response =~ "Are you sure you want to log out?"
end
test "logs the user in with remember me", %{conn: conn, current_user: current_user} do
conn =
post(conn, Routes.user_session_path(conn, :create), %{
"user" => %{
"email" => current_user.email,
"password" => valid_user_password(),
"remember_me" => "true"
user: %{
email: current_user.email,
password: valid_user_password(),
remember_me: "true"
}
})
@ -61,9 +60,9 @@ defmodule CanneryWeb.UserSessionControllerTest do
conn
|> init_test_session(user_return_to: "/foo/bar")
|> post(Routes.user_session_path(conn, :create), %{
"user" => %{
"email" => current_user.email,
"password" => valid_user_password()
user: %{
email: current_user.email,
password: valid_user_password()
}
})
@ -74,12 +73,12 @@ defmodule CanneryWeb.UserSessionControllerTest do
%{conn: conn, current_user: current_user} do
conn =
post(conn, Routes.user_session_path(conn, :create), %{
"user" => %{"email" => current_user.email, "password" => "bad"}
user: %{email: current_user.email, password: "bad"}
})
response = html_response(conn, 200)
assert response =~ dgettext("actions", "Log in")
assert response =~ dgettext("errors", "Invalid email or password")
assert response =~ "Log in"
assert response =~ "Invalid email or password"
end
end
@ -88,14 +87,14 @@ defmodule CanneryWeb.UserSessionControllerTest do
conn = conn |> log_in_user(current_user) |> delete(Routes.user_session_path(conn, :delete))
assert redirected_to(conn) == "/"
refute get_session(conn, :user_token)
assert get_flash(conn, :info) =~ gettext("Logged out successfully")
assert get_flash(conn, :info) =~ "Logged out successfully"
end
test "succeeds even if the user is not logged in", %{conn: conn} do
conn = delete(conn, Routes.user_session_path(conn, :delete))
assert redirected_to(conn) == "/"
refute get_session(conn, :user_token)
assert get_flash(conn, :info) =~ gettext("Logged out successfully")
assert get_flash(conn, :info) =~ "Logged out successfully"
end
end
end

69
test/cannery_web/controllers/user_settings_controller_test.exs
View File

@ -4,7 +4,6 @@ defmodule CanneryWeb.UserSettingsControllerTest do
"""
use CanneryWeb.ConnCase, async: true
import CanneryWeb.Gettext
alias Cannery.Accounts
@moduletag :user_settings_controller_test
@ -15,7 +14,7 @@ defmodule CanneryWeb.UserSettingsControllerTest do
test "renders settings page", %{conn: conn} do
conn = get(conn, Routes.user_settings_path(conn, :edit))
response = html_response(conn, 200)
assert response =~ gettext("Settings")
assert response =~ "Settings"
end
test "redirects if user is not logged in" do
@ -30,40 +29,36 @@ defmodule CanneryWeb.UserSettingsControllerTest do
%{conn: conn, current_user: current_user} do
new_password_conn =
put(conn, Routes.user_settings_path(conn, :update), %{
"action" => "update_password",
"current_password" => valid_user_password(),
"user" => %{
"password" => "new valid password",
"password_confirmation" => "new valid password"
action: "update_password",
current_password: valid_user_password(),
user: %{
password: "new valid password",
password_confirmation: "new valid password"
}
})
assert redirected_to(new_password_conn) == Routes.user_settings_path(conn, :edit)
assert get_session(new_password_conn, :user_token) != get_session(conn, :user_token)
assert get_flash(new_password_conn, :info) =~
dgettext("actions", "Password updated successfully")
assert get_flash(new_password_conn, :info) =~ "Password updated successfully"
assert Accounts.get_user_by_email_and_password(current_user.email, "new valid password")
end
test "does not update password on invalid data", %{conn: conn} do
old_password_conn =
put(conn, Routes.user_settings_path(conn, :update), %{
"action" => "update_password",
"current_password" => "invalid",
"user" => %{
"password" => "too short",
"password_confirmation" => "does not match"
action: "update_password",
current_password: "invalid",
user: %{
password: "too short",
password_confirmation: "does not match"
}
})
response = html_response(old_password_conn, 200)
assert response =~ gettext("Settings")
assert response =~ dgettext("errors", "should be at least 12 character(s)")
assert response =~ dgettext("errors", "does not match password")
assert response =~ dgettext("errors", "is not valid")
assert response =~ "Settings"
assert response =~ "should be at least 12 character(s)"
assert response =~ "does not match password"
assert response =~ "is not valid"
assert get_session(old_password_conn, :user_token) == get_session(conn, :user_token)
end
end
@ -73,18 +68,15 @@ defmodule CanneryWeb.UserSettingsControllerTest do
test "updates the user email", %{conn: conn, current_user: current_user} do
conn =
put(conn, Routes.user_settings_path(conn, :update), %{
"action" => "update_email",
"current_password" => valid_user_password(),
"user" => %{"email" => unique_user_email()}
action: "update_email",
current_password: valid_user_password(),
user: %{email: unique_user_email()}
})
assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
assert get_flash(conn, :info) =~
dgettext(
"prompts",
"A link to confirm your email change has been sent to the new address."
)
assert Accounts.get_user_by_email(current_user.email)
end
@ -92,15 +84,15 @@ defmodule CanneryWeb.UserSettingsControllerTest do
test "does not update email on invalid data", %{conn: conn} do
conn =
put(conn, Routes.user_settings_path(conn, :update), %{
"action" => "update_email",
"current_password" => "invalid",
"user" => %{"email" => "with spaces"}
action: "update_email",
current_password: "invalid",
user: %{email: "with spaces"}
})
response = html_response(conn, 200)
assert response =~ gettext("Settings")
assert response =~ dgettext("errors", "must have the @ sign and no spaces")
assert response =~ dgettext("errors", "is not valid")
assert response =~ "Settings"
assert response =~ "must have the @ sign and no spaces"
assert response =~ "is not valid"
end
end
@ -124,24 +116,19 @@ defmodule CanneryWeb.UserSettingsControllerTest do
%{conn: conn, current_user: current_user, token: token, email: email} do
conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token))
assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
assert get_flash(conn, :info) =~ dgettext("prompts", "Email changed successfully")
assert get_flash(conn, :info) =~ "Email changed successfully"
refute Accounts.get_user_by_email(current_user.email)
assert Accounts.get_user_by_email(email)
conn = get(conn, Routes.user_settings_path(conn, :confirm_email, token))
assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
assert get_flash(conn, :error) =~
dgettext("errors", "Email change link is invalid or it has expired")
assert get_flash(conn, :error) =~ "Email change link is invalid or it has expired"
end
test "does not update email with invalid token", %{conn: conn, current_user: current_user} do
conn = get(conn, Routes.user_settings_path(conn, :confirm_email, "oops"))
assert redirected_to(conn) == Routes.user_settings_path(conn, :edit)
assert get_flash(conn, :error) =~
dgettext("errors", "Email change link is invalid or it has expired")
assert get_flash(conn, :error) =~ "Email change link is invalid or it has expired"
assert Accounts.get_user_by_email(current_user.email)
end

276
test/cannery_web/live/ammo_group_live_test.exs
View File

@ -5,43 +5,40 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
use CanneryWeb.ConnCase
import Phoenix.LiveViewTest
import CanneryWeb.Gettext
alias Cannery.{Ammo, Repo}
@moduletag :ammo_group_live_test
@shot_group_create_attrs %{"ammo_left" => 5, "notes" => "some notes"}
@shot_group_update_attrs %{
"count" => 5,
"date" => ~N[2022-02-13 03:17:00],
"notes" => "some updated notes"
}
@create_attrs %{"count" => 42, "notes" => "some notes", "price_paid" => 120.5}
@update_attrs %{"count" => 43, "notes" => "some updated notes", "price_paid" => 456.7}
@create_attrs %{count: 42, notes: "some notes", price_paid: 120.5}
@update_attrs %{count: 43, notes: "some updated notes", price_paid: 456.7}
@invalid_attrs %{count: nil, notes: nil, price_paid: nil}
@ammo_group_create_limit 10_000
@shot_group_create_attrs %{ammo_left: 5, notes: "some notes"}
@shot_group_update_attrs %{
count: 5,
date: ~N[2022-02-13 03:17:00],
notes: "some updated notes"
}
@shot_group_invalid_attrs %{ammo_left: nil, count: nil, notes: nil}
@empty_attrs %{
"price_paid" => 50,
"count" => 20
price_paid: 50,
count: 20
}
@shot_group_attrs %{
"price_paid" => 50,
"count" => 20
price_paid: 50,
count: 20
}
# @invalid_attrs %{count: -1, notes: nil, price_paid: nil}
defp create_ammo_group(%{current_user: current_user}) do
ammo_type = ammo_type_fixture(current_user)
container = container_fixture(current_user)
{1, [ammo_group]} = ammo_group_fixture(@create_attrs, ammo_type, container, current_user)
%{ammo_type: ammo_type, ammo_group: ammo_group, container: container}
[ammo_type: ammo_type, ammo_group: ammo_group, container: container]
end
defp create_shot_group(%{current_user: current_user, ammo_group: ammo_group}) do
shot_group = shot_group_fixture(@shot_group_update_attrs, current_user, ammo_group)
ammo_group = ammo_group |> Repo.reload!()
%{ammo_group: ammo_group, shot_group: shot_group}
[ammo_group: ammo_group, shot_group: shot_group]
end
defp create_empty_ammo_group(%{
@ -52,7 +49,7 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
{1, [ammo_group]} = ammo_group_fixture(@empty_attrs, ammo_type, container, current_user)
shot_group = shot_group_fixture(@shot_group_attrs, current_user, ammo_group)
ammo_group = ammo_group |> Repo.reload!()
%{empty_ammo_group: ammo_group, shot_group: shot_group}
[empty_ammo_group: ammo_group, shot_group: shot_group]
end
describe "Index of ammo group" do
@ -60,19 +57,18 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
test "lists all ammo_groups", %{conn: conn, ammo_group: ammo_group} do
{:ok, _index_live, html} = live(conn, Routes.ammo_group_index_path(conn, :index))
ammo_group = ammo_group |> Repo.preload(:ammo_type)
assert html =~ gettext("Ammo")
assert html =~ "Ammo"
assert html =~ ammo_group.ammo_type.name
end
test "can sort by type",
%{conn: conn, container: container, current_user: current_user} do
rifle_type = ammo_type_fixture(%{"type" => "rifle"}, current_user)
rifle_type = ammo_type_fixture(%{type: "rifle"}, current_user)
{1, [rifle_ammo_group]} = ammo_group_fixture(rifle_type, container, current_user)
shotgun_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user)
shotgun_type = ammo_type_fixture(%{type: "shotgun"}, current_user)
{1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_type, container, current_user)
pistol_type = ammo_type_fixture(%{"type" => "pistol"}, current_user)
pistol_type = ammo_type_fixture(%{type: "pistol"}, current_user)
{1, [pistol_ammo_group]} = ammo_group_fixture(pistol_type, container, current_user)
{:ok, index_live, html} = live(conn, Routes.ammo_group_index_path(conn, :index))
@ -128,10 +124,9 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
assert html =~ ammo_group.ammo_type.name
assert index_live
|> form(~s/form[phx-change="search"]/,
search: %{search_term: ammo_group.ammo_type.name}
)
|> render_change() =~ ammo_group.ammo_type.name
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: ammo_group.ammo_type.name}) =~
ammo_group.ammo_type.name
assert_patch(
index_live,
@ -139,14 +134,15 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
)
refute index_live
|> form(~s/form[phx-change="search"]/, search: %{search_term: "something_else"})
|> render_change() =~ ammo_group.ammo_type.name
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: "something_else"}) =~
ammo_group.ammo_type.name
assert_patch(index_live, Routes.ammo_group_index_path(conn, :search, "something_else"))
assert index_live
|> form(~s/form[phx-change="search"]/, search: %{search_term: ""})
|> render_change() =~ ammo_group.ammo_type.name
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: ""}) =~ ammo_group.ammo_type.name
assert_patch(index_live, Routes.ammo_group_index_path(conn, :index))
end
@ -154,85 +150,65 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
test "saves a single new ammo_group", %{conn: conn} do
{:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "Add Ammo")) |> render_click() =~
dgettext("actions", "Add Ammo")
assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo"
assert_patch(index_live, Routes.ammo_group_index_path(conn, :new))
# assert index_live
# |> form("#ammo_group-form", ammo_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_group-form")
|> render_change(ammo_group: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#ammo_group-form", ammo_group: @create_attrs)
|> render_submit()
|> form("#ammo_group-form")
|> render_submit(ammo_group: @create_attrs)
|> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index))
assert html =~ dgettext("prompts", "Ammo added successfully")
assert html =~ "Ammo added successfully"
assert html =~ "\n42\n"
end
test "saves multiple new ammo_groups", %{conn: conn, current_user: current_user} do
multiplier = 25
{:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "Add Ammo")) |> render_click() =~
dgettext("actions", "Add Ammo")
assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo"
assert_patch(index_live, Routes.ammo_group_index_path(conn, :new))
# assert index_live
# |> form("#ammo_group-form", ammo_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_group-form")
|> render_change(ammo_group: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#ammo_group-form",
ammo_group: @create_attrs |> Map.put("multiplier", to_string(multiplier))
)
|> render_submit()
|> form("#ammo_group-form")
|> render_submit(ammo_group: @create_attrs |> Map.put(:multiplier, multiplier))
|> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index))
assert html =~ dgettext("prompts", "Ammo added successfully")
assert html =~ "Ammo added successfully"
assert Ammo.list_ammo_groups(nil, :all, current_user) |> Enum.count() == multiplier + 1
end
test "does not save invalid number of new ammo_groups", %{conn: conn} do
{:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "Add Ammo")) |> render_click() =~
dgettext("actions", "Add Ammo")
assert index_live |> element("a", "Add Ammo") |> render_click() =~ "Add Ammo"
assert_patch(index_live, Routes.ammo_group_index_path(conn, :new))
# assert index_live
# |> form("#ammo_group-form", ammo_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_group-form")
|> render_change(ammo_group: @invalid_attrs) =~ "can&#39;t be blank"
assert index_live
|> form("#ammo_group-form", ammo_group: @create_attrs |> Map.put("multiplier", "0"))
|> render_submit() =~
dgettext(
"errors",
"Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}",
multiplier: 0,
max: @ammo_group_create_limit
)
|> form("#ammo_group-form")
|> render_submit(ammo_group: @create_attrs |> Map.put(:multiplier, "0")) =~
"Invalid number of copies, must be between 1 and #{@ammo_group_create_limit}. Was 0"
assert index_live
|> form("#ammo_group-form",
ammo_group:
@create_attrs |> Map.put("multiplier", to_string(@ammo_group_create_limit + 1))
)
|> render_submit() =~
dgettext(
"errors",
"Invalid number of copies, must be between 1 and %{max}. Was %{multiplier}",
multiplier: @ammo_group_create_limit + 1,
max: @ammo_group_create_limit
)
|> form("#ammo_group-form")
|> render_submit(
ammo_group: @create_attrs |> Map.put(:multiplier, @ammo_group_create_limit + 1)
) =~
"Invalid number of copies, must be between 1 and #{@ammo_group_create_limit}. Was #{@ammo_group_create_limit + 1}"
end
test "updates ammo_group in listing", %{conn: conn, ammo_group: ammo_group} do
@ -240,22 +216,21 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
assert index_live
|> element(~s/a[aria-label="Edit ammo group of #{ammo_group.count} bullets"]/)
|> render_click() =~
gettext("Edit ammo")
|> render_click() =~ "Edit ammo"
assert_patch(index_live, Routes.ammo_group_index_path(conn, :edit, ammo_group))
# assert index_live
# |> form("#ammo_group-form", ammo_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_group-form")
|> render_change(ammo_group: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#ammo_group-form", ammo_group: @update_attrs)
|> render_submit()
|> form("#ammo_group-form")
|> render_submit(ammo_group: @update_attrs)
|> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index))
assert html =~ dgettext("prompts", "Ammo updated successfully")
assert html =~ "Ammo updated successfully"
assert html =~ "\n43\n"
end
@ -267,24 +242,38 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
|> element(~s/a[aria-label="Clone ammo group of #{ammo_group.count} bullets"]/)
|> render_click()
assert html =~ dgettext("actions", "Add Ammo")
assert html =~ gettext("$%{amount}", amount: display_currency(120.5))
assert html =~ "Add Ammo"
assert html =~ "$#{display_currency(120.5)}"
assert_patch(index_live, Routes.ammo_group_index_path(conn, :clone, ammo_group))
# assert index_live
# |> form("#ammo_group-form", ammo_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
{:ok, _view, html} =
{:ok, _index_live, html} =
index_live
|> form("#ammo_group-form")
|> render_submit()
|> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index))
assert html =~ dgettext("prompts", "Ammo added successfully")
assert html =~ "Ammo added successfully"
assert html =~ "\n42\n"
assert html =~ gettext("$%{amount}", amount: display_currency(120.5))
assert html =~ "$#{display_currency(120.5)}"
end
test "checks validity when cloning", %{conn: conn, ammo_group: ammo_group} do
{:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index))
html =
index_live
|> element(~s/a[aria-label="Clone ammo group of #{ammo_group.count} bullets"]/)
|> render_click()
assert html =~ "Add Ammo"
assert html =~ "$#{display_currency(120.5)}"
assert_patch(index_live, Routes.ammo_group_index_path(conn, :clone, ammo_group))
assert index_live
|> form("#ammo_group-form")
|> render_change(ammo_group: @invalid_attrs) =~ "can&#39;t be blank"
end
test "clones ammo_group in listing with updates", %{conn: conn, ammo_group: ammo_group} do
@ -295,24 +284,23 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
|> element(~s/a[aria-label="Clone ammo group of #{ammo_group.count} bullets"]/)
|> render_click()
assert html =~ dgettext("actions", "Add Ammo")
assert html =~ gettext("$%{amount}", amount: display_currency(120.5))
assert html =~ "Add Ammo"
assert html =~ "$#{display_currency(120.5)}"
assert_patch(index_live, Routes.ammo_group_index_path(conn, :clone, ammo_group))
# assert index_live
# |> form("#ammo_group-form", ammo_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_group-form")
|> render_change(ammo_group: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#ammo_group-form", ammo_group: Map.merge(@create_attrs, %{"count" => 43}))
|> render_submit()
|> form("#ammo_group-form")
|> render_submit(ammo_group: @create_attrs |> Map.put(:count, 43))
|> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index))
assert html =~ dgettext("prompts", "Ammo added successfully")
assert html =~ "Ammo added successfully"
assert html =~ "\n43\n"
assert html =~ gettext("$%{amount}", amount: display_currency(120.5))
assert html =~ "$#{display_currency(120.5)}"
end
test "deletes ammo_group in listing", %{conn: conn, ammo_group: ammo_group} do
@ -328,22 +316,20 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
test "saves new shot_group", %{conn: conn, ammo_group: ammo_group} do
{:ok, index_live, _html} = live(conn, Routes.ammo_group_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "Record shots")) |> render_click() =~
gettext("Record shots")
assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots"
assert_patch(index_live, Routes.ammo_group_index_path(conn, :add_shot_group, ammo_group))
# assert index_live
# |> form("#shot_group-form", shot_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "is invalid")
assert index_live
|> form("#shot-group-form")
|> render_change(shot_group: @shot_group_invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#shot-group-form", shot_group: @shot_group_create_attrs)
|> render_submit()
|> form("#shot-group-form")
|> render_submit(shot_group: @shot_group_create_attrs)
|> follow_redirect(conn, Routes.ammo_group_index_path(conn, :index))
assert html =~ dgettext("prompts", "Shots recorded successfully")
assert html =~ "Shots recorded successfully"
end
@spec display_currency(float()) :: String.t()
@ -360,21 +346,20 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
} do
{:ok, show_live, html} = live(conn, Routes.ammo_group_index_path(conn, :index))
assert html =~ dgettext("actions", "Show used")
refute html =~ gettext("$%{amount}", amount: display_currency(50.00))
assert html =~ "Show used"
refute html =~ "$#{display_currency(50.00)}"
percentage = ammo_group |> Ammo.get_percentage_remaining(current_user)
refute html =~ "\n#{gettext("%{percentage}%", percentage: percentage)}\n"
refute html =~ "\n#{"#{percentage}%"}\n"
html =
show_live
|> element(~s/input[type="checkbox"][aria-labelledby="toggle_show_used-label"}]/)
|> render_click()
assert html =~ gettext("$%{amount}", amount: display_currency(50.00))
assert html =~ "$#{display_currency(50.00)}"
percentage = ammo_group |> Ammo.get_percentage_remaining(current_user)
assert html =~ "\n#{gettext("%{percentage}%", percentage: percentage)}\n"
assert html =~ "\n#{"#{percentage}%"}\n"
end
end
@ -383,9 +368,8 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
test "displays ammo_group", %{conn: conn, ammo_group: ammo_group} do
{:ok, _show_live, html} = live(conn, Routes.ammo_group_show_path(conn, :show, ammo_group))
ammo_group = ammo_group |> Repo.preload(:ammo_type)
assert html =~ gettext("Show Ammo")
assert html =~ "Show Ammo"
assert html =~ ammo_group.ammo_type.name
end
@ -394,44 +378,41 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
assert show_live
|> element(~s/a[aria-label="Edit ammo group of #{ammo_group.count} bullets"]/)
|> render_click() =~
gettext("Edit Ammo")
|> render_click() =~ "Edit Ammo"
assert_patch(show_live, Routes.ammo_group_show_path(conn, :edit, ammo_group))
# assert show_live
# |> form("#ammo_group-form", ammo_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert show_live
|> form("#ammo_group-form")
|> render_change(ammo_group: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
show_live
|> form("#ammo_group-form", ammo_group: @update_attrs)
|> render_submit()
|> form("#ammo_group-form")
|> render_submit(ammo_group: @update_attrs)
|> follow_redirect(conn, Routes.ammo_group_show_path(conn, :show, ammo_group))
assert html =~ dgettext("prompts", "Ammo updated successfully")
assert html =~ "Ammo updated successfully"
assert html =~ "some updated notes"
end
test "saves new shot_group", %{conn: conn, ammo_group: ammo_group} do
{:ok, index_live, _html} = live(conn, Routes.ammo_group_show_path(conn, :show, ammo_group))
assert index_live |> element("a", dgettext("actions", "Record shots")) |> render_click() =~
gettext("Record shots")
assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots"
assert_patch(index_live, Routes.ammo_group_show_path(conn, :add_shot_group, ammo_group))
# assert index_live
# |> form("#shot_group-form", shot_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "is invalid")
assert index_live
|> form("#shot-group-form")
|> render_change(shot_group: @shot_group_invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#shot-group-form", shot_group: @shot_group_create_attrs)
|> render_submit()
|> form("#shot-group-form")
|> render_submit(shot_group: @shot_group_create_attrs)
|> follow_redirect(conn, Routes.ammo_group_show_path(conn, :show, ammo_group))
assert html =~ dgettext("prompts", "Shots recorded successfully")
assert html =~ "Shots recorded successfully"
end
end
@ -444,25 +425,24 @@ defmodule CanneryWeb.AmmoGroupLiveTest do
assert index_live
|> element(~s/a[aria-label="Edit shot group of #{shot_group.count} shots"]/)
|> render_click() =~
gettext("Edit Shot Records")
|> render_click() =~ "Edit Shot Records"
assert_patch(
index_live,
Routes.ammo_group_show_path(conn, :edit_shot_group, ammo_group, shot_group)
)
# assert index_live
# |> form("#shot_group-form", shot_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "is invalid")
assert index_live
|> form("#shot-group-form")
|> render_change(shot_group: @shot_group_invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#shot-group-form", shot_group: @shot_group_update_attrs)
|> render_submit()
|> form("#shot-group-form")
|> render_submit(shot_group: @shot_group_update_attrs)
|> follow_redirect(conn, Routes.ammo_group_show_path(conn, :show, ammo_group))
assert html =~ dgettext("actions", "Shot records updated successfully")
assert html =~ "Shot records updated successfully"
assert html =~ "some updated notes"
end

147
test/cannery_web/live/ammo_type_live_test.exs
View File

@ -5,54 +5,51 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
use CanneryWeb.ConnCase
import Phoenix.LiveViewTest
import CanneryWeb.Gettext
alias Cannery.{Ammo, Repo}
@moduletag :ammo_type_live_test
@create_attrs %{
"bullet_type" => "some bullet_type",
"case_material" => "some case_material",
"desc" => "some desc",
"manufacturer" => "some manufacturer",
"name" => "some name",
"grains" => 120
bullet_type: "some bullet_type",
case_material: "some case_material",
desc: "some desc",
manufacturer: "some manufacturer",
name: "some name",
grains: 120
}
@update_attrs %{
"bullet_type" => "some updated bullet_type",
"case_material" => "some updated case_material",
"desc" => "some updated desc",
"manufacturer" => "some updated manufacturer",
"name" => "some updated name",
"grains" => 456
bullet_type: "some updated bullet_type",
case_material: "some updated case_material",
desc: "some updated desc",
manufacturer: "some updated manufacturer",
name: "some updated name",
grains: 456
}
@invalid_attrs %{
bullet_type: nil,
case_material: nil,
desc: nil,
manufacturer: nil,
name: nil,
grains: nil
}
@ammo_group_attrs %{
"notes" => "some ammo group",
"count" => 20
notes: "some ammo group",
count: 20
}
@shot_group_attrs %{
"notes" => "some shot group",
"count" => 20
notes: "some shot group",
count: 20
}
# @invalid_attrs %{
# "bullet_type" => nil,
# "case_material" => nil,
# "desc" => nil,
# "manufacturer" => nil,
# "name" => nil,
# "grains" => nil
# }
defp create_ammo_type(%{current_user: current_user}) do
%{ammo_type: ammo_type_fixture(@create_attrs, current_user)}
[ammo_type: ammo_type_fixture(@create_attrs, current_user)]
end
defp create_ammo_group(%{ammo_type: ammo_type, current_user: current_user}) do
container = container_fixture(current_user)
{1, [ammo_group]} = ammo_group_fixture(@ammo_group_attrs, ammo_type, container, current_user)
%{ammo_group: ammo_group, container: container}
[ammo_group: ammo_group, container: container]
end
defp create_empty_ammo_group(%{ammo_type: ammo_type, current_user: current_user}) do
@ -60,8 +57,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
{1, [ammo_group]} = ammo_group_fixture(@ammo_group_attrs, ammo_type, container, current_user)
shot_group = shot_group_fixture(@shot_group_attrs, current_user, ammo_group)
ammo_group = ammo_group |> Repo.reload!()
%{ammo_group: ammo_group, container: container, shot_group: shot_group}
[ammo_group: ammo_group, container: container, shot_group: shot_group]
end
describe "Index" do
@ -69,15 +65,14 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
test "lists all ammo_types", %{conn: conn, ammo_type: ammo_type} do
{:ok, _index_live, html} = live(conn, Routes.ammo_type_index_path(conn, :index))
assert html =~ gettext("Catalog")
assert html =~ "Catalog"
assert html =~ ammo_type.bullet_type
end
test "can sort by type", %{conn: conn, current_user: current_user} do
rifle_type = ammo_type_fixture(%{"type" => "rifle"}, current_user)
shotgun_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user)
pistol_type = ammo_type_fixture(%{"type" => "pistol"}, current_user)
rifle_type = ammo_type_fixture(%{type: "rifle"}, current_user)
shotgun_type = ammo_type_fixture(%{type: "shotgun"}, current_user)
pistol_type = ammo_type_fixture(%{type: "pistol"}, current_user)
{:ok, index_live, html} = live(conn, Routes.ammo_type_index_path(conn, :index))
@ -152,14 +147,12 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
test "saves new ammo_type", %{conn: conn, current_user: current_user, ammo_type: ammo_type} do
{:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "New Ammo type")) |> render_click() =~
gettext("New Ammo type")
assert index_live |> element("a", "New Ammo type") |> render_click() =~ "New Ammo type"
assert_patch(index_live, Routes.ammo_type_index_path(conn, :new))
# assert index_live
# |> form("#ammo_type-form", ammo_type: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_type-form")
|> render_change(ammo_type: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
@ -168,7 +161,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
|> follow_redirect(conn, Routes.ammo_type_index_path(conn, :index))
ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user)
assert html =~ dgettext("prompts", "%{name} created successfully", name: ammo_type.name)
assert html =~ "#{ammo_type.name} created successfully"
assert html =~ "some bullet_type"
end
@ -177,13 +170,13 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
{:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index))
assert index_live |> element(~s/a[aria-label="Edit #{ammo_type.name}"]/) |> render_click() =~
gettext("Edit %{ammo_type_name}", ammo_type_name: ammo_type.name)
"Edit #{ammo_type.name}"
assert_patch(index_live, Routes.ammo_type_index_path(conn, :edit, ammo_type))
# assert index_live
# |> form("#ammo_type-form", ammo_type: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_type-form")
|> render_change(ammo_type: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
@ -192,7 +185,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
|> follow_redirect(conn, Routes.ammo_type_index_path(conn, :index))
ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user)
assert html =~ dgettext("prompts", "%{name} updated successfully", name: ammo_type.name)
assert html =~ "#{ammo_type.name} updated successfully"
assert html =~ "some updated bullet_type"
end
@ -201,14 +194,14 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
{:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index))
html = index_live |> element(~s/a[aria-label="Clone #{ammo_type.name}"]/) |> render_click()
assert html =~ gettext("New Ammo type")
assert html =~ "New Ammo type"
assert html =~ "some bullet_type"
assert_patch(index_live, Routes.ammo_type_index_path(conn, :clone, ammo_type))
# assert index_live
# |> form("#ammo_type-form", ammo_type: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_type-form")
|> render_change(ammo_type: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
@ -217,7 +210,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
|> follow_redirect(conn, Routes.ammo_type_index_path(conn, :index))
ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user)
assert html =~ dgettext("prompts", "%{name} created successfully", name: ammo_type.name)
assert html =~ "#{ammo_type.name} created successfully"
assert html =~ "some bullet_type"
end
@ -226,31 +219,30 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
{:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index))
html = index_live |> element(~s/a[aria-label="Clone #{ammo_type.name}"]/) |> render_click()
assert html =~ gettext("New Ammo type")
assert html =~ "New Ammo type"
assert html =~ "some bullet_type"
assert_patch(index_live, Routes.ammo_type_index_path(conn, :clone, ammo_type))
# assert index_live
# |> form("#ammo_type-form", ammo_type: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#ammo_type-form")
|> render_change(ammo_type: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#ammo_type-form")
|> render_submit(
ammo_type: Map.merge(@create_attrs, %{"bullet_type" => "some updated bullet_type"})
ammo_type: Map.merge(@create_attrs, %{bullet_type: "some updated bullet_type"})
)
|> follow_redirect(conn, Routes.ammo_type_index_path(conn, :index))
ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user)
assert html =~ dgettext("prompts", "%{name} created successfully", name: ammo_type.name)
assert html =~ "#{ammo_type.name} created successfully"
assert html =~ "some updated bullet_type"
end
test "deletes ammo_type in listing", %{conn: conn, ammo_type: ammo_type} do
{:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index))
assert index_live |> element(~s/a[aria-label="Delete #{ammo_type.name}"]/) |> render_click()
refute has_element?(index_live, "#ammo_type-#{ammo_type.id}")
end
@ -263,27 +255,27 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
%{conn: conn, ammo_group: ammo_group, current_user: current_user} do
{:ok, index_live, html} = live(conn, Routes.ammo_type_index_path(conn, :index))
assert html =~ dgettext("actions", "Show used")
refute html =~ gettext("Used rounds")
refute html =~ gettext("Total ever rounds")
refute html =~ gettext("Used packs")
refute html =~ gettext("Total ever packs")
assert html =~ "Show used"
refute html =~ "Used rounds"
refute html =~ "Total ever rounds"
refute html =~ "Used packs"
refute html =~ "Total ever packs"
html =
index_live
|> element(~s/input[type="checkbox"][aria-labelledby="toggle_show_used-label"}]/)
|> render_click()
assert html =~ gettext("Used rounds")
assert html =~ gettext("Total ever rounds")
assert html =~ gettext("Used packs")
assert html =~ gettext("Total ever packs")
assert html =~ "Used rounds"
assert html =~ "Total ever rounds"
assert html =~ "Used packs"
assert html =~ "Total ever packs"
assert html =~ "\n20\n"
assert html =~ "\n0\n"
assert html =~ "\n1\n"
shot_group_fixture(%{"count" => 5}, current_user, ammo_group)
shot_group_fixture(%{count: 5}, current_user, ammo_group)
{:ok, index_live, _html} = live(conn, Routes.ammo_type_index_path(conn, :index))
@ -315,13 +307,13 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
{:ok, show_live, _html} = live(conn, Routes.ammo_type_show_path(conn, :show, ammo_type))
assert show_live |> element(~s/a[aria-label="Edit #{ammo_type.name}"]/) |> render_click() =~
gettext("Edit %{ammo_type_name}", ammo_type_name: name)
"Edit #{name}"
assert_patch(show_live, Routes.ammo_type_show_path(conn, :edit, ammo_type))
# assert show_live
# |> form("#ammo_type-form", ammo_type: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert show_live
|> form("#ammo_type-form")
|> render_change(ammo_type: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
show_live
@ -330,7 +322,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
|> follow_redirect(conn, Routes.ammo_type_show_path(conn, :show, ammo_type))
ammo_type = ammo_type.id |> Ammo.get_ammo_type!(current_user)
assert html =~ dgettext("prompts", "%{name} updated successfully", name: ammo_type.name)
assert html =~ "#{ammo_type.name} updated successfully"
assert html =~ "some updated bullet_type"
end
end
@ -370,8 +362,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
test "displays empty ammo groups on toggle",
%{conn: conn, ammo_type: ammo_type, container: %{name: container_name}} do
{:ok, show_live, html} = live(conn, Routes.ammo_type_show_path(conn, :show, ammo_type))
assert html =~ dgettext("actions", "Show used")
assert html =~ "Show used"
refute html =~ "\n20\n"
html =
@ -393,7 +384,7 @@ defmodule CanneryWeb.AmmoTypeLiveTest do
|> element(~s/input[type="checkbox"][aria-labelledby="toggle_table-label"}]/)
|> render_click()
assert html =~ dgettext("actions", "Show used")
assert html =~ "Show used"
refute html =~ "\n20\n"
html =

138
test/cannery_web/live/container_live_test.exs
View File

@ -5,48 +5,46 @@ defmodule CanneryWeb.ContainerLiveTest do
use CanneryWeb.ConnCase
import Phoenix.LiveViewTest
import CanneryWeb.Gettext
alias Cannery.Containers
@moduletag :container_live_test
@create_attrs %{
"desc" => "some desc",
"location" => "some location",
"name" => "some name",
"type" => "some type"
desc: "some desc",
location: "some location",
name: "some name",
type: "some type"
}
@update_attrs %{
"desc" => "some updated desc",
"location" => "some updated location",
"name" => "some updated name",
"type" => "some updated type"
desc: "some updated desc",
location: "some updated location",
name: "some updated name",
type: "some updated type"
}
@invalid_attrs %{desc: nil, location: nil, name: nil, type: nil}
@ammo_type_attrs %{
"bullet_type" => "some bullet_type",
"case_material" => "some case_material",
"desc" => "some desc",
"manufacturer" => "some manufacturer",
"name" => "some name",
"grains" => 120
bullet_type: "some bullet_type",
case_material: "some case_material",
desc: "some desc",
manufacturer: "some manufacturer",
name: "some name",
grains: 120
}
@ammo_group_attrs %{
"notes" => "some ammo group",
"count" => 20
notes: "some ammo group",
count: 20
}
# @invalid_attrs %{desc: nil, location: nil, name: nil, type: nil}
defp create_container(%{current_user: current_user}) do
container = container_fixture(@create_attrs, current_user)
%{container: container}
[container: container]
end
defp create_ammo_group(%{container: container, current_user: current_user}) do
ammo_type = ammo_type_fixture(@ammo_type_attrs, current_user)
{1, [ammo_group]} = ammo_group_fixture(@ammo_group_attrs, ammo_type, container, current_user)
%{ammo_type: ammo_type, ammo_group: ammo_group}
[ammo_type: ammo_type, ammo_group: ammo_group]
end
describe "Index" do
@ -55,7 +53,7 @@ defmodule CanneryWeb.ContainerLiveTest do
test "lists all containers", %{conn: conn, container: container} do
{:ok, _index_live, html} = live(conn, Routes.container_index_path(conn, :index))
assert html =~ gettext("Containers")
assert html =~ "Containers"
assert html =~ container.location
end
@ -67,7 +65,7 @@ defmodule CanneryWeb.ContainerLiveTest do
|> element(~s/input[type="checkbox"][aria-labelledby="toggle_table-label"}]/)
|> render_click()
assert html =~ gettext("Containers")
assert html =~ "Containers"
assert html =~ container.location
end
@ -77,22 +75,20 @@ defmodule CanneryWeb.ContainerLiveTest do
assert html =~ container.location
assert index_live
|> form(~s/form[phx-change="search"]/,
search: %{search_term: container.location}
)
|> render_change() =~ container.location
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: container.location}) =~ container.location
assert_patch(index_live, Routes.container_index_path(conn, :search, container.location))
refute index_live
|> form(~s/form[phx-change="search"]/, search: %{search_term: "something_else"})
|> render_change() =~ container.location
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: "something_else"}) =~ container.location
assert_patch(index_live, Routes.container_index_path(conn, :search, "something_else"))
assert index_live
|> form(~s/form[phx-change="search"]/, search: %{search_term: ""})
|> render_change() =~ container.location
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: ""}) =~ container.location
assert_patch(index_live, Routes.container_index_path(conn, :index))
end
@ -100,22 +96,20 @@ defmodule CanneryWeb.ContainerLiveTest do
test "saves new container", %{conn: conn, container: container} do
{:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "New Container")) |> render_click() =~
gettext("New Container")
assert index_live |> element("a", "New Container") |> render_click() =~ "New Container"
assert_patch(index_live, Routes.container_index_path(conn, :new))
# assert index_live
# |> form("#container-form", container: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#container-form")
|> render_change(container: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#container-form", container: @create_attrs)
|> render_submit()
|> form("#container-form")
|> render_submit(container: @create_attrs)
|> follow_redirect(conn, Routes.container_index_path(conn, :index))
assert html =~ dgettext("prompts", "%{name} created successfully", name: container.name)
assert html =~ "#{container.name} created successfully"
assert html =~ "some location"
end
@ -127,22 +121,22 @@ defmodule CanneryWeb.ContainerLiveTest do
{:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index))
assert index_live |> element(~s/a[aria-label="Edit #{container.name}"]/) |> render_click() =~
gettext("Edit %{name}", name: container.name)
"Edit #{container.name}"
assert_patch(index_live, Routes.container_index_path(conn, :edit, container))
# assert index_live
# |> form("#container-form", container: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#container-form")
|> render_change(container: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#container-form", container: @update_attrs)
|> render_submit()
|> form("#container-form")
|> render_submit(container: @update_attrs)
|> follow_redirect(conn, Routes.container_index_path(conn, :index))
container = container.id |> Containers.get_container!(current_user)
assert html =~ dgettext("prompts", "%{name} updated successfully", name: container.name)
assert html =~ "#{container.name} updated successfully"
assert html =~ "some updated location"
end
@ -154,23 +148,23 @@ defmodule CanneryWeb.ContainerLiveTest do
{:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index))
html = index_live |> element(~s/a[aria-label="Clone #{container.name}"]/) |> render_click()
assert html =~ gettext("New Container")
assert html =~ "New Container"
assert html =~ "some location"
assert_patch(index_live, Routes.container_index_path(conn, :clone, container))
# assert index_live
# |> form("#container-form", container: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#container-form")
|> render_change(container: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#container-form", container: @create_attrs)
|> render_submit()
|> form("#container-form")
|> render_submit(container: @create_attrs)
|> follow_redirect(conn, Routes.container_index_path(conn, :index))
container = container.id |> Containers.get_container!(current_user)
assert html =~ dgettext("prompts", "%{name} created successfully", name: container.name)
assert html =~ "#{container.name} created successfully"
assert html =~ "some location"
end
@ -182,30 +176,29 @@ defmodule CanneryWeb.ContainerLiveTest do
{:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index))
assert index_live |> element(~s/a[aria-label="Clone #{container.name}"]/) |> render_click() =~
gettext("New Container")
"New Container"
assert_patch(index_live, Routes.container_index_path(conn, :clone, container))
# assert index_live
# |> form("#container-form", container: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#container-form")
|> render_change(container: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#container-form",
|> form("#container-form")
|> render_submit(
container: Map.merge(@create_attrs, %{location: "some updated location"})
)
|> render_submit()
|> follow_redirect(conn, Routes.container_index_path(conn, :index))
container = container.id |> Containers.get_container!(current_user)
assert html =~ dgettext("prompts", "%{name} created successfully", name: container.name)
assert html =~ "#{container.name} created successfully"
assert html =~ "some updated location"
end
test "deletes container in listing", %{conn: conn, container: container} do
{:ok, index_live, _html} = live(conn, Routes.container_index_path(conn, :index))
assert index_live |> element(~s/a[aria-label="Delete #{container.name}"]/) |> render_click()
refute has_element?(index_live, "#container-#{container.id}")
end
@ -219,7 +212,6 @@ defmodule CanneryWeb.ContainerLiveTest do
container: %{name: name, location: location} = container
} do
{:ok, _show_live, html} = live(conn, Routes.container_show_path(conn, :show, container))
assert html =~ name
assert html =~ location
end
@ -232,32 +224,32 @@ defmodule CanneryWeb.ContainerLiveTest do
{:ok, show_live, _html} = live(conn, Routes.container_show_path(conn, :show, container))
assert show_live |> element(~s/a[aria-label="Edit #{container.name}"]/) |> render_click() =~
gettext("Edit %{name}", name: container.name)
"Edit #{container.name}"
assert_patch(show_live, Routes.container_show_path(conn, :edit, container))
# assert show_live
# |> form("#container-form", container: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert show_live
|> form("#container-form")
|> render_change(container: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
show_live
|> form("#container-form", container: @update_attrs)
|> render_submit()
|> form("#container-form")
|> render_submit(container: @update_attrs)
|> follow_redirect(conn, Routes.container_show_path(conn, :show, container))
container = container.id |> Containers.get_container!(current_user)
assert html =~ dgettext("prompts", "%{name} updated successfully", name: container.name)
assert html =~ "#{container.name} updated successfully"
assert html =~ "some updated location"
end
test "can sort by type",
%{conn: conn, container: container, current_user: current_user} do
rifle_type = ammo_type_fixture(%{"type" => "rifle"}, current_user)
rifle_type = ammo_type_fixture(%{type: "rifle"}, current_user)
{1, [rifle_ammo_group]} = ammo_group_fixture(rifle_type, container, current_user)
shotgun_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user)
shotgun_type = ammo_type_fixture(%{type: "shotgun"}, current_user)
{1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_type, container, current_user)
pistol_type = ammo_type_fixture(%{"type" => "pistol"}, current_user)
pistol_type = ammo_type_fixture(%{type: "pistol"}, current_user)
{1, [pistol_ammo_group]} = ammo_group_fixture(pistol_type, container, current_user)
{:ok, index_live, html} = live(conn, Routes.container_show_path(conn, :show, container))

5
test/cannery_web/live/home_live_test.exs
View File

@ -5,14 +5,13 @@ defmodule CanneryWeb.HomeLiveTest do
use CanneryWeb.ConnCase
import Phoenix.LiveViewTest
import CanneryWeb.Gettext
@moduletag :home_live_test
test "disconnected and connected render", %{conn: conn} do
{:ok, home_live, disconnected_html} = live(conn, "/")
assert disconnected_html =~ gettext("Welcome to %{name}", name: "Cannery")
assert render(home_live) =~ gettext("Welcome to %{name}", name: "Cannery")
assert disconnected_html =~ "Welcome to Cannery"
assert render(home_live) =~ "Welcome to Cannery"
end
test "displays version number", %{conn: conn} do

48
test/cannery_web/live/invite_live_test.exs
View File

@ -5,13 +5,12 @@ defmodule CanneryWeb.InviteLiveTest do
use CanneryWeb.ConnCase
import Phoenix.LiveViewTest
import CanneryWeb.Gettext
alias Cannery.Accounts.Invites
@moduletag :invite_live_test
@create_attrs %{"name" => "some name"}
@update_attrs %{"name" => "some updated name"}
# @invalid_attrs %{"name" => nil}
@create_attrs %{name: "some name"}
@update_attrs %{name: "some updated name"}
@invalid_attrs %{name: nil}
describe "Index" do
setup [:register_and_log_in_user]
@ -24,32 +23,27 @@ defmodule CanneryWeb.InviteLiveTest do
test "lists all invites", %{conn: conn, invite: invite} do
{:ok, _index_live, html} = live(conn, Routes.invite_index_path(conn, :index))
assert html =~ gettext("Invites")
assert html =~ "Invites"
assert html =~ invite.name
end
test "saves new invite", %{conn: conn} do
{:ok, index_live, _html} = live(conn, Routes.invite_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "Create Invite")) |> render_click() =~
gettext("New Invite")
assert index_live |> element("a", "Create Invite") |> render_click() =~ "New Invite"
assert_patch(index_live, Routes.invite_index_path(conn, :new))
# assert index_live
# |> form("#invite-form", invite: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#invite-form")
|> render_change(invite: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _live, html} =
index_live
|> form("#invite-form", invite: @create_attrs)
|> render_submit()
|> form("#invite-form")
|> render_submit(invite: @create_attrs)
|> follow_redirect(conn, Routes.invite_index_path(conn, :index))
assert html =~
dgettext("prompts", "%{invite_name} created successfully", invite_name: "some name")
assert html =~ "some name"
assert html =~ "some name created successfully"
end
test "updates invite in listing", %{conn: conn, invite: invite} do
@ -57,27 +51,21 @@ defmodule CanneryWeb.InviteLiveTest do
assert index_live
|> element(~s/a[aria-label="Edit invite for #{invite.name}"]/)
|> render_click() =~
gettext("Edit Invite")
|> render_click() =~ "Edit Invite"
assert_patch(index_live, Routes.invite_index_path(conn, :edit, invite))
# assert index_live
# |> form("#invite-form", invite: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#invite-form")
|> render_change(invite: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _live, html} =
index_live
|> form("#invite-form", invite: @update_attrs)
|> render_submit()
|> form("#invite-form")
|> render_submit(invite: @update_attrs)
|> follow_redirect(conn, Routes.invite_index_path(conn, :index))
assert html =~
dgettext("prompts", "%{invite_name} updated successfully",
invite_name: "some updated name"
)
assert html =~ "some updated name"
assert html =~ "some updated name updated successfully"
end
test "deletes invite in listing", %{conn: conn, invite: invite} do

70
test/cannery_web/live/range_live_test.exs
View File

@ -6,22 +6,20 @@ defmodule CanneryWeb.RangeLiveTest do
use CanneryWeb.ConnCase
import Phoenix.LiveViewTest
import Cannery.Fixtures
import CanneryWeb.Gettext
@moduletag :range_live_test
@create_attrs %{"ammo_left" => 5, "notes" => "some notes"}
@update_attrs %{"count" => 16, "notes" => "some updated notes"}
# @invalid_attrs %{"count" => nil, "notes" => nil}
@create_attrs %{ammo_left: 5, notes: "some notes"}
@update_attrs %{count: 16, notes: "some updated notes"}
@invalid_attrs %{count: nil, notes: nil}
defp create_shot_group(%{current_user: current_user}) do
container = container_fixture(%{"staged" => true}, current_user)
container = container_fixture(%{staged: true}, current_user)
ammo_type = ammo_type_fixture(current_user)
{1, [ammo_group]} =
ammo_group_fixture(%{"staged" => true}, ammo_type, container, current_user)
{1, [ammo_group]} = ammo_group_fixture(%{staged: true}, ammo_type, container, current_user)
shot_group =
%{"count" => 5, "date" => ~N[2022-02-13 03:17:00], "notes" => "some notes"}
%{count: 5, date: ~N[2022-02-13 03:17:00], notes: "some notes"}
|> shot_group_fixture(current_user, ammo_group)
[
@ -38,29 +36,28 @@ defmodule CanneryWeb.RangeLiveTest do
test "lists all shot_groups", %{conn: conn, shot_group: shot_group} do
{:ok, _index_live, html} = live(conn, Routes.range_index_path(conn, :index))
assert html =~ gettext("Range day")
assert html =~ "Range day"
assert html =~ shot_group.notes
end
test "can sort by type",
%{conn: conn, container: container, current_user: current_user} do
rifle_ammo_type = ammo_type_fixture(%{"type" => "rifle"}, current_user)
rifle_ammo_type = ammo_type_fixture(%{type: "rifle"}, current_user)
{1, [rifle_ammo_group]} = ammo_group_fixture(rifle_ammo_type, container, current_user)
rifle_shot_group =
shot_group_fixture(%{"notes" => "group_one"}, current_user, rifle_ammo_group)
rifle_shot_group = shot_group_fixture(%{notes: "group_one"}, current_user, rifle_ammo_group)
shotgun_ammo_type = ammo_type_fixture(%{"type" => "shotgun"}, current_user)
shotgun_ammo_type = ammo_type_fixture(%{type: "shotgun"}, current_user)
{1, [shotgun_ammo_group]} = ammo_group_fixture(shotgun_ammo_type, container, current_user)
shotgun_shot_group =
shot_group_fixture(%{"notes" => "group_two"}, current_user, shotgun_ammo_group)
shot_group_fixture(%{notes: "group_two"}, current_user, shotgun_ammo_group)
pistol_ammo_type = ammo_type_fixture(%{"type" => "pistol"}, current_user)
pistol_ammo_type = ammo_type_fixture(%{type: "pistol"}, current_user)
{1, [pistol_ammo_group]} = ammo_group_fixture(pistol_ammo_type, container, current_user)
pistol_shot_group =
shot_group_fixture(%{"notes" => "group_three"}, current_user, pistol_ammo_group)
shot_group_fixture(%{notes: "group_three"}, current_user, pistol_ammo_group)
{:ok, index_live, html} = live(conn, Routes.range_index_path(conn, :index))
@ -113,22 +110,20 @@ defmodule CanneryWeb.RangeLiveTest do
assert html =~ shot_group.notes
assert index_live
|> form(~s/form[phx-change="search"]/,
search: %{search_term: shot_group.notes}
)
|> render_change() =~ shot_group.notes
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: shot_group.notes}) =~ shot_group.notes
assert_patch(index_live, Routes.range_index_path(conn, :search, shot_group.notes))
refute index_live
|> form(~s/form[phx-change="search"]/, search: %{search_term: "something_else"})
|> render_change() =~ shot_group.notes
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: "something_else"}) =~ shot_group.notes
assert_patch(index_live, Routes.range_index_path(conn, :search, "something_else"))
assert index_live
|> form(~s/form[phx-change="search"]/, search: %{search_term: ""})
|> render_change() =~ shot_group.notes
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: ""}) =~ shot_group.notes
assert_patch(index_live, Routes.range_index_path(conn, :index))
end
@ -136,22 +131,20 @@ defmodule CanneryWeb.RangeLiveTest do
test "saves new shot_group", %{conn: conn, ammo_group: ammo_group} do
{:ok, index_live, _html} = live(conn, Routes.range_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "Record shots")) |> render_click() =~
gettext("Record shots")
assert index_live |> element("a", "Record shots") |> render_click() =~ "Record shots"
assert_patch(index_live, Routes.range_index_path(conn, :add_shot_group, ammo_group))
# assert index_live
# |> form("#shot_group-form", shot_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "is invalid")
assert index_live
|> form("#shot-group-form")
|> render_change(shot_group: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#shot-group-form", shot_group: @create_attrs)
|> render_submit()
|> form("#shot-group-form")
|> render_submit(shot_group: @create_attrs)
|> follow_redirect(conn, Routes.range_index_path(conn, :index))
assert html =~ dgettext("prompts", "Shots recorded successfully")
assert html =~ "Shots recorded successfully"
assert html =~ "some notes"
end
@ -160,14 +153,13 @@ defmodule CanneryWeb.RangeLiveTest do
assert index_live
|> element(~s/a[aria-label="Edit shot record of #{shot_group.count} shots"]/)
|> render_click() =~
gettext("Edit Shot Records")
|> render_click() =~ "Edit Shot Records"
assert_patch(index_live, Routes.range_index_path(conn, :edit, shot_group))
# assert index_live
# |> form("#shot_group-form", shot_group: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "is invalid")
assert index_live
|> form("#shot-group-form")
|> render_change(shot_group: @invalid_attrs) =~ "can&#39;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

72
test/cannery_web/live/tag_live_test.exs
View File

@ -5,26 +5,24 @@ defmodule CanneryWeb.TagLiveTest do
use CanneryWeb.ConnCase
import Phoenix.LiveViewTest
import CanneryWeb.Gettext
@moduletag :tag_live_test
@create_attrs %{
"bg_color" => "#100000",
"name" => "some name",
"text_color" => "#000000"
bg_color: "#100000",
name: "some name",
text_color: "#000000"
}
@update_attrs %{
"bg_color" => "#100001",
"name" => "some updated name",
"text_color" => "#000001"
bg_color: "#100001",
name: "some updated name",
text_color: "#000001"
}
@invalid_attrs %{
bg_color: nil,
name: nil,
text_color: nil
}
# @invalid_attrs %{
# "bg_color" => nil,
# "name" => nil,
# "text_color" => nil
# }
def create_tag(%{current_user: current_user}) do
tag = tag_fixture(current_user)
@ -37,7 +35,7 @@ defmodule CanneryWeb.TagLiveTest do
test "lists all tags", %{conn: conn, tag: tag} do
{:ok, _index_live, html} = live(conn, Routes.tag_index_path(conn, :index))
assert html =~ gettext("Tags")
assert html =~ "Tags"
assert html =~ tag.bg_color
end
@ -47,22 +45,20 @@ defmodule CanneryWeb.TagLiveTest do
assert html =~ tag.name
assert index_live
|> form(~s/form[phx-change="search"]/,
search: %{search_term: tag.name}
)
|> render_change() =~ tag.name
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: tag.name}) =~ tag.name
assert_patch(index_live, Routes.tag_index_path(conn, :search, tag.name))
refute index_live
|> form(~s/form[phx-change="search"]/, search: %{search_term: "something_else"})
|> render_change() =~ tag.name
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: "something_else"}) =~ tag.name
assert_patch(index_live, Routes.tag_index_path(conn, :search, "something_else"))
assert index_live
|> form(~s/form[phx-change="search"]/, search: %{search_term: ""})
|> render_change() =~ tag.name
|> form(~s/form[phx-change="search"]/)
|> render_change(search: %{search_term: ""}) =~ tag.name
assert_patch(index_live, Routes.tag_index_path(conn, :index))
end
@ -70,22 +66,20 @@ defmodule CanneryWeb.TagLiveTest do
test "saves new tag", %{conn: conn} do
{:ok, index_live, _html} = live(conn, Routes.tag_index_path(conn, :index))
assert index_live |> element("a", dgettext("actions", "New Tag")) |> render_click() =~
dgettext("actions", "New Tag")
assert index_live |> element("a", "New Tag") |> render_click() =~ "New Tag"
assert_patch(index_live, Routes.tag_index_path(conn, :new))
# assert index_live
# |> form("#tag-form", tag: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#tag-form")
|> render_change(tag: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#tag-form", tag: @create_attrs)
|> render_submit()
|> form("#tag-form")
|> render_submit(tag: @create_attrs)
|> follow_redirect(conn, Routes.tag_index_path(conn, :index))
assert html =~ dgettext("actions", "%{name} created successfully", name: "some name")
assert html =~ "some name created successfully"
assert html =~ "#100000"
end
@ -93,23 +87,21 @@ defmodule CanneryWeb.TagLiveTest do
{:ok, index_live, _html} = live(conn, Routes.tag_index_path(conn, :index))
assert index_live |> element(~s/a[aria-label="Edit #{tag.name}"]/) |> render_click() =~
dgettext("actions", "Edit Tag")
"Edit Tag"
assert_patch(index_live, Routes.tag_index_path(conn, :edit, tag))
# assert index_live
# |> form("#tag-form", tag: @invalid_attrs)
# |> render_change() =~ dgettext("errors", "can't be blank")
assert index_live
|> form("#tag-form")
|> render_change(tag: @invalid_attrs) =~ "can&#39;t be blank"
{:ok, _view, html} =
index_live
|> form("#tag-form", tag: @update_attrs)
|> render_submit()
|> form("#tag-form")
|> render_submit(tag: @update_attrs)
|> follow_redirect(conn, Routes.tag_index_path(conn, :index))
assert html =~
dgettext("prompts", "%{name} updated successfully", name: "some updated name")
assert html =~ "some updated name updated successfully"
assert html =~ "#100001"
end

7
test/cannery_web/views/error_view_test.exs
View File

@ -4,19 +4,16 @@ defmodule CanneryWeb.ErrorViewTest do
"""
use CanneryWeb.ConnCase, async: true
import CanneryWeb.Gettext
# Bring render/3 and render_to_string/3 for testing custom views
import Phoenix.View
@moduletag :error_view_test
test "renders 404.html" do
assert render_to_string(CanneryWeb.ErrorView, "404.html", []) =~
dgettext("errors", "Not found")
assert render_to_string(CanneryWeb.ErrorView, "404.html", []) =~ "Not found"
end
test "renders 500.html" do
assert render_to_string(CanneryWeb.ErrorView, "500.html", []) =~
dgettext("errors", "Internal Server Error")
assert render_to_string(CanneryWeb.ErrorView, "500.html", []) =~ "Internal Server Error"
end
end

32
test/support/fixtures.ex
View File

@ -24,8 +24,8 @@ defmodule Cannery.Fixtures do
def user_fixture(attrs \\ %{}) do
attrs
|> Enum.into(%{
"email" => unique_user_email(),
"password" => valid_user_password()
email: unique_user_email(),
password: valid_user_password()
})
|> Accounts.register_user()
|> unwrap_ok_tuple()
@ -36,8 +36,8 @@ defmodule Cannery.Fixtures do
def admin_fixture(attrs \\ %{}) do
attrs
|> Enum.into(%{
"email" => unique_user_email(),
"password" => valid_user_password()
email: unique_user_email(),
password: valid_user_password()
})
|> Accounts.register_user()
|> unwrap_ok_tuple()
@ -76,9 +76,9 @@ defmodule Cannery.Fixtures do
def shot_group_fixture(attrs \\ %{}, %User{} = user, %AmmoGroup{} = ammo_group) do
attrs
|> Enum.into(%{
"count" => 20,
"date" => ~N[2022-02-13 03:17:00],
"notes" => random_string()
count: 20,
date: ~N[2022-02-13 03:17:00],
notes: random_string()
})
|> Cannery.ActivityLog.create_shot_group(user, ammo_group)
|> unwrap_ok_tuple()
@ -91,7 +91,7 @@ defmodule Cannery.Fixtures do
@spec container_fixture(attrs :: map(), User.t()) :: Container.t()
def container_fixture(attrs \\ %{}, %User{} = user) do
attrs
|> Enum.into(%{"name" => random_string(), "type" => "Ammo can"})
|> Enum.into(%{name: random_string(), type: "Ammo can"})
|> Containers.create_container(user)
|> unwrap_ok_tuple()
end
@ -103,7 +103,7 @@ defmodule Cannery.Fixtures do
@spec ammo_type_fixture(attrs :: map(), User.t()) :: AmmoType.t()
def ammo_type_fixture(attrs \\ %{}, %User{} = user) do
attrs
|> Enum.into(%{"name" => random_string(), "type" => "rifle"})
|> Enum.into(%{name: random_string(), type: "rifle"})
|> Ammo.create_ammo_type(user)
|> unwrap_ok_tuple()
end
@ -131,10 +131,10 @@ defmodule Cannery.Fixtures do
) do
attrs
|> Enum.into(%{
"ammo_type_id" => ammo_type_id,
"container_id" => container_id,
"count" => 20,
"purchased_on" => Date.utc_today()
ammo_type_id: ammo_type_id,
container_id: container_id,
count: 20,
purchased_on: Date.utc_today()
})
|> Ammo.create_ammo_groups(multiplier, user)
|> unwrap_ok_tuple()
@ -148,9 +148,9 @@ defmodule Cannery.Fixtures do
def tag_fixture(attrs \\ %{}, %User{} = user) do
attrs
|> Enum.into(%{
"bg_color" => "#100000",
"name" => random_string(),
"text_color" => "#000000"
bg_color: "#100000",
name: random_string(),
text_color: "#000000"
})
|> Containers.create_tag(user)
|> unwrap_ok_tuple()