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

# Abstract phase

PropEr divides the execution of a finite state machine test into two phases, one abstract and one real. The abstract phase is used to create a test scenario using the model and command generation callbacks to build out the sequence of calls that will later be applied to the system.

A graphical representation might look like this: 

The two big conceptual changes from stateful properties are in the initial state, which now use both `initial_state` and `initial_state_data`, and an optional `weight` callback. Once the initial state and data are generated, the `StateName` callback is called, along with the optional `weight` function, to generate the next state transition and symbolic call to run.

That symbolic call is then passed, along with the data, to a `precondition` callback, which determines whether the call is valid or not. If the validation fails, PropEr tries again with a new generated command and state. Once a suitable command is found, the FSM generation moves forward.

The `next_state_data` function takes the command and the current state and has to return a new data structure. Then the whole process is repeated over and over until PropEr decides it has enough commands. 

# Real phase

Once a full sequence of commands is generated, PropEr will start applying them against the real system. This is what that looks like graphically:

Understand the execution model of FSM properties in both the abstract and real phases. 

How State Machine Properties Run

Understand the execution model of FSM properties in both the abstract and real phases.

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

How State Machine Properties Run

Abstract phase