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

# Shrinking

A critical component of property-based testing is **shrinking**. Shrinking is the mechanism by which a property-based testing framework can be told how to simplify failure cases enough to let us figure out exactly what the minimal reproducible case is. While finding complex obtuse cases is worthwhile, being able to reduce failing inputs to a simple counterexample truly is the killer feature.

But there are some cases where PropEr can’t do what we need. Either it can’t shrink large data structures well enough to be understandable, or it’s not shrinking them the way we want it to. In this chapter, learn about  two different macros to help us handle things:
1. `?SHRINK` 
2. `LETSHRINK` 

These macros help us give the framework hints about what we want it to do. But first, we have to see how shrinking works at a high level.

# How shrinking works

In general, we can think of shrinking as the framework attempting to bring the data generator closer to its own zero-point, and successfully doing so as long as the property fails. Zero for a generator is somewhat arbitrary, but if we play with the default generators a bit by calling `proper_gen:sampleshrink` on them in the shell, notice the following:


- A number tends to shrink from floating-point values toward integers, and integers tend to shrink toward the number 0.
- Binaries tend to shrink from things full of bytes toward the empty binary.
- Lists tend to shrink toward the empty list.
- Elements (`[A,B,C]`) will shrink toward the value `A`.

In short, data structures that contain other data tend to empty themselves, and other values try to find a neutral point. The nice aspect of this is that as custom generators are built from other generators, the shrinking is inherited, and a custom generator may get its own shrinking for free: a map full of people records made of strings and numbers will see the strings get shorter and simpler, the numbers will get closer to zero, and the map will get fewer and fewer elements until only the components essential to trigger a failure are left.

In short, data structures that contain other data tend to empty themselves, and other values try to find a neutral point. The nice aspect of this is that as custom generators are built from other generators, the shrinking is inherited, and a custom generator can get its own shrinking for free. For example, a map full of people’s records made of strings and numbers will see the strings get shorter and simpler, the numbers will get closer to zero, and the map will retain fewer and fewer elements until only the components essential to trigger a failure are left.

These cases, even if they are rare, require the `?SHRINK` macro. 


Get introduced to shrinking and the basic concepts of how to manipulate the process in PropEr. 

Introduction to Shrinking

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

Introduction to Shrinking

Shrinking