How to test for the presence of multiple items in a container, in a single assert?

[seanh]

Does anyone know of a good way to assert that a container contains each one of several items, while ignoring the order and also ignoring other items that the container might contain?

The obvious way to write it is like this:

def test_it():
    result = [1, 2, 3]
    expected_items = [1, 4, 5]

    for item in expected_items:
        assert item in result

This test will fail because result contains neither 4 nor 5. Note that result does contain 2 and 3, which are not in expected_items, but this would not cause the test to fail: 2 and 3 should be ignored.

The above code works fine but it doesn't produce an ideal error message. Because we've used multiple assert's in a for loop, the error message only reports about the first item that was missing (4).

    def test_it():
        result = [1, 2, 3]
        expected_items = [1, 4, 5]
    
        for item in expected_items:
>           assert item in result
E           assert 4 in [1, 2, 3]

Ideally it would report that 5 is also missing. I guess you could do something like this:

def test_it():
    result = [1, 2, 3]
    expected_items = [1, 4, 5]

    matching_items = [item for item in expected_items if item in result]
    assert matching_items == expected_items

This results in a better failure message:

    def test_it():
        result = [1, 2, 3]
        expected_items = [1, 4, 5]
    
        matching_items = [item for item in expected_items if item in result]
>       assert matching_items == expected_items
E       assert [1] == [1, 4, 5]
E         
E         Right contains 2 more items, first extra item: 4
E         Use -v to get more diff

Note that I'm trying to avoid things like requiring the items to be sortable (to use sorted()) or hashable (to use set()).

That's a bit much to write if you have a lot of tests that need to do this type of assertion. You could write a global helper function for it:

def test_it():
    result = [1, 2, 3]
    expected_items = [1, 4, 5]

    assert_contains(result, expected_items)

def assert_contains(container, items):
    matching_items = [item for item in items if item in container]
    assert matching_items == items

That's better but it does make the failure messages a bit longer because the failing assertion is actually in the assert_contains() helper (which would probably be in some other file like conftest.py or somewhere):

    def test_it():
        result = [1, 2, 3]
        expected_items = [1, 4, 5]
    
>       assert_contains(result, expected_items)

tests/unit/h_matchers/pytest_test.py:20: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

container = [1, 2, 3], items = [1, 4, 5]

    def assert_contains(container, items):
        matching_items = [item for item in items if item in container]
>       assert matching_items == items
E       assert [1] == [1, 4, 5]
E         
E         Right contains 2 more items, first extra item: 4
E         Use -v to get more diff

Is there a better way, or am I on the right track?

Thanks

[seanh]

def assert_contains(container, items):
    matching_items = [item for item in items if item in container]
    assert matching_items == items

Oh, just realised that this of course requires the items to be in the same order, which is not what I want. But I don't want to use sorted() or set() because I don't want to require things to be sortable or hashable. Hmm.

I want to do only a single assert statement in order to get the best failure message out of pytest (covering all differing items between the two containers). But I think there may be no way to do that without using either sorted() or set().

[RonnyPfannschmidt]

The unordered plugin provides orders defying helpers for those cases

[seanh]

The unordered plugin provides orders defying helpers for those cases

Yeah that does look good. But from the docs it doesn't look like it supports partial matches: it looks like it's testing that two collections contain all the same items (just not necessarily in the same order), rather than just testing whether one collection is an (unordered) subset of another.

[RonnyPfannschmidt]

I recently stumbled on the anys Library and the hope to expand it a little on the sprint