cannery/test/support/fixtures.ex
2023-03-30 22:02:36 -04:00

199 lines
5.1 KiB
Elixir

defmodule Cannery.Fixtures do
@moduledoc """
This module defines test helpers for creating entities
"""
import Cannery.DataCase
alias Cannery.{
Accounts,
Accounts.User,
ActivityLog.ShotRecord,
Ammo,
Ammo.Pack,
Ammo.Type,
Containers,
Containers.Container,
Containers.Tag,
Email,
Repo
}
@spec user_fixture() :: User.t()
@spec user_fixture(attrs :: map()) :: User.t()
def user_fixture(attrs \\ %{}) do
attrs
|> Enum.into(%{
email: unique_user_email(),
password: valid_user_password()
})
|> Accounts.register_user()
|> unwrap_ok_tuple()
end
@spec admin_fixture() :: User.t()
@spec admin_fixture(attrs :: map()) :: User.t()
def admin_fixture(attrs \\ %{}) do
attrs
|> Enum.into(%{
email: unique_user_email(),
password: valid_user_password()
})
|> Accounts.register_user()
|> unwrap_ok_tuple()
|> User.role_changeset(:admin)
|> Repo.update!()
end
def extract_user_token(fun) do
%{args: %{attrs: attrs, email: email_key, user_id: user_id}} = fun.(&"[TOKEN]#{&1}[TOKEN]")
# convert atoms to string keys
attrs = attrs |> Map.new(fn {atom_key, value} -> {atom_key |> Atom.to_string(), value} end)
email =
email_key
|> Atom.to_string()
|> Email.generate_email(Accounts.get_user!(user_id), attrs)
[_, html_token | _] = email.html_body |> String.split("[TOKEN]")
[_, text_token | _] = email.text_body |> String.split("[TOKEN]")
^text_token = html_token
end
def valid_user_attributes(attrs \\ %{}) do
Enum.into(attrs, %{
email: unique_user_email(),
password: valid_user_password()
})
end
@doc """
Generate a ShotRecord
"""
@spec shot_record_fixture(User.t(), Pack.t()) :: ShotRecord.t()
@spec shot_record_fixture(attrs :: map(), User.t(), Pack.t()) :: ShotRecord.t()
def shot_record_fixture(attrs \\ %{}, %User{} = user, %Pack{} = pack) do
attrs
|> Enum.into(%{
count: 20,
date: ~N[2022-02-13 03:17:00],
notes: random_string()
})
|> Cannery.ActivityLog.create_shot_record(user, pack)
|> unwrap_ok_tuple()
end
@doc """
Generate a Container
"""
@spec container_fixture(User.t()) :: Container.t()
@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",
location: random_string(),
desc: random_string()
})
|> Containers.create_container(user)
|> unwrap_ok_tuple()
end
@doc """
Generate a Type
"""
@spec type_fixture(User.t()) :: Type.t()
@spec type_fixture(attrs :: map(), User.t()) :: Type.t()
def type_fixture(attrs \\ %{}, %User{} = user) do
attrs
|> Enum.into(%{
name: random_string(),
class: :rifle,
desc: random_string(),
bullet_type: random_string(),
bullet_core: random_string(),
cartridge: random_string(),
caliber: random_string(),
case_material: random_string(),
jacket_type: random_string(),
muzzle_velocity: 3,
powder_type: random_string(),
powder_grains_per_charge: 5,
grains: 7,
pressure: random_string(),
primer_type: random_string(),
firing_type: random_string(),
wadding: random_string(),
shot_type: random_string(),
shot_material: random_string(),
shot_size: random_string(),
unfired_length: random_string(),
brass_height: random_string(),
chamber_size: random_string(),
load_grains: 9,
shot_charge_weight: random_string(),
dram_equivalent: random_string(),
tracer: false,
incendiary: false,
blank: false,
corrosive: false,
manufacturer: random_string(),
upc: random_string()
})
|> Ammo.create_type(user)
|> unwrap_ok_tuple()
end
@doc """
Generate a Pack
"""
@spec pack_fixture(Type.t(), Container.t(), User.t()) ::
{count :: non_neg_integer(), [Pack.t()]}
@spec pack_fixture(attrs :: map(), Type.t(), Container.t(), User.t()) ::
{count :: non_neg_integer(), [Pack.t()]}
@spec pack_fixture(
attrs :: map(),
multiplier :: non_neg_integer(),
Type.t(),
Container.t(),
User.t()
) :: {count :: non_neg_integer(), [Pack.t()]}
def pack_fixture(
attrs \\ %{},
multiplier \\ 1,
%Type{id: type_id},
%Container{id: container_id},
%User{} = user
) do
attrs
|> Enum.into(%{
type_id: type_id,
container_id: container_id,
count: 20,
purchased_on: Date.utc_today()
})
|> Ammo.create_packs(multiplier, user)
|> unwrap_ok_tuple()
end
@doc """
Generates a Tag
"""
@spec tag_fixture(User.t()) :: Tag.t()
@spec tag_fixture(attrs :: map(), User.t()) :: Tag.t()
def tag_fixture(attrs \\ %{}, %User{} = user) do
attrs
|> Enum.into(%{
bg_color: "#100000",
name: random_string(),
text_color: "#000000"
})
|> Containers.create_tag(user)
|> unwrap_ok_tuple()
end
defp unwrap_ok_tuple({:ok, value}), do: value
end