mirror of
https://github.com/emilybache/GildedRose-Refactoring-Kata.git
synced 2026-02-08 11:11:24 +00:00
696 lines
22 KiB
Python
696 lines
22 KiB
Python
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:
|
|
__slots__ = ['x']
|
|
|
|
|
|
class FussyDefineComparison:
|
|
|
|
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:
|
|
@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:
|
|
@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:
|
|
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: 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:
|
|
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:
|
|
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:
|
|
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:
|
|
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:
|
|
def __init__(self, **attrs):
|
|
self.__dict__.update(attrs)
|
|
|
|
c = Comparison(MyClass, a=1, partial=True)
|
|
assert c == MyClass(a=1, b=2)
|