Mini Shell

from collections import OrderedDict
from textwrap import dedent

from testfixtures import MappingComparison, ShouldRaise, compare


def check_repr(obj, expected):
    compare(repr(obj), expected=dedent(expected).rstrip('\n'))


class TestMappingComparison(object):

    def test_repr(self):
        m = MappingComparison({'a': 1}, b=2)
        check_repr(m, "<MappingComparison(ordered=False, partial=False)>'a': 1, 'b': 2</>")

    def test_repr_ordered(self):
        m = MappingComparison((('b', 3), ('a', 1)), ordered=True)
        check_repr(m, "<MappingComparison(ordered=True, partial=False)>'b': 3, 'a': 1</>")

    def test_repr_long(self):
        m = MappingComparison({1: 'a', 2: 'b'*60})
        compare(repr(m)[:65],
                expected="\n<MappingComparison(ordered=False, partial=False)>\n1: 'a',\n2: 'bb")

    def test_repr_after_equal(self):
        m = MappingComparison({'a': 1})
        assert m == {'a': 1}
        check_repr(m, "<MappingComparison(ordered=False, partial=False)>'a': 1</>")

    def test_equal_mapping(self):
        m = MappingComparison({'a': 1})
        assert m == {'a': 1}

    def test_equal_sequence(self):
        m = MappingComparison(('a', 1), ('b', 2))
        assert m == {'a': 1, 'b': 2}

    def test_equal_items(self):
        m = MappingComparison(a=1)
        assert m == {'a': 1}

    def test_equal_both(self):
        m = MappingComparison({'a': 1, 'b': 2}, b=3)
        assert m == {'a': 1, 'b': 3}

    def test_equal_items_ordered(self):
        m = MappingComparison(b=3, a=1, ordered=True)
        assert m == {'b': 3, 'a': 1}

    def test_equal_ordered_and_dict_supplied(self):
        m = MappingComparison({'b': 3, 'a': 1}, ordered=True)
        assert m == {'b': 3, 'a': 1}

    def test_equal_ordered_dict_sequence_expected(self):
        m = MappingComparison((('a', 1), ('b', 3)), ordered=True)
        assert m == OrderedDict((('a', 1), ('b', 3)))

    def test_equal_ordered_dict_ordered_dict_expected(self):
        m = MappingComparison(OrderedDict((('a', 1), ('b', 3))), ordered=True)
        assert m == OrderedDict((('a', 1), ('b', 3)))

    def test_equal_partial(self):
        m = MappingComparison({'a': 1}, partial=True)
        assert m == {'a': 1, 'b': 2}

    def test_equal_partial_ordered(self):
        m = MappingComparison((('a', 1), ('b', 3)), ordered=True, partial=True)
        assert m == OrderedDict((('a', 1), ('c', 2), ('b', 3)))

    def test_unequal_wrong_type(self):
        m = MappingComparison({'a': 1})
        assert m != []
        compare(repr(m),
                expected="<MappingComparison(ordered=False, partial=False)(failed)>bad type</>")

    def test_unequal_not_partial(self):
        m = MappingComparison({'a': 1, 'b': 2})
        assert m != {'a': 1, 'b': 2, 'c': 3}
        check_repr(m, expected='''
            <MappingComparison(ordered=False, partial=False)(failed)>
            same:
            ['a', 'b']
            
            in actual but not expected:
            'c': 3
            </MappingComparison(ordered=False, partial=False)>
        ''')

    def test_unequal_keys_and_values(self):
        m = MappingComparison({'a': 1, 'b': 2, 'c': 3})
        assert m != {'a': 1, 'c': 4, 'd': 5}
        check_repr(m, expected='''
            <MappingComparison(ordered=False, partial=False)(failed)>
            same:
            ['a']
            
            in expected but not actual:
            'b': 2
            
            in actual but not expected:
            'd': 5
            
            values differ:
            'c': 3 (expected) != 4 (actual)
            </MappingComparison(ordered=False, partial=False)>
        ''')

    def test_unequal_order(self):
        m = MappingComparison((('b', 3), ('a', 1)), ordered=True)
        assert m != OrderedDict((('a', 1), ('b', 3)))
        check_repr(m, expected='''
            <MappingComparison(ordered=True, partial=False)(failed)>
            wrong key order:
            
            same:
            []
            
            expected:
            ['b', 'a']
            
            actual:
            ['a', 'b']
            </MappingComparison(ordered=True, partial=False)>
        ''')

    def test_unequal_order_recursive(self):
        m = MappingComparison(((('b', 'x'), 3), (('b', 'y'), 1)), ordered=True, recursive=True)
        assert m != OrderedDict(((('b', 'y'), 1), (('b', 'x'), 3)))
        check_repr(m, expected='''
            <MappingComparison(ordered=True, partial=False)(failed)>
            wrong key order:
            
            same:
            []
            
            expected:
            [('b', 'x'), ('b', 'y')]
            
            actual:
            [('b', 'y'), ('b', 'x')]
            
            While comparing [0]: sequence not as expected:
            
            same:
            ('b',)
            
            expected:
            ('x',)
            
            actual:
            ('y',)
            
            While comparing [0][1]: 'x' (expected) != 'y' (actual)
            </MappingComparison(ordered=True, partial=False)>
        ''')

    def test_unequal_order_wrong(self):
        m = MappingComparison(b=3, a=1, ordered=True)
        assert m != {'a': 1, 'b': 3}
        check_repr(m, expected='''
            <MappingComparison(ordered=True, partial=False)(failed)>
            wrong key order:
            
            same:
            []
            
            expected:
            ['b', 'a']
            
            actual:
            ['a', 'b']
            </MappingComparison(ordered=True, partial=False)>
        ''')

    def test_unequal_partial_keys_missing(self):
        m = MappingComparison({'a': 1, 'b': 2}, partial=True)
        assert m != {'a': 1}
        check_repr(m, expected='''
            <MappingComparison(ordered=False, partial=True)(failed)>
            same:
            ['a']
            
            in expected but not actual:
            'b': 2
            </MappingComparison(ordered=False, partial=True)>
        ''')

    def test_unequal_partial_values_wrong(self):
        m = MappingComparison({'a': 1, 'b': 2}, partial=True)
        assert m != {'a': 1, 'b': 3}
        check_repr(m, expected='''
            <MappingComparison(ordered=False, partial=True)(failed)>
            same:
            ['a']
            
            values differ:
            'b': 2 (expected) != 3 (actual)
            </MappingComparison(ordered=False, partial=True)>
        ''')

    def test_unequal_partial_ordered(self):
        m = MappingComparison((('b', 3), ('a', 1)), partial=True, ordered=True)
        assert m != OrderedDict((('a', 1), ('b', 3)))
        check_repr(m, expected='''
            <MappingComparison(ordered=True, partial=True)(failed)>
            wrong key order:
            
            same:
            []
            
            expected:
            ['b', 'a']
            
            actual:
            ['a', 'b']
            </MappingComparison(ordered=True, partial=True)>
        ''')

    def test_unequal_partial_ordered_some_ignored(self):
        m = MappingComparison((('b', 3), ('c', 1), ('a', 1)), partial=True, ordered=True)
        assert m != OrderedDict((('b', 3), ('d', 4), ('a', 1), ('c', 1), ))
        check_repr(m, expected='''
            <MappingComparison(ordered=True, partial=True)(failed)>
            ignored:
            ['d']
            
            wrong key order:
            
            same:
            ['b']
            
            expected:
            ['c', 'a']
            
            actual:
            ['a', 'c']
            </MappingComparison(ordered=True, partial=True)>
        ''')

    def test_unequal_recursive(self):
        m = MappingComparison({'a': 1, 'b': {'c': 2}}, recursive=True)
        assert m != {'a': 1, 'b': {'c': 3}}
        check_repr(m, expected='''
            <MappingComparison(ordered=False, partial=False)(failed)>
            same:
            ['a']
            
            values differ:
            'b': {'c': 2} (expected) != {'c': 3} (actual)
            
            While comparing ['b']: dict not as expected:
            
            values differ:
            'c': 2 (expected) != 3 (actual)
            </MappingComparison(ordered=False, partial=False)>
        ''')

    def test_everything_wrong(self):
        m = MappingComparison((('a', 1), ('b', 2), ('c', 3)),
                              ordered=True, partial=True, recursive=True)
        assert m != OrderedDict((('b', 2), ('a', 1), ('d', 4)))
        check_repr(m, expected='''
            <MappingComparison(ordered=True, partial=True)(failed)>
            ignored:
            ['d']
            
            same:
            ['a', 'b']
            
            in expected but not actual:
            'c': 3
            
            wrong key order:
            
            same:
            []
            
            expected:
            ['a', 'b', 'c']
            
            actual:
            ['b', 'a']
            
            While comparing [0]: 'a' (expected) != 'b' (actual)
            </MappingComparison(ordered=True, partial=True)>
        ''')

    def test_partial_nothing_specified(self):
        m = MappingComparison(partial=True)
        assert m == {}

    def test_partial_nothing_specified_wrong_type(self):
        m = MappingComparison(partial=True)
        assert m != []
        check_repr(m, '<MappingComparison(ordered=False, partial=True)(failed)>bad type</>')

    def test_boolean_return(self):
        m = MappingComparison({'k': 'v'})
        result = m != {'k': 'v'}
        assert isinstance(result, bool)