Misleading message "Right contains one more item"

[sanyassh]

When pytest compares lists of different length and tries to show what the extra items are, it prints incorrect message "Right contains one more item" pointing to the wrong item. At the same time the "Full diff" section correctly indicates extra item. For "Left contains" issue is the same.

Minimal example:

    def test_cmp():
>       assert ['1', '2', '3'] == ['1', '2', '0', '3']
E       AssertionError: assert ['1', '2', '3'] == ['1', '2', '0', '3']
E         
E         At index 2 diff: '3' != '0'
E         Right contains one more item: '3'
E         
E         Full diff:
E           [
E               '1',
E               '2',
E         -     '0',
E               '3',
E           ]

versions:
Ubuntu 22.04.5 LTS
pytest 8.3.3

[The-Compiler]

I think the explanation is correct (even though confusing). Imagine you're looking at pairs of item step by step, basically:

>>> list(itertools.zip_longest(['1', '2', '3'], ['1', '2', '0', '3']))
[('1', '1'), ('2', '2'), ('3', '0'), (None, '3')]

Then indeed you'll see the differences as explained by pytest:

• At index 2, the rhs has a 0 in place of a 3
• The rhs has an additional item, which is 3

Not sure what to do here. Probably pytest would need to be quite clever (possibly too clever) to explain this in human language based on what a diff can show.

[macdjord]

This particular case seems like it would be common enough to maybe warrant a special case in the diff-display code. Something like this:

def diff_items_added(lhs: list, rhs: list) -> str | None:
    """If one list is just the other with additional items added, return a special-case diff string;
    otherwise return None to fall back to the default diff generator
    """

    if len(lhs) == len(rhs):
        return None

    # Identify which side is longer
    longer_side: str
    longer: list
    shorter: list
    if len(lhs) > len(rhs):
        longer_side = "Left"
        longer = lhs
        shorter = rhs
    else:
        longer_side = "Right"
        longer = rhs
        shorter = lhs

    # Even more special case: the shorter sequence is a strict prefix or suffix of the longer one:
    num_extra: int = len(longer) - len(shorter)
    if longer[:-num_extra] == shorter:
        diff_lines: list[str] = [f"{longer_side} ends with {num_extra} additional items:"]
        diff_lines.extend(f"  - {extra_item!r}" for extra_item in longer[-num_extra:])
        return "\n".join(diff_lines)
    elif longer[num_extra:] == shorter:
        diff_lines: list[str] = [f"{longer_side} starts with {num_extra} additional items:"]
        diff_lines.extend(f"  - {extra_item!r}" for extra_item in longer[:num_extra])
        return "\n".join(diff_lines)

    longer_items: typing.Iterator[tuple[int, typing.Any]] = iter(enumerate(longer))
    extra_items: list[tuple[int, typing.Any]] = []
    for shorter_item in shorter:
        # Search through the items in the longer sequence,
        # looking for one which matches this element from the shorter sequence,
        # keeping track of any mis-matches
        while True:
            try:
                i, longer_item = next(longer_items)
            except StopIteration:
                # If we run out of items from the longer sequence before matching all the items from the shorter one,
                # then we know the longer sequence is not, in fact, the shorter one with some extra items inserted
                return None

            if longer_item == shorter_item:
                break
            extra_items.append((i, longer_item))

    # If there are any items from the longer sequence that haven't been matched yet, they are also additions
    extra_items.extend(longer_items)

    diff_lines: list[str] = [f"{longer_side} contains {len(extra_items)} more items:"]
    diff_lines.extend(f"  - At index {i}: {extra_item!r}" for i, extra_item in extra_items)
    return "\n".join(diff_lines)