Есть ли функция сопоставления равенства массивов, которая игнорирует позицию элемента в jest.js?

Нет встроенного метода для сравнения массивов без сравнения порядка, но вы можете просто отсортировать массивы, используя _ 1_ перед сравнением:

expect(["ping wool", "diorite"].sort()).toEqual(["diorite", "pink wool"].sort());

Вы можете проверить пример в этой скрипке.

Собираем элементы в набор. Jest знает, как их сочетать.

expect(new Set(["pink wool", "diorite"])).toEqual(new Set(["diorite", "pink wool"]));

Как уже упоминалось, expect.arrayContaining проверяет, содержит ли массив actual массив expected в качестве подмножества. Для проверки эквивалентности можно

• либо утверждать, что длина обоих массивов одинакова (но это не приведет к появлению полезного сообщения об ошибке)
• или утверждать обратное: что массив expected содержит массив actual:

// This is TypeScript, but remove the types and you get JavaScript
const expectArrayEquivalence = <T>(actual: T[], expected: T[]) => {
  expect(actual).toEqual(expect.arrayContaining(expected));
  expect(expected).toEqual(expect.arrayContaining(actual));
};

По-прежнему существует проблема, заключающаяся в том, что когда тест не проходит в первом утверждении, человек узнает только об элементах, отсутствующих в actual, и не о дополнительных элементах, которых нет в expected.

это не дает точного ответа на вопрос, но все же может помочь людям, которые попадают сюда с помощью поиска Google:

если вас интересует только то, что подмножество массива содержит определенные элементы, используйте expect.arrayContaining() https://jestjs.io/docs/en/expect#expectarraycontainarray

e.g.,

expect(["ping wool", "diorite"])
  .toEqual(expect.arrayContaining(["diorite", "pink wool"]));

Если вы хотите сравнить два массива в JEST, используйте приведенную ниже модель.

Официальная ссылка: https://jestjs.io/docs/en/expect#expectarraycontainarray

const array1 = ['a', 'b', 'c'];
const array2 = ['a', 'b', 'c'];
const array3 = ['a', 'b'];


it("test two arrays, this will be true", () => { 
    expect(array1).toEqual(expect.arrayContaining(array2));
});

it("test two arrays, this will be false", () => { 
    expect(array3).toEqual(expect.arrayContaining(array1));
});

Вы можете комбинировать использование наборов, как указано в этом ответе, с проверкой длины фактического результата и ожидания. Это проигнорирует положение элемента и одновременно защитит вас от дублирования элементов.

const materials = ['pink wool', 'diorite'];
const expectedMaterials = ['diorite', 'pink wool'];

expect(new Set(materials)).toEqual(new Set(expectedMaterials));
expect(materials.length).toBe(expectedMaterials.length);

Если у вас нет массива объектов, вы можете просто использовать sort () функция для сортировки перед сравнением. (упоминается в принятом ответе):

expect(["ping wool", "diorite"].sort()).toEqual(["diorite", "pink wool"].sort());

Однако проблема возникает, если у вас есть массив объектов, и в этом случае функция sort не будет работать. В этом случае вам необходимо предоставить настраиваемую функцию сортировки. Пример:

const x = [
{key: 'forecast', visible: true},
{key: 'pForecast', visible: false},
{key: 'effForecast', visible: true},
{key: 'effRegForecast', visible: true}
]

// In my use case, i wanted to sort by key
const sortByKey = (a, b) => { 
  if(a.key < b.key) return -1; 
  else if(a.key > b.key) return 1; 
  else return 0; 
  }

x.sort(sortByKey)
console.log(x)

Надеюсь, это когда-нибудь поможет кому-нибудь.

Работа еще продолжается, но это должно сработать, хотя сообщения об ошибках могут быть нечеткими:

expect.extend({
  arrayContainingExactly(receivedOriginal, expected) {
    const received = [...receivedOriginal];

    if (received.length !== expected.length) return {
      message: () => `Expected array of length ${expected.length} but got an array of length ${received.length}`,
      pass: false,
    };

    const pass = expected.every((expectedItem, index) => {
      const receivedIndex = findIndex(received, receivedItem => {
          if (expectedItem.asymmetricMatch) return expectedItem.asymmetricMatch(receivedItem);
          return isEqual(expectedItem, receivedItem);
      });
      if (receivedIndex === -1) return false;
      received.splice(receivedIndex, 1);
      return true;
    });

    return {
      message: () => 'Success',
      pass,
    }
  }
});

Затем используйте это так:

expect(['foo', 'bar']).arrayContainingExactly(['foo']) // This should fail

or

expect({foo: ['foo', 'bar']}).toEqual({
  foo: expect.arrayContainingExactly(['bar', 'foo'])
}) // This should pass

Мы перебираем каждое значение в цикле и удаляем его из полученного массива, чтобы мы могли воспользоваться преимуществом асимметричного сопоставления, предоставляемого Jest. Если бы мы просто хотели сделать прямую эквивалентность, это можно было бы упростить, просто сравнив 2 отсортированных массива.

Примечание. В этом решении используются findIndex и isEqual из lodash.

Другой способ - использовать настраиваемый сопоставитель .toIncludeSameMembers() из jest-community / jest-extended.

Пример из README

test('passes when arrays match in a different order', () => {
    expect([1, 2, 3]).toIncludeSameMembers([3, 1, 2]);
    expect([{ foo: 'bar' }, { baz: 'qux' }]).toIncludeSameMembers([{ baz: 'qux' }, { foo: 'bar' }]);
});

Возможно, нет смысла импортировать библиотеку только для одного сопоставителя, но у них есть много других полезных сопоставителей, которые я считаю полезными.