Preserve insertion order for extra dict items in assertion output

[RafiB982]

When dict assertions fail, pytest currently displays extra items using
unordered set iteration, which loses insertion order.

This change preserves insertion order for the
"Left contains N more items" and "Right contains N more items" sections
by iterating keys in mapping order instead of set order.

A focused regression test is included.

Closes #13503

[nicoddemus]

Thanks @RafiB982, please take a look at my comments.

[nicoddemus]

It is more efficient to reuse the set for the containment check:

Suggested change

	extra_left = [k for k in left if k not in right]
	extra_left = [k for k in left if k not in set_right]

[nicoddemus]

Suggested change

	extra_right = [k for k in right if k not in left]
	extra_right = [k for k in right if k not in set_left]

[nicoddemus]

Please let's use a dict with more keys for this test, only 2 seems few to catch any regressions. I suggest using simply "a", "b", etc, inserted in non-alphabetical order.

[nicoddemus]

Could we use just result.stdout.fnmatch_lines instead to verify the output, instead of this custom parsing logic?

[RafiB982]

Thanks for the review @nicoddemus

I’ve addressed the feedback by:

1. reusing sets for containment checks in the implementation

2. expanding the test to use more keys in non-alphabetical insertion order

3. relying on -vv full assertion diffs and result.stdout.fnmatch_lines for verification

4. The rebase conflict has been resolved and tox -e py310 passes successfully.

Please let me know if you’d like any further adjustments.

[nicoddemus]

Thanks, but I noticed the test as written still passes in main, because it ends up matching against several lines of the output by chance.

Here is the output of the internal test_order in your branch:

================================ FAILURES =================================
_______________________________ test_order ________________________________

    def test_order():
        a = {
            "b": 2,
            "a": 1,
            "d": 4,
            "e": 5,
            "c": 3,
        }
>       assert a == {}
E       AssertionError: assert {'b': 2, 'a': 1, 'd': 4, 'e': 5, 'c': 3} == {}
E
E         Left contains 5 more items:
E         {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
E
E         Full diff:
E         - {}
E         + {
E         +     'a': 1,
E         +     'b': 2,
E         +     'c': 3,
E         +     'd': 4,
E         +     'e': 5,
E         + }

.tmp\test_order.py:12: AssertionError
========================= short test summary info =========================
FAILED .tmp\test_order.py::test_order - AssertionError: assert {'b': 2, 'a': 1, 'd': 4, 'e': 5, 'c': 3} == {}

  Left contains 5 more items:
  {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

  Full diff:
  - {}
  + {
  +     'a': 1,
  +     'b': 2,
  +     'c': 3,
  +     'd': 4,
  +     'e': 5,
  + }
============================ 1 failed in 0.19s ============================

As we can see, the full diff still shows the keys in sorted order.

The problem is that the keys (for example 'a': 1) appear many times in the output and the test as written ends up matching that in different places, even though the "Full diff" output is still sorted.

Here is an improved version of the test which fails in main:

Suggested change

	def test_dict_extra_items_preserve_insertion_order(pytester):
	pytester.makepyfile(
	test_order="""
	def test_order():
	a = {
	"b": 2,
	"a": 1,
	"d": 4,
	"e": 5,
	"c": 3,
	}
	assert a == {}
	"""
	)
	result = pytester.runpytest("-vv")
	result.stdout.fnmatch_lines(
	[
	"*Left contains 5 more items:*",
	"*'b': 2*",
	"*'a': 1*",
	"*'d': 4*",
	"*'e': 5*",
	"*'c': 3*",
	]
	)
	def test_dict_extra_items_preserve_insertion_order(pytester: Pytester) -> None:
	"""Assertion output of dict diff shows keys in insertion order (#13503)."""
	pytester.makepyfile(
	test_order="""
	def test_order():
	a = {
	"b": 2,
	"a": 1,
	"d": 4,
	"e": 5,
	"c": 3,
	}
	assert a == {}
	"""
	)
	result = pytester.runpytest("-vv")
	result.stdout.fnmatch_lines(
	[
	"*Left contains 5 more items:*",
	"*Full diff:",
	"* + *'b': 2,",
	"* + *'a': 1,",
	"* + *'d': 4,",
	"* + *'e': 5,",
	"* + *'c': 3,",
	"test_order.py:*: AssertionError",
	]
	)

The test above fails in main and also fails in this branch. It seems more work is needed to handle the Full diff output.

[nicoddemus]

Suggested change

	Preserved insertion order for extra dictionary items in assertion failure output.
	Display dictionary differences in assertion failures using the original key insertion order instead of sorted order.

[nicoddemus]

The documentation failure is being addressed in #14067.

[RafiB982]

Hi @nicoddemus ,
I’ve addressed the latest feedback as follows:

1. Updated test_dict_extra_items_preserve_insertion_order to assert against the Full diff section explicitly, ensuring the test fails on main and only passes when insertion order is preserved. This avoids false positives from matching keys appearing elsewhere in the output.

2. Insertion order coverage: Expanded the test data to include multiple keys inserted in a non-alphabetical order (b, a, d, e, c) to better guard against regressions.

3. Assertion output behavior: Updated the assertion diff logic to preserve dictionary insertion order when rendering extra items, including in the Full diff output.

4. Reused precomputed key sets (set_left / set_right) for containment checks as suggested.

5. Changelog
   Updated changelog/13503.bugfix.rst to reflect the corrected behavior.

I’ve rebased the branch and pushed the changes. Please let me know if anything else should be adjusted.