@avi770/testteam 1.2.0

package/agents/__tests__/14-data-integrity-auditor-extended.test.ts

@@ -0,0 +1,573 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config
+// ---------------------------------------------------------------------------
+
+const stubConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: {
+    loginUrl: 'http://localhost/login',
+    credentials: { admin: { email: 'admin@test.com', password: 'secret' } },
+  },
+  modules: [{ id: 'clients', route: '/clients', sidebarIcon: true }],
+  environments: {
+    beta: { baseUrl: 'http://localhost:3000', seed: false },
+  },
+  portals: [],
+  breakpoints: [],
+  integrations: [],
+  workers: [],
+  workflows: [],
+  accuracy: { enabled: true, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' as const },
+  agentClassification: { blocking: [], advisory: [] },
+  thresholds: {
+    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+    apiResponseTime: 2000,
+    bundleSizeLimit: 500000,
+    maxConsoleErrors: 0,
+  },
+  disabledAgents: [],
+  disabledAgentSet: new Set<number>(),
+} satisfies ValidatedConfig;
+
+// ---------------------------------------------------------------------------
+// Mock fetch
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock ApiClient
+// ---------------------------------------------------------------------------
+
+type MockApiResponse = { status: number; body: unknown; headers: Record<string, string>; durationMs: number };
+
+interface MockApiClientInstance {
+  get: ReturnType<typeof vi.fn>;
+  post: ReturnType<typeof vi.fn>;
+  put: ReturnType<typeof vi.fn>;
+  delete: ReturnType<typeof vi.fn>;
+}
+
+const mockApiClientInstance: MockApiClientInstance = {
+  get: vi.fn(),
+  post: vi.fn(),
+  put: vi.fn(),
+  delete: vi.fn(),
+};
+
+const createAuthenticatedMock = vi.fn().mockResolvedValue(mockApiClientInstance);
+
+vi.mock('../../helpers/api-client', () => ({
+  ApiClient: {
+    createAuthenticated: (...args: unknown[]) => createAuthenticatedMock(...args),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Response helpers
+// ---------------------------------------------------------------------------
+
+function ok(body: unknown): MockApiResponse {
+  return { status: 200, body, headers: {}, durationMs: 10 };
+}
+
+function created(body: unknown): MockApiResponse {
+  return { status: 201, body, headers: {}, durationMs: 10 };
+}
+
+function noContent(): MockApiResponse {
+  return { status: 204, body: null, headers: {}, durationMs: 10 };
+}
+
+function notFound(): MockApiResponse {
+  return { status: 404, body: { message: 'Not Found' }, headers: {}, durationMs: 10 };
+}
+
+function serverError(): MockApiResponse {
+  return { status: 500, body: { message: 'Error' }, headers: {}, durationMs: 10 };
+}
+
+// ---------------------------------------------------------------------------
+// Dynamic import
+// ---------------------------------------------------------------------------
+
+const { DataIntegrityAuditorAgent } = await import('../14-data-integrity-auditor');
+
+function createAgent(
+  config: ValidatedConfig = stubConfig,
+  phase: Phase = 'beta',
+): InstanceType<typeof DataIntegrityAuditorAgent> {
+  return new DataIntegrityAuditorAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests — extended coverage
+// ---------------------------------------------------------------------------
+
+describe('DataIntegrityAuditorAgent — extended coverage', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    createAuthenticatedMock.mockReset().mockResolvedValue(mockApiClientInstance);
+    mockApiClientInstance.get.mockReset();
+    mockApiClientInstance.post.mockReset();
+    mockApiClientInstance.put.mockReset();
+    mockApiClientInstance.delete.mockReset();
+  });
+
+  // -----------------------------------------------------------------------
+  // CRUD — no environment
+  // -----------------------------------------------------------------------
+
+  describe('no environment configured', () => {
+    it('returns critical finding when no environment exists', async () => {
+      const noEnvConfig: ValidatedConfig = {
+        ...stubConfig,
+        environments: {},
+      };
+
+      // preFlight resolveEnvironment returns no env — throws
+      const agent = createAgent(noEnvConfig);
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // CRUD — no credentials
+  // -----------------------------------------------------------------------
+
+  describe('no credentials', () => {
+    it('returns critical finding when no credentials configured', async () => {
+      const noCredConfig: ValidatedConfig = {
+        ...stubConfig,
+        auth: { loginUrl: '/login', credentials: {} },
+      };
+
+      const agent = createAgent(noCredConfig);
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id === '14-no-credentials');
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('critical');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // CRUD — POST fails
+  // -----------------------------------------------------------------------
+
+  describe('CRUD create errors', () => {
+    it('creates critical finding when POST throws', async () => {
+      mockApiClientInstance.post.mockRejectedValue(new Error('Connection refused'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id === '14-crud-create-error');
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('critical');
+    });
+
+    it('creates high finding when POST returns non-200/201 status', async () => {
+      mockApiClientInstance.post.mockResolvedValue(serverError());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id === '14-crud-create-status');
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('high');
+    });
+
+    it('creates high finding when POST response has no id field', async () => {
+      mockApiClientInstance.post.mockResolvedValue(created({ name: 'test' }));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id === '14-crud-create-no-id');
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('high');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // CRUD — GET (read) errors
+  // -----------------------------------------------------------------------
+
+  describe('CRUD read errors', () => {
+    it('creates critical finding when GET after create throws', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid' };
+      mockApiClientInstance.post.mockResolvedValue(created(record));
+      mockApiClientInstance.get.mockRejectedValue(new Error('Timeout'));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id.includes('crud-read-error'));
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('critical');
+    });
+
+    it('creates high finding when GET returns non-200 status after create', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let postCount = 0;
+      let getCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        postCount++;
+        const b = body as Record<string, unknown>;
+        if (postCount === 1) return created({ id: 'abc-123', ...b, createdAt: '2026-03-27T10:00:00Z' });
+        return serverError(); // decimal/tz tests get 500
+      });
+
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return notFound(); // read after create returns 404 — NOT 200
+        return notFound();
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(ok(record));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id.includes('crud-read-status'));
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('high');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // CRUD — UPDATE errors
+  // -----------------------------------------------------------------------
+
+  describe('CRUD update errors', () => {
+    it('creates high finding when PUT throws', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let getCount = 0;
+      mockApiClientInstance.post
+        .mockResolvedValueOnce(created(record))
+        .mockResolvedValue(serverError());
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok(record);
+        if (getCount === 2) return ok({ ...record, name: 'TF-DataIntegrity-Updated' });
+        return notFound();
+      });
+      mockApiClientInstance.put.mockRejectedValue(new Error('Connection reset'));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id.includes('crud-update-error'));
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('high');
+    });
+
+    it('creates high finding when update read-back shows name mismatch', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let getCount = 0;
+      mockApiClientInstance.post
+        .mockResolvedValueOnce(created(record))
+        .mockResolvedValue(serverError());
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok(record); // read after create
+        if (getCount === 2) return ok({ ...record, name: 'WRONG-NAME' }); // read after update — name not updated!
+        return notFound(); // after delete
+      });
+      mockApiClientInstance.put.mockResolvedValue(ok({ ...record, name: 'TF-DataIntegrity-Updated' }));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id.includes('crud-update-mismatch'));
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('high');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // CRUD — DELETE errors
+  // -----------------------------------------------------------------------
+
+  describe('CRUD delete errors', () => {
+    it('creates high finding when DELETE throws', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let getCount = 0;
+      mockApiClientInstance.post
+        .mockResolvedValueOnce(created(record))
+        .mockResolvedValue(serverError());
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok(record);
+        if (getCount === 2) return ok({ ...record, name: 'TF-DataIntegrity-Updated' });
+        return notFound();
+      });
+      mockApiClientInstance.put.mockResolvedValue(ok({ ...record, name: 'TF-DataIntegrity-Updated' }));
+      mockApiClientInstance.delete.mockRejectedValue(new Error('DB locked'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id.includes('crud-delete-error'));
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('high');
+    });
+
+    it('creates medium finding when DELETE returns non-200/204 status', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let getCount = 0;
+      mockApiClientInstance.post
+        .mockResolvedValueOnce(created(record))
+        .mockResolvedValue(serverError());
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok(record);
+        if (getCount === 2) return ok({ ...record, name: 'TF-DataIntegrity-Updated' });
+        return notFound();
+      });
+      mockApiClientInstance.put.mockResolvedValue(ok({ ...record, name: 'TF-DataIntegrity-Updated' }));
+      mockApiClientInstance.delete.mockResolvedValue(serverError());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const finding = result.findings.find((f) => f.id.includes('crud-delete-status'));
+      expect(finding).toBeDefined();
+      expect(finding!.severity).toBe('medium');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Timezone tests
+  // -----------------------------------------------------------------------
+
+  describe('timezone validation', () => {
+    it('creates finding when createdAt does not match configured timezone or UTC', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let postCount = 0;
+      let getCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        postCount++;
+        const b = body as Record<string, unknown>;
+        if (postCount === 1) return created({ id: 'crud-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+        if (postCount === 2) return created({ id: 'decimal-id', ...b });
+        // timezone test
+        return created({ id: 'tz-id', ...b, createdAt: '2026-03-27T10:00:00+05:30' });
+      });
+
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok({ ...record, id: 'crud-id', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 2) return ok({ ...record, id: 'crud-id', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 3) return notFound(); // after delete
+        if (getCount === 4) return ok({ id: 'decimal-id', amount: 1000.11 }); // decimal - correct
+        if (getCount === 5) return ok({ id: 'tz-id', createdAt: '2026-03-27T10:00:00+05:30' }); // non-UTC, non-configured
+        return notFound();
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(ok({ id: 'crud-id', name: 'TF-DataIntegrity-Updated' }));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const tzFinding = result.findings.find((f) => f.id.includes('timezone-mismatch'));
+      expect(tzFinding).toBeDefined();
+      expect(tzFinding!.severity).toBe('medium');
+    });
+
+    it('does NOT create timezone finding when createdAt ends with Z (UTC)', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let postCount = 0;
+      let getCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        postCount++;
+        const b = body as Record<string, unknown>;
+        if (postCount === 1) return created({ id: 'crud-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+        if (postCount === 2) return created({ id: 'decimal-id', ...b });
+        return created({ id: 'tz-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+      });
+
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok({ ...record, id: 'crud-id', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 2) return ok({ ...record, id: 'crud-id', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 3) return notFound();
+        if (getCount === 4) return ok({ id: 'decimal-id', amount: 1000.11 });
+        if (getCount === 5) return ok({ id: 'tz-id', createdAt: '2026-03-27T10:00:00Z' }); // UTC — OK
+        return notFound();
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(ok({ id: 'crud-id', name: 'TF-DataIntegrity-Updated' }));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const tzFindings = result.findings.filter((f) => f.id.includes('timezone-mismatch'));
+      expect(tzFindings).toHaveLength(0);
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Decimal precision — API doesn't support amount
+  // -----------------------------------------------------------------------
+
+  describe('decimal precision edge cases', () => {
+    it('skips decimal test when API does not support amount field (non-200 create)', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let postCount = 0;
+      let getCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        postCount++;
+        const b = body as Record<string, unknown>;
+        if (postCount === 1) return created({ id: 'crud-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+        // decimal test — endpoint rejects
+        if (postCount === 2) return serverError();
+        return created({ id: 'tz-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+      });
+
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok({ ...record, id: 'crud-id', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 2) return ok({ ...record, id: 'crud-id', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 3) return notFound();
+        if (getCount === 4) return ok({ id: 'tz-id', createdAt: '2026-03-27T10:00:00Z' });
+        return notFound();
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(ok({ id: 'crud-id', name: 'TF-DataIntegrity-Updated' }));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const decimalFindings = result.findings.filter((f) => f.id.includes('decimal'));
+      expect(decimalFindings).toHaveLength(0);
+    });
+
+    it('skips decimal check when amount is undefined in response', async () => {
+      const record = { id: 'abc-123', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' };
+      let postCount = 0;
+      let getCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        postCount++;
+        const b = body as Record<string, unknown>;
+        if (postCount === 1) return created({ id: 'crud-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+        if (postCount === 2) return created({ id: 'decimal-id', ...b });
+        return created({ id: 'tz-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+      });
+
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok({ ...record, id: 'crud-id', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 2) return ok({ ...record, id: 'crud-id', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 3) return notFound();
+        // decimal read — amount not returned
+        if (getCount === 4) return ok({ id: 'decimal-id' /* no amount */ });
+        if (getCount === 5) return ok({ id: 'tz-id', createdAt: '2026-03-27T10:00:00Z' });
+        return notFound();
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(ok({ id: 'crud-id', name: 'TF-DataIntegrity-Updated' }));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const decimalFindings = result.findings.filter((f) => f.id.includes('decimal'));
+      expect(decimalFindings).toHaveLength(0);
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Email mismatch in CRUD
+  // -----------------------------------------------------------------------
+
+  describe('CRUD email mismatch', () => {
+    it('creates finding when email field does not match after create', async () => {
+      let capturedBody: Record<string, unknown> = {};
+      let getCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        capturedBody = body as Record<string, unknown>;
+        return created({ id: 'abc-123', ...capturedBody, createdAt: '2026-03-27T10:00:00Z' });
+      });
+
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) {
+          return ok({ id: 'abc-123', ...capturedBody, email: 'WRONG@test.invalid', createdAt: '2026-03-27T10:00:00Z' });
+        }
+        if (getCount === 2) return ok({ id: 'abc-123', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        return notFound();
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(ok({}));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const mismatchFinding = result.findings.find((f) => f.id.includes('crud-field-mismatch'));
+      expect(mismatchFinding).toBeDefined();
+      expect(mismatchFinding!.description).toContain('email');
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Cleanup after decimal/timezone tests
+  // -----------------------------------------------------------------------
+
+  describe('test cleanup', () => {
+    it('deletes test records even when decimal/timezone checks fail', async () => {
+      let postCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        postCount++;
+        const b = body as Record<string, unknown>;
+        if (postCount === 1) return created({ id: 'crud-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+        return created({ id: `test-${postCount}`, ...b });
+      });
+
+      let getCount = 0;
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCount++;
+        if (getCount === 1) return ok({ id: 'crud-id', name: 'TF-DataIntegrity-Test', email: 'tf@test.invalid', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 2) return ok({ id: 'crud-id', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        if (getCount === 3) return notFound();
+        return ok({ id: 'test-2', amount: 1000.11, createdAt: '2026-03-27T10:00:00Z' });
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(ok({}));
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      await agent.run();
+
+      // delete should have been called for crud record + decimal record + timezone record
+      expect(mockApiClientInstance.delete).toHaveBeenCalled();
+    });
+  });
+});