Add an assertion for same members where order is important

I’ve come to discover that it’s not straightforward to test that an array has the same members, and that those members are in the expected order. Consider this base example:

var a = {};
var b = {};
var list = [ a, b ];

All of the assertions around “members” all explicitly do not consider order, but it would be really convenient to be able to assert that too:

// no idea what to call this assertion
assert.sameExactMembers(list, [ a, b ]);

My use-case is that I have an internal list that I can retrieve. In one case I return the list unsorted. (so sameMembers works great) In the other case, I am sorting it in a specific way, so I want to assert that my sort worked as expected.

I am using deepEqual now, but the member objects can be fairly big/deep and it’s very inefficient to traverse these objects, especially since I have the direct object refs in my tests.

// in my case, a & b could be huge, so would prefer not traverse them
assert.deepEqual(list, [ a, b ]);

Another option is that I can just use strictEqual on each item in the array, but that gets unwieldy quickly imo:

// only 2 in this case... but it's copy-pasta and ugly beyond a few members
assert.strictEqual(list[0], a);
assert.strictEqual(list[1], b);

[meeber]

What should be the behavior if both the contains and the ordered flags are set? Specifically, should both of these tests pass or only the first?

expect([1, 2, 3]).to.include.ordered.members([1, 2]);
expect([1, 2, 3]).to.include.ordered.members([2, 3]);

I’m leaning toward only the first passing, as I suspect it’s a more common use case to test that an array begins with an ordered subset.

[meeber]

Hmm… I think there are two main approaches:

1. New flag that tells the members assertion to require same-order.
2. New assertion that is very similar to members but requires same-order.

Either way, it should be usable with either deep or strict comparison.

Brainstorming syntax:

expect([1, 2, 3]).to.have.ordered.members([1, 2, 3]); // strict
expect([1, 2, 3]).to.have.deep.ordered.members([1, 2, 3]); // deep

expect([1, 2, 3]).to.have.orderedMembers([1, 2, 3]); // strict
expect([1, 2, 3]).to.have.deep.orderedMembers([1, 2, 3]); // deep