Generator¶

Installation¶

pip install test-generator

Introduction¶

Have you ever written tests that loop through a list of inputs to validate the functionality?

Something like?

from mything import thingy

class MyTestCase(unittest.TestCase):
    def test_thingy(self):
        for input in [
            'a',
            'b',
            'cccc',
            'ddd'
            'eeeeee',
            'f',
            'g'
        ]:
            self.assertTrue(thingy(input))

But running in a loop limits all the functionality in TestCase like per- test setUp or tearDown. It also fails on the first input and you can’t run a single test input, you have to run them all? (Doesn’t work well when each test is more complicated than this toy case).

Instead, what if you wrote your test like:

from generator import generator, generate
from mything import thingy

@generator
class MyTestCase(unittest.TestCase):

    @generate('a', 'b', 'cccc', 'ddd', 'eeeeee', 'f', 'g')
    def test_thingy(self, input):
        self.assertTrue(thingy(input))

And when you run your tests, you see:

----------------------------------------------------------------------
Ran 7 tests in 0.001s

OK

Generator gives you simple decorators to mulitply your test methods based on an argument list. It’s great for checking a range of inputs, a list of error conditions or expected status codes.

Examples¶

import mock
from generator import generator, generate
from example import client, APIError

@generator
class TestAPIErrorHandling(unittest.TestCase):

    @generate(400, 401, 403, 404, 500, 502, 503)
    def test_error(self, status_code):
        with mock.patch(client, '_request') as _request_stub:
            _request_stub.return_value.status_code = status_code

            self.assertRaises(APIError):
                client.get('/path/')

from generator import generator, generate
from example.sanitize import strip_tags

@generator
class TestStripTags(unittest.TestCase):

    @generate(
        ('<h1>hi</h1>', 'hi'),
        ('<script></script>something', 'something'),
        ('<div class="important"><p>some text</p></div>', 'some text'),
    )
    def test_strip_tags(self, input, expected):
        self.assertEqual(strip_tags(input), expected)

Decorator¶

import unittest
from generator import generate, generator


@generator
class MyTestCase(unittest.TestCase):

    @generate(1, 2, 3):
    def test_is_positive(self, value):
        self.assertGreater(value, 0)

Mixin¶

import unittest
from generator import generate, GeneratorMixin


class MyTestCase(GeneratorMixin, unittest.TestCase):

    @generate(1, 2, 3):
    def test_is_positive(self, value):
        self.assertGreater(value, 0)


class AnotherMyTestCase(MyTestCase):

    @generate(1, 3, 5):
    def test_is_odd(self, value):
        self.assertTrue(value % 2)

Types of Contributions¶

Get Started!¶

Ready to contribute? Here’s how to set up generator for local development.

1. Fork the generator repo on GitHub.

2. Clone your fork locally:

   $ git clone git@github.com:your_name_here/generator.git
   

3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development:

   $ mkvirtualenv generator
   $ cd generator/
   $ python setup.py develop
   

4. Create a branch for local development:

   $ git checkout -b name-of-your-bugfix-or-feature
   

   Now you can make your changes locally.

5. When you’re done making changes, check that your changes pass flake8 and the tests, including testing other Python versions with tox:

   $ flake8 generator tests
   $ python setup.py test
   $ tox
   

   To get flake8 and tox, just pip install them into your virtualenv.

6. Commit your changes and push your branch to GitHub:

   $ git add .
   $ git commit -m "Your detailed description of your changes."
   $ git push origin name-of-your-bugfix-or-feature
   

7. Submit a pull request through the GitHub website.

Pull Request Guidelines¶

Before you submit a pull request, check that it meets these guidelines:

1. The pull request should include tests.
2. If the pull request adds functionality, the docs should be updated. Put your new functionality into a function with a docstring, and add the feature to the list in README.rst.
3. The pull request should work for Python 2.6, 2.7, 3.3, and 3.4, and for PyPy. Check https://travis-ci.org/kevinastone/generator/pull_requests and make sure that the tests pass for all supported Python versions.

Tips¶

To run a subset of tests:

$ python -m unittest tests.test_generator

Development Lead¶

• Kevin Stone <kevinastone@gmail.com>

Contributors¶

None yet. Why not be the first?