shibao/cannery
1
2
Fork 1
Code Issues 14 Pull Requests Projects 1 Releases 40 Wiki Activity

shot groups to shot records

Browse Source
This commit is contained in:
shibao
2023-03-30 20:43:30 -04:00
parent 32801828fa
commit 5f8d1a917f
41 changed files with 585 additions and 707 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
test/cannery/activity_log_test.exs
View File

@@ -5,11 +5,11 @@ defmodule Cannery.ActivityLogTest do
use Cannery.DataCase
import Cannery.Fixtures
alias Cannery.{ActivityLog, ActivityLog.ShotGroup, Ammo}
alias Cannery.{ActivityLog, ActivityLog.ShotRecord, Ammo}
@moduletag :activity_log_test
describe "shot_groups" do
describe "shot_records" do
setup do
current_user = user_fixture()
container = container_fixture(current_user)
@@ -18,9 +18,9 @@ defmodule Cannery.ActivityLogTest do
{1, [%{id: pack_id} = pack]} =
pack_fixture(%{count: 25}, ammo_type, container, current_user)
shot_group =
shot_record =
%{count: 5, date: ~N[2022-02-13 03:17:00], notes: "some notes"}
|> shot_group_fixture(current_user, pack)
|> shot_record_fixture(current_user, pack)
pack = pack_id |> Ammo.get_pack!(current_user)
@@ -29,7 +29,7 @@ defmodule Cannery.ActivityLogTest do
container: container,
ammo_type: ammo_type,
pack: pack,
shot_group: shot_group
shot_record: shot_record
]
end
@@ -37,10 +37,10 @@ defmodule Cannery.ActivityLogTest do
%{pack: pack, current_user: current_user} do
assert ActivityLog.get_shot_record_count!(current_user) == 1
shot_group_fixture(%{count: 1, date: ~N[2022-02-13 03:17:00]}, current_user, pack)
shot_record_fixture(%{count: 1, date: ~N[2022-02-13 03:17:00]}, current_user, pack)
assert ActivityLog.get_shot_record_count!(current_user) == 2
shot_group_fixture(%{count: 1, date: ~N[2022-02-13 03:17:00]}, current_user, pack)
shot_record_fixture(%{count: 1, date: ~N[2022-02-13 03:17:00]}, current_user, pack)
assert ActivityLog.get_shot_record_count!(current_user) == 3
other_user = user_fixture()
@@ -49,83 +49,84 @@ defmodule Cannery.ActivityLogTest do
container = container_fixture(other_user)
ammo_type = ammo_type_fixture(other_user)
{1, [pack]} = pack_fixture(%{count: 25}, ammo_type, container, other_user)
shot_group_fixture(%{count: 1, date: ~N[2022-02-13 03:17:00]}, other_user, pack)
shot_record_fixture(%{count: 1, date: ~N[2022-02-13 03:17:00]}, other_user, pack)
assert ActivityLog.get_shot_record_count!(other_user) == 1
end
test "get_shot_group!/2 returns the shot_group with given id",
%{shot_group: shot_group, current_user: current_user} do
assert ActivityLog.get_shot_group!(shot_group.id, current_user) == shot_group
test "get_shot_record!/2 returns the shot_record with given id",
%{shot_record: shot_record, current_user: current_user} do
assert ActivityLog.get_shot_record!(shot_record.id, current_user) == shot_record
end
test "get_shot_group!/2 does not return a shot_group of another user",
%{shot_group: shot_group} do
test "get_shot_record!/2 does not return a shot_record of another user",
%{shot_record: shot_record} do
another_user = user_fixture()
assert_raise Ecto.NoResultsError, fn ->
ActivityLog.get_shot_group!(shot_group.id, another_user)
ActivityLog.get_shot_record!(shot_record.id, another_user)
end
end
test "create_shot_group/3 with valid data creates a shot_group",
test "create_shot_record/3 with valid data creates a shot_record",
%{current_user: current_user, pack: pack} do
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, pack)
assert {:ok, %ShotRecord{} = shot_record} =
ActivityLog.create_shot_record(valid_attrs, current_user, pack)
assert shot_group.count == 10
assert shot_group.date == ~D[2022-02-13]
assert shot_group.notes == "some notes"
assert shot_record.count == 10
assert shot_record.date == ~D[2022-02-13]
assert shot_record.notes == "some notes"
end
test "create_shot_group/3 removes corresponding count from pack",
test "create_shot_record/3 removes corresponding count from pack",
%{
current_user: current_user,
pack: %{id: pack_id, count: org_count} = pack
} do
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, pack)
assert {:ok, %ShotRecord{} = shot_record} =
ActivityLog.create_shot_record(valid_attrs, current_user, pack)
%{count: new_count} = pack_id |> Ammo.get_pack!(current_user)
assert org_count - shot_group.count == new_count
assert org_count - shot_record.count == new_count
assert new_count == 10
end
test "create_shot_group/3 does not remove more tha pack amount",
test "create_shot_record/3 does not remove more tha pack amount",
%{current_user: current_user, pack: %{id: pack_id} = pack} do
valid_attrs = %{count: 20, date: ~D[2022-02-13], notes: "some notes"}
assert {:ok, %ShotGroup{}} = ActivityLog.create_shot_group(valid_attrs, current_user, pack)
assert {:ok, %ShotRecord{}} =
ActivityLog.create_shot_record(valid_attrs, current_user, pack)
pack = pack_id |> Ammo.get_pack!(current_user)
assert pack.count == 0
assert {:error, %Ecto.Changeset{}} =
ActivityLog.create_shot_group(%{count: 1}, current_user, pack)
ActivityLog.create_shot_record(%{count: 1}, current_user, pack)
end
test "create_shot_group/3 with invalid data returns error changeset",
test "create_shot_record/3 with invalid data returns error changeset",
%{current_user: current_user, pack: pack} do
invalid_params = %{count: nil, date: nil, notes: nil}
assert {:error, %Ecto.Changeset{}} =
ActivityLog.create_shot_group(invalid_params, current_user, pack)
ActivityLog.create_shot_record(invalid_params, current_user, pack)
end
test "update_shot_group/3 with valid data updates the shot_group and pack",
test "update_shot_record/3 with valid data updates the shot_record and pack",
%{
shot_group: shot_group,
shot_record: shot_record,
pack: %{id: pack_id},
current_user: current_user
} do
assert {:ok, %ShotGroup{} = shot_group} =
ActivityLog.update_shot_group(
shot_group,
assert {:ok, %ShotRecord{} = shot_record} =
ActivityLog.update_shot_record(
shot_record,
%{
count: 10,
date: ~D[2022-02-13],
@@ -136,14 +137,14 @@ defmodule Cannery.ActivityLogTest do
pack = pack_id |> Ammo.get_pack!(current_user)
assert shot_group.count == 10
assert shot_record.count == 10
assert pack.count == 15
assert shot_group.date == ~D[2022-02-13]
assert shot_group.notes == "some updated notes"
assert shot_record.date == ~D[2022-02-13]
assert shot_record.notes == "some updated notes"
assert {:ok, %ShotGroup{} = shot_group} =
ActivityLog.update_shot_group(
shot_group,
assert {:ok, %ShotRecord{} = shot_record} =
ActivityLog.update_shot_record(
shot_record,
%{
count: 25,
date: ~D[2022-02-13],
@@ -154,37 +155,37 @@ defmodule Cannery.ActivityLogTest do
pack = pack_id |> Ammo.get_pack!(current_user)
assert shot_group.count == 25
assert shot_record.count == 25
assert pack.count == 0
end
test "update_shot_group/3 with invalid data returns error changeset",
%{shot_group: shot_group, current_user: current_user} do
test "update_shot_record/3 with invalid data returns error changeset",
%{shot_record: shot_record, current_user: current_user} do
assert {:error, %Ecto.Changeset{}} =
ActivityLog.update_shot_group(
shot_group,
ActivityLog.update_shot_record(
shot_record,
%{count: 26, date: nil, notes: nil},
current_user
)
assert {:error, %Ecto.Changeset{}} =
ActivityLog.update_shot_group(
shot_group,
ActivityLog.update_shot_record(
shot_record,
%{count: -1, date: nil, notes: nil},
current_user
)
assert shot_group == ActivityLog.get_shot_group!(shot_group.id, current_user)
assert shot_record == ActivityLog.get_shot_record!(shot_record.id, current_user)
end
test "delete_shot_group/2 deletes the shot_group and adds value back",
%{shot_group: shot_group, current_user: current_user, pack: %{id: pack_id}} do
assert {:ok, %ShotGroup{}} = ActivityLog.delete_shot_group(shot_group, current_user)
test "delete_shot_record/2 deletes the shot_record and adds value back",
%{shot_record: shot_record, current_user: current_user, pack: %{id: pack_id}} do
assert {:ok, %ShotRecord{}} = ActivityLog.delete_shot_record(shot_record, current_user)
assert %{count: 25} = pack_id |> Ammo.get_pack!(current_user)
assert_raise Ecto.NoResultsError, fn ->
ActivityLog.get_shot_group!(shot_group.id, current_user)
ActivityLog.get_shot_record!(shot_record.id, current_user)
end
end
@@ -198,10 +199,10 @@ defmodule Cannery.ActivityLogTest do
assert 0 = another_pack |> ActivityLog.get_used_count(current_user)
assert 5 = pack |> ActivityLog.get_used_count(current_user)
shot_group_fixture(%{count: 15}, current_user, pack)
shot_record_fixture(%{count: 15}, current_user, pack)
assert 20 = pack |> ActivityLog.get_used_count(current_user)
shot_group_fixture(%{count: 10}, current_user, pack)
shot_record_fixture(%{count: 10}, current_user, pack)
assert 30 = pack |> ActivityLog.get_used_count(current_user)
{1, [another_pack]} = pack_fixture(ammo_type, container, current_user)
@@ -220,17 +221,17 @@ defmodule Cannery.ActivityLogTest do
assert %{pack_id => 5} ==
[pack, another_pack] |> ActivityLog.get_used_counts(current_user)
shot_group_fixture(%{count: 5}, current_user, another_pack)
shot_record_fixture(%{count: 5}, current_user, another_pack)
used_counts = [pack, another_pack] |> ActivityLog.get_used_counts(current_user)
assert %{^pack_id => 5} = used_counts
assert %{^another_pack_id => 5} = used_counts
shot_group_fixture(%{count: 15}, current_user, pack)
shot_record_fixture(%{count: 15}, current_user, pack)
used_counts = [pack, another_pack] |> ActivityLog.get_used_counts(current_user)
assert %{^pack_id => 20} = used_counts
assert %{^another_pack_id => 5} = used_counts
shot_group_fixture(%{count: 10}, current_user, pack)
shot_record_fixture(%{count: 10}, current_user, pack)
used_counts = [pack, another_pack] |> ActivityLog.get_used_counts(current_user)
assert %{^pack_id => 30} = used_counts
assert %{^another_pack_id => 5} = used_counts
@@ -240,17 +241,17 @@ defmodule Cannery.ActivityLogTest do
pack: pack,
ammo_type: ammo_type,
container: container,
shot_group: %{date: date},
shot_record: %{date: date},
current_user: current_user
} do
{1, [another_pack]} = pack_fixture(ammo_type, container, current_user)
assert another_pack |> ActivityLog.get_last_used_date(current_user) |> is_nil()
assert ^date = pack |> ActivityLog.get_last_used_date(current_user)
%{date: date} = shot_group_fixture(%{date: ~D[2022-11-10]}, current_user, pack)
%{date: date} = shot_record_fixture(%{date: ~D[2022-11-10]}, current_user, pack)
assert ^date = pack |> ActivityLog.get_last_used_date(current_user)
%{date: date} = shot_group_fixture(%{date: ~D[2022-11-11]}, current_user, pack)
%{date: date} = shot_record_fixture(%{date: ~D[2022-11-11]}, current_user, pack)
assert ^date = pack |> ActivityLog.get_last_used_date(current_user)
end
@@ -258,7 +259,7 @@ defmodule Cannery.ActivityLogTest do
pack: %{id: pack_id} = pack,
ammo_type: ammo_type,
container: container,
shot_group: %{date: date},
shot_record: %{date: date},
current_user: current_user
} do
{1, [%{id: another_pack_id} = another_pack]} =
@@ -268,32 +269,32 @@ defmodule Cannery.ActivityLogTest do
assert %{pack_id => date} ==
[pack, another_pack] |> ActivityLog.get_last_used_dates(current_user)
shot_group_fixture(%{date: ~D[2022-11-09]}, current_user, another_pack)
shot_record_fixture(%{date: ~D[2022-11-09]}, current_user, another_pack)
# setting initial date
last_used_shot_groups =
last_used_shot_records =
[pack, another_pack] |> ActivityLog.get_last_used_dates(current_user)
assert %{^pack_id => ^date} = last_used_shot_groups
assert %{^another_pack_id => ~D[2022-11-09]} = last_used_shot_groups
assert %{^pack_id => ^date} = last_used_shot_records
assert %{^another_pack_id => ~D[2022-11-09]} = last_used_shot_records
# setting another date
shot_group_fixture(%{date: ~D[2022-11-10]}, current_user, pack)
shot_record_fixture(%{date: ~D[2022-11-10]}, current_user, pack)
last_used_shot_groups =
last_used_shot_records =
[pack, another_pack] |> ActivityLog.get_last_used_dates(current_user)
assert %{^pack_id => ~D[2022-11-10]} = last_used_shot_groups
assert %{^another_pack_id => ~D[2022-11-09]} = last_used_shot_groups
assert %{^pack_id => ~D[2022-11-10]} = last_used_shot_records
assert %{^another_pack_id => ~D[2022-11-09]} = last_used_shot_records
# setting yet another date
shot_group_fixture(%{date: ~D[2022-11-11]}, current_user, pack)
shot_record_fixture(%{date: ~D[2022-11-11]}, current_user, pack)
last_used_shot_groups =
last_used_shot_records =
[pack, another_pack] |> ActivityLog.get_last_used_dates(current_user)
assert %{^pack_id => ~D[2022-11-11]} = last_used_shot_groups
assert %{^another_pack_id => ~D[2022-11-09]} = last_used_shot_groups
assert %{^pack_id => ~D[2022-11-11]} = last_used_shot_records
assert %{^another_pack_id => ~D[2022-11-09]} = last_used_shot_records
end
test "get_used_count_for_ammo_type/2 gets accurate used round count for ammo type",
@@ -302,10 +303,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, pack)
shot_record_fixture(%{count: 5}, current_user, pack)
assert 10 = ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user)
shot_group_fixture(%{count: 1}, current_user, pack)
shot_record_fixture(%{count: 1}, current_user, pack)
assert 11 = ammo_type |> ActivityLog.get_used_count_for_ammo_type(current_user)
end
@@ -323,7 +324,7 @@ defmodule Cannery.ActivityLogTest do
|> ActivityLog.get_used_count_for_ammo_types(current_user)
# use generated pack
shot_group_fixture(%{count: 5}, current_user, pack)
shot_record_fixture(%{count: 5}, current_user, pack)
used_counts =
[ammo_type, another_ammo_type] |> ActivityLog.get_used_count_for_ammo_types(current_user)
@@ -332,7 +333,7 @@ defmodule Cannery.ActivityLogTest do
assert %{^another_ammo_type_id => 5} = used_counts
# use generated pack again
shot_group_fixture(%{count: 1}, current_user, pack)
shot_record_fixture(%{count: 1}, current_user, pack)
used_counts =
[ammo_type, another_ammo_type] |> ActivityLog.get_used_count_for_ammo_types(current_user)
@@ -342,7 +343,7 @@ defmodule Cannery.ActivityLogTest do
end
end
describe "list_shot_groups/3" do
describe "list_shot_records/3" do
setup do
current_user = user_fixture()
container = container_fixture(current_user)
@@ -357,7 +358,7 @@ defmodule Cannery.ActivityLogTest do
]
end
test "list_shot_groups/3 returns relevant shot_groups for a type",
test "list_shot_records/3 returns relevant shot_records for a type",
%{current_user: current_user, container: container} do
other_user = user_fixture()
other_container = container_fixture(other_user)
@@ -365,56 +366,56 @@ defmodule Cannery.ActivityLogTest do
for class <- ["rifle", "shotgun", "pistol"] do
other_ammo_type = ammo_type_fixture(%{class: class}, other_user)
{1, [other_pack]} = pack_fixture(other_ammo_type, other_container, other_user)
shot_group_fixture(other_user, other_pack)
shot_record_fixture(other_user, other_pack)
end
rifle_ammo_type = ammo_type_fixture(%{class: :rifle}, current_user)
{1, [rifle_pack]} = pack_fixture(rifle_ammo_type, container, current_user)
rifle_shot_group = shot_group_fixture(current_user, rifle_pack)
rifle_shot_record = shot_record_fixture(current_user, rifle_pack)
shotgun_ammo_type = ammo_type_fixture(%{class: :shotgun}, current_user)
{1, [shotgun_pack]} = pack_fixture(shotgun_ammo_type, container, current_user)
shotgun_shot_group = shot_group_fixture(current_user, shotgun_pack)
shotgun_shot_record = shot_record_fixture(current_user, shotgun_pack)
pistol_ammo_type = ammo_type_fixture(%{class: :pistol}, current_user)
{1, [pistol_pack]} = pack_fixture(pistol_ammo_type, container, current_user)
pistol_shot_group = shot_group_fixture(current_user, pistol_pack)
pistol_shot_record = shot_record_fixture(current_user, pistol_pack)
assert [^rifle_shot_group] = ActivityLog.list_shot_groups(:rifle, current_user)
assert [^shotgun_shot_group] = ActivityLog.list_shot_groups(:shotgun, current_user)
assert [^pistol_shot_group] = ActivityLog.list_shot_groups(:pistol, current_user)
assert [^rifle_shot_record] = ActivityLog.list_shot_records(:rifle, current_user)
assert [^shotgun_shot_record] = ActivityLog.list_shot_records(:shotgun, current_user)
assert [^pistol_shot_record] = ActivityLog.list_shot_records(:pistol, current_user)
shot_groups = ActivityLog.list_shot_groups(:all, current_user)
assert Enum.count(shot_groups) == 3
assert rifle_shot_group in shot_groups
assert shotgun_shot_group in shot_groups
assert pistol_shot_group in shot_groups
shot_records = ActivityLog.list_shot_records(:all, current_user)
assert Enum.count(shot_records) == 3
assert rifle_shot_record in shot_records
assert shotgun_shot_record in shot_records
assert pistol_shot_record in shot_records
shot_groups = ActivityLog.list_shot_groups(nil, current_user)
assert Enum.count(shot_groups) == 3
assert rifle_shot_group in shot_groups
assert shotgun_shot_group in shot_groups
assert pistol_shot_group in shot_groups
shot_records = ActivityLog.list_shot_records(nil, current_user)
assert Enum.count(shot_records) == 3
assert rifle_shot_record in shot_records
assert shotgun_shot_record in shot_records
assert pistol_shot_record in shot_records
end
test "list_shot_groups/3 returns relevant shot_groups for a search", %{
test "list_shot_records/3 returns relevant shot_records for a search", %{
ammo_type: ammo_type,
pack: pack,
container: container,
current_user: current_user
} do
shot_group_a = shot_group_fixture(%{notes: "amazing"}, current_user, pack)
shot_record_a = shot_record_fixture(%{notes: "amazing"}, current_user, pack)
{1, [another_pack]} =
pack_fixture(%{notes: "stupendous"}, ammo_type, container, current_user)
shot_group_b = shot_group_fixture(current_user, another_pack)
shot_record_b = shot_record_fixture(current_user, another_pack)
another_ammo_type = ammo_type_fixture(%{name: "fabulous ammo"}, current_user)
{1, [yet_another_pack]} = pack_fixture(another_ammo_type, container, current_user)
shot_group_c = shot_group_fixture(current_user, yet_another_pack)
shot_record_c = shot_record_fixture(current_user, yet_another_pack)
another_user = user_fixture()
another_container = container_fixture(another_user)
@@ -422,16 +423,16 @@ defmodule Cannery.ActivityLogTest do
{1, [another_pack]} = pack_fixture(another_ammo_type, another_container, another_user)
_shouldnt_return = shot_group_fixture(another_user, another_pack)
_shouldnt_return = shot_record_fixture(another_user, another_pack)
# notes
assert ActivityLog.list_shot_groups("amazing", :all, current_user) == [shot_group_a]
assert ActivityLog.list_shot_records("amazing", :all, current_user) == [shot_record_a]
# pack attributes
assert ActivityLog.list_shot_groups("stupendous", :all, current_user) == [shot_group_b]
assert ActivityLog.list_shot_records("stupendous", :all, current_user) == [shot_record_b]
# ammo type attributes
assert ActivityLog.list_shot_groups("fabulous", :all, current_user) == [shot_group_c]
assert ActivityLog.list_shot_records("fabulous", :all, current_user) == [shot_record_c]
end
end
end

76
test/cannery/ammo_test.exs
View File

@@ -362,10 +362,10 @@ defmodule Cannery.AmmoTest do
assert 51 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user)
shot_group_fixture(%{count: 26}, current_user, pack)
shot_record_fixture(%{count: 26}, current_user, pack)
assert 25 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user)
shot_group_fixture(%{count: 1}, current_user, first_pack)
shot_record_fixture(%{count: 1}, current_user, first_pack)
assert 24 = Ammo.get_round_count_for_ammo_type(ammo_type, current_user)
end
@@ -397,7 +397,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, pack)
shot_record_fixture(%{count: 26}, current_user, pack)
round_counts =
[ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user)
@@ -405,7 +405,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_pack)
shot_record_fixture(%{count: 1}, current_user, first_pack)
round_counts =
[ammo_type, another_ammo_type] |> Ammo.get_round_count_for_ammo_types(current_user)
@@ -426,10 +426,10 @@ defmodule Cannery.AmmoTest do
assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user)
shot_group_fixture(%{count: 26}, current_user, pack)
shot_record_fixture(%{count: 26}, current_user, pack)
assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user)
shot_group_fixture(%{count: 1}, current_user, first_pack)
shot_record_fixture(%{count: 1}, current_user, first_pack)
assert 51 = Ammo.get_historical_count_for_ammo_type(ammo_type, current_user)
end
@@ -464,7 +464,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, pack)
shot_record_fixture(%{count: 26}, current_user, pack)
historical_counts =
[ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user)
@@ -472,7 +472,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_pack)
shot_record_fixture(%{count: 1}, current_user, first_pack)
historical_counts =
[ammo_type, another_ammo_type] |> Ammo.get_historical_count_for_ammo_types(current_user)
@@ -493,10 +493,10 @@ defmodule Cannery.AmmoTest do
assert 0 = Ammo.get_used_packs_count_for_type(ammo_type, current_user)
shot_group_fixture(%{count: 50}, current_user, pack)
shot_record_fixture(%{count: 50}, current_user, pack)
assert 1 = Ammo.get_used_packs_count_for_type(ammo_type, current_user)
shot_group_fixture(%{count: 1}, current_user, first_pack)
shot_record_fixture(%{count: 1}, current_user, first_pack)
assert 2 = Ammo.get_used_packs_count_for_type(ammo_type, current_user)
end
@@ -526,7 +526,7 @@ defmodule Cannery.AmmoTest do
# testing ammo type with used pack
{1, [another_pack]} = pack_fixture(%{count: 50}, another_ammo_type, container, current_user)
shot_group_fixture(%{count: 50}, current_user, another_pack)
shot_record_fixture(%{count: 50}, current_user, another_pack)
assert %{another_ammo_type_id => 1} ==
[ammo_type, another_ammo_type]
@@ -534,7 +534,7 @@ defmodule Cannery.AmmoTest do
# testing two ammo types with zero and one used packs
{1, [pack]} = pack_fixture(%{count: 50}, ammo_type, container, current_user)
shot_group_fixture(%{count: 50}, current_user, pack)
shot_record_fixture(%{count: 50}, current_user, pack)
used_counts =
[ammo_type, another_ammo_type] |> Ammo.get_used_packs_count_for_types(current_user)
@@ -543,7 +543,7 @@ defmodule Cannery.AmmoTest do
assert %{^another_ammo_type_id => 1} = used_counts
# testing two ammo type with one and two used packs
shot_group_fixture(%{count: 1}, current_user, first_pack)
shot_record_fixture(%{count: 1}, current_user, first_pack)
used_counts =
[ammo_type, another_ammo_type] |> Ammo.get_used_packs_count_for_types(current_user)
@@ -562,10 +562,10 @@ defmodule Cannery.AmmoTest do
assert 26 = Ammo.get_packs_count_for_container!(container, current_user)
shot_group_fixture(%{count: 1}, current_user, first_pack)
shot_record_fixture(%{count: 1}, current_user, first_pack)
assert 26 = Ammo.get_packs_count_for_container!(container, current_user)
shot_group_fixture(%{count: 4}, current_user, first_pack)
shot_record_fixture(%{count: 4}, current_user, first_pack)
assert 25 = Ammo.get_packs_count_for_container!(container, current_user)
end
@@ -596,7 +596,7 @@ defmodule Cannery.AmmoTest do
assert %{^container_id => 26} = packs_count
assert %{^another_container_id => 1} = packs_count
shot_group_fixture(%{count: 1}, current_user, first_pack)
shot_record_fixture(%{count: 1}, current_user, first_pack)
packs_count =
[container, another_container]
@@ -605,7 +605,7 @@ defmodule Cannery.AmmoTest do
assert %{^container_id => 26} = packs_count
assert %{^another_container_id => 1} = packs_count
shot_group_fixture(%{count: 4}, current_user, first_pack)
shot_record_fixture(%{count: 4}, current_user, first_pack)
packs_count =
[container, another_container]
@@ -625,7 +625,7 @@ defmodule Cannery.AmmoTest do
assert 130 = Ammo.get_round_count_for_container!(container, current_user)
shot_group_fixture(%{count: 5}, current_user, first_pack)
shot_record_fixture(%{count: 5}, current_user, first_pack)
assert 125 = Ammo.get_round_count_for_container!(container, current_user)
end
@@ -655,7 +655,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_pack)
shot_record_fixture(%{count: 5}, current_user, first_pack)
round_counts =
[container, another_container] |> Ammo.get_round_count_for_containers(current_user)
@@ -725,7 +725,7 @@ defmodule Cannery.AmmoTest do
{1, [another_pack]} =
pack_fixture(%{count: 30}, other_ammo_type, other_container, other_user)
shot_group_fixture(%{count: 30}, other_user, another_pack)
shot_record_fixture(%{count: 30}, other_user, another_pack)
assert Ammo.get_packs_count!(other_user) == 0
assert Ammo.get_packs_count!(other_user, true) == 1
end
@@ -767,7 +767,7 @@ defmodule Cannery.AmmoTest do
{1, [%{id: another_pack_id} = another_pack]} =
pack_fixture(%{count: 30}, ammo_type, container, current_user)
shot_group_fixture(%{count: 30}, current_user, another_pack)
shot_record_fixture(%{count: 30}, current_user, another_pack)
another_pack = Ammo.get_pack!(another_pack_id, current_user)
assert Ammo.list_packs(nil, :all, current_user, false) == [pack]
@@ -831,7 +831,7 @@ defmodule Cannery.AmmoTest do
{1, [pack]} = pack_fixture(ammo_type, container, current_user)
assert [^pack] = Ammo.list_packs_for_type(ammo_type, current_user)
shot_group_fixture(current_user, pack)
shot_record_fixture(current_user, pack)
pack = Ammo.get_pack!(pack.id, current_user)
assert [] == Ammo.list_packs_for_type(ammo_type, current_user)
assert [^pack] = Ammo.list_packs_for_type(ammo_type, current_user, true)
@@ -1013,15 +1013,15 @@ defmodule Cannery.AmmoTest do
%{pack: %{id: pack_id} = pack, current_user: current_user} do
assert 100 = pack |> Ammo.get_percentage_remaining(current_user)
shot_group_fixture(%{count: 14}, current_user, pack)
shot_record_fixture(%{count: 14}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
assert 72 = pack |> Ammo.get_percentage_remaining(current_user)
shot_group_fixture(%{count: 11}, current_user, pack)
shot_record_fixture(%{count: 11}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
assert 50 = pack |> Ammo.get_percentage_remaining(current_user)
shot_group_fixture(%{count: 25}, current_user, pack)
shot_record_fixture(%{count: 25}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
assert 0 = pack |> Ammo.get_percentage_remaining(current_user)
end
@@ -1044,7 +1044,7 @@ defmodule Cannery.AmmoTest do
assert %{^pack_id => 100} = percentages
assert %{^another_pack_id => 100} = percentages
shot_group_fixture(%{count: 14}, current_user, pack)
shot_record_fixture(%{count: 14}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
percentages = [pack, another_pack] |> Ammo.get_percentages_remaining(current_user)
@@ -1052,7 +1052,7 @@ defmodule Cannery.AmmoTest do
assert %{^pack_id => 72} = percentages
assert %{^another_pack_id => 100} = percentages
shot_group_fixture(%{count: 11}, current_user, pack)
shot_record_fixture(%{count: 11}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
percentages = [pack, another_pack] |> Ammo.get_percentages_remaining(current_user)
@@ -1060,7 +1060,7 @@ defmodule Cannery.AmmoTest do
assert %{^pack_id => 50} = percentages
assert %{^another_pack_id => 100} = percentages
shot_group_fixture(%{count: 25}, current_user, pack)
shot_record_fixture(%{count: 25}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
percentages = [pack, another_pack] |> Ammo.get_percentages_remaining(current_user)
@@ -1104,8 +1104,8 @@ defmodule Cannery.AmmoTest do
assert 0.722 = pack |> Ammo.get_cpr(current_user)
# with shot group, maintains total
shot_group_fixture(%{count: 14}, current_user, pack)
# with shot record, maintains total
shot_record_fixture(%{count: 14}, current_user, pack)
pack = Ammo.get_pack!(pack.id, current_user)
assert 0.722 = pack |> Ammo.get_cpr(current_user)
end
@@ -1151,8 +1151,8 @@ defmodule Cannery.AmmoTest do
assert %{^another_pack_id => 1.5} = cprs
assert %{^yet_another_pack_id => 0.722} = cprs
# with shot group, maintains total
shot_group_fixture(%{count: 14}, current_user, yet_another_pack)
# with shot record, maintains total
shot_record_fixture(%{count: 14}, current_user, yet_another_pack)
yet_another_pack = Ammo.get_pack!(yet_another_pack.id, current_user)
cprs = [pack, another_pack, yet_another_pack] |> Ammo.get_cprs(current_user)
@@ -1166,15 +1166,15 @@ defmodule Cannery.AmmoTest do
%{pack: %{id: pack_id} = pack, current_user: current_user} do
assert 50 = pack |> Ammo.get_original_count(current_user)
shot_group_fixture(%{count: 14}, current_user, pack)
shot_record_fixture(%{count: 14}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
assert 50 = pack |> Ammo.get_original_count(current_user)
shot_group_fixture(%{count: 11}, current_user, pack)
shot_record_fixture(%{count: 11}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
assert 50 = pack |> Ammo.get_original_count(current_user)
shot_group_fixture(%{count: 25}, current_user, pack)
shot_record_fixture(%{count: 25}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
assert 50 = pack |> Ammo.get_original_count(current_user)
end
@@ -1192,19 +1192,19 @@ defmodule Cannery.AmmoTest do
assert %{^pack_id => 50} = original_counts
assert %{^another_pack_id => 25} = original_counts
shot_group_fixture(%{count: 14}, current_user, pack)
shot_record_fixture(%{count: 14}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
original_counts = [pack, another_pack] |> Ammo.get_original_counts(current_user)
assert %{^pack_id => 50} = original_counts
assert %{^another_pack_id => 25} = original_counts
shot_group_fixture(%{count: 11}, current_user, pack)
shot_record_fixture(%{count: 11}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
original_counts = [pack, another_pack] |> Ammo.get_original_counts(current_user)
assert %{^pack_id => 50} = original_counts
assert %{^another_pack_id => 25} = original_counts
shot_group_fixture(%{count: 25}, current_user, pack)
shot_record_fixture(%{count: 25}, current_user, pack)
pack = Ammo.get_pack!(pack_id, current_user)
original_counts = [pack, another_pack] |> Ammo.get_original_counts(current_user)
assert %{^pack_id => 50} = original_counts