immutable-js · jdeniau · Mar 27, 2025 · Mar 27, 2025 · Mar 27, 2025
diff --git a/__tests__/ArraySeq.ts b/__tests__/ArraySeq.ts
@@ -1,4 +1,5 @@
 import { Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('ArraySequence', () => {
   it('every is true when predicate is true for all entries', () => {

diff --git a/__tests__/Comparator.ts b/__tests__/Comparator.ts
@@ -1,4 +1,5 @@
 import { List, OrderedSet, Seq, type Comparator, PairSorting } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 const sourceNumbers: readonly number[] = [3, 4, 5, 6, 7, 9, 10, 12, 90, 92, 95];
 

diff --git a/__tests__/Conversion.ts b/__tests__/Conversion.ts
@@ -1,4 +1,5 @@
 import { fromJS, is, List, Map, OrderedMap, Record } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc, { type JsonValue } from 'fast-check';
 
 describe('Conversion', () => {

diff --git a/__tests__/Equality.ts b/__tests__/Equality.ts
@@ -1,4 +1,5 @@
 import { is, List, Map, Seq, Set } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 
 describe('Equality', () => {

diff --git a/__tests__/IndexedSeq.ts b/__tests__/IndexedSeq.ts
@@ -1,4 +1,5 @@
 import { Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('IndexedSequence', () => {
   it('maintains skipped offset', () => {

diff --git a/__tests__/KeyedSeq.ts b/__tests__/KeyedSeq.ts
@@ -1,8 +1,9 @@
 import { Range, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 
 describe('KeyedSeq', () => {
-  it('it iterates equivalently', () => {
+  it('iterates equivalently', () => {
     fc.assert(
       fc.property(fc.array(fc.integer()), (ints) => {
         const seq = Seq(ints);

diff --git a/__tests__/List.ts b/__tests__/List.ts
@@ -1,4 +1,5 @@
 import { fromJS, List, Map, Range, Seq, Set } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 import { create as createSeed } from 'random-seed';
 

diff --git a/__tests__/ListJS.js b/__tests__/ListJS.js
@@ -1,4 +1,5 @@
 import { List } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 const NON_NUMBERS = {
   array: ['not', 'a', 'number'],

diff --git a/__tests__/Map.ts b/__tests__/Map.ts
@@ -1,4 +1,5 @@
 import { fromJS, is, List, Map, Range, Record, Seq } from 'immutable';
+import { describe, expect, it, vi } from 'vitest';
 import fc from 'fast-check';
 
 describe('Map', () => {
@@ -110,7 +111,7 @@ describe('Map', () => {
 
   it('iterates values', () => {
     const m = Map({ a: 'A', b: 'B', c: 'C' });
-    const iterator = jest.fn();
+    const iterator = vi.fn();
     m.forEach(iterator);
     expect(iterator.mock.calls).toEqual([
       ['A', 'a', m],

diff --git a/__tests__/MultiRequire.js b/__tests__/MultiRequire.js
@@ -1,8 +1,9 @@
 import * as Immutable1 from '../src/Immutable';
+import { describe, expect, it, vi } from 'vitest';
 
-jest.resetModules();
+vi.resetModules();
 
-const Immutable2 = jest.requireActual('../src/Immutable');
+const Immutable2 = await vi.importActual('../src/Immutable');
 
 describe('MultiRequire', () => {
   it('might require two different instances of Immutable', () => {

diff --git a/__tests__/ObjectSeq.ts b/__tests__/ObjectSeq.ts
@@ -1,4 +1,5 @@
 import { Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('ObjectSequence', () => {
   it('maps', () => {

diff --git a/__tests__/OrderedMap.ts b/__tests__/OrderedMap.ts
@@ -1,4 +1,5 @@
 import { OrderedMap, Range, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('OrderedMap', () => {
   it('converts from object', () => {

diff --git a/__tests__/OrderedSet.ts b/__tests__/OrderedSet.ts
@@ -1,4 +1,5 @@
 import { OrderedSet, Map } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('OrderedSet', () => {
   it('provides initial values in a mixed order', () => {

diff --git a/__tests__/Predicates.ts b/__tests__/Predicates.ts
@@ -7,6 +7,7 @@ import {
   Set,
   Stack,
 } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('isImmutable', () => {
   it('behaves as advertised', () => {

diff --git a/__tests__/Range.ts b/__tests__/Range.ts
@@ -1,4 +1,5 @@
 import { Range } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 
 describe('Range', () => {

diff --git a/__tests__/Record.ts b/__tests__/Record.ts
@@ -1,4 +1,5 @@
 import { isKeyed, List, Map, Record, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('Record', () => {
   it('defines a constructor', () => {
@@ -78,7 +79,7 @@ describe('Record', () => {
     const MyType = Record({ a: 1, b: 2, c: 3 });
     const t1 = MyType({ a: 10 });
     const t2 = MyType({ a: 10, b: 2 });
-    expect(t1.equals(t2));
+    expect(t1.equals(t2)).toBe(true);
   });
 
   it('if compared against undefined or null should return false', () => {

diff --git a/__tests__/RecordJS.js b/__tests__/RecordJS.js
@@ -1,4 +1,5 @@
 import { Record } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('Record', () => {
   it('defines a record factory', () => {
@@ -41,8 +42,8 @@ describe('Record', () => {
     const t = new Alphabet();
     const t2 = t.set('b', 200);
 
-    expect(t instanceof Record);
-    expect(t instanceof Alphabet);
+    expect(t).toBeInstanceOf(Record);
+    expect(t).toBeInstanceOf(Alphabet);
     expect(t.soup()).toBe(6);
     expect(t2.soup()).toBe(204);
 

diff --git a/__tests__/Repeat.ts b/__tests__/Repeat.ts
@@ -1,4 +1,5 @@
 import { Repeat } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('Repeat', () => {
   it('fixed repeat', () => {

diff --git a/__tests__/Seq.ts b/__tests__/Seq.ts
@@ -1,4 +1,5 @@
 import { isCollection, isIndexed, isKeyed, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('Seq', () => {
   it('returns undefined if empty and first is called without default argument', () => {

diff --git a/__tests__/Set.ts b/__tests__/Set.ts
@@ -1,4 +1,5 @@
 import { fromJS, is, List, Map, OrderedSet, Seq, Set } from 'immutable';
+import { describe, expect, it, vi } from 'vitest';
 
 describe('Set', () => {
   it('accepts array of values', () => {
@@ -138,7 +139,7 @@ describe('Set', () => {
 
   it('iterates values', () => {
     const s = Set([1, 2, 3]);
-    const iterator = jest.fn();
+    const iterator = vi.fn();
     s.forEach(iterator);
     expect(iterator.mock.calls).toEqual([
       [1, 1, s],

diff --git a/__tests__/Stack.ts b/__tests__/Stack.ts
@@ -1,4 +1,5 @@
 import { Seq, Stack } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 
 function arrayOfSize(s) {

diff --git a/__tests__/__snapshots__/Record.ts.snap b/__tests__/__snapshots__/Record.ts.snap
@@ -1,7 +1,7 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`Record does not accept a Record as constructor 1`] = `"Can not call \`Record\` with an immutable Record as default values. Use a plain javascript object instead."`;
+exports[`Record > does not accept a Record as constructor 1`] = `[Error: Can not call \`Record\` with an immutable Record as default values. Use a plain javascript object instead.]`;
 
-exports[`Record does not accept a non object as constructor 1`] = `"Can not call \`Record\` with a non-object as default values. Use a plain javascript object instead."`;
+exports[`Record > does not accept a non object as constructor 1`] = `[Error: Can not call \`Record\` with a non-object as default values. Use a plain javascript object instead.]`;
 
-exports[`Record does not accept an immutable object that is not a Record as constructor 1`] = `"Can not call \`Record\` with an immutable Collection as default values. Use a plain javascript object instead."`;
+exports[`Record > does not accept an immutable object that is not a Record as constructor 1`] = `[Error: Can not call \`Record\` with an immutable Collection as default values. Use a plain javascript object instead.]`;
diff --git a/__tests__/concat.ts b/__tests__/concat.ts
@@ -1,4 +1,5 @@
 import { List, Seq, Set } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('concat', () => {
   it('concats two sequences', () => {
@@ -189,7 +190,7 @@ describe('concat', () => {
     }
 
     expect(meta.toList().size).toBe(10000);
-  });
+  }, 20000);
 
   it('should handle iterator on many concatenated sequences', () => {
     const nbLoops = 10000;
@@ -206,7 +207,7 @@ describe('concat', () => {
       done = !!result.done;
     }
     expect(i).toBe(nbLoops);
-  });
+  }, 20000);
 
   it('should iterate on reverse order on concatenated sequences', () => {
     let meta = Seq([1]);

diff --git a/__tests__/count.ts b/__tests__/count.ts
@@ -1,4 +1,5 @@
 import { Range, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('count', () => {
   it('counts sequences with known lengths', () => {

diff --git a/__tests__/find.ts b/__tests__/find.ts
@@ -1,4 +1,5 @@
 import { Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('find', () => {
   it('find returns notSetValue when match is not found', () => {

diff --git a/__tests__/flatten.ts b/__tests__/flatten.ts
@@ -1,4 +1,5 @@
 import { Collection, fromJS, List, Range, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('flatten', () => {
   it('flattens sequences one level deep', () => {

diff --git a/__tests__/fromJS.ts b/__tests__/fromJS.ts
@@ -1,5 +1,5 @@
 import { runInNewContext } from 'vm';
-
+import { describe, expect, it } from 'vitest';
 import { List, Map, Set, isCollection, fromJS } from 'immutable';
 
 describe('fromJS', () => {
@@ -64,6 +64,7 @@ describe('fromJS', () => {
     expect(isCollection(fromJS({}))).toBe(true);
   });
 
+  // eslint-disable-next-line vitest/expect-expect
   it('is iterable inside of a vm', () => {
     runInNewContext(
       `

diff --git a/__tests__/functional/get.ts b/__tests__/functional/get.ts
@@ -1,4 +1,5 @@
 import { get, Map, List, Range } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('get', () => {
   it('for immutable structure', () => {

diff --git a/__tests__/functional/has.ts b/__tests__/functional/has.ts
@@ -1,4 +1,5 @@
 import { has, Map, List, Range } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('has', () => {
   it('for immutable structure', () => {

diff --git a/__tests__/functional/remove.ts b/__tests__/functional/remove.ts
@@ -1,4 +1,5 @@
 import { remove, List, Map } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('remove', () => {
   it('for immutable structure', () => {

diff --git a/__tests__/functional/set.ts b/__tests__/functional/set.ts
@@ -1,4 +1,5 @@
 import { set } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('set', () => {
   it('for immutable structure', () => {

diff --git a/__tests__/functional/update.ts b/__tests__/functional/update.ts
@@ -1,4 +1,5 @@
 import { update } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('update', () => {
   it('for immutable structure', () => {

diff --git a/__tests__/get.ts b/__tests__/get.ts
@@ -1,4 +1,5 @@
 import { Range } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('get', () => {
   it('gets any index', () => {

diff --git a/__tests__/getIn.ts b/__tests__/getIn.ts
@@ -1,4 +1,5 @@
 import { fromJS, getIn, List, Map } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('getIn', () => {
   it('deep get', () => {

diff --git a/__tests__/groupBy.ts b/__tests__/groupBy.ts
@@ -9,6 +9,7 @@ import {
   Set,
   Stack,
 } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('groupBy', () => {
   it.each`

diff --git a/__tests__/hasIn.ts b/__tests__/hasIn.ts
@@ -1,4 +1,5 @@
 import { fromJS, hasIn, List, Map } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('hasIn', () => {
   it('deep has', () => {

diff --git a/__tests__/hash.ts b/__tests__/hash.ts
@@ -1,4 +1,5 @@
 import { hash } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 
 describe('hash', () => {

diff --git a/__tests__/interpose.ts b/__tests__/interpose.ts
@@ -1,4 +1,5 @@
 import { Range } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('interpose', () => {
   it('separates with a value', () => {

diff --git a/__tests__/issues.ts b/__tests__/issues.ts
@@ -8,6 +8,7 @@ import {
   Seq,
   Set,
 } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('Issue #1175', () => {
   it('invalid hashCode() response should not infinitly recurse', () => {
@@ -34,7 +35,7 @@ describe('Issue #1188', () => {
   });
 });
 
-describe('Issue #1220 : Seq.rest() throws an exception when invoked on a single item sequence ', () => {
+describe('Issue #1220 : Seq.rest() throws an exception when invoked on a single item sequence', () => {
   it('should be iterable', () => {
     // Helper for this test
     const ITERATOR_SYMBOL =
@@ -122,15 +123,17 @@ describe('Issue #1643', () => {
 
     it(`Collection#hashCode() should handle objects that return ${label} for valueOf`, () => {
       const set = Set().add(new MyClass());
-      set.hashCode();
+      expect(() => set.hashCode()).not.toThrow();
     });
   });
 });
 
 describe('Issue #1785', () => {
-  const emptyRecord = Record({})();
+  it('merge() should not return undefined', () => {
+    const emptyRecord = Record({})();
 
-  expect(emptyRecord.merge({ id: 1 })).toBe(emptyRecord);
+    expect(emptyRecord.merge({ id: 1 })).toBe(emptyRecord);
+  });
 });
 
 describe('Issue #1475', () => {

diff --git a/__tests__/join.ts b/__tests__/join.ts
@@ -1,4 +1,5 @@
 import { Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 
 describe('join', () => {

diff --git a/__tests__/merge.ts b/__tests__/merge.ts
@@ -8,6 +8,7 @@ import {
   Record,
   Set,
 } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('merge', () => {
   it('merges two maps', () => {

diff --git a/__tests__/minmax.ts b/__tests__/minmax.ts
@@ -1,4 +1,5 @@
 import { is, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 
 const genHeterogeneousishArray = fc.oneof(

diff --git a/__tests__/partition.ts b/__tests__/partition.ts
@@ -11,12 +11,13 @@ import {
   Seq,
   Set as ISet,
 } from 'immutable';
+import { beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
 
 describe('partition', () => {
-  let isOdd: jest.Mock<unknown, [x: number]>;
+  let isOdd: Mock<(x: number) => number>;
 
   beforeEach(() => {
-    isOdd = jest.fn((x) => x % 2);
+    isOdd = vi.fn((x) => x % 2);
   });
 
   it('partitions keyed sequence', () => {

diff --git a/__tests__/slice.ts b/__tests__/slice.ts
@@ -1,4 +1,5 @@
 import { List, Range, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 import fc from 'fast-check';
 
 describe('slice', () => {

diff --git a/__tests__/sort.ts b/__tests__/sort.ts
@@ -1,4 +1,5 @@
 import { List, OrderedMap, Range, Seq } from 'immutable';
+import { describe, expect, it } from 'vitest';
 
 describe('sort', () => {
   it('sorts a sequence', () => {