emulating dict interface python

Question

For some reason, I cannot perfectly emulate a dictionary behaviour for my type.

class IValType:
    def __init__(self, v):
        self.v = v

    def __repr__(self):
        return self.v.__repr__()

    def __str__(self):
        return self.v.__str__()

    def __eq__(self, other):
        return self.v.__eq__(other)

class Map(IValType, dict):
    def __init__(self, v: dict):
        super(Map, self).__init__(v)
        print("debug")

    def __contains__(self, item):
        return self.v.__contains__(item)

    def __getitem__(self, item):
        return self.v[item]

    def __setitem__(self, key, value):
        self.v[key] = value

    def __delitem__(self, key):
        self.v.__delitem__(key)

    def __missing__(self, key):
        return self.v.__missing__(key)

    def __get__(self, instance, owner):
        return self.__get__(instance, owner)

    def __iter__(self):
        return self.v.__iter__()

    def __len__(self):
        return len(self.v)

    @staticmethod
    def fromkeys(seq):
        return dict.fromkeys(seq)

    def values(self):
        return self.v.values()

    def keys(self):
        return self.v.keys()

    def items(self):
        return self.v.items()

    def pop(self, k):
        return self.v.pop(k)

    def popitem(self):
        return self.v.popitem()

    def setdefault(self, k, default=None):
        return self.v.setdefault(k, default)

    def get(self, k):
        return self.v.get(k)

    def update(self, __m, **kwargs):
        self.v.update(__m, **kwargs)

The test for equality fails.

class MainTest(unittest.TestCase):

    def test_4(self):
        # make a full test for dicts
        d = {"k": 1,"p":2}
        dm = Map(d)
        self.assertIn("k", dm)
        self.assertEqual(dm["k"], d["k"])
        self.assertDictEqual(dm,d)

AssertionError: {'p': 2, 'k': 1} != {'p': 2, 'k': 1}
- {'p': 2, 'k': 1}
+ {'k': 1, 'p': 2}

I have implemented almost every magical method, what I am missing? I don't have these troubles with reimplementing Lists in the same way, and they are tested (successfully) for equality too. This is py 3.5

Any help please?

Answer 1

Your problem is the missing implementation not equal, which is what assertDictEqual uses internally (see here):

>>> dm != d
True

Define the __ne__ for IValType.

That's also arguably a bug in unittest.TestCase, so you might consider filing an issue at bugs.python.org and/or switching to a better test runner.