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

# General property structure
A property has 3 parts for both Erlang and Elixir:
1. Type generator
2. Instance of type
3. Property expression

The generator functions help the date enter into the `type_generator` position. The framework will take these generators, execute them, and turn them into actual data, which will then be bound to the `instance_of_type` variable. This variable is then made available within `property_expression`, a piece of arbitrary code that must return true if the test is to pass or false if it fails. Since `property_expression` is a single expression, we’ll frequently see `begin ... end` blocks used in that area to wrap more complex sequences of expressions into a single one. 


# Property 

Let’s take a look at the `property "some description"` property. Standing out is the `forall` Erlang macro, which has been imported through the module attribute from the property in the last lesson. The macro has this form:

```elixir
property "some description" do
  forall instance_of_type <- type_generator do
    property_expression
  end 
end

```

We can translate the `forall` macro:

```psuedocode
proper:forall(TypeGenerator, fun(InstanceOfType) -> PropertyExpression end).
```

Since all property-based testing frameworks implement the `forall` macro interface, we’ll use that format to make sure everyone feels at home.

Learn how property structure works to make writing properties easier.

Property Structure

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

Property Structure

General property structure