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

# Aggregate

The `aggregate` function is similar to the `collect` function with one simple exception. The `aggregate` function can take a list of categories to store. Let's look at the function in action.

# Code

Let's start off with a basic property that uses the function. Take a look at it in the code below:

%% the plugin itself
{project_plugins, [rebar3_proper]}.

%% The PropEr dependency is still required to compile the test cases,
%% but only as a test dependency
{profiles,
    [{test, [
        {erl_opts, [nowarn_export_all]},
        {deps, [{proper, "1.3.0"}]}
    ]}
]}.


import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

This property’s generator creates a hand of five cards in a list. The list of cards is passed directly to `aggregate`, with no transformations. There may be duplicate cards since nothing keeps the generator from returning something like `{spade, 1}` five times. The function can use these multiple values and generate statistics for the overall set of possible cards.

In terms of distribution, the property tells us all cards can be obtained rather uniformly. This can be done even though multiple cards are drawn in every round.

> Running the command as `rebar3 do proper -c, cover -v` will give coverage analysis to our code. 

Let's look at another interesting case for aggregation. Let's take an example of a case where we are required to gather metrics for various data categories. Let's say we’re analyzing generated text to see if it contains tricky characters. We may want to take the original string, and look at each class of characters we get, according to some categories we define. It would look something like this:

Learn about the aggregate function and how to use it in properties.

Gathering Statistics: Aggregating

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

Gathering Statistics: Aggregating

Aggregate

Code