Metadata-Version: 1.1
Name: pytest-fauxfactory
Version: 1.1.0
Summary: Integration of fauxfactory into pytest.
Home-page: https://github.com/omaciel/pytest-fauxfactory
Author: Og Maciel
Author-email: omaciel@ogmaciel.com
License: GPLv3
Description-Content-Type: UNKNOWN
Description: pytest-fauxfactory
        ==================
        
        .. image:: https://img.shields.io/pypi/v/pytest-fauxfactory.svg
            :target: https://pypi.python.org/pypi/pytest-fauxfactory
        
        .. image:: https://img.shields.io/pypi/l/pytest-fauxfactory.svg
            :target: https://pypi.python.org/pypi/pytest-fauxfactory
        
        .. image:: https://img.shields.io/pypi/pyversions/pytest-fauxfactory.svg
            :target: https://pypi.python.org/pypi/pytest-fauxfactory
        
        .. image:: https://travis-ci.org/omaciel/pytest-fauxfactory.svg?branch=master
            :target: https://travis-ci.org/omaciel/pytest-fauxfactory
        
        ---------------
        
        **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
        
        .. code-block:: python
        
            @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:
        
        .. code-block:: python
        
            @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:
        
        .. code-block:: python
        
            @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:
        
        .. code-block:: python
        
            @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:
        
        .. code-block:: python
        
            @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:
        
        .. code-block:: python
        
            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:
        
        .. code-block:: python
        
            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:
        
        .. code-block:: python
        
            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:
        
        .. code-block:: python
        
            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:
        
        
        .. code-block:: python
        
            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:
        
        .. code-block:: python
        
            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:
        
        
        .. code-block:: python
        
            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:
        
        .. code-block:: python
        
            @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
        ----------------
        
        - Og Maciel `@omaciel <https://github.com/omaciel/>`_
        
        Contributors
        ------------
        
        - Djebran Lezzoum `@ldjebran https://github.com/ldjebran`
        - Milan Falešník `@mfalesni https://github.com/mfalesni`
        
        
        .. :changelog:
        
        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.
        
Keywords: pytest
Platform: UNKNOWN
Classifier: Topic :: Utilities
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Topic :: Software Development :: Testing
