Greetings! I am relatively new to property-based testing. I am practicing writing property tests and hoping for a code review if any practitioner has any comments or suggestions on the test.
defmodule Academy.UserPropTest do
alias Academy.UserShim
use Academy.TestCase, async: true
use PropCheck
use PropCheck.StateM
require ExUnitProperties
# Generators
def first_name() do
StreamData.string(:alphanumeric, length: 10..20)
end
def email() do
StreamData.string(:alphanumeric, length: 10)
end
def email(s) do
attrs = Map.get(s, :existing)
StreamData.constant(attrs.email)
end
def uid() do
StreamData.string(:alphanumeric, length: 10)
end
def uid(s) do
attrs = Map.get(s, :existing)
StreamData.constant(attrs.uid)
end
def role() do
StreamData.member_of(["admin", "editor", "tester", "support", "user"])
end
def profile() do
StreamData.nonempty(StreamData.map_of(StreamData.constant("lang"), StreamData.string(:ascii)))
end
def attrs() do
Enum.take(
StreamData.fixed_map(%{
first_name: first_name(),
email: email(),
uid: uid(),
role: role(),
profile: profile()
}),
1
)
end
def attrs(s) do
Enum.take(
StreamData.fixed_map(%{
first_name: first_name(),
email: email(s),
uid: uid(),
role: role(),
profile: profile()
}),
1
)
end
# Helpers
def like_email(map, email) do
Enum.any?(
Map.values(map),
fn attrs -> attrs.email == email end
)
end
property "user stateful operations", [:verbose] do
forall cmds <- commands(__MODULE__) do
{history, state, result} = run_commands(__MODULE__, cmds)
(result == :ok)
|> aggregate(command_names(cmds))
|> when_fail(
IO.puts("""
History: #{inspect(history)}
State: #{inspect(state)}
Result: #{inspect(result)}
""")
)
end
end
# initial model value at system start. Should be deterministic.
def initial_state(), do: %{}
def command(state) do
always_possible = [
{:call, UserShim, :create, attrs()}
]
relies_on_state =
case Map.equal?(state, %{}) do
# no values yet
true ->
[]
# values from which to work
false ->
s = state
[
{:call, UserShim, :create_existing, attrs(s)}
]
end
oneof(always_possible ++ relies_on_state)
end
# Picks whether a command should be valid under the current state.
def precondition(s, {:call, _, :create, [attrs | _]}) do
not like_email(s, attrs.email)
end
# - all calls with known emails
def precondition(s, {:call, _mod, _fun, [attrs | _]}) do
like_email(s, attrs.email)
end
# Given the state *prior* to the call {:call, mod, fun, args},
# determine whether the result (coming from the actual system)
# makes sense.
def postcondition(_state, {_, _mod, :create, _args}, {:ok, _}) do
true
end
def postcondition(_state, {_, _mod, :create_existing, _args}, {:error, _}) do
true
end
# Assuming the postcondition for a call was true, update the model
# accordingly for the test to proceed
def next_state(
state,
_,
{:call, _, :create, [attrs]}
) do
Map.put(state, :existing, attrs)
end
def next_state(state, _res, {:call, _mod, _fun, _args}) do
new_state = state
new_state
end
end
defmodule Academy.UserShim do
def create(attrs) do
Academy.User.create(attrs)
end
def create_existing(attrs) do
Academy.User.create(attrs)
end
end