more tests

Author: pawelangelow

redisinsight/api/test/api/array/POST-databases-id-array-get_next_index.test.ts

@@ -107,6 +107,44 @@ describe('POST /databases/:instanceId/array/get-next-index', () => {
       });
     });
 
+    it('Should return null when the cursor is exhausted', async () => {
+      const keyName = constants.getRandomString();
+      // Reach exhaustion: ARSEEK to the max valid index (2^64-2) then
+      // ARINSERT one element. The next slot would be 2^64-1, which Redis
+      // reserves as the no-index sentinel — ARNEXT reports the cursor as
+      // exhausted via a nil reply, which toIndexString must surface as
+      // JSON null (NOT the literal string "null").
+      await rte.client.call('ARSEEK', keyName, '18446744073709551614');
+      await rte.client.call('ARINSERT', keyName, 'last');
+
+      await validateApiCall({
+        endpoint,
+        data: { keyName },
+        responseSchema,
+        responseBody: { keyName, index: null },
+      });
+    });
+
+    it('Should round-trip a cursor above MAX_SAFE_INTEGER', async () => {
+      const keyName = constants.getRandomString();
+      // ARSEEK to a u64 cursor that exceeds Number.MAX_SAFE_INTEGER (2^53-1).
+      // If the wire path ever decodes the integer reply as a JS number,
+      // precision is silently lost — this assertion catches that regression.
+      const hugeCursor = '9223372036854775818';
+      await rte.client.call('ARSEEK', keyName, hugeCursor);
+
+      await validateApiCall({
+        endpoint,
+        data: { keyName },
+        responseSchema,
+        responseBody: { keyName, index: hugeCursor },
+        checkFn: ({ body }: any) => {
+          expect(typeof body.index).to.eql('string');
+          expect(body.index).to.eql(hugeCursor);
+        },
+      });
+    });
+
     [
       {
         name: 'Should return BadRequest if key holds a non-array type',

redisinsight/api/test/api/array/POST-databases-id-array-scan.test.ts

@@ -118,6 +118,18 @@ describe('POST /databases/:instanceId/array/scan', () => {
         },
         statusCode: 400,
       },
+      {
+        // DTO contract: @IsOptional + @IsInt + @Min(1). limit:0 must fail
+        // validation before it can become a no-op `LIMIT 0` at Redis.
+        name: 'Should reject limit: 0 (below @Min(1))',
+        data: {
+          keyName: constants.getRandomString(),
+          start: '0',
+          end: '5',
+          limit: 0,
+        },
+        statusCode: 400,
+      },
     ].map(mainCheckFn);
   });
 
@@ -162,16 +174,14 @@ describe('POST /databases/:instanceId/array/scan', () => {
       });
     });
 
-    // Skipped: ARSCAN's response `index` is returned by Redis as a RESP
-    // integer, which ioredis decodes to a JS number — values above 2^53
-    // round before they reach the API. Round-tripping the request side at
-    // the upper edge is covered by /get-range and /get-element (neither
-    // echoes the index in the response). Remove .skip once the integer-
-    // reply precision path is fixed (see PR #6064 discussion).
-    it.skip('Should round-trip the index when scanning at the maximum valid index (2^64-2)', async () => {
+    it('Should round-trip the index when scanning at the maximum valid index (2^64-2)', async () => {
       const keyName = constants.getRandomString();
       const maxIndex = '18446744073709551614';
 
+      // Redis 8.8 returns u64 values ≥ 2^63 as RESP bulk strings (not RESP
+      // integers), so ARSCAN's `index` field survives the wire intact for
+      // values in this range. Locks in the contract that the API surfaces
+      // the index as a decimal string even at the upper edge of u64.
       await rte.client.call('ARSET', keyName, maxIndex, 'edge');
 
       await validateApiCall({
@@ -220,6 +230,24 @@ describe('POST /databases/:instanceId/array/scan', () => {
       });
     });
 
+    it('Should accept a span of exactly 1,000,000 elements', async () => {
+      const keyName = constants.getRandomString();
+      await rte.client.call('ARSET', keyName, '0', 'x');
+
+      // Boundary case: span = end - start + 1 = 1_000_000 → just within cap.
+      // Mirror of the get-range boundary test — both endpoints share the
+      // span validator.
+      await validateApiCall({
+        endpoint,
+        data: { keyName, start: '0', end: '999999' },
+        responseSchema,
+        responseBody: {
+          keyName,
+          elements: [{ index: '0', value: 'x' }],
+        },
+      });
+    });
+
     it('Should return an empty list when the range covers only empty slots', async () => {
       const keyName = constants.getRandomString();
       await seedSparse(keyName);

redisinsight/api/test/api/array/POST-databases-id-array.test.ts

@@ -120,6 +120,7 @@ describe('POST /databases/:id/array', () => {
   describe('Sparse (ARMSET)', () => {
     const sparseKey = constants.getRandomString();
     const sparseTtlKey = constants.getRandomString();
+    const dupIndexKey = constants.getRandomString();
 
     [
       {
@@ -157,6 +158,25 @@ describe('POST /databases/:id/array', () => {
           expect(await rte.client.ttl(sparseTtlKey)).to.gte(95);
         },
       },
+      {
+        // Pin "last write wins" for duplicate indexes — ARMSET accepts the
+        // duplicate server-side and the trailing value overwrites the earlier
+        // one. Count stays 1 because only one slot ends up populated.
+        name: 'Should accept a duplicate index and keep the last value (sparse, last wins)',
+        data: {
+          keyName: dupIndexKey,
+          mode: ArrayCreationMode.Sparse,
+          elements: [
+            { index: '5', value: 'first' },
+            { index: '5', value: 'second' },
+          ],
+        },
+        statusCode: 201,
+        after: async () => {
+          expect(await arget(dupIndexKey, '5')).to.eql('second');
+          expect(await arcount(dupIndexKey)).to.eql(1);
+        },
+      },
     ].map(createCheckFn);
   });
 
@@ -202,6 +222,17 @@ describe('POST /databases/:id/array', () => {
         },
         statusCode: 400,
       },
+      {
+        // Symmetric @ArrayMinSize(1) guard for the sparse path — without it,
+        // we'd issue ARMSET with no pairs and surface the server error.
+        name: 'Should reject sparse mode with an empty elements array',
+        data: {
+          keyName: constants.getRandomString(),
+          mode: ArrayCreationMode.Sparse,
+          elements: [],
+        },
+        statusCode: 400,
+      },
       {
         name: 'Should reject an unknown mode',
         data: {