Construye una salida PyUnit espectáculo para toda aserción

Question

¿Cómo puedo hacer unittest módulo de programa de salida del pitón para cada afirmación, en lugar de fallar en la primera uno por caso de prueba? Sería mucho más fácil de depurar si podía ver el patrón completo de los fallos en lugar de sólo la primera.

En mi caso, las afirmaciones se basan en un par bucles a través de una matriz que contiene un objeto además de algunos nombres de funciones y la salida esperada (véase más adelante), por lo que no es una forma obvia (al menos para mí) a apenas separada toda afirmación en un TestCase separada:

import unittest
import get_nodes

class mytest2(unittest.TestCase):
    def testfoo(self):
        root = get_nodes.mmnode_plus.factory('mytree.xml')

        tests = [
            (root, {'skip_traversal': False, 'skip_as_child': True, 'skip_as_parent': False, 'is_leaf': False}),
            (root[0], {'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': False, 'is_leaf': False}),
            (root[1], {'skip_traversal': True, 'skip_as_child': True, 'skip_as_parent': True}),
            (root[1][0], {'skip_traversal': True}),
            (root[0][0], {'is_leaf': False, 'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': False}),
            (root[0][0][0], {'is_leaf': True, 'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': True}),
            (root[0][4], {'skip_traversal': True, 'skip_as_child': True, 'skip_as_parent': True}),
            (root[0][7], {'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': True}),
        ]       

        for (node, states) in tests:
            for test_state, exp_result in states.iteritems():
                self.assertEqual(node.__getattribute__(test_state)(), exp_result, "unexpected %s for state %s of node %s %s" % (not exp_result, test_state, repr(node), repr(node.__dict__)))

unittest.main()

Los rendimientos obj.__getattribute__('hello') obj.hello por lo node.__getattribute__(test_state)() es mi forma de llamar a la función de miembro del nodo cuyo nombre se almacena en la variable test_state.

Answer 1

yo era capaz de hacerlo al hacer nuevas clases TestCase dinámicamente utilizando el tipo interno () fábrica:

root = get_nodes.mmnode_plus.factory('somenodes.xml')

tests = [
    (root, {'skip_traversal': False, 'skip_as_child': True, 'skip_as_parent': False, 'is_leaf': False}),
    (root[0], {'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': False, 'is_leaf': False}),
    (root[1], {'skip_traversal': True, 'skip_as_child': True, 'skip_as_parent': True}),
    (root[1][0], {'skip_traversal': True}),
    (root[0][0], {'is_leaf': False, 'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': False}),
    (root[0][0][0], {'is_leaf': True, 'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': True}),
    (root[0][4], {'skip_traversal': True, 'skip_as_child': True, 'skip_as_parent': True}),
    (root[0][7], {'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': True}),
]

i = 0
for (node, states) in tests:
    for test_state, exp_result in states.iteritems():

        input = node.__getattribute__(test_state)()
        errstr = "expected %s, not %s for state %s of node %s" % (input, exp_result, test_state, repr(node))

        locals()['foo' + str(i)] = type('foo' + str(i), (unittest.TestCase,),
            {'input': input, 'exp_result': exp_result, 'errstr': errstr, 'testme': lambda self: self.assertEqual(self.input, self.exp_result, self.errstr)})
        i += 1

Answer 2

import unittest
import get_nodes

class TestSuper(unittest.TestCase):
    def setUp( self ):
        self.root = get_nodes.mmnode_plus.factory('mytree.xml')
    def condition( self, aNode, skip_traversal, skip_as_child, skip_as_parent, is_leaf ):
        self.assertEquals( skip_traversal, aNode.skip_traversal )
        self.assertEquals( skip_as_child, aNode. skip_as_child)
        self.assertEquals( skip_as_parent, aNode. skip_as_parent)
        self.assertEquals( is_leaf , aNode. is_leaf )

class TestRoot( TestSuper ):
    def testRoot( self ):
        self.condition( self.root, **{'skip_traversal': False, 'skip_as_child': True, 'skip_as_parent': False, 'is_leaf': False} )

class TestRoot0( TestSuper ):
    def testRoot0( self ):
        self.condition( self.root[0], **{'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': False, 'is_leaf': False} )

class TestRoot1( TestSuper ):
    def testRoot1( self ):
        self.condition( self.root[1], **{'skip_traversal': True, 'skip_as_child': True, 'skip_as_parent': True})

class TestRoot10( TestSuper ):
    def testRoot10( self ):
        self.condition( self.root[1][0], **{'skip_traversal': True})

class TestRoot00( TestSuper ):
    def testRoot00( self ):
        self.condition( self.root[0][0], **{'is_leaf': False, 'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': False})

class TestRoot0( TestSuper ):
    def testRoot000( self ):
        self.condition( root[0][0][0], **{'is_leaf': True, 'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': True})

class TestRoot04( TestSuper ):
    def testRoot04( self ):
        self.condition( self.root[0][4], **{'skip_traversal': True, 'skip_as_child': True, 'skip_as_parent': True})

class TestRoot07( TestSuper ):
    def testRoot07( self ):
        self.condition( self.root[0][7], **{'skip_traversal': False, 'skip_as_child': False, 'skip_as_parent': True})

unittest.main()