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

# Getting started

Since we have a fairly large stateful system to validate, we should start by figuring out what data the system should accept, and what is valid and invalid. This is useful because it sets a baseline for expectations on which to build. It can also hint at useful paths or strategies moving forward. We’ve got a basic idea about the shape of data based on our database schema.

# The generators

We'll have a total of three generators for the initial testing of the application. They are as follows:

- Title.
- Author.
- The ISBN, or International Standard Book Number, is a series of ten or thirteen digits that uniquely identify every book published. 

Let's take a look at these generators. 

```elixir
def title() do
    let s <- utf8() do
      elements([s, String.to_charlist(s)])
    end 
  end

  def author() do
    let s <- utf8() do
      elements([s, String.to_charlist(s)])
    end 
  end

def isbn() do
  let isbn <- [
        oneof(['978', '979']),
        let(x <- range(0, 9999), do: to_charlist(x)),
        let(x <- range(0, 9999), do: to_charlist(x)),
        let(x <- range(0, 999), do: to_charlist(x)),
        frequency([{10, [range(?0, ?9)]}, {1, 'X'}])
      ] do
    to_string(Enum.join(isbn, "-"))
  end
end
```

Since this is Elixir, and given that the virtual machine has no dedicated string types, both generators will create either multiple lists of characters (`string()`) or binaries of the same text encoded as UTF-8. This will let us check out whether the entire stack can support both types for the `author` and `title` generators. 

For the `isbn` generator we don’t really care about their text formatting and will assume some other part of the system would test, validate, and normalize them. Instead, we use a more random generator that lets us focus on state transitions for the stateful model.

Now let's test the generators to see if they work.


Take a look at the basic generators required to test the system. 

Writing Generators

Take a look at the basic generators required to test the system.

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

Writing Generators

Getting started