rubico/x/isDeepEqual.test.js

[a]synchronous functional programming

const assert = require('assert')
const isDeepEqual = require('./isDeepEqual')

describe('isDeepEqual', () => {
  it('checks for deep equality', async () => {
    assert.strictEqual(isDeepEqual(
      [1, 2, 3],
      [1, 2, 3],
    ), true)
    assert.strictEqual(isDeepEqual(
      [1, 2, 3],
      [1, 2, 3, 4],
    ), false)
    assert.strictEqual(isDeepEqual(
      [1, 2, 3, 4],
      [1, 2, 3],
    ), false)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: 2, c: 3 },
      { a: 1, b: 2, c: 3 },
    ), true)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: 2, c: 3 },
      { a: 1 },
    ), false)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: [1, 2, 3] },
      { a: 1, b: [1, 2, 3] },
    ), true)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: [1, 2, 3] },
      { a: 1, b: [1, 2] },
    ), false)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: new Set([]) },
      { a: 1, b: new Set([1, 2, 3]) },
    ), false)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: new Set([1, 2, 3]) },
      { a: 1, b: new Set([1, 2, 3]) },
    ), true)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: new Set([1, 2, { a: 1 }]) },
      { a: 1, b: new Set([1, 2, { b: 2 }]) },
    ), false)
    assert.strictEqual(isDeepEqual(
      new Map([['a', 1]]),
      new Map([['a', 1]]),
    ), true)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: new Map([['a', 1], ['b', { a: 1 }]]) },
      { a: 1, b: new Map([['a', 1], ['b', { a: 1 }]]) },
    ), true)
    assert.strictEqual(isDeepEqual(
      { a: 1, b: new Map([['a', 1], ['b', { a: 1 }]]) },
      { a: 1, b: new Map([['a', 1], ['b', { b: 2 }]]) },
    ), false)
  })

  it('takes functions as arguments, returning a partially applied function', async () => {
    assert.strictEqual(isDeepEqual([1, 2, 3], array => array)([1, 2, 3]), true)
    assert.strictEqual(isDeepEqual(array => array, [1, 2, 3])([1, 2, 3]), true)
    assert.strictEqual(isDeepEqual(array => array, () => [1, 2, 3])([1, 2, 3]), true)
    assert.strictEqual(await isDeepEqual([1, 2, 3], async array => array)([1, 2, 3]), true)
    assert.strictEqual(await isDeepEqual(async array => array, [1, 2, 3])([1, 2, 3]), true)
    assert.strictEqual(await isDeepEqual(async array => array, async () => [1, 2, 3])([1, 2, 3]), true)
    assert.strictEqual(await isDeepEqual(async array => array, () => [1, 2, 3])([1, 2, 3]), true)
    assert.strictEqual(await isDeepEqual(array => array, async () => [1, 2, 3])([1, 2, 3]), true)
  })

  it('treats nullish (null and undefined) differently', async () => {
    assert.strictEqual(isDeepEqual(null, null), true)
    assert.strictEqual(isDeepEqual(null, undefined), false)
    assert.strictEqual(isDeepEqual(undefined, undefined), true)
  })

  it('checks values by SameValueZero', async () => {
    assert.strictEqual(isDeepEqual(NaN, NaN), true)
    assert.strictEqual(isDeepEqual(+0, -0), true)
    assert.strictEqual(isDeepEqual(1, 1), true)
    assert.strictEqual(isDeepEqual(0, 0), true)
    assert.strictEqual(isDeepEqual(false, false), true)
    assert.strictEqual(isDeepEqual(true, false), false)
    assert.strictEqual(isDeepEqual(1, '1'), false)
    assert.strictEqual(isDeepEqual('1', '1'), true)
  })

  it('checks empty deep equality', async () => {
    assert.strictEqual(isDeepEqual({}, {}), true)
    assert.strictEqual(isDeepEqual({}, []), false)
    assert.strictEqual(isDeepEqual([], []), true)
  })
})