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

# What are symmetric properties?
From time to time, we may find it difficult to discern what components depend on each other to succeed. Two bits of code may perform opposite actions, such as an encoder and a decoder. We need the encoder to test the decoder, and the decoder to test the encoder. In other cases, we may have a chain of operations that could be made reversible: 

- Editing text and undoing changes, 
- Translating text from French to English to Spanish and back to French. 
- Passing a message across multiple servers until it’s back to its original one. 
- Allowing a character in a game to walk in every direction until it makes its way back to its origin.

Whenever we have a reversible sequence of actions that we can assemble, we can write one of the most concise types of properties: **symmetric properties**. 

The trick with symmetric properties is that we have to test all of the moving parts at once. If one action is the opposite of the other, then applying both operations should yield the initial input as its final output. We pass in some data, apply the reversible sequence of operations, and check that we get the initial data back. If it’s the same, then all the parts must fit well together. 

So we can say that symmetric properties are tests that perform a reversible action and check if the input and output are equal to test all of the functions used. 

# Example

Let’s say we have a piece of code that does encoding and decoding. We could write the following property for it:

```elixir
property "symmetric encoding/decoding" do
    forall data <- list({atom(), any()}) do
        data == decode(encoded)
    end
end
```

This property demonstrates that a list of key and value pairs can go around encoding and decoding without changing, showing that our encoding and decoding mechanisms are stable and lossless. If we subscribe to the test-driven development’s approach of “make the test pass simply and then refactor,” then we know that we'll be able to defeat this test by writing an implementation like this one:

```elixir
def encode(t), do: t 
def decode(t), do: t
```

The property will pass all the time. The problem is that while the chosen property is useful, it isn’t sufficient enough on its own to be a good test of encoding and decoding. It checks that the encoding and decoding together don’t lose any information, but we don’t have anything to check that data actually gets encoded at all. Let's look at an additional property of encoding that can be added to the same test.

Learn the concepts of symmetric properties and learn to write them with ease. 

Symmetric Properties

Learn the concepts of symmetric properties and learn to write them with ease.

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

Symmetric Properties

What are symmetric properties?