Gain insights into property-based testing with PropEr in Erlang. Delve into foundational principles, common frameworks, custom data generators, and applying testing in realistic projects for robust code validation.

Property Based Testing with PropEr in Erlang_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, rather than unit tests which specify the expected output in response to some inputs. In this course, you’ll cover the concepts you need to get started, up to the point where you feel confident enough to use the most advanced features of PropEr with Erlang.

You’ll start smoothly with the basic and foundational principles of property-based testing. From there, you will cover some of the common frameworks, how to think in properties, how to write your own custom data generators, and more. You'll also see how you can use Property-Based Testing in a realistic project.

By the time you finish this course, you will be comfortable testing real-world applications using properties.

Property-Based Testing with PropEr in Erlang


# Limitations of targeted properties

Targeted properties do not allow all the same facilities as we’d get with regular properties. They don’t work well with recursive generators, whether we use `?LAZY` or not. Using that combination may yield infinite loops. In those cases, it is best to stick to rather straightforward combinations of default generators.

They also don’t allow the gathering of statistics and metrics using `collect/2` and `aggregate/2`, so any validation and accounting that needs to be done will have to be done by hand, through regular output and other side effects. 


## Search macros
These limitations are due to an implementation detail of targeted properties. Targeted properties are in fact a special variation of a feature called search macros. There are two of them:

1. `?EXISTS(Var, Generator, Expression)`has arguments that are similar to those in `?FORALL`. However, this macro will succeed as soon as `Expression` returns `true` once, and will otherwise fail if it is allowed to run all of its executions while only returning false.
2. `?NOT_EXISTS(Var, Generator, Expression)` is the opposite of `?EXISTS`. It only succeeds if all executions run to completion while returning `false`.


Search macros allow us to add further search and validation to an existing property by embedding them inside the property. For example, if a company is doing video streaming or IoT data reporting, it may want to test a client that has multiple possible endpoints to contact based on arbitrary failures. In such a case, it may not just want a property that always passes, but one that just eventually works. It doesn’t matter if it fails fifty times, as long as at some point it does pass once.

We could, for example, illustrate the retry logic we just described with the following pseudocode:

```erlang
prop_retry() ->
    ?FORALL({Data, Config}, {term(), environment_generator()},
    begin 
        cause_some_server_failures(Config), 
        ?EXISTS(IP, pick_server(Config),
            is_successful(request(IP, Data))) 
    end).
```


In this pseudocode, it doesn’t matter if all but one of the servers fail, as long as eventually the right server is picked and things pass.

Targeted properties were initially added to these search macros before being generalized with the `?FORALL_TARGETED` mechanism. In fact, `FORALL_TARGETED(Pattern, Generator, Property)` is implemented roughly as `?NOT_EXISTS(Pattern, Generator, not(Property))`.

Regardless of their limitations, targeted properties can prove to be very interesting and useful.

Understand the limitations of targeted properties. 

Limitations of Targeted Properties

Understand the limitations of targeted properties.

Foundations of Property-Based Testing

Writing Properties

Thinking in Properties

Custom Generators

Responsible Testing

Properties-Driven Development

Shrinking

Targeted Properties

Stateful Properties

Case Study: Bookstore

State Machine Properties

Conclusion

Limitations of Targeted Properties

Limitations of targeted properties