Hacked By AnonymousFox
import sys
from unittest import TestCase
from testfixtures import Comparison as C, TempDirectory, diff, Comparison
from testfixtures.tests.sample1 import SampleClassA, a_function
class AClass:
def __init__(self, x, y=None):
self.x = x
if y:
self.y = y
def __repr__(self):
return '<'+self.__class__.__name__+'>'
class BClass(AClass):
pass
class WeirdException(Exception):
def __init__(self, x, y):
self.x = x
self.y = y
class X(object):
__slots__ = ['x']
class FussyDefineComparison(object):
def __init__(self, attr):
self.attr = attr
def __eq__(self, other):
if not isinstance(other, self.__class__): # pragma: no cover
raise TypeError()
return False # pragma: no cover
def __ne__(self, other):
return not self == other # pragma: no cover
def compare_repr(obj, expected):
actual = diff(expected, repr(obj))
if actual: # pragma: no cover
raise AssertionError(actual)
class TestC(TestCase):
def test_example(self):
# In this pattern, we want to check a sequence is
# of the correct type and order.
r = a_function()
self.assertEqual(r, (
C('testfixtures.tests.sample1.SampleClassA'),
C('testfixtures.tests.sample1.SampleClassB'),
C('testfixtures.tests.sample1.SampleClassA'),
))
# We also want to check specific parts of some
# of the returned objects' attributes
self.assertEqual(r[0].args[0], 1)
self.assertEqual(r[1].args[0], 2)
self.assertEqual(r[2].args[0], 3)
def test_example_with_object(self):
# Here we see compare an object with a Comparison
# based on an object of the same type and with the
# same attributes:
self.assertEqual(
C(AClass(1, 2)),
AClass(1, 2),
)
# ...even though the original class doesn't support
# meaningful comparison:
self.assertNotEqual(
AClass(1, 2),
AClass(1, 2),
)
def test_example_with_vars(self):
# Here we use a Comparison to make sure both the
# type and attributes of an object are correct.
self.assertEqual(
C('testfixtures.tests.test_comparison.AClass',
x=1, y=2),
AClass(1, 2),
)
def test_example_with_odd_vars(self):
# If the variable names class with parameters to the
# Comparison constructor, they can be specified in a
# dict:
self.assertEqual(
C('testfixtures.tests.test_comparison.AClass',
{'x': 1, 'y': 2}),
AClass(1, 2),
)
def test_example_partial(self):
self.assertEqual(
C('testfixtures.tests.test_comparison.AClass',
x=1,
partial=True),
AClass(1, 2),
)
def test_example_dont_use_c_wrappers_on_both_sides(self):
# NB: don't use C wrappers on both sides!
e = ValueError('some message')
x, y = C(e), C(e)
assert x != y
compare_repr(x, "<C:builtins.ValueError(failed)>wrong type</>")
compare_repr(y, "<C:builtins.ValueError>args: ('some message',)</>")
def test_repr_module(self):
compare_repr(C('datetime'), '<C:datetime>')
def test_repr_class(self):
compare_repr(C('testfixtures.tests.sample1.SampleClassA'),
'<C:testfixtures.tests.sample1.SampleClassA>')
def test_repr_function(self):
compare_repr(C('testfixtures.tests.sample1.z'),
'<C:testfixtures.tests.sample1.z>')
def test_repr_instance(self):
compare_repr(C(SampleClassA('something')),
"<C:testfixtures.tests.sample1.SampleClassA>"
"args: ('something',)"
"</>"
)
def test_repr_exception(self):
compare_repr(C(ValueError('something')), "<C:builtins.ValueError>args: ('something',)</>")
def test_repr_exception_not_args(self):
compare_repr(
C(WeirdException(1, 2)),
"\n<C:testfixtures.tests.test_comparison.WeirdException>\n"
"args: (1, 2)\n"
"x: 1\n"
"y: 2\n"
"</C:testfixtures.tests.test_comparison.WeirdException>"
)
def test_repr_class_and_vars(self):
compare_repr(
C(SampleClassA, {'args': (1,)}),
"<C:testfixtures.tests.sample1.SampleClassA>args: (1,)</>"
)
def test_repr_nested(self):
compare_repr(
C(SampleClassA, y=C(AClass), z=C(BClass(1, 2))),
"\n"
"<C:testfixtures.tests.sample1.SampleClassA>\n"
"y: <C:testfixtures.tests.test_comparison.AClass>\n"
"z: \n"
" <C:testfixtures.tests.test_comparison.BClass>\n"
" x: 1\n"
" y: 2\n"
" </C:testfixtures.tests.test_comparison.BClass>\n"
"</C:testfixtures.tests.sample1.SampleClassA>"
)
def test_repr_failed_wrong_class(self):
c = C('testfixtures.tests.test_comparison.AClass', x=1, y=2)
assert c != BClass(1, 2)
compare_repr(c,
"<C:testfixtures.tests.test_comparison.AClass(failed)>"
"wrong type</>"
)
def test_repr_failed_all_reasons_in_one(self):
c = C('testfixtures.tests.test_comparison.AClass',
y=5, z='missing')
assert c != AClass(1, 2)
compare_repr(c,
"\n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes in Comparison but not actual:\n"
"'z': 'missing'\n\n"
"attributes in actual but not Comparison:\n"
"'x': 1\n\n"
"attributes differ:\n"
"'y': 5 (Comparison) != 2 (actual)\n"
"</C:testfixtures.tests.test_comparison.AClass>",
)
def test_repr_failed_not_in_other(self):
c = C('testfixtures.tests.test_comparison.AClass',
x=1, y=2, z=(3, ))
assert c != AClass(1, 2)
compare_repr(c ,
"\n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes same:\n"
"['x', 'y']\n\n"
"attributes in Comparison but not actual:\n"
"'z': (3,)\n"
"</C:testfixtures.tests.test_comparison.AClass>",
)
def test_repr_failed_not_in_self(self):
c = C('testfixtures.tests.test_comparison.AClass', y=2)
assert c != AClass(x=(1, ), y=2)
compare_repr(c,
"\n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes same:\n"
"['y']\n\n"
"attributes in actual but not Comparison:\n"
"'x': (1,)\n"
"</C:testfixtures.tests.test_comparison.AClass>",
)
def test_repr_failed_not_in_self_partial(self):
c = C('testfixtures.tests.test_comparison.AClass', x=1, y=2, z=(3, ), partial=True)
assert c != AClass(x=1, y=2)
compare_repr(c,
"\n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes same:\n"
"['x', 'y']\n\n"
"attributes in Comparison but not actual:\n"
"'z': (3,)\n"
"</C:testfixtures.tests.test_comparison.AClass>",
)
def test_repr_failed_one_attribute_not_equal(self):
c = C('testfixtures.tests.test_comparison.AClass', x=1, y=(2, ))
assert c != AClass(1, (3, ))
compare_repr(c,
"\n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes same:\n"
"['x']\n\n"
"attributes differ:\n"
"'y': (2,) (Comparison) != (3,) (actual)\n"
"</C:testfixtures.tests.test_comparison.AClass>",
)
def test_repr_failed_nested(self):
left_side = [C(AClass, x=1, y=2),
C(BClass, x=C(AClass, x=1, y=2), y=C(AClass))]
right_side = [AClass(1, 3), AClass(1, 3)]
# do the comparison
left_side == right_side
compare_repr(
left_side,
"[\n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes same:\n"
"['x']\n\n"
"attributes differ:\n"
"'y': 2 (Comparison) != 3 (actual)\n"
"</C:testfixtures.tests.test_comparison.AClass>, \n"
"<C:testfixtures.tests.test_comparison.BClass>\n"
"x: \n"
" <C:testfixtures.tests.test_comparison.AClass>\n"
" x: 1\n"
" y: 2\n"
" </C:testfixtures.tests.test_comparison.AClass>\n"
"y: <C:testfixtures.tests.test_comparison.AClass>\n"
"</C:testfixtures.tests.test_comparison.BClass>]"
)
compare_repr(right_side, "[<AClass>, <AClass>]")
def test_repr_failed_nested_failed(self):
left_side = [C(AClass, x=1, y=2),
C(BClass,
x=C(AClass, x=1, partial=True),
y=C(AClass, z=2))]
right_side = [AClass(1, 2),
BClass(AClass(1, 2), AClass(1, 2))]
# do the comparison
left_side == right_side
compare_repr(
left_side,
"[\n"
"<C:testfixtures.tests.test_comparison.AClass>\n"
"x: 1\n"
"y: 2\n"
"</C:testfixtures.tests.test_comparison.AClass>, \n"
"<C:testfixtures.tests.test_comparison.BClass(failed)>\n"
"attributes same:\n"
"['x']\n\n"
"attributes differ:\n"
"'y': \n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes in Comparison but not actual:\n"
"'z': 2\n\n"
"attributes in actual but not Comparison:\n"
"'x': 1\n"
"'y': 2\n"
"</C:testfixtures.tests.test_comparison.AClass> (Comparison) != <AClass> (actual)\n"
"</C:testfixtures.tests.test_comparison.BClass>]",
)
compare_repr(right_side, '[<AClass>, <BClass>]')
def test_repr_failed_passed_failed(self):
c = C('testfixtures.tests.test_comparison.AClass', x=1, y=2)
assert c != AClass(1, 3)
compare_repr(c,
"\n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes same:\n"
"['x']\n\n"
"attributes differ:\n"
"'y': 2 (Comparison) != 3 (actual)\n"
"</C:testfixtures.tests.test_comparison.AClass>",
)
assert c == AClass(1, 2)
assert c != AClass(3, 2)
compare_repr(c,
"\n"
"<C:testfixtures.tests.test_comparison.AClass(failed)>\n"
"attributes same:\n"
"['y']\n\n"
"attributes differ:\n"
"'x': 1 (Comparison) != 3 (actual)\n"
"</C:testfixtures.tests.test_comparison.AClass>",
)
def test_first(self):
self.assertEqual(
C('testfixtures.tests.sample1.SampleClassA'),
SampleClassA()
)
def test_second(self):
self.assertEqual(
SampleClassA(),
C('testfixtures.tests.sample1.SampleClassA'),
)
def test_not_same_first(self):
self.assertNotEqual(
C('datetime'),
SampleClassA()
)
def test_not_same_second(self):
self.assertNotEqual(
SampleClassA(),
C('datetime')
)
def test_object_supplied(self):
self.assertEqual(
SampleClassA(1),
C(SampleClassA(1))
)
def test_class_and_vars(self):
self.assertEqual(
SampleClassA(1),
C(SampleClassA, {'args': (1,)})
)
def test_class_and_kw(self):
self.assertEqual(
SampleClassA(1),
C(SampleClassA, args=(1,))
)
def test_class_and_vars_and_kw(self):
self.assertEqual(
AClass(1, 2),
C(AClass, {'x': 1}, y=2)
)
def test_object_and_vars(self):
# vars passed are used instead of the object's
self.assertEqual(
SampleClassA(1),
C(SampleClassA(), {'args': (1,)})
)
def test_object_and_kw(self):
# kws passed are used instead of the object's
self.assertEqual(
SampleClassA(1),
C(SampleClassA(), args=(1,))
)
def test_object_partial(self):
# only attributes on comparison object
# are used
self.assertEqual(
C(AClass(1), partial=True),
AClass(1, 2),
)
def run_property_equal_test(self, partial):
class SomeClass(object):
@property
def prop(self):
return 1
self.assertEqual(
C(SomeClass, prop=1, partial=partial),
SomeClass()
)
def test_property_equal(self):
self.run_property_equal_test(partial=False)
def test_property_equal_partial(self):
self.run_property_equal_test(partial=True)
def run_property_not_equal_test(self, partial):
class SomeClass(object):
@property
def prop(self):
return 1
c = C(SomeClass, prop=2, partial=partial)
self.assertNotEqual(c, SomeClass())
compare_repr(
c,
"\n"
"<C:testfixtures.tests.test_comparison.SomeClass(failed)>\n"
"attributes differ:\n"
"'prop': 2 (Comparison) != 1 (actual)\n"
"</C:testfixtures.tests.test_comparison.SomeClass>")
def test_property_not_equal(self):
self.run_property_not_equal_test(partial=False)
def test_property_not_equal_partial(self):
self.run_property_not_equal_test(partial=True)
def run_method_equal_test(self, partial):
class SomeClass(object):
def method(self):
pass # pragma: no cover
instance = SomeClass()
self.assertEqual(
C(SomeClass, method=instance.method, partial=partial),
instance
)
def test_method_equal(self):
self.run_method_equal_test(partial=False)
def test_method_equal_partial(self):
self.run_method_equal_test(partial=True)
def run_method_not_equal_test(self, partial):
class SomeClass(object): pass
instance = SomeClass()
instance.method = min
c = C(SomeClass, method=max, partial=partial)
self.assertNotEqual(c, instance)
compare_repr(
c,
"\n"
"<C:testfixtures.tests.test_comparison.SomeClass(failed)>\n"
"attributes differ:\n"
"'method': <built-in function max> (Comparison)"
" != <built-in function min> (actual)\n"
"</C:testfixtures.tests.test_comparison.SomeClass>"
)
def test_method_not_equal(self):
self.run_method_not_equal_test(partial=False)
def test_method_not_equal_partial(self):
self.run_method_not_equal_test(partial=True)
def test_exception(self):
self.assertEqual(
ValueError('foo'),
C(ValueError('foo'))
)
def test_exception_class_and_args(self):
self.assertEqual(
ValueError('foo'),
C(ValueError, args=('foo', ))
)
def test_exception_instance_and_args(self):
self.assertEqual(
ValueError('foo'),
C(ValueError('bar'), args=('foo', ))
)
def test_exception_not_same(self):
self.assertNotEqual(
ValueError('foo'),
C(ValueError('bar'))
)
def test_exception_no_args_different(self):
self.assertNotEqual(
WeirdException(1, 2),
C(WeirdException(1, 3))
)
def test_exception_no_args_same(self):
self.assertEqual(
C(WeirdException(1, 2)),
WeirdException(1, 2)
)
def test_repr_file_different(self):
with TempDirectory() as d:
path = d.write('file', b'stuff')
f = open(path)
f.close()
c = C('io.TextIOWrapper', name=path, mode='r', closed=False,
partial=True)
assert f != c
compare_repr(c,
"\n"
"<C:_io.TextIOWrapper(failed)>\n"
"attributes same:\n"
"['mode', 'name']\n\n"
"attributes differ:\n"
"'closed': False (Comparison) != True (actual)\n"
"</C:_io.TextIOWrapper>",
)
def test_file_same(self):
with TempDirectory() as d:
path = d.write('file', b'stuff')
f = open(path)
f.close()
self.assertEqual(
f,
C('io.TextIOWrapper', name=path, mode='r', closed=True,
partial=True)
)
def test_no___dict___strict(self):
c = C(X, x=1)
assert c != X()
compare_repr(c, "\n"
"<C:testfixtures.tests.test_comparison.X(failed)>\n"
"attributes in Comparison but not actual:\n"
"'x': 1\n"
"</C:testfixtures.tests.test_comparison.X>")
def test_no___dict___partial_same(self):
x = X()
x.x = 1
self.assertEqual(C(X, x=1, partial=True), x)
def test_no___dict___partial_missing_attr(self):
c = C(X, x=1, partial=True)
assert c != X()
compare_repr(c,
"\n"
"<C:testfixtures.tests.test_comparison.X(failed)>\n"
"attributes in Comparison but not actual:\n"
"'x': 1\n"
"</C:testfixtures.tests.test_comparison.X>",
)
def test_no___dict___partial_different(self):
x = X()
x.x = 2
c = C(X, x=1, y=2, partial=True)
assert c != x
compare_repr(c,
"\n"
"<C:testfixtures.tests.test_comparison.X(failed)>\n"
"attributes in Comparison but not actual:\n"
"'y': 2\n\n"
"attributes differ:\n"
"'x': 1 (Comparison) != 2 (actual)\n"
"</C:testfixtures.tests.test_comparison.X>",
)
def test_compared_object_defines_eq(self):
# If an object defines eq, such as Django instances,
# things become tricky
class Annoying:
def __init__(self):
self.eq_called = 0
def __eq__(self, other):
self.eq_called += 1
if isinstance(other, Annoying):
return True
return False
self.assertEqual(Annoying(), Annoying())
# Suddenly, order matters.
# This order is wrong, as it uses the class's __eq__:
self.assertFalse(Annoying() == C(Annoying))
# but on __eq__ is used as a fallback:
self.assertTrue(Annoying() != C(Annoying))
# This is the right ordering:
self.assertTrue(C(Annoying) == Annoying())
self.assertFalse(C(Annoying) != Annoying())
# When the ordering is right, you still get the useful
# comparison representation afterwards
c = C(Annoying, eq_called=1)
c == Annoying()
compare_repr(
c,
'\n<C:testfixtures.tests.test_comparison.Annoying(failed)>\n'
'attributes differ:\n'
"'eq_called': 1 (Comparison) != 0 (actual)\n"
'</C:testfixtures.tests.test_comparison.Annoying>'
)
def test_importerror(self):
assert C(ImportError('x')) == ImportError('x')
def test_class_defines_comparison_strictly(self):
self.assertEqual(
C('testfixtures.tests.test_comparison.FussyDefineComparison',
attr=1),
FussyDefineComparison(1)
)
def test_cant_resolve(self):
try:
C('testfixtures.bonkers')
except Exception as e:
self.assertTrue(isinstance(e, AttributeError))
self.assertEqual(
e.args,
("'testfixtures.bonkers' could not be resolved", )
)
else:
self.fail('No exception raised!')
def test_no_name(self):
class NoName(object):
pass
NoName.__name__ = ''
NoName.__module__ = ''
c = C(NoName)
self.assertEqual(repr(c), "<C:<class '.TestC.test_no_name.<locals>.NoName'>>")
def test_missing_expected_attribute_not_partial(self):
class MyClass(object):
def __init__(self, **attrs):
self.__dict__.update(attrs)
c = Comparison(MyClass, b=2, c=3, partial=False)
assert c != MyClass(a=1, b=2)
def test_missing_expected_attribute_partial(self):
class MyClass(object):
def __init__(self, **attrs):
self.__dict__.update(attrs)
c = Comparison(MyClass, b=2, c=3, partial=True)
assert c != MyClass(a=1, b=2)
def test_extra_expected_attribute_not_partial(self):
class MyClass(object):
def __init__(self, **attrs):
self.__dict__.update(attrs)
c = Comparison(MyClass, a=1, partial=False)
assert c != MyClass(a=1, b=2)
def test_extra_expected_attribute_partial(self):
class MyClass(object):
def __init__(self, **attrs):
self.__dict__.update(attrs)
c = Comparison(MyClass, a=1, partial=True)
assert c == MyClass(a=1, b=2)
Hacked By AnonymousFox1.0, Coded By AnonymousFox