def test_generator_second_shorted(self): self.checkRaises( generator(1, 2, 3), generator(1, 2), "sequence not as expected:\n\n" "same:\n(1, 2)\n\n" "first:\n(3,)\n\n" "second:\n()")
def test_generator_different(self): self.checkRaises( generator(1, 2, 3), generator(1, 2, 4), "Sequence not as expected:\n\n" "same:\n(1, 2)\n\n" "first:\n(3,)\n\n" "second:\n(4,)")
def test_generator_different(self): self.checkRaises( generator(1, 2, 3), generator(1, 2, 4), "sequence not as expected:\n\n" "same:\n(1, 2)\n\n" "first:\n(3,)\n\n" "second:\n(4,)")
def test_generator_second_shorted(self): self.checkRaises( generator(1, 2, 3), generator(1, 2), "Sequence not as expected:\n\n" "same:\n(1, 2)\n\n" "first:\n(3,)\n\n" "second:\n()")
def test_generator_first_shorter(self): self.check_raises( generator(1, 2), generator(1, 2, 3), "sequence not as expected:\n\n" "same:\n(1, 2)\n\n" "first:\n()\n\n" "second:\n(3,)" )
def test_generator_totally_different(self): self.check_raises( generator(1, ), generator(2, ), "sequence not as expected:\n\n" "same:\n()\n\n" "first:\n(1,)\n\n" "second:\n(2,)" )
def test_deep_breadcrumbs(self): obj1 = singleton('obj1') obj2 = singleton('obj2') gen1 = generator(obj1, obj2) gen2 = generator(obj1) self.checkRaises( dict(x=[1, ('a', 'b', gen1), 3], y=[3, 4]), dict(x=[1, ('a', 'b', gen2), 3], y=[3, 4]), "dict not as expected:\n\nsame:\n['y']\n\nvalues differ:\n'x': [1, ('a', 'b', {gen1}), 3] != [1, ('a', 'b', {gen2}), 3]\n\nWhile comparing ['x']: sequence not as expected:\n\nsame:\n[1]\n\nfirst:\n[('a', 'b', {gen1}), 3]\n\nsecond:\n[('a', 'b', {gen2}), 3]\n\nWhile comparing ['x'][1]: sequence not as expected:\n\nsame:\n('a', 'b')\n\nfirst:\n({gen1},)\n\nsecond:\n({gen2},)\n\nWhile comparing ['x'][1][2]: sequence not as expected:\n\nsame:\n(<obj1>,)\n\nfirst:\n(<obj2>,)\n\nsecond:\n()" .format(gen1=hexsub(repr(gen1)), gen2=hexsub(repr(gen2))))
def test_nested_labels(self): obj1 = singleton('obj1') obj2 = singleton('obj2') gen1 = generator(obj1, obj2) gen2 = generator(obj1, ) # dict -> list -> tuple -> generator self.check_raises( dict(x=[1, ('a', 'b', gen1), 3], y=[3, 4]), dict(x=[1, ('a', 'b', gen2), 3], y=[3, 4]), ( "dict not as expected:\n" "\n" "same:\n" "['y']\n" "\n" "values differ:\n" "'x': [1, ('a', 'b', {gen1}), 3] (expected) != " "[1, ('a', 'b', {gen2}), 3] (actual)\n" "\n" "While comparing ['x']: sequence not as expected:\n" "\n" "same:\n" "[1]\n" "\n" "expected:\n" "[('a', 'b', {gen1}), 3]\n" "\n" "actual:\n" "[('a', 'b', {gen2}), 3]\n" "\n" "While comparing ['x'][1]: sequence not as expected:\n" "\n" "same:\n" "('a', 'b')\n" "\n" "expected:\n" "({gen1},)\n" "\n" "actual:\n" "({gen2},)\n" "\n" "While comparing ['x'][1][2]: sequence not as expected:\n" "\n" "same:\n" "(<obj1>,)\n" "\n" "expected:\n" "(<obj2>,)\n" "\n" "actual:\n" "()" ).format(gen1=hexsub(repr(gen1)), gen2=hexsub(repr(gen2))), x_label='expected', y_label='actual', )
def test_nested_labels(self): obj1 = singleton('obj1') obj2 = singleton('obj2') gen1 = generator(obj1, obj2) gen2 = generator(obj1) self.checkRaises( dict(x=[1, ('a', 'b', gen1), 3], y=[3, 4]), dict(x=[1, ('a', 'b', gen2), 3], y=[3, 4]), "dict not as expected:\n\nsame:\n['y']\n\nvalues differ:\n'x': [1, ('a', 'b', {gen1}), 3] (expected) != [1, ('a', 'b', {gen2}), 3] (actual)\n\nWhile comparing ['x']: sequence not as expected:\n\nsame:\n[1]\n\nexpected:\n[('a', 'b', {gen1}), 3]\n\nactual:\n[('a', 'b', {gen2}), 3]\n\nWhile comparing ['x'][1]: sequence not as expected:\n\nsame:\n('a', 'b')\n\nexpected:\n({gen1},)\n\nactual:\n({gen2},)\n\nWhile comparing ['x'][1][2]: sequence not as expected:\n\nsame:\n(<obj1>,)\n\nexpected:\n(<obj2>,)\n\nactual:\n()" .format(gen1=hexsub(repr(gen1)), gen2=hexsub(repr(gen2))), x_label='expected', y_label='actual')
def test_deep_breadcrumbs(self): obj1 = singleton('obj1') obj2 = singleton('obj2') gen1 = generator(obj1, obj2) gen2 = generator(obj1, ) # dict -> list -> tuple -> generator self.check_raises( dict(x=[1, ('a', 'b', gen1), 3], y=[3, 4]), dict(x=[1, ('a', 'b', gen2), 3], y=[3, 4]), ( "dict not as expected:\n" "\n" "same:\n" "['y']\n" "\n" "values differ:\n" "'x': [1, ('a', 'b', {gen1}), 3] != [1, ('a', 'b', {gen2}), 3]" "\n\n" "While comparing ['x']: sequence not as expected:\n" "\n" "same:\n" "[1]\n" "\n" "first:\n" "[('a', 'b', {gen1}), 3]\n" "\n" "second:\n" "[('a', 'b', {gen2}), 3]\n" "\n" "While comparing ['x'][1]: sequence not as expected:\n" "\n" "same:\n" "('a', 'b')\n" "\n" "first:\n" "({gen1},)\n" "\n" "second:\n" "({gen2},)\n" "\n" "While comparing ['x'][1][2]: sequence not as expected:\n" "\n" "same:\n" "(<obj1>,)\n" "\n" "first:\n" "(<obj2>,)\n" "\n" "second:\n" "()" ).format(gen1=hexsub(repr(gen1)), gen2=hexsub(repr(gen2))) )
def test_nested_generator_different(self): self.checkRaises( generator(1, 2, generator(3), 4), generator(1, 2, generator(3), 5), "sequence not as expected:\n" "\n" "same:\n" "(1, 2, <generator object generator at ...>)\n" "\n" "first:\n" "(4,)\n" "\n" "second:\n" "(5,)")
def test_nested_generator_different(self): self.check_raises( generator(1, 2, generator(3), 4), generator(1, 2, generator(3), 5), "sequence not as expected:\n" "\n" "same:\n" "(1, 2, <generator object generator at ...>)\n" "\n" "first:\n" "(4,)\n" "\n" "second:\n" "(5,)" )
def test_simple(self): # we use our own parser to get a convertor and a constant in there class TheParser(Parser): class ARecord(Record): prefix = Discriminator('A') data = Field(2, int) const = Field(1, one_of( x = Constant('X', 'an X'), y = Constant('Y', 'a Y'), )) class BRecord(Record): prefix = Discriminator('B') d1 = Field(2) d2 = Field(2) compare(generator( TheParser.BRecord.type(prefix='B', d1='XX', d2='YY'), TheParser.ARecord.type(prefix='A', data=2, const=TheParser.ARecord.const.x ), TheParser.ARecord.type(prefix='A', data=13, const=TheParser.ARecord.const.y), ), TheParser(['BXXYY', 'A 2X', 'A13Y']))
def test_generator_with_buggy_generator(self): def bad_gen(): yield 1 raise TypeError('foo') with ShouldRaise(TypeError('foo')): compare(generator(1, 2, 3), bad_gen())
def test_register(self): register_session('sqlite://') # create the tables session = get_session() self.Base.metadata.create_all(session.bind) # check registrations compare(generator( C('zope.component.registry.UtilityRegistration', component=C('sqlalchemy.orm.scoping.ScopedSession'), factory=None, info=u'', name=u'', provided=ISession, registry=self.components.registry )),self.components.registry.registeredUtilities()) # this is what get_session goes: session = getSiteManager().getUtility(ISession) session.add(self.Model(id=1,name='foo')) model = session.query(self.Model).one() self.assertEqual(model.id,1) self.assertEqual(model.name,'foo')
def test_register_with_name(self): register_session('sqlite://','foo') # check registrations compare(generator( C('zope.component.registry.UtilityRegistration', component=C('sqlalchemy.orm.scoping.ScopedSession'), factory=None, info=u'', name=u'foo', provided=ISession, registry=self.components.registry )),self.components.registry.registeredUtilities()) registry = getSiteManager() # check we don't register with no name: with ShouldRaise(ComponentLookupError(ISession, u'')): registry.getUtility(ISession) # check we do with the right name self.failUnless(isinstance( registry.getUtility(ISession,'foo')(), Session ))
def test_short_lines_for_disc(self): compare(generator( C('fixed.UnknownRecordType', discriminator='', line='', args=()) ), self.parser(['']))
def test_simple(self): # we use our own parser to get a convertor and a constant in there class TheParser(Parser): class ARecord(Record): prefix = Discriminator('A') data = Field(2, int) const = Field( 1, one_of( x=Constant('X', 'an X'), y=Constant('Y', 'a Y'), )) class BRecord(Record): prefix = Discriminator('B') d1 = Field(2) d2 = Field(2) compare( generator( TheParser.BRecord.type(prefix='B', d1='XX', d2='YY'), TheParser.ARecord.type(prefix='A', data=2, const=TheParser.ARecord.const.x), TheParser.ARecord.type(prefix='A', data=13, const=TheParser.ARecord.const.y), ), TheParser(['BXXYY', 'A 2X', 'A13Y']))
def test_short_lines_for_disc(self): compare( generator( C('fixed.UnknownRecordType', discriminator='', line='', args=())), self.parser(['']))
def test_generator_with_buggy_generator(self): def bad_gen(): yield 1 # raising a TypeError here is important :-/ raise TypeError('foo') with ShouldRaise(TypeError('foo')): compare(generator(1, 2, 3), bad_gen())
def test_iterable_and_generator_strict(self): expected = compile( "x?range\\(1, 4\\) \\(<(class|type) 'x?range'>\\) != <generator object (generator )?at... \\(<(class|type) 'generator'>\\)" ) self.checkRaises(xrange(1, 4), generator(1, 2, 3), regex=expected, strict=True)
def test_file(self): with TempDirectory() as dir: path = dir.write('file', 'AXX\nBYY\n') with open(path) as source: compare(generator( self.parser.ARecord.type('A', 'XX'), self.parser.BRecord.type('B', 'YY'), ), self.parser(source))
def test_generator_and_sequence(self): expected = compile( "\(1, 2, 3\) != <generator object (generator )?at ...>") self.checkRaises( (1, 2, 3), generator(1, 2, 3), regex=expected, )
def test_sequence_and_generator(self): expected = compile( "\(1, 2, 3\) != <generator object (generator )?at ...>") self.checkRaises( (1, 2, 3), generator(1, 2, 3), regex=expected, )
def test_iterable_and_generator(self): expected = compile( "x?range\(1, 4\) != <generator object (generator )?at ...>") self.checkRaises( xrange(1, 4), generator(1, 2, 3), regex=expected, )
def test_fixed_width(self): # make sure file wrapped with iterator works with TempDirectory() as dir: path = dir.write('file', 'AXXBYY') with open(path) as source: compare(generator( self.parser.ARecord.type('A', 'XX'), self.parser.BRecord.type('B', 'YY'), ), self.parser(Chunker(source, 3)))
def test_unknown_record_type_returns(self): # Return rather than raise exception. # This is optimised to be fast. compare( generator( C('fixed.UnknownRecordType', discriminator='C', line='CXX', args=())), self.parser(['CXX']))
def test_unknown_record_type_returns(self): # Return rather than raise exception. # This is optimised to be fast. compare(generator( C('fixed.UnknownRecordType', discriminator='C', line='CXX', args=()) ), self.parser(['CXX']))
def test_file(self): with TempDirectory() as dir: path = dir.write('file', 'AXX\nBYY\n') with open(path) as source: compare( generator( self.parser.ARecord.type('A', 'XX'), self.parser.BRecord.type('B', 'YY'), ), self.parser(source))
def test_sequence_and_generator_strict(self): expected = compile("\(1, 2, 3\) \(<(class|type) 'tuple'>\) != " "<generator object (generator )?at... " "\(<(class|type) 'generator'>\)") self.checkRaises( (1, 2, 3), generator(1, 2, 3), regex=expected, strict=True, )
def test_fixed_width(self): # make sure file wrapped with iterator works with TempDirectory() as dir: path = dir.write('file', 'AXXBYY') with open(path) as source: compare( generator( self.parser.ARecord.type('A', 'XX'), self.parser.BRecord.type('B', 'YY'), ), self.parser(Chunker(source, 3)))
def test_sequence_and_generator_strict(self): expected = compile( "\\(1, 2, 3\\) \\(<(class|type) 'tuple'>\\) \\(expected\\) != <generator object (generator )?at... \\(<(class|type) 'generator'>\\) \\(actual\\)" ) self.checkRaises((1, 2, 3), generator(1, 2, 3), regex=expected, strict=True, x_label='expected', y_label='actual')
def test_iterable_and_generator_strict(self): expected = compile( "x?range\(1, 4\) \(<(class|type) 'x?range'>\) != " "<generator object (generator )?at... " "\(<(class|type) 'generator'>\)" ) self.check_raises( xrange(1, 4), generator(1, 2, 3), regex=expected, strict=True, )
def test_sequence_and_generator_strict(self): expected = compile( "\(1, 2, 3\) \(<(class|type) 'tuple'>\) != " "<generator object (generator )?at... " "\(<(class|type) 'generator'>\)" ) self.checkRaises( (1,2,3), generator(1,2,3), regex=expected, strict=True, )
def test_sequence_and_generator_strict(self): expected = compile( "\(1, 2, 3\) \(<(class|type) 'tuple'>\) \(expected\) != " "<generator object (generator )?at... " "\(<(class|type) 'generator'>\) \(actual\)" ) self.check_raises( (1, 2, 3), generator(1, 2, 3), regex=expected, strict=True, x_label='expected', y_label='actual', )
def test_unequal_generator(self): s = SequenceComparison(1, 3) assert s != generator(1, 2) compare(repr(s), expected=( '\n' '<SequenceComparison(ordered=True, partial=False)(failed)>\n' 'same:\n' "[1]\n\n" 'expected:\n' '[3]\n\n' 'actual:\n' '[2]\n' '</SequenceComparison(ordered=True, partial=False)>' ))
def test_ignore_unknown_rows(self): class MyHandler(Handler): # the magic line: parse_unknown = False # stuff for testing: @handles(self.parser.ARecord) def handle_ARecord(self, rec): pass @handles(fixed.UnknownRecordType) def handle_unknown(self, source, line_no, rec): return source, line_no, rec handler = MyHandler() source = ['CYY'] compare(generator(), handler.handled(source))
def test_method_handles_multiple_types(self): class MyHandler(Handler): @handles(self.parser.ARecord) @handles(self.parser.BRecord) def handle_ARecord(self, source, line_no, rec): return (source, line_no, rec) handler = MyHandler() source = ['AXX', 'BYY'] handler.handle(source) compare( generator( (source, 1, self.parser.ARecord.type('A', 'XX')), (source, 2, self.parser.BRecord.type('B', 'YY')), ), handler.handled(source))
def test_method_handles_multiple_types(self): class MyHandler(Handler): @handles(self.parser.ARecord) @handles(self.parser.BRecord) def handle_ARecord(self, source, line_no, rec): return (source, line_no, rec) handler = MyHandler() source = ['AXX', 'BYY'] handler.handle(source) compare(generator( (source, 1, self.parser.ARecord.type('A', 'XX')), (source, 2, self.parser.BRecord.type('B', 'YY')), ), handler.handled(source))
def test_exception_handling_implemented(self): class MyHandler(Handler): @handles(self.parser.ARecord) def handle_ARecord(self, rec): pass @handles(fixed.UnknownRecordType) def handle_unknown(self, source, line_no, rec): return source, line_no, rec handler = MyHandler() source = ['CYY'] compare(generator( (source, 1, C('fixed.UnknownRecordType', discriminator='C', line='CYY', args=())), ), handler.handled(source))
def test_convertor_fail_yields(self): # This will be slow; avoid having it happen! class TheParser(Parser): class ARecord(Record): prefix = Discriminator('A') data = Field(1, int) compare(generator( C('fixed.ConversionError', args=(), problems=dict(data=C( 'fixed.Problem', raw='X', convert=int, exception=C( ValueError, args=("invalid literal for int() with base 10: 'X'", ), )))) ), TheParser(['AX']))
def test_exception_handling_implemented(self): class MyHandler(Handler): @handles(self.parser.ARecord) def handle_ARecord(self, rec): pass @handles(fixed.UnknownRecordType) def handle_unknown(self, source, line_no, rec): return source, line_no, rec handler = MyHandler() source = ['CYY'] compare( generator((source, 1, C('fixed.UnknownRecordType', discriminator='C', line='CYY', args=())), ), handler.handled(source))
def test_handled_iterator(self): class MyHandler(Handler): @handles(self.parser.ARecord) def handle_ARecord(self, source, line_no, rec): return ('A', source, line_no, rec) @handles(self.parser.BRecord) def handle_BRecord(self, source, line_no, rec): return ('B', source, line_no, rec) handler = MyHandler() # in reality, the following list would likely be a file # or a Chunker. source = ['AXX', 'BYY'] handler.handle(source) compare( generator( ('A', source, 1, self.parser.ARecord.type('A', 'XX')), ('B', source, 2, self.parser.BRecord.type('B', 'YY')), ), handler.handled(source))
def test_convertor_fail_yields(self): # This will be slow; avoid having it happen! class TheParser(Parser): class ARecord(Record): prefix = Discriminator('A') data = Field(1, int) compare( generator( C('fixed.ConversionError', args=(), problems=dict(data=C( 'fixed.Problem', raw='X', convert=int, exception=C( ValueError, args=( "invalid literal for int() with base 10: 'X'", ), ))))), TheParser(['AX']))
def test_handled_iterator(self): class MyHandler(Handler): @handles(self.parser.ARecord) def handle_ARecord(self, source, line_no, rec): return ('A', source, line_no, rec) @handles(self.parser.BRecord) def handle_BRecord(self, source, line_no, rec): return ('B', source, line_no, rec) handler = MyHandler() # in reality, the following list would likely be a file # or a Chunker. source = ['AXX', 'BYY'] handler.handle(source) compare(generator( ('A', source, 1, self.parser.ARecord.type('A', 'XX')), ('B', source, 2, self.parser.BRecord.type('B', 'YY')), ), handler.handled(source))
def test_generator_with_non_generator(self): self.check_raises( generator(1, 2, 3), None, '<generator object generator at ...> != None', )
def test_generator_and_iterable(self): compare(generator(1, 2, 3), xrange(1, 4))
def test_iterable_and_generator(self): compare(xrange(1, 4), generator(1, 2, 3))
def test_generator_and_sequence(self): compare(generator(1, 2, 3), (1, 2, 3))
def test_nested_generator_tuple_right(self): compare( generator(1, 2, generator(3), 4), generator(1, 2, (3, ), 4), )
def test_sequence_and_generator(self): compare((1, 2, 3), generator(1, 2, 3))