Asked  6 Months ago    Answers:  5   Viewed   39 times

I have some kind of test data and want to create a unit test for each item. My first idea was to do it like this:

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequence(unittest.TestCase):
    def testsample(self):
        for name, a,b in l:
            print "test", name

if __name__ == '__main__':

The downside of this is that it handles all data in one test. I would like to generate one test for each item on the fly. Any suggestions?



This is called "parametrization".

There are several tools that support this approach. E.g.:

  • pytest's decorator
  • parameterized

The resulting code looks like this:

from parameterized import parameterized

class TestSequence(unittest.TestCase):
        ["foo", "a", "a",],
        ["bar", "a", "b"],
        ["lee", "b", "b"],
    def test_sequence(self, name, a, b):

Which will generate the tests:

test_sequence_0_foo (__main__.TestSequence) ... ok
test_sequence_1_bar (__main__.TestSequence) ... FAIL
test_sequence_2_lee (__main__.TestSequence) ... ok

FAIL: test_sequence_1_bar (__main__.TestSequence)
Traceback (most recent call last):
  File "/usr/local/lib/python2.7/site-packages/parameterized/", line 233, in <lambda>
    standalone_func = lambda *a: func(*(a + p.args), **p.kwargs)
  File "", line 12, in test_sequence
AssertionError: 'a' != 'b'

For historical reasons I'll leave the original answer circa 2008):

I use something like this:

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequense(unittest.TestCase):

def test_generator(a, b):
    def test(self):
    return test

if __name__ == '__main__':
    for t in l:
        test_name = 'test_%s' % t[0]
        test = test_generator(t[1], t[2])
        setattr(TestSequense, test_name, test)
Tuesday, June 1, 2021
answered 6 Months ago

edit: This answer works, but nowadays you should just use the requests library as mentioned by other answers below.

Use httplib.

>>> import httplib
>>> conn = httplib.HTTPConnection("")
>>> conn.request("HEAD", "/index.html")
>>> res = conn.getresponse()
>>> print res.status, res.reason
200 OK
>>> print res.getheaders()
[('content-length', '0'), ('expires', '-1'), ('server', 'gws'), ('cache-control', 'private, max-age=0'), ('date', 'Sat, 20 Sep 2008 06:43:36 GMT'), ('content-type', 'text/html; charset=ISO-8859-1')]

There's also a getheader(name) to get a specific header.

Tuesday, June 1, 2021
answered 6 Months ago

Ellipsis, or ... is not a hidden feature, it's just a constant. It's quite different to, say, javascript ES6 where it's a part of the language syntax. No builtin class or Python language constuct makes use of it.

So the syntax for it depends entirely on you, or someone else, having written code to understand it.

Numpy uses it, as stated in the documentation. Some examples here.

In your own class, you'd use it like this:

>>> class TestEllipsis(object):
...     def __getitem__(self, item):
...         if item is Ellipsis:
...             return "Returning all items"
...         else:
...             return "return %r items" % item
>>> x = TestEllipsis()
>>> print x[2]
return 2 items
>>> print x[...]
Returning all items

Of course, there is the python documentation, and language reference. But those aren't very helpful.

Sunday, June 6, 2021
answered 6 Months ago

When you are using the patch decorator from the unittest.mock package you are not patching the namespace the module is imported from (in this case app.my_module.get_user_name) you are patching it in the namespace under test app.mocking.get_user_name.

To do the above with Mock try something like the below:

from mock import patch
from app.mocking import test_method 

class MockingTestTestCase(unittest.TestCase):

    def test_mock_stubs(self, test_patch):
        test_patch.return_value = 'Mocked This Silly'
        ret = test_method()
        self.assertEqual(ret, 'Mocked This Silly')

The standard library documentation includes a useful section describing this.

Wednesday, June 9, 2021
answered 6 Months ago

Make a subclass of the abstract class, then test the subclass.

from abc import ABCMeta, abstractmethod

class ThisIsAnAbstractClass(object):
    __metaclass__ = ABCMeta # <--

    def __init__(self, parameter):
        self.parameter = parameter

    def do_something():
        """do something"""

class ConcreteClass(ThisIsAnAbstractClass):
    def __init__(self, parameter):
        super(ConcreteClass, self).__init__(parameter)

    assert False, 'Abstract class instance created!'
except TypeError:

assert ConcreteClass('test').parameter == 'test'

NOTE: You should use abc.ABCMeta as a metaclass.

Saturday, November 20, 2021
answered 1 Week ago
Only authorized users can answer the question. Please sign in first, or register a free account.
Not the answer you're looking for? Browse other questions tagged :