Add `partialDeepEqual()` in strict assertion mode

[regseb]

What is the problem this feature will solve?

I use strict assertion mode in my tests:

import assert from "node:assert/strict";

assert.equal("...", "...");
assert.deepEqual({ "..." }, { "..." });
assert.partialDeepEqual({ "..." }, { "..." });

But the partialDeepEqual() doesn't exist. You have to use partialDeepStrictEqual() that has the word Strict in its name, whereas the other methods do not.

What is the feature you are proposing to solve the problem?

The "node:assert/strict" module should re-export partialDeepStrictEqual() with the name partialDeepEqual() so that function names are consistent in strict assertion mode.

Additional information

The partialDeepStrictEqual() function was added with #54630. I couldn't find any references to the terms strict assertion mode.

"Re-export" takes place in two locations:

• Probably for import assert from "node:assert/strict"
  

  node/lib/assert.js

  Lines 126 to 131 in 56aba88

  	if (options.strict) {
  	this.equal = this.strictEqual;
  	this.deepEqual = this.deepStrictEqual;
  	this.notEqual = this.notStrictEqual;
  	this.notDeepEqual = this.notDeepStrictEqual;
  	}

• Probably for import { strict as assert } from "node:assert"
  

  node/lib/assert.js

  Lines 894 to 899 in 56aba88

  	assert.strict = ObjectAssign(strict, assert, {
  	equal: assert.strictEqual,
  	deepEqual: assert.deepStrictEqual,
  	notEqual: assert.notStrictEqual,
  	notDeepEqual: assert.notDeepStrictEqual,
  	});

I don't think adding the following two lines is enough?

// if (options.strict) { 
this.partialDeepEqual = this.partialDeepStrictEqual; 

// assert.strict = ObjectAssign(strict, assert, { 
partialDeepEqual: assert.partialDeepStrictEqual, 

Because partialDeepEqual() doesn't exist in legacy assertion mode. So we need to manage the fact that the Assert type will be different between the two modes.

[regseb]

I see three possibilities:

1. Have only partialDeepStrictEqual() (current version)
   • Advantage: We know that partialDeepStrictEqual() does not exist in legacy mode.
   • Disadvantage: In strict mode, all methods have aliases without strict except partialDeepStrictEqual().
2. Have partialDeepStrictEqual() and partialDeepEqual() (the worst-case scenario 👎)
   • Advantage: All methods exist in both modes, and they are all aliases without strict in strict mode.
   • Disadvantage: You have to add a deprecated method.
3. Have partialDeepStrictEqual() and its alias partialDeepEqual() only in strict mode (my suggestion ❤️)
   • Advantage: All methods have their aliases without strict in strict mode.
   • Disadvantage: partialDeepEqual() only exists in strict mode.

---

In my projects, I only use strict mode and aliases without strict. Aliases allow for shorter method names and make the code more readable. I'd really like to have the partialDeepEqual() alias (only in strict mode) for these two reasons, as well as to maintain consistency in my asserts.

[Renegade334]

The shape of the assert and assert/strict modules should remain equivalent. We shouldn't start adding pseudo-aliases to one that don't exist in the other, particularly when the only real argument is "it looks nicer".

[BridgeAR]

Having strict in any of our names is not ideal and it is purely a legacy issue that we can not really solve.

The strict mode was implemented with avoiding that word while still having the overall implementation as expected. I slightly lean on the third suggestion therefore (adding the alias in strict mode only), while I also very well understand the reasoning of @Renegade334 to not introduce a pseudo-alias. This is a tricky not perfect API world and either way it is not ideal.

[ljharb]

I’d prefer 2; i weigh consistency more highly than “non-strict methods are icky”