RI-6564: Download bulk delete report (#4427)

* bulk delete keys to the frontend

* remove dummy logging

* add BulkDeleteSummaryButton

* styling

* this is better

* more styling

* fix tests

* add test for UI

* add tests

* add more testss

* use proper type

* use proper type in UI

* address PR comments

* change children type

* report the key type

* add tests

* use consistent naming of key type

Author: pawelangelow

redisinsight/api/src/__mocks__/bulk-actions.ts

@@ -23,6 +23,7 @@ export const mockBulkActionOverview = {
     processed: 0,
     succeed: 0,
     errors: [],
+    keys: [],
   },
 };
 

redisinsight/api/src/modules/bulk-actions/bulk-import.service.spec.ts

@@ -188,6 +188,7 @@ describe('BulkImportService', () => {
             succeed: 100_000,
             failed: 0,
             errors: [],
+            keys: [],
           },
           duration: expect.anything(),
         });
@@ -207,6 +208,7 @@ describe('BulkImportService', () => {
             succeed: 10_000,
             failed: 0,
             errors: [],
+            keys: [],
           },
           duration: expect.anything(),
         });
@@ -228,6 +230,7 @@ describe('BulkImportService', () => {
           succeed: 0,
           failed: 2,
           errors: [],
+          keys: [],
         },
         duration: expect.anything(),
       });

redisinsight/api/src/modules/bulk-actions/bulk-import.service.ts

@@ -80,6 +80,7 @@ export class BulkImportService {
         succeed: 0,
         failed: 0,
         errors: [],
+        keys: [],
       },
       progress: null,
       filter: null,

redisinsight/api/src/modules/bulk-actions/interfaces/bulk-action-summary-overview.interface.ts

@@ -1,6 +1,9 @@
+import { RedisString } from 'src/common/constants';
+
 export interface IBulkActionSummaryOverview {
-  processed: number,
-  succeed: number,
-  failed: number,
-  errors: Array<Record<string, string>>
+  processed: number;
+  succeed: number;
+  failed: number;
+  errors: Array<Record<string, string>>;
+  keys: Array<RedisString>;
 }

redisinsight/api/src/modules/bulk-actions/models/bulk-action-summary.spec.ts

@@ -100,6 +100,7 @@ describe('BulkActionSummary', () => {
         succeed: 500,
         failed: 1000,
         errors: generateErrors(500),
+        keys: [],
       });
 
       expect(summary['processed']).toEqual(1500);

redisinsight/api/src/modules/bulk-actions/models/bulk-action-summary.ts

@@ -1,3 +1,4 @@
+import { RedisString } from 'src/common/constants';
 import { IBulkActionSummaryOverview } from 'src/modules/bulk-actions/interfaces/bulk-action-summary-overview.interface';
 
 export class BulkActionSummary {
@@ -9,6 +10,8 @@ export class BulkActionSummary {
 
   private errors: Array<Record<string, string>> = [];
 
+  private keys: Array<RedisString> = [];
+
   addProcessed(count: number) {
     this.processed += count;
   }
@@ -29,12 +32,17 @@ export class BulkActionSummary {
     }
   }
 
+  addKeys(keys: Array<RedisString>) {
+    this.keys.push(...keys);
+  }
+
   getOverview(): IBulkActionSummaryOverview {
     const overview = {
       processed: this.processed,
       succeed: this.succeed,
       failed: this.failed,
       errors: this.errors,
+      keys: this.keys,
     };
 
     this.errors = [];

redisinsight/api/src/modules/bulk-actions/models/bulk-action.spec.ts

@@ -114,6 +114,7 @@ describe('AbstractBulkActionSimpleRunner', () => {
         succeed: 0,
         failed: 0,
         errors: [],
+        keys: [],
       });
 
       await new Promise((res) => setTimeout(res, 100));
@@ -141,6 +142,7 @@ describe('AbstractBulkActionSimpleRunner', () => {
         succeed: 0,
         failed: 0,
         errors: [],
+        keys: [],
       });
 
       await new Promise((res) => setTimeout(res, 100));
@@ -168,6 +170,7 @@ describe('AbstractBulkActionSimpleRunner', () => {
         succeed: 0,
         failed: 0,
         errors: [],
+        keys: [],
       });
 
       await new Promise((res) => setTimeout(res, 100));
@@ -207,6 +210,7 @@ describe('AbstractBulkActionSimpleRunner', () => {
         succeed: 900_000,
         failed: 100_000,
         errors: generateMockBulkActionErrors(500, false),
+        keys: [],
       });
     });
     it('should return overview for cluster', async () => {
@@ -227,10 +231,96 @@ describe('AbstractBulkActionSimpleRunner', () => {
         succeed: 2_700_000,
         failed: 300_000,
         errors: generateMockBulkActionErrors(500, false),
+        keys: [],
       });
     });
   });
 
+  describe('getOverview - keys aggregation', () => {
+    let mockSummary1;
+    let mockSummary2;
+    let mockSummary3;
+    let mockRunner1;
+    let mockRunner2;
+    let mockRunner3;
+    let mockProgress1;
+    let mockProgress2;
+    let mockProgress3;
+
+    beforeEach(() => {
+      mockProgress1 = {
+        getOverview: jest.fn().mockReturnValue({ total: 500, scanned: 400 }),
+      };
+      mockProgress2 = {
+        getOverview: jest.fn().mockReturnValue({ total: 1000, scanned: 800 }),
+      };
+      mockProgress3 = {
+        getOverview: jest.fn().mockReturnValue({ total: 1500, scanned: 1200 }),
+      };
+
+      mockSummary1 = {
+        getOverview: jest.fn().mockReturnValue({
+          processed: 100,
+          succeed: 90,
+          failed: 10,
+          errors: [],
+          keys: ['key1', 'key2'],
+        }),
+      };
+      mockSummary2 = {
+        getOverview: jest.fn().mockReturnValue({
+          processed: 200,
+          succeed: 180,
+          failed: 20,
+          errors: [],
+          keys: ['key3'],
+        }),
+      };
+      mockSummary3 = {
+        getOverview: jest.fn().mockReturnValue({
+          processed: 300,
+          succeed: 270,
+          failed: 30,
+          errors: [],
+          keys: ['key4', 'key5', 'key6'],
+        }),
+      };
+
+      mockRunner1 = {
+        getSummary: jest.fn().mockReturnValue(mockSummary1),
+        getProgress: jest.fn().mockReturnValue(mockProgress1),
+      };
+      mockRunner2 = {
+        getSummary: jest.fn().mockReturnValue(mockSummary2),
+        getProgress: jest.fn().mockReturnValue(mockProgress2),
+      };
+      mockRunner3 = {
+        getSummary: jest.fn().mockReturnValue(mockSummary3),
+        getProgress: jest.fn().mockReturnValue(mockProgress3),
+      };
+
+      bulkAction['runners'] = [mockRunner1, mockRunner2, mockRunner3];
+      bulkAction['status'] = BulkActionStatus.Completed;
+    });
+
+    it('should correctly concatenate keys from all runners', async () => {
+      const overview = bulkAction.getOverview();
+
+      // Convert to a Set to make the test order-independent
+      const expectedKeys = new Set([
+        'key1',
+        'key2',
+        'key3',
+        'key4',
+        'key5',
+        'key6',
+      ]);
+      const actualKey = new Set(overview.summary.keys);
+
+      expect(actualKey).toEqual(expectedKeys);
+    });
+  });
+
   describe('setStatus', () => {
     const testCases = [
       { input: BulkActionStatus.Completed, affect: true },

redisinsight/api/src/modules/bulk-actions/models/bulk-action.ts

@@ -102,18 +102,24 @@ export class BulkAction implements IBulkAction {
         scanned: 0,
       });
 
-    const summary = this.runners.map((runner) => runner.getSummary().getOverview())
-      .reduce((cur, prev) => ({
-        processed: prev.processed + cur.processed,
-        succeed: prev.succeed + cur.succeed,
-        failed: prev.failed + cur.failed,
-        errors: prev.errors.concat(cur.errors),
-      }), {
-        processed: 0,
-        succeed: 0,
-        failed: 0,
-        errors: [],
-      });
+    const summary = this.runners
+      .map((runner) => runner.getSummary().getOverview())
+      .reduce(
+        (cur, prev) => ({
+          processed: prev.processed + cur.processed,
+          succeed: prev.succeed + cur.succeed,
+          failed: prev.failed + cur.failed,
+          errors: prev.errors.concat(cur.errors),
+          keys: [...prev.keys, ...cur.keys],
+        }),
+        {
+          processed: 0,
+          succeed: 0,
+          failed: 0,
+          errors: [],
+          keys: [],
+        },
+      );
 
     summary.errors = summary.errors.slice(0, 500).map((error) => ({
       key: error.key.toString(),

redisinsight/api/src/modules/bulk-actions/models/runners/simple/abstract.bulk-action.simple.runner.spec.ts

@@ -226,4 +226,45 @@ describe('AbstractBulkActionSimpleRunner', () => {
       expect(runIterationSpy).toHaveBeenCalledTimes(2);
     });
   });
+
+  describe('processIterationResults', () => {
+    let addProcessedSpy;
+    let addKeysSpy;
+    let addSuccessSpy;
+    let addErrorsSpy;
+
+    beforeEach(() => {
+      addProcessedSpy = jest.spyOn(deleteRunner['summary'], 'addProcessed');
+      addKeysSpy = jest.spyOn(deleteRunner['summary'], 'addKeys');
+      addSuccessSpy = jest.spyOn(deleteRunner['summary'], 'addSuccess');
+      addErrorsSpy = jest.spyOn(deleteRunner['summary'], 'addErrors');
+    });
+
+    it('should add keys to the summary and correctly process results', () => {
+      const keys = [
+        Buffer.from('key1'),
+        Buffer.from('key2'),
+        Buffer.from('key3'),
+      ];
+      const results: [Error | null, number | null][] = [
+        [null, 1], // Success
+        [mockReplyError, null], // Error
+        [null, 1], // Success
+      ];
+
+      deleteRunner.processIterationResults(keys, results);
+
+      expect(addProcessedSpy).toHaveBeenCalledWith(3);
+      expect(addKeysSpy).toHaveBeenCalledWith(keys);
+
+      expect(addSuccessSpy).toHaveBeenNthCalledWith(1, 1); // first call
+      expect(addSuccessSpy).toHaveBeenNthCalledWith(2, 1); // second call
+      expect(addErrorsSpy).toHaveBeenCalledWith([
+        {
+          key: Buffer.from('key2'),
+          error: mockRESPError,
+        },
+      ]);
+    });
+  });
 });

redisinsight/api/src/modules/bulk-actions/models/runners/simple/abstract.bulk-action.simple.runner.ts

@@ -77,6 +77,7 @@ export abstract class AbstractBulkActionSimpleRunner extends AbstractBulkActionR
    */
   processIterationResults(keys, res: [Error | null, RedisClientCommandReply][]) {
     this.summary.addProcessed(res.length);
+    this.summary.addKeys(keys);
 
     const errors = [];