Skip to main content
Python Software Foundation 20th Year Anniversary Fundraiser  Donate today!

Integration of fauxfactory into pytest.

Project description

pytest-fauxfactory

https://img.shields.io/pypi/v/pytest-fauxfactory.svg https://img.shields.io/pypi/l/pytest-fauxfactory.svg https://img.shields.io/pypi/pyversions/pytest-fauxfactory.svg https://travis-ci.org/omaciel/pytest-fauxfactory.svg?branch=master

pytest-fauxfactory is a Pytest plugin that helps you pass random data to your automated tests, leveraging the power of FauxFactory https://github.com/omaciel/fauxfactory.

Features

pytest-fauxfactory let’s you create parameterized automated tests, providing:

  • Randomically generated strings via FauxFactory
  • Allowing you to provide a callable method to return the type and number of data items to be used by your tests
  • Allowing you to provide a generator method to return the type and number of data items to be used by your tests

Installation

$ pip install pytest-fauxfactory

Usage Examples

Generating Random Strings: faux_string

Let’s say you need to generate a random string value (identified as author) for a test

@pytest.mark.faux_string()
def test_generate_alpha_strings(author):
    assert author

The allowed types of strings that can be generated are:

  • ‘alpha’
  • ‘alphanumeric’
  • ‘cjk’
  • ‘html’
  • ‘latin1’
  • ‘numeric’
  • ‘utf8’
  • ‘punctuation

Using the faux_string mark without any arguments will generate a single random string for your test.

test_generate_alpha_strings[faux_string_0] PASSED

Suppose you want to generate 4 random alpha strings (identified as book) for a test:

@pytest.mark.faux_string(4, 'alpha')
def test_generate_alpha_strings(book):
    assert book.isalpha()

You will then have 4 tests, each with different values:

test_generate_alpha_strings[faux_string_0] PASSED
test_generate_alpha_strings[faux_string_1] PASSED
test_generate_alpha_strings[faux_string_2] PASSED
test_generate_alpha_strings[faux_string_3] PASSED

Now, suppose you also want to make sure that all strings have exactly 43 characters:

@pytest.mark.faux_string(4, 'alpha', length=43)
def test_generate_alpha_strings(value):
    assert len(value) == 43

Additionally, you can run tests with different string lengths by passing in a list of lengths:

@pytest.mark.faux_string(4, 'alpha', length=[5, 15])
def test_gen_alpha_string_with_variable_length(value):
    """Generate an `alpha` string of length of either 5 or 15."""
    assert len(value) == 5 or len(value) == 15

This will generate 4 new tests

tests/test_faux_string.py::test_gen_alpha_string_with_variable_length[faux_string_0] PASSED                                                                                                                                          [ 91%]
tests/test_faux_string.py::test_gen_alpha_string_with_variable_length[faux_string_1] PASSED                                                                                                                                [ 92%]
tests/test_faux_string.py::test_gen_alpha_string_with_variable_length[faux_string_2] PASSED                                                                                                                                          [ 93%]
tests/test_faux_string.py::test_gen_alpha_string_with_variable_length[faux_string_3] PASSED

Similarly, you can run tests with different string types by passing in a list of types:

@pytest.mark.faux_string(4, ['alpha', 'alphanumeric'], length=[5, 10])
def test_gen_alpha_string_with_variable_types(value):
    """Generate alpha strings with length 5, alphanumeric with length 10."""
    if len(value) == 5:
        assert not contains_number(value)
    else:
        assert contains_number(value)

This will generate 4 new tests

tests/test_faux_string.py::test_gen_alpha_string_with_variable_types[faux_string_0] PASSED                                                                                                                                           [ 96%]
tests/test_faux_string.py::test_gen_alpha_string_with_variable_types[faux_string_1] PASSED                                                                                                                                      [ 97%]
tests/test_faux_string.py::test_gen_alpha_string_with_variable_types[faux_string_2] PASSED                                                                                                                                           [ 98%]
tests/test_faux_string.py::test_gen_alpha_string_with_variable_types[faux_string_3] PASSED

Using Custom Functions: faux_callable

Now imagine that you have a custom function that generates values of any type instead of the default types used by faux_string. Using fauxfactory.gen_integer for example:

import fauxfactory
import pytest

@pytest.mark.faux_callable(4, fauxfactory.gen_integer)
def test_callable_generate_integers(value):
    """Test function that return generated integer"""
    assert isinstance(value, int)

This will generate 4 new tests

tests/test_pytest_fauxfactory.py::test_generate_integers[faux_callable_0] PASSED
tests/test_pytest_fauxfactory.py::test_generate_integers[faux_callable_1] PASSED
tests/test_pytest_fauxfactory.py::test_generate_integers[faux_callable_2] PASSED
tests/test_pytest_fauxfactory.py::test_generate_integers[faux_callable_3] PASSED

faux_callable can also transfer arguments to the callable function:

import fauxfactory
import pytest

@pytest.mark.faux_callable(4, fauxfactory.gen_integer, min_value=0,
                           max_value=100)
def test_callable_generate_integers(value):
    """Test function that return generated integer with kwargs"""
    assert isinstance(value, int)
    assert 0 <= value <= 100

This will generate 4 new tests

tests/test_pytest_fauxfactory.py::test_generate_integers[faux_callable_0] PASSED
tests/test_pytest_fauxfactory.py::test_generate_integers[faux_callable_1] PASSED
tests/test_pytest_fauxfactory.py::test_generate_integers[faux_callable_2] PASSED
tests/test_pytest_fauxfactory.py::test_generate_integers[faux_callable_3] PASSED

Of course the generated values can be of any type! For example, let’s generate values as a tuple of alpha strings:

import fauxfactory
import pytest

def generate_alpha_strings(number=1, length=10):
    """function that return a tuple of generated alpha string"""
    return tuple(fauxfactory.gen_alpha(length=length) for _ in range(number))

@pytest.mark.faux_callable(5, generate_alpha_strings, number=3, length=12)
def test_callable_generate_from_custom_function(value):
    """Test generic function that return a tuple of generated strings"""
    assert isinstance(value, tuple)
    assert len(value) == 3
    # unpack
    location, organization, cv = value
    for str_alpha in (location, organization, cv):
        assert len(str_alpha) == 12
        assert location != organization
        assert location != cv

This will generate 5 new tests

tests/test_pytest_fauxfactory.py::test_generate_from_custom_function[faux_callable_0] PASSED
tests/test_pytest_fauxfactory.py::test_generate_from_custom_function[faux_callable_1] PASSED
tests/test_pytest_fauxfactory.py::test_generate_from_custom_function[faux_callable_2] PASSED
tests/test_pytest_fauxfactory.py::test_generate_from_custom_function[faux_callable_3] PASSED
tests/test_pytest_fauxfactory.py::test_generate_from_custom_function[faux_callable_4] PASSED

Let’s now generate values from a custom function that returns a dictionary:

import fauxfactory
import pytest

def generate_person():
    """Generate a random person record."""
    return {
        'name': fauxfactory.gen_alpha(length=12),
        'age': fauxfactory.gen_integer(min_value=12, max_value=100)
    }

@pytest.mark.faux_callable(3, generate_person)
def test_callable_generate_person(value):
    """Test generic function that return a dict"""
    assert isinstance(value, dict)
    assert 'name' in value
    assert 'age' in value
    assert len(value['name']) == 12
    assert 12 <= value['age'] <= 100

This will generate 5 new tests

tests/test_pytest_fauxfactory.py::test_generate_person[faux_callable_0] PASSED
tests/test_pytest_fauxfactory.py::test_generate_person[faux_callable_1] PASSED
tests/test_pytest_fauxfactory.py::test_generate_person[faux_callable_2] PASSED

Using Generators: faux_generator

Now instead of using a callable function, we want to generate tests with values of any types from a generator function or generator expression. For this purpose we can use the “faux_generator” mark:

def alpha_strings_generator(items=1, length=10):
    """Generate alpha string value at each iteration."""
    for _ in range(items):
        yield fauxfactory.gen_alpha(length=length)


@pytest.mark.faux_generator(alpha_strings_generator(items=3, length=12))
def test_generator_alpha_strings(value):
    """Test function generator with kwargs."""
    assert len(value) == 12

This will generate 3 new tests

tests/test_pytest_fauxfactory.py::test_generator_alpha_strings[faux_generator_0] PASSED
tests/test_pytest_fauxfactory.py::test_generator_alpha_strings[faux_generator_1] PASSED
tests/test_pytest_fauxfactory.py::test_generator_alpha_strings[faux_generator_2] PASSED

We can also use a generator expression:

list_of_integers = [fauxfactory.gen_integer(min_value=0) for _ in range(4)]


@pytest.mark.faux_generator(int_val for int_val in list_of_integers)
def test_generator_expression(value):
    """Test generator expression."""
    assert isinstance(value, int)
    assert value >= 0

This will generate 4 tests

tests/test_pytest_fauxfactory.py::test_generator_expression[faux_generator_0] PASSED
tests/test_pytest_fauxfactory.py::test_generator_expression[faux_generator_1] PASSED
tests/test_pytest_fauxfactory.py::test_generator_expression[faux_generator_2] PASSED
tests/test_pytest_fauxfactory.py::test_generator_expression[faux_generator_3] PASSED

Of course the returned values can be of any type:

def foo_generator():
    """Returns different values: first, a string 'foo'; second iteration, a
    list of integers."""
    yield 'foo'
    yield [1, 2, 3]


@pytest.mark.faux_generator(foo_generator())
def test_generator_foo_generator(value):
    """Test diffrent type values."""
    if isinstance(value, list):
        assert value == [1, 2, 3]
    else:
        assert value == 'foo'

This will generate 2 tests

tests/test_pytest_fauxfactory.py::test_generator_foo_generator[faux_generator_0] PASSED
tests/test_pytest_fauxfactory.py::test_generator_foo_generator[faux_generator_1] PASSED

We can also combine all the above generators:

@pytest.mark.faux_generator(
    alpha_strings_generator(items=3, length=12),
    (int_val for int_val in list_of_integers),
    foo_generator()
)
def test_generator_combined(value):
    """Test combined generators."""
    if isinstance(value, list):
        assert value == [1, 2, 3]
    elif isinstance(value, int):
        assert value >= 0
    else:
        assert value.isalpha()

This will generate 9 tests

tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_0] PASSED
tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_1] PASSED
tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_2] PASSED
tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_3] PASSED
tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_4] PASSED
tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_5] PASSED
tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_6] PASSED
tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_7] PASSED
tests/test_pytest_fauxfactory.py::test_generator_combined[faux_generator_8] PASSED

Documentation

Documentation is in the works but we would love to get help from the community!

Authors

pytest-fauxfactory is written and maintained by Og Maciel and various contributors.

Development Lead

Contributors

  • Djebran Lezzoum @ldjebran https://github.com/ldjebran
  • Milan Falešník @mfalesni https://github.com/mfalesni

Release History

1.1.0 (2017-12-06)

  • Renamed gen_string mark to faux_string with extended capabilities
  • Added new faux_callable and faux_generator marks
  • Updated README file to include usable examples

1.0.1 (2017-10-18)

  • First release as a Pytest plugin exposing a gen_string mark
  • Tests can be decorated with new mark to generate random strings as parameters

1.0.0 (2017-12-06)

  • First release.

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for pytest-fauxfactory, version 1.1.0
Filename, size File type Python version Upload date Hashes
Filename, size pytest_fauxfactory-1.1.0-py3-none-any.whl (11.5 kB) File type Wheel Python version py3 Upload date Hashes View
Filename, size pytest-fauxfactory-1.1.0.tar.gz (8.3 kB) File type Source Python version None Upload date Hashes View

Supported by

AWS AWS Cloud computing Datadog Datadog Monitoring DigiCert DigiCert EV certificate Facebook / Instagram Facebook / Instagram PSF Sponsor Fastly Fastly CDN Google Google Object Storage and Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Salesforce Salesforce PSF Sponsor Sentry Sentry Error logging StatusPage StatusPage Status page