Gain insights into property-based testing with PropEr in Elixir. Learn foundational principles, custom data generators, and advanced concepts for effective real-world application testing.

Property Based Testing with PropEr in Elixr_468 x 60 copy.png

propert-based-testing.tar.gz

Erlang

Elixer

Erlang-Chap2

Elixir-Chap2

Erlang-Shell

erlang-user

elixir-user

elixir-shell

elrang-eunit

erlang-chap5-employee

elixir-cover_test

erlang-cover_test

erlang-chap10-databaseinit

erlang-chap10-user

elixir-chap10-user

erlang-chap10-shell

elixir-chap10-shell

erlang-chap10-dbsetup

elixir-chap10-dbSetup

erlang-chap5-templating

erlang-chap5-last

elixir-chap5-last

erlang-chap10-default

elixir-chap10-default

elixir-chap10-default-copy

Erlang-Chap2-copy

Elixir-Chap2-copy

Erlang-Shell-copy

elixir-shell-copy

erlang-default-force

elixir-default-force

erlang-test-shell

elxir-test-shell

Property-based testing relies on specifying some property of code, unlike unit tests, which specify the expected output in response to some inputs. In this course, we'll cover the concepts we need to feel confident about using even the most advanced features of PropEr with Elixir.

We'll start with the basic and foundational principles of property-based testing, see what the framework offers us to get started, make our way through thinking in properties, write our own custom data generators, and then learn more advanced concepts. We'll also see how you can use property-based testing in a realistic project.

By the time we finish this course, we should feel comfortable testing real-world applications using properties.

Property-Based Testing with PropEr in Elixir

Which of the following macros is used for shrinking?

Which of the following macros is used for shrinking?

`let_shrink` always takes a list of arguments and generators, whereas `let` takes any pattern and any generator into its first two arguments.

A `let` macro has rules to apply specific transformations.


One of the generators in the list will be used, but without the transformations being applied in the `let_shrink` macro.

Which of the following is a difference between the `let_shrink` macro and the `let` macro?

Which of the following is a difference between the <code>let_shrink</code> macro and the <code>let</code> macro?

The generator provides a list but the property expects atoms.

The property expects a list coming out of the generator, but the generator is providing atoms.

The code should work and the fail cases will provide enough information about the problem.

In the following property, a list of servings for a meal is generated. If any serving contains dairy, the property fails. The property and generator are as follows:

```elixir
property "dairy" do
 forall food <- meal() do
 dairy_count(food) == 0
 end
end

defp dairy_count(list) do
 Enum.count(list, &is_dairy/1)
end

defp is_dairy(:cheesesticks), do: true
defp is_dairy(:lasagna), do: true
defp is_dairy(:icecream), do: true
defp is_dairy(:milk), do: true
defp is_dairy(_), do: false

def meal() do
 let_shrink([
 appetizer <- elements([:soup, :salad, :cheesesticks]),
 drink <- elements([:coffee, :tea, :milk, :water, :juice]),
 entree <- elements([:lasagna, :tofu, :steak]),
 dessert <- elements([:cake, :chocolate, :icecream])
 ]) do
 [appetizer, drink, entree, dessert]
 end
end
```

Whenever the test case fails, we receive a result set containing four courses. What is a possible problem?

In the following property, a list of servings for a meal is generated. If any serving contains dairy, the property fails. The property and generator are as follows:
<pre><code class="language-elixir">property &quot;dairy&quot; do
 forall food &lt;- meal() do
 dairy_count(food) == 0
 end
end

defp dairy_count(list) do
 Enum.count(list, &amp;is_dairy/1)
end

defp is_dairy(:cheesesticks), do: true
defp is_dairy(:lasagna), do: true
defp is_dairy(:icecream), do: true
defp is_dairy(:milk), do: true
defp is_dairy(_), do: false

def meal() do
 let_shrink([
 appetizer &lt;- elements([:soup, :salad, :cheesesticks]),
 drink &lt;- elements([:coffee, :tea, :milk, :water, :juice]),
 entree &lt;- elements([:lasagna, :tofu, :steak]),
 dessert &lt;- elements([:cake, :chocolate, :icecream])
 ]) do
 [appetizer, drink, entree, dessert]
 end
end
</code></pre>
Whenever the test case fails, we receive a result set containing four courses. What is a possible problem?

Solve a short quiz to test your understanding of the concepts of shrinking.

Foundations of Property-Based Testing

Writing Properties

Thinking in Properties

Custom Generators

Responsible Testing

Properties-Driven Development

Shrinking

Stateful Properties

Case Study: Bookstore

State Machine Properties

Conclusion

Quiz Yourself on Shrinking