py.test, assertion for assertDictContainsSubset?

[tony]

self.assertDictContainsSubset is in unittest in Standard Library.

See https://github.com/python/cpython/blob/bbd3cf8/Lib/unittest/case.py#L1122.

Googled and looked around, I haven't seen a way to do it.

In py.test, assert <dict> in <dict2> should be the same as self.assertDictContainsSubset(dict, dict2.

Is this already a feature and I'm missing it? Is py.test open to a PR for it?

[RonnyPfannschmidt]

@tony unfortunately that cant work because a in b in python always means b contains a as an element so py.test has no equivalent of that unittest method yet

there is no clear consens on how to add it propperly

[tony]

Any ideas come to mind?

Standard library has this functionality, so I'm inclined to say it may be better of it's in pytest. Do you think so? Or would it be better as a plugin?

[smehan]

how about creating a new infix operator? Like 'assert dict1 contains dict2'?

[RonnyPfannschmidt]

@sallner python does not support adding new operators

@tony a plugin may be a good place to experiment with it, py.test is in need for a good way to do more complex assertions than normal python operators allow

however it usually takes a few tries to get it to a good quality level, so a plugin to spearhead that would probably be best

i did create an issue about this in #95 a while back, but i haven't found the time to revisit

[The-Compiler]

@RonnyPfannschmidt you mean @smehan and not @sallner 😉

[RonnyPfannschmidt]

oh, yes, thanks for the note

[henri-hulski]

What's about

assert dict1.items() <= dict2.items()

This should work for Python 3.

Edit:
For Python 2 it would be:

assert dict1.viewitems() <= dict2.viewitems()

[mortonjt]

This is somewhat tangential, but having a assertIsSubset could be useful, particularly with set objects.

While the below will work just fine

assert set1.issubset(set2)

Actually printing out the elements that are not within set1 (but in set2) would be a nifty/simple feature to have off of the shelf.

[chrisbrake]

I know this is old, but... you could just do this.

expected = {'important': 'value to test'}
actual = {'important': 'value to test', 'irrelevant': 'potato', 'un-important': 'hair dryer'}
assert expected == {k: v for k, v in actual.items() if k in expected}

[nicoddemus]

From #6367 (comment):

While @asottile is correct, I do wonder if we should perhaps have an official assertion library/plugin, as it solves practical problems. Immediately comes to mind how often I use fnmatch_lines even though it is private.

But before we introduce assertions, I would like to see a possible list of "assertion helpers" that should be included, so we can take a look at the landscape and decide if this should be indeed a separate library (perhaps under pytest-dev directly) or introduced into pytest itself (I tend for the former, as it doesn't depend on the internals and might have a different release cycle than the core).

This has been brought up before: #2376

cc @ssbarnea

[aklajnert]

Isn't pytest.raises() an example of an assertion built-in to pytest? It doesn't have an assert in the name but acts like it.

[sorXCode]

@henri-hulski , thanks.
Using self.assertLessEqual(a.items(), b.items()) works fine.

[verhovsky]

The way to do assertDictContainsSubset(dict1, dict2) with pytest is

assert dict2 | dict1 == dict2

on Python 3.9+, or

assert {**dict2, **dict1} == dict2

if you need to support older versions of Python.

[mschneiderwind]

Can we consider adding something like

assert {'a': 3} <= {'a': 3, 'b': 4}

Today we can do this, but it doesn't feel great.

assert {'a': 3}.items() <= {'a': 3, 'b': 4}.items()

[asottile]

what you're suggesting requires a change to python itself and is outside of what pytest can do

[soxofaan]

Another approach is the following pattern based on pytest.approx and helpers like https://github.com/utapyngo/pytest-unordered:

class DictSubSet:
    def __init__(self, items: dict):
        self.items = items

    def __eq__(self, other):
        return self.items == {k: other[k] for k in self.items if k in other}

    def __repr__(self):
        return repr(self.items)

assert {"foo": "bar", "meh": 4} == DictSubSet({"foo": "bar"})  # passes

(class name, capitalization and other details are up for dicsussion of course)

As noted above this probably first belongs in a plugin for experimentation. Maybe that already exists somewhere?

[haakenlid]

I am looking for something like this, too. But it should support nested data structures. It seems most of the suggestions in this issue only does a shallow comparison of dicts.

I found this little used library that almost solves my problem, but doesn't give useful output on failed assertions in pytest.

https://github.com/qweeze/matchlib

[soxofaan]

@haakenlid my basic implementation of DictSubSet does support nesing, e.g.

def test_dict_subset_nesting():
    assert {1: 2, 3: 4, 5: {6: 7, 8: 9}} == DictSubSet({3: 4, 5: DictSubSet({8: 9})})
    assert {1: {2: 3, 4: 5}} == {1: DictSubSet({4: 5})}
    assert {1: {2: {3: {4: 5, 6: 7}}}} == {1: {2: DictSubSet({3: DictSubSet({})})}}