@aztec/kv-store 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

package/dest/interfaces/map_test_suite.js

@@ -1,5 +1,4 @@
 import { toArray } from '@aztec/foundation/iterable';
-import { expect } from 'chai';
 import { isSyncStore } from './utils.js';
 export function describeAztecMap(testName, getStore, forceAsync = false) {
     describe(testName, ()=>{
@@ -30,9 +29,9 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
         it('should be able to set and get values', async ()=>{
             await map.set('foo', 'bar');
             await map.set('baz', 'qux');
-            expect(await get('foo')).to.equal('bar');
-            expect(await get('baz')).to.equal('qux');
-            expect(await get('quux')).to.equal(undefined);
+            expect(await get('foo')).toBe('bar');
+            expect(await get('baz')).toBe('qux');
+            expect(await get('quux')).toBe(undefined);
         });
         it('should be able to set many values', async ()=>{
             const pairs = Array.from({
@@ -43,41 +42,62 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
                 }));
             await map.setMany(pairs);
             for (const { key, value } of pairs){
-                expect(await get(key)).to.equal(value);
+                expect(await get(key)).toBe(value);
             }
         });
         it('should be able to overwrite values', async ()=>{
             await map.set('foo', 'bar');
             await map.set('foo', 'baz');
-            expect(await get('foo')).to.equal('baz');
+            expect(await get('foo')).toBe('baz');
         });
         it('should be able to set values if they do not exist', async ()=>{
-            expect(await map.setIfNotExists('foo', 'bar')).to.equal(true);
-            expect(await map.setIfNotExists('foo', 'baz')).to.equal(false);
-            expect(await get('foo')).to.equal('bar');
+            expect(await map.setIfNotExists('foo', 'bar')).toBe(true);
+            expect(await map.setIfNotExists('foo', 'baz')).toBe(false);
+            expect(await get('foo')).toBe('bar');
         });
         it('should be able to delete values', async ()=>{
             await map.set('foo', 'bar');
             await map.set('baz', 'qux');
             await map.delete('foo');
-            expect(await get('foo')).to.equal(undefined);
-            expect(await get('baz')).to.equal('qux');
+            expect(await get('foo')).toBe(undefined);
+            expect(await get('baz')).toBe('qux');
         });
         it('should be able to return size of the map', async ()=>{
             await map.set('foo', 'bar');
-            expect(await size()).to.equal(1);
+            expect(await size()).toBe(1);
             await map.set('baz', 'qux');
-            expect(await size()).to.equal(2);
+            expect(await size()).toBe(2);
             await map.delete('foo');
-            expect(await size()).to.equal(1);
+            expect(await size()).toBe(1);
+        });
+        it('returns 0 for empty map size', async ()=>{
+            expect(await size()).toBe(0);
+        });
+        it('calculates size correctly across multiple operations', async ()=>{
+            expect(await size()).toBe(0);
+            // Add items
+            await map.set('a', 'value1');
+            await map.set('b', 'value2');
+            await map.set('c', 'value3');
+            expect(await size()).toBe(3);
+            // Update existing (size should not change)
+            await map.set('b', 'updated');
+            expect(await size()).toBe(3);
+            // Delete some
+            await map.delete('a');
+            expect(await size()).toBe(2);
+            // Delete all
+            await map.delete('b');
+            await map.delete('c');
+            expect(await size()).toBe(0);
         });
         it('should be able to iterate over entries when there are no keys', async ()=>{
-            expect(await entries()).to.deep.equal([]);
+            expect(await entries()).toEqual([]);
         });
         it('should be able to iterate over entries', async ()=>{
             await map.set('foo', 'bar');
             await map.set('baz', 'qux');
-            expect(await entries()).to.deep.equal([
+            expect(await entries()).toEqual([
                 [
                     'baz',
                     'qux'
@@ -91,7 +111,7 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
         it('should be able to iterate over values', async ()=>{
             await map.set('foo', 'bar');
             await map.set('baz', 'quux');
-            expect(await values()).to.deep.equal([
+            expect(await values()).toEqual([
                 'quux',
                 'bar'
             ]);
@@ -99,7 +119,7 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
         it('should be able to iterate over keys', async ()=>{
             await map.set('foo', 'bar');
             await map.set('baz', 'qux');
-            expect(await keys()).to.deep.equal([
+            expect(await keys()).toEqual([
                 'baz',
                 'foo'
             ]);
@@ -107,7 +127,7 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
         it('should be able to iterate over string keys that represent numbers', async ()=>{
             await map.set('0x22', 'bar');
             await map.set('0x31', 'qux');
-            expect(await keys()).to.deep.equal([
+            expect(await keys()).toEqual([
                 '0x22',
                 '0x31'
             ]);
@@ -131,8 +151,15 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
                     4
                 ]
             ],
-            // disabled because indexeddb sorts lexigographically
-            // ['negative numbers', [-4, -3, -2, -1]],
+            [
+                'negative numbers',
+                [
+                    -4,
+                    -3,
+                    -2,
+                    -1
+                ]
+            ],
             [
                 'strings',
                 [
@@ -150,6 +177,24 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
                     2,
                     3
                 ]
+            ],
+            [
+                'large numbers',
+                [
+                    100,
+                    999,
+                    1000,
+                    1001
+                ]
+            ],
+            [
+                'mixed negative and positive',
+                [
+                    -1000,
+                    -1,
+                    1,
+                    1000
+                ]
             ]
         ]){
             it(`supports range queries over ${name} keys`, async ()=>{
@@ -158,7 +203,7 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
                 await map.set(b, 'b');
                 await map.set(c, 'c');
                 await map.set(d, 'd');
-                expect(await keys()).to.deep.equal([
+                expect(await keys()).toEqual([
                     a,
                     b,
                     c,
@@ -167,19 +212,19 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
                 expect(await keys({
                     start: b,
                     end: c
-                })).to.deep.equal([
+                })).toEqual([
                     b
                 ]);
                 expect(await keys({
                     start: b
-                })).to.deep.equal([
+                })).toEqual([
                     b,
                     c,
                     d
                 ]);
                 expect(await keys({
                     end: c
-                })).to.deep.equal([
+                })).toEqual([
                     a,
                     b
                 ]);
@@ -187,26 +232,26 @@ export function describeAztecMap(testName, getStore, forceAsync = false) {
                     start: b,
                     end: c,
                     reverse: true
-                })).to.deep.equal([
+                })).toEqual([
                     c
                 ]);
                 expect(await keys({
                     start: b,
                     limit: 1
-                })).to.deep.equal([
+                })).toEqual([
                     b
                 ]);
                 expect(await keys({
                     start: b,
                     reverse: true
-                })).to.deep.equal([
+                })).toEqual([
                     d,
                     c
                 ]);
                 expect(await keys({
                     end: b,
                     reverse: true
-                })).to.deep.equal([
+                })).toEqual([
                     b,
                     a
                 ]);

package/dest/interfaces/multi_map_test_suite.d.ts

@@ -1,3 +1,3 @@
 import type { AztecAsyncKVStore, AztecKVStore } from './store.js';
 export declare function describeAztecMultiMap(testName: string, getStore: () => AztecKVStore | Promise<AztecAsyncKVStore>, forceAsync?: boolean): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsdGlfbWFwX3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2VzL211bHRpX21hcF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxNQUFNLFlBQVksQ0FBQztBQUdsRSx3QkFBZ0IscUJBQXFCLENBQ25DLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLFFBQVEsRUFBRSxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsaUJBQWlCLENBQUMsRUFDekQsVUFBVSxHQUFFLE9BQWUsUUF5VTVCIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsdGlfbWFwX3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2VzL211bHRpX21hcF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxNQUFNLFlBQVksQ0FBQztBQUdsRSx3QkFBZ0IscUJBQXFCLENBQ25DLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLFFBQVEsRUFBRSxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsaUJBQWlCLENBQUMsRUFDekQsVUFBVSxHQUFFLE9BQWUsUUF5VzVCIn0=

package/dest/interfaces/multi_map_test_suite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multi_map_test_suite.d.ts","sourceRoot":"","sources":["../../src/interfaces/multi_map_test_suite.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGlE,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,EACzD,UAAU,GAAE,OAAe,QAyU5B"}
+{"version":3,"file":"multi_map_test_suite.d.ts","sourceRoot":"","sources":["../../src/interfaces/multi_map_test_suite.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGlE,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,EACzD,UAAU,GAAE,OAAe,QAyW5B"}

package/dest/interfaces/multi_map_test_suite.js

@@ -1,5 +1,4 @@
 import { toArray } from '@aztec/foundation/iterable';
-import { expect } from 'chai';
 import { isSyncStore } from './utils.js';
 export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
     describe(testName, ()=>{
@@ -36,37 +35,62 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
         it('should be able to set and get values', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('baz', 'qux');
-            expect(await get('foo')).to.equal('bar');
-            expect(await get('baz')).to.equal('qux');
-            expect(await get('quux')).to.equal(undefined);
+            expect(await get('foo')).toBe('bar');
+            expect(await get('baz')).toBe('qux');
+            expect(await get('quux')).toBe(undefined);
         });
         it('should be able to set values if they do not exist', async ()=>{
-            expect(await multiMap.setIfNotExists('foo', 'bar')).to.equal(true);
-            expect(await multiMap.setIfNotExists('foo', 'baz')).to.equal(false);
-            expect(await get('foo')).to.equal('bar');
+            expect(await multiMap.setIfNotExists('foo', 'bar')).toBe(true);
+            expect(await multiMap.setIfNotExists('foo', 'baz')).toBe(false);
+            expect(await get('foo')).toBe('bar');
         });
         it('should be able to delete values', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('baz', 'qux');
             await multiMap.delete('foo');
-            expect(await get('foo')).to.equal(undefined);
-            expect(await get('baz')).to.equal('qux');
+            expect(await get('foo')).toBe(undefined);
+            expect(await get('baz')).toBe('qux');
         });
         it('should be able to get size of the map', async ()=>{
             await multiMap.set('foo', 'bar');
-            expect(await size()).to.equal(1);
+            expect(await size()).toBe(1);
             await multiMap.set('baz', 'qux');
-            expect(await size()).to.equal(2);
+            expect(await size()).toBe(2);
             await multiMap.delete('foo');
-            expect(await size()).to.equal(1);
+            expect(await size()).toBe(1);
+        });
+        it('returns 0 for empty multimap size', async ()=>{
+            expect(await size()).toBe(0);
+        });
+        it('calculates size correctly with multiple values per key', async ()=>{
+            expect(await size()).toBe(0);
+            // Add multiple values for same key
+            await multiMap.set('key1', 'value1');
+            expect(await size()).toBe(1);
+            await multiMap.set('key1', 'value2');
+            expect(await size()).toBe(2);
+            await multiMap.set('key1', 'value3');
+            expect(await size()).toBe(3);
+            // Add values for different key
+            await multiMap.set('key2', 'value4');
+            expect(await size()).toBe(4);
+            // Delete one value from key1
+            await multiMap.deleteValue('key1', 'value2');
+            expect(await size()).toBe(3);
+            // Delete entire key
+            await multiMap.delete('key1');
+            expect(await size()).toBe(1);
+            // Delete last key
+            await multiMap.delete('key2');
+            expect(await size()).toBe(0);
         });
         it('should be able to iterate over entries when there are no keys', async ()=>{
-            expect(await entries()).to.deep.equal([]);
+            expect(await entries()).toEqual([]);
         });
         it('should be able to iterate over entries', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('baz', 'qux');
-            expect(await entries()).to.deep.equal([
+            expect(await entries()).toEqual([
                 [
                     'baz',
                     'qux'
@@ -80,7 +104,7 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
         it('should be able to iterate over values', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('baz', 'quux');
-            expect(await values()).to.deep.equal([
+            expect(await values()).toEqual([
                 'quux',
                 'bar'
             ]);
@@ -88,7 +112,7 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
         it('should be able to iterate over keys', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('baz', 'qux');
-            expect(await keys()).to.deep.equal([
+            expect(await keys()).toEqual([
                 'baz',
                 'foo'
             ]);
@@ -96,7 +120,7 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
         it('should be able to get multiple values for a single key', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('foo', 'baz');
-            expect(await getValues('foo')).to.deep.equal([
+            expect(await getValues('foo')).toEqual([
                 'bar',
                 'baz'
             ]);
@@ -104,7 +128,7 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
         it('should ignore multiple identical values', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('foo', 'bar');
-            expect(await getValues('foo')).to.deep.equal([
+            expect(await getValues('foo')).toEqual([
                 'bar'
             ]);
         });
@@ -113,7 +137,7 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
             await multiMap.set('foo', '2');
             await multiMap.set('foo', '3');
             await multiMap.deleteValue('foo', '2');
-            expect(await getValues('foo')).to.deep.equal([
+            expect(await getValues('foo')).toEqual([
                 '1',
                 '3'
             ]);
@@ -122,25 +146,25 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
             await multiMap.set('foo', '1');
             await multiMap.set('foo', '2');
             await multiMap.set('foo', '3');
-            expect(await size()).to.equal(3);
+            expect(await size()).toBe(3);
             await multiMap.set('bar', '1');
             await multiMap.set('bar', '2');
             await multiMap.set('bar', '3');
-            expect(await size()).to.equal(6);
+            expect(await size()).toBe(6);
             await multiMap.deleteValue('foo', '2');
-            expect(await size()).to.equal(5);
+            expect(await size()).toBe(5);
         });
         it('should be able to delete the last and first values for a key', async ()=>{
             await multiMap.set('foo', '1');
             await multiMap.set('foo', '2');
             await multiMap.set('foo', '3');
             await multiMap.deleteValue('foo', '1');
-            expect(await getValues('foo')).to.deep.equal([
+            expect(await getValues('foo')).toEqual([
                 '2',
                 '3'
             ]);
             await multiMap.deleteValue('foo', '3');
-            expect(await getValues('foo')).to.deep.equal([
+            expect(await getValues('foo')).toEqual([
                 '2'
             ]);
         });
@@ -151,7 +175,7 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
             await multiMap.deleteValue('foo', '1');
             await multiMap.deleteValue('foo', '3');
             await multiMap.deleteValue('foo', '2');
-            expect(await getValues('foo')).to.deep.equal([]);
+            expect(await getValues('foo')).toEqual([]);
         });
         it('should be able to insert after deletion', async ()=>{
             await multiMap.set('foo', '1');
@@ -159,14 +183,14 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
             await multiMap.set('foo', '3');
             await multiMap.deleteValue('foo', '2');
             await multiMap.set('foo', 'bar');
-            expect(await getValues('foo')).to.deep.equal([
+            expect(await getValues('foo')).toEqual([
                 '1',
                 '3',
                 'bar'
             ]);
             // Delete the just-added entry
             await multiMap.deleteValue('foo', 'bar');
-            expect(await getValues('foo')).to.deep.equal([
+            expect(await getValues('foo')).toEqual([
                 '1',
                 '3'
             ]);
@@ -175,7 +199,7 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
             // LMDB and IndexedDB behave differently here, the former ordering by value and the latter by insertion. This is
             // fine because there is no expectation for values in a multimap to be ordered.
             const values = (await getValues('foo')).sort((a, b)=>a.localeCompare(b));
-            expect(values).to.deep.equal([
+            expect(values).toEqual([
                 '1',
                 '2',
                 '3'
@@ -187,7 +211,7 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
             // Insert some more
             await multiMap.set('foo', 'baz');
             await multiMap.set('foo', 'qux');
-            expect(await getValues('foo')).to.deep.equal([
+            expect(await getValues('foo')).toEqual([
                 'baz',
                 'qux'
             ]);
@@ -200,19 +224,19 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
             expect(await keys({
                 start: 'b',
                 end: 'c'
-            })).to.deep.equal([
+            })).toEqual([
                 'b'
             ]);
             expect(await keys({
                 start: 'b'
-            })).to.deep.equal([
+            })).toEqual([
                 'b',
                 'c',
                 'd'
             ]);
             expect(await keys({
                 end: 'c'
-            })).to.deep.equal([
+            })).toEqual([
                 'a',
                 'b'
             ]);
@@ -220,86 +244,86 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
                 start: 'b',
                 end: 'c',
                 reverse: true
-            })).to.deep.equal([
+            })).toEqual([
                 'c'
             ]);
             expect(await keys({
                 start: 'b',
                 limit: 1
-            })).to.deep.equal([
+            })).toEqual([
                 'b'
             ]);
             expect(await keys({
                 start: 'b',
                 reverse: true
-            })).to.deep.equal([
+            })).toEqual([
                 'd',
                 'c'
             ]);
             expect(await keys({
                 end: 'b',
                 reverse: true
-            })).to.deep.equal([
+            })).toEqual([
                 'b',
                 'a'
             ]);
         });
         it('returns 0 for missing key', async ()=>{
-            expect(await getValueCount('missing')).to.equal(0);
+            expect(await getValueCount('missing')).toBe(0);
         });
         it('counts a single value', async ()=>{
             await multiMap.set('foo', 'bar');
-            expect(await getValueCount('foo')).to.equal(1);
+            expect(await getValueCount('foo')).toBe(1);
         });
         it('counts multiple distinct values for same key', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('foo', 'baz');
             await multiMap.set('foo', 'qux');
-            expect(await getValueCount('foo')).to.equal(3);
+            expect(await getValueCount('foo')).toBe(3);
         });
         it('does not increase count for duplicate inserts', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('foo', 'bar');
             await multiMap.set('foo', 'baz');
             await multiMap.set('foo', 'baz');
-            expect(await getValueCount('foo')).to.equal(2);
-            expect(await getValues('foo')).to.have.members([
+            expect(await getValueCount('foo')).toBe(2);
+            expect((await getValues('foo')).sort()).toEqual([
                 'bar',
                 'baz'
-            ]);
+            ].sort());
         });
         it('decrements when deleting a single value', async ()=>{
             await multiMap.set('foo', '1');
             await multiMap.set('foo', '2');
             await multiMap.set('foo', '3');
-            expect(await getValueCount('foo')).to.equal(3);
+            expect(await getValueCount('foo')).toBe(3);
             await multiMap.deleteValue('foo', '2');
-            expect(await getValueCount('foo')).to.equal(2);
-            expect(await getValues('foo')).to.have.members([
+            expect(await getValueCount('foo')).toBe(2);
+            expect((await getValues('foo')).sort()).toEqual([
                 '1',
                 '3'
-            ]);
+            ].sort());
         });
         it('does not change count when deleting a non-existent value', async ()=>{
             await multiMap.set('foo', '1');
             await multiMap.set('foo', '3');
-            expect(await getValueCount('foo')).to.equal(2);
+            expect(await getValueCount('foo')).toBe(2);
             await multiMap.deleteValue('foo', '2');
-            expect(await getValueCount('foo')).to.equal(2);
+            expect(await getValueCount('foo')).toBe(2);
         });
         it('clears all values when deleting a key', async ()=>{
             await multiMap.set('foo', 'bar');
             await multiMap.set('foo', 'baz');
-            expect(await getValueCount('foo')).to.equal(2);
+            expect(await getValueCount('foo')).toBe(2);
             await multiMap.delete('foo');
-            expect(await getValueCount('foo')).to.equal(0);
-            expect(await getValues('foo')).to.deep.equal([]);
+            expect(await getValueCount('foo')).toBe(0);
+            expect(await getValues('foo')).toEqual([]);
         });
         it('count equals enumerated values length', async ()=>{
             await multiMap.set('foo', '1');
             await multiMap.set('foo', '2');
             const vals = await getValues('foo');
-            expect(await getValueCount('foo')).to.equal(vals.length);
+            expect(await getValueCount('foo')).toBe(vals.length);
         });
         it('sum of per-key counts equals total size', async ()=>{
             await multiMap.set('foo', '1');
@@ -311,29 +335,29 @@ export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
             const uniqueKeys = Array.from(new Set(allKeys));
             const counts = await Promise.all(uniqueKeys.map((k)=>getValueCount(k)));
             const sum = counts.reduce((s, n)=>s + n, 0);
-            expect(sum).to.equal(await size());
+            expect(sum).toBe(await size());
         });
         it('supports sparse slots: delete middle, reinsert new, count remains correct', async ()=>{
             await multiMap.set('foo', '1');
             await multiMap.set('foo', '2');
             await multiMap.set('foo', '3');
-            expect(await getValueCount('foo')).to.equal(3);
+            expect(await getValueCount('foo')).toBe(3);
             await multiMap.deleteValue('foo', '2');
-            expect(await getValueCount('foo')).to.equal(2);
+            expect(await getValueCount('foo')).toBe(2);
             await multiMap.set('foo', '4');
-            expect(await getValueCount('foo')).to.equal(3);
-            expect(await getValues('foo')).to.have.members([
+            expect(await getValueCount('foo')).toBe(3);
+            expect((await getValues('foo')).sort()).toEqual([
                 '1',
                 '3',
                 '4'
-            ]);
+            ].sort());
         });
         it('multiple keys are independent', async ()=>{
             await multiMap.set('foo', '1');
             await multiMap.set('foo', '2');
             await multiMap.set('bar', '3');
-            expect(await getValueCount('foo')).to.equal(2);
-            expect(await getValueCount('bar')).to.equal(1);
+            expect(await getValueCount('foo')).toBe(2);
+            expect(await getValueCount('bar')).toBe(1);
         });
     });
 }

package/dest/interfaces/set_test_suite.d.ts

@@ -1,3 +1,3 @@
 import type { AztecAsyncKVStore, AztecKVStore } from './store.js';
 export declare function describeAztecSet(testName: string, getStore: () => AztecKVStore | Promise<AztecAsyncKVStore>, forceAsync?: boolean): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0X3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2VzL3NldF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxNQUFNLFlBQVksQ0FBQztBQUdsRSx3QkFBZ0IsZ0JBQWdCLENBQzlCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLFFBQVEsRUFBRSxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsaUJBQWlCLENBQUMsRUFDekQsVUFBVSxHQUFFLE9BQWUsUUFvRTVCIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0X3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2VzL3NldF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxNQUFNLFlBQVksQ0FBQztBQUdsRSx3QkFBZ0IsZ0JBQWdCLENBQzlCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLFFBQVEsRUFBRSxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsaUJBQWlCLENBQUMsRUFDekQsVUFBVSxHQUFFLE9BQWUsUUFvRTVCIn0=

package/dest/interfaces/set_test_suite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set_test_suite.d.ts","sourceRoot":"","sources":["../../src/interfaces/set_test_suite.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGlE,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,EACzD,UAAU,GAAE,OAAe,QAoE5B"}
+{"version":3,"file":"set_test_suite.d.ts","sourceRoot":"","sources":["../../src/interfaces/set_test_suite.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGlE,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,EACzD,UAAU,GAAE,OAAe,QAoE5B"}