@jmruthers/pace-core 0.5.111 → 0.5.112

package/src/components/DataTable/DataTable.test.tsx

@@ -1,58 +1,99 @@
+/**
+ * @file DataTable Component Tests
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/__tests__
+ * @since 0.4.0
+ * 
+ * Comprehensive test suite for DataTable wrapper component following testing guidelines.
+ * Tests cover feature normalization, validation logic, prop forwarding, and edge cases.
+ */
+
 import React from 'react';
-import { render, screen, cleanup } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup, waitFor } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
 import { DataTable } from './DataTable';
-import { createTestData, createTestColumns } from './__tests__/test-utils/dataFactories';
-import { createDefaultFeatures } from './__tests__/test-utils';
-
-// Mock DataTableCore to avoid complex dependencies
-vi.mock('./components/DataTableCore', () => ({
-  DataTableCore: ({ features, ...props }: any) => (
-    <div data-testid="data-table-core" data-features={JSON.stringify(features)} {...props}>
+import { createTestData, createTestColumns, testDataScenarios } from './__tests__/test-utils/dataFactories';
+import { createDefaultFeatures, createFullFeatures, createFeaturesWithEnabled } from './__tests__/test-utils';
+import type { DataTableFeatureConfig } from './types';
+import { DataTableCore } from './components/DataTableCore';
+
+// Mock DataTableCore to focus on wrapper logic
+// Note: Must define mock inside factory due to hoisting
+vi.mock('./components/DataTableCore', () => {
+  const mockDataTableCore = vi.fn(({ features, ...props }: any) => (
+    <div 
+      data-testid="data-table-core" 
+      data-features={JSON.stringify(features)}
+      data-title={props.title}
+      data-description={props.description}
+      data-variant={props.variant}
+      data-class-name={props.className}
+      data-page-id={props.rbac?.pageId}
+      data-page-name={props.rbac?.pageName}
+    >
       Mock DataTableCore
     </div>
-  ),
-}));
+  ));
+  
+  return {
+    DataTableCore: mockDataTableCore,
+  };
+});
 
 // Mock the logger utility
-vi.mock('../../utils/logger', () => ({
-  createLogger: () => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  }),
-}));
-
-// Mock the feature normalization utility
-vi.mock('./utils/normalizeDataTableFeatures', () => ({
-  normalizeDataTableFeatures: (features: any) => features || {},
-}));
+// Create a module-level mock logger that can be accessed in tests
+const mockLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+};
+
+// Note: Must define mock inside factory due to hoisting
+vi.mock('../../utils/logger', () => {
+  return {
+    createLogger: () => mockLogger,
+  };
+});
+
+// Store original console.log to spy on it
+const originalConsoleLog = console.log;
+const consoleLogSpy = vi.fn();
+beforeAll(() => {
+  console.log = consoleLogSpy;
+});
+
+afterAll(() => {
+  console.log = originalConsoleLog;
+});
 
 describe('[component] DataTable', () => {
   const testData = createTestData(3);
   const testColumns = createTestColumns();
+  const defaultRBAC = { pageId: 'test-page-id' };
   const defaultProps = {
     data: testData,
     columns: testColumns,
-    rbac: {
-      permissions: ['read'],
-      accessLevel: 'read' as const,
-    },
+    rbac: defaultRBAC,
   };
 
+  // Helper to get the mocked DataTableCore function
+  const getMockedDataTableCore = () => vi.mocked(DataTableCore);
+
   beforeEach(() => {
     vi.clearAllMocks();
+    consoleLogSpy.mockClear();
   });
 
   afterEach(() => {
     cleanup();
   });
 
-  describe('Basic Rendering', () => {
-    it('renders DataTableCore with basic props', () => {
+  describe('Rendering', () => {
+    it('renders DataTableCore with required props', () => {
       render(<DataTable {...defaultProps} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledTimes(1);
     });
 
     it('renders with title and description', () => {
@@ -64,256 +105,466 @@ describe('[component] DataTable', () => {
         />
       );
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      const core = screen.getByTestId('data-table-core');
+      expect(core).toHaveAttribute('data-title', 'Test Table');
+      expect(core).toHaveAttribute('data-description', 'Test description');
     });
 
     it('renders with custom variant', () => {
       render(<DataTable {...defaultProps} variant="compact" />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      const core = screen.getByTestId('data-table-core');
+      expect(core).toHaveAttribute('data-variant', 'compact');
+    });
+
+    it('renders with custom className', () => {
+      render(<DataTable {...defaultProps} className="custom-table-class" />);
+      
+      const core = screen.getByTestId('data-table-core');
+      expect(core).toHaveAttribute('data-class-name', 'custom-table-class');
     });
   });
 
   describe('Feature Configuration', () => {
-    it('renders with default features', () => {
+    it('normalizes undefined features to default disabled features', () => {
       render(<DataTable {...defaultProps} />);
       
       const core = screen.getByTestId('data-table-core');
-      expect(core).toBeInTheDocument();
+      const features = JSON.parse(core.getAttribute('data-features') || '{}');
+      
+      expect(features).toMatchObject({
+        search: false,
+        pagination: false,
+        sorting: false,
+        filtering: false,
+        import: false,
+        export: false,
+        selection: false,
+        creation: false,
+        editing: false,
+        deletion: false,
+        deleteSelected: false,
+        grouping: false,
+        columnVisibility: false,
+        columnReordering: false,
+        hierarchical: false,
+      });
     });
 
-    it('renders with custom features', () => {
-      const features = createDefaultFeatures();
-      render(<DataTable {...defaultProps} features={features} />);
+    it('normalizes partial features by merging with defaults', () => {
+      const partialFeatures: DataTableFeatureConfig = {
+        search: true,
+        pagination: true,
+      };
+      
+      render(<DataTable {...defaultProps} features={partialFeatures} />);
       
       const core = screen.getByTestId('data-table-core');
-      expect(core).toBeInTheDocument();
+      const features = JSON.parse(core.getAttribute('data-features') || '{}');
+      
+      expect(features.search).toBe(true);
+      expect(features.pagination).toBe(true);
+      expect(features.sorting).toBe(false); // Default value
+      expect(features.editing).toBe(false); // Default value
     });
 
-    it('renders with enabled features', () => {
-      const features = {
+    it('passes fully normalized features to DataTableCore', () => {
+      const features = createFullFeatures();
+      render(<DataTable {...defaultProps} features={features} />);
+      
+      const core = screen.getByTestId('data-table-core');
+      const normalizedFeatures = JSON.parse(core.getAttribute('data-features') || '{}');
+      
+      expect(normalizedFeatures).toMatchObject({
         search: true,
         pagination: true,
         sorting: true,
-      };
-      render(<DataTable {...defaultProps} features={features} />);
+        filtering: true,
+        import: true,
+        export: true,
+        selection: true,
+        creation: true,
+        editing: true,
+        deletion: true,
+        deleteSelected: true,
+      });
+    });
+
+    it('memoizes normalized features when features prop does not change', () => {
+      const features = createDefaultFeatures();
+      const { rerender } = render(<DataTable {...defaultProps} features={features} />);
       
-      const core = screen.getByTestId('data-table-core');
-      expect(core).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledTimes(1);
+      
+      rerender(<DataTable {...defaultProps} features={features} />);
+      
+      // Should not re-normalize if features object reference is the same
+      expect(getMockedDataTableCore()).toHaveBeenCalledTimes(2);
     });
   });
 
   describe('RBAC Configuration', () => {
-    it('renders with read permissions', () => {
+    it('passes rbac with pageId to DataTableCore', () => {
+      render(<DataTable {...defaultProps} rbac={{ pageId: 'custom-page-id' }} />);
+      
+      const core = screen.getByTestId('data-table-core');
+      expect(core).toHaveAttribute('data-page-id', 'custom-page-id');
+    });
+
+    it('passes rbac with pageName to DataTableCore', () => {
+      render(<DataTable {...defaultProps} rbac={{ pageName: 'custom-page-name' }} />);
+      
+      const core = screen.getByTestId('data-table-core');
+      expect(core).toHaveAttribute('data-page-name', 'custom-page-name');
+    });
+  });
+
+  describe('Validation and Warnings', () => {
+    it('logs debug information in development mode', () => {
       render(<DataTable {...defaultProps} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        '[DataTable] 🎯 DataTable WRAPPER called:',
+        expect.objectContaining({
+          dataLength: testData.length,
+          columnsCount: testColumns.length,
+          pageName: defaultRBAC.pageId,
+        })
+      );
     });
 
-    it('renders with write permissions', () => {
-      const propsWithWrite = {
-        ...defaultProps,
-        rbac: {
-          permissions: ['read', 'write'],
-          accessLevel: 'write' as const,
-        },
-      };
-      render(<DataTable {...propsWithWrite} />);
+    it('logs info message when features are not provided in development', async () => {
+      // Note: vitest.config.ts sets import.meta.env.MODE to 'development' by default
+      // This test verifies the development warning when features are not provided
+      // Skip if not in development mode to avoid false failures
+      if (import.meta.env.MODE !== 'development') {
+        return;
+      }
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      // Clear mock before test to ensure clean state
+      mockLogger.info.mockClear();
+      
+      // Render without features prop - should trigger the warning in development mode
+      render(<DataTable {...defaultProps} />);
+      
+      // Wait for useEffect to run - it runs after render
+      // The effect checks: if (!features && import.meta.env?.MODE === 'development')
+      await waitFor(() => {
+        expect(mockLogger.info).toHaveBeenCalled();
+      }, { 
+        timeout: 1000,
+        interval: 50 
+      });
+      
+      // Verify it was called with the correct message
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        'DataTable: no features provided; all capabilities default to disabled. Pass a features object to enable functionality.'
+      );
     });
 
-    it('renders with admin permissions', () => {
-      const propsWithAdmin = {
-        ...defaultProps,
-        rbac: {
-          permissions: ['read', 'write', 'admin'],
-          accessLevel: 'admin' as const,
-        },
-      };
-      render(<DataTable {...propsWithAdmin} />);
+    it('does not log info message when features are provided', () => {
+      render(<DataTable {...defaultProps} features={createDefaultFeatures()} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(mockLogger.info).not.toHaveBeenCalled();
+    });
+
+    it('warns when deleteSelected is enabled without deletion', () => {
+      const invalidFeatures = createFeaturesWithEnabled({
+        deleteSelected: true,
+        deletion: false,
+      });
+      
+      render(<DataTable {...defaultProps} features={invalidFeatures} />);
+      
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        'deleteSelected requires deletion to be enabled'
+      );
+    });
+
+    it('does not warn when deleteSelected is enabled with deletion', () => {
+      const validFeatures = createFeaturesWithEnabled({
+        deleteSelected: true,
+        deletion: true,
+      });
+      
+      render(<DataTable {...defaultProps} features={validFeatures} />);
+      
+      expect(mockLogger.warn).not.toHaveBeenCalled();
     });
   });
 
   describe('Event Handlers', () => {
-    it('renders with edit row handler', () => {
+    it('passes onEditRow handler to DataTableCore', () => {
       const onEditRow = vi.fn();
       render(<DataTable {...defaultProps} onEditRow={onEditRow} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          onEditRow,
+        }),
+        expect.anything()
+      );
     });
 
-    it('renders with delete row handler', () => {
+    it('passes onDeleteRow handler to DataTableCore', () => {
       const onDeleteRow = vi.fn();
       render(<DataTable {...defaultProps} onDeleteRow={onDeleteRow} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          onDeleteRow,
+        }),
+        expect.anything()
+      );
     });
 
-    it('renders with create row handler', () => {
+    it('passes onCreateRow handler to DataTableCore', () => {
       const onCreateRow = vi.fn();
       render(<DataTable {...defaultProps} onCreateRow={onCreateRow} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          onCreateRow,
+        }),
+        expect.anything()
+      );
     });
 
-    it('renders with import handler', () => {
+    it('passes onImport handler to DataTableCore', () => {
       const onImport = vi.fn();
       render(<DataTable {...defaultProps} onImport={onImport} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
-    });
-
-    it('renders with export handler', () => {
-      const onExport = vi.fn();
-      render(<DataTable {...defaultProps} onExport={onExport} />);
-      
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          onImport,
+        }),
+        expect.anything()
+      );
     });
 
-    it('renders with row selection change handler', () => {
+    it('passes onRowSelectionChange handler to DataTableCore', () => {
       const onRowSelectionChange = vi.fn();
       render(<DataTable {...defaultProps} onRowSelectionChange={onRowSelectionChange} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          onRowSelectionChange,
+        }),
+        expect.anything()
+      );
     });
 
-    it('renders with delete selected handler', () => {
+    it('passes onDeleteSelected handler to DataTableCore', () => {
       const onDeleteSelected = vi.fn();
       render(<DataTable {...defaultProps} onDeleteSelected={onDeleteSelected} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          onDeleteSelected,
+        }),
+        expect.anything()
+      );
     });
   });
 
-  describe('Performance Configuration', () => {
-    it('renders with server-side configuration', () => {
-      const serverConfig = {
-        serverSide: true,
-        serverSidePagination: true,
-        serverSideSorting: true,
-      };
-      render(<DataTable {...defaultProps} {...serverConfig} />);
+  describe('Data Handling', () => {
+    it('handles empty data array', () => {
+      render(<DataTable {...defaultProps} data={[]} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[DataTable]'),
+        expect.objectContaining({
+          dataLength: 0,
+        })
+      );
     });
 
-    it('renders with pagination mode override', () => {
-      render(<DataTable {...defaultProps} paginationMode="server" />);
+    it('handles single data item', () => {
+      const singleData = testDataScenarios.single;
+      render(<DataTable {...defaultProps} data={singleData} />);
+      
+      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[DataTable]'),
+        expect.objectContaining({
+          dataLength: 1,
+        })
+      );
+    });
+
+    it('handles large dataset', () => {
+      const largeData = testDataScenarios.large;
+      render(<DataTable {...defaultProps} data={largeData} />);
+      
+      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[DataTable]'),
+        expect.objectContaining({
+          dataLength: largeData.length,
+        })
+      );
+    });
+
+    it('handles data with null values', () => {
+      const dataWithNulls = testDataScenarios.withNulls;
+      render(<DataTable {...defaultProps} data={dataWithNulls} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
     });
+  });
 
-    it('renders with chunking configuration', () => {
-      const chunkingConfig = {
-        chunkSize: 100,
+  describe('Performance Configuration', () => {
+    it('passes performance config to DataTableCore', () => {
+      const performance = {
+        virtualScrolling: true,
         enableChunking: true,
       };
-      render(<DataTable {...defaultProps} {...chunkingConfig} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      render(<DataTable {...defaultProps} performance={performance} />);
+      
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          performance,
+        }),
+        expect.anything()
+      );
     });
 
-    it('renders with search index configuration', () => {
-      const searchConfig = {
-        searchIndex: ['name', 'email'],
-        enableSearchIndex: true,
+    it('passes serverSide config to DataTableCore', () => {
+      const serverSide = {
+        fetchData: vi.fn(),
+        enableServerSorting: true,
       };
-      render(<DataTable {...defaultProps} {...searchConfig} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      render(<DataTable {...defaultProps} serverSide={serverSide} />);
+      
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          serverSide,
+        }),
+        expect.anything()
+      );
+    });
+
+    it('passes paginationMode to DataTableCore', () => {
+      render(<DataTable {...defaultProps} paginationMode="server" />);
+      
+      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
+        expect.objectContaining({
+          paginationMode: 'server',
+        }),
+        expect.anything()
+      );
     });
   });
 
   describe('Component Integration', () => {
-    it('passes all props to DataTableCore', () => {
+    it('passes all props to DataTableCore except features', () => {
       const allProps = {
         ...defaultProps,
         title: 'Test Table',
         description: 'Test description',
-        variant: 'compact',
-        features: createDefaultFeatures(),
+        variant: 'compact' as const,
+        className: 'custom-class',
+        features: createFullFeatures(),
         onEditRow: vi.fn(),
         onDeleteRow: vi.fn(),
         onCreateRow: vi.fn(),
         onImport: vi.fn(),
-        onExport: vi.fn(),
         onRowSelectionChange: vi.fn(),
         onDeleteSelected: vi.fn(),
+        performance: { virtualScrolling: true },
+        initialPageSize: 25,
       };
+      
       render(<DataTable {...allProps} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
-    });
-
-    it('handles React.memo optimization', () => {
-      const { rerender } = render(<DataTable {...defaultProps} />);
+      const mockDataTableCore = getMockedDataTableCore();
+      const lastCall = mockDataTableCore.mock.calls[mockDataTableCore.mock.calls.length - 1][0];
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(lastCall).toMatchObject({
+        data: allProps.data,
+        columns: allProps.columns,
+        rbac: allProps.rbac,
+        title: allProps.title,
+        description: allProps.description,
+        variant: allProps.variant,
+        className: allProps.className,
+        onEditRow: allProps.onEditRow,
+        onDeleteRow: allProps.onDeleteRow,
+        onCreateRow: allProps.onCreateRow,
+        onImport: allProps.onImport,
+        onRowSelectionChange: allProps.onRowSelectionChange,
+        onDeleteSelected: allProps.onDeleteSelected,
+        performance: allProps.performance,
+        initialPageSize: allProps.initialPageSize,
+      });
       
-      // Re-render with same props should not cause issues
-      rerender(<DataTable {...defaultProps} />);
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      // Features should be normalized, not the original object
+      expect(lastCall.features).toBeDefined();
+      expect(lastCall.features).not.toBe(allProps.features);
     });
   });
 
-  describe('Error Boundaries', () => {
-    it('handles component errors gracefully', () => {
-      render(<DataTable {...defaultProps} />);
+  describe('Memory Management', () => {
+    it('cleans up resources on unmount', () => {
+      const { unmount } = render(<DataTable {...defaultProps} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
-    });
-  });
-
-  describe('Accessibility', () => {
-    it('renders with proper ARIA roles', () => {
-      render(<DataTable {...defaultProps} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      unmount();
+      expect(screen.queryByTestId('data-table-core')).not.toBeInTheDocument();
     });
 
-    it('maintains accessibility with custom variants', () => {
-      render(<DataTable {...defaultProps} variant="compact" />);
+    it('handles rapid mount/unmount cycles', () => {
+      const { unmount: unmount1 } = render(<DataTable {...defaultProps} />);
+      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      unmount1();
       
+      const { unmount: unmount2 } = render(<DataTable {...defaultProps} />);
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      unmount2();
+      
+      expect(screen.queryByTestId('data-table-core')).not.toBeInTheDocument();
     });
+  });
 
-    it('preserves accessibility with all features enabled', () => {
-      const features = {
-        search: true,
-        pagination: true,
-        sorting: true,
-        editing: true,
-        deletion: true,
-        import: true,
-        export: true,
-      };
-      render(<DataTable {...defaultProps} features={features} />);
+  describe('Edge Cases', () => {
+    it('handles missing columns gracefully', () => {
+      render(<DataTable {...defaultProps} columns={[]} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[DataTable]'),
+        expect.objectContaining({
+          columnsCount: 0,
+        })
+      );
     });
-  });
 
-  describe('Memory Management', () => {
-    it('cleans up resources on unmount', () => {
-      const { unmount } = render(<DataTable {...defaultProps} />);
+    it('handles undefined rbac pageId and pageName', () => {
+      render(<DataTable {...defaultProps} rbac={{}} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
-      
-      unmount();
-      // Component should be unmounted
-      expect(screen.queryByTestId('data-table-core')).not.toBeInTheDocument();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[DataTable]'),
+        expect.objectContaining({
+          pageName: undefined,
+        })
+      );
     });
 
-    it('handles rapid mount/unmount cycles', () => {
-      const { unmount } = render(<DataTable {...defaultProps} />);
+    it('handles rapid feature prop changes', () => {
+      const { rerender } = render(<DataTable {...defaultProps} features={{ search: true }} />);
       
-      expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
+      expect(getMockedDataTableCore()).toHaveBeenCalledTimes(1);
       
-      unmount();
-      expect(screen.queryByTestId('data-table-core')).not.toBeInTheDocument();
+      rerender(<DataTable {...defaultProps} features={{ search: false }} />);
+      expect(getMockedDataTableCore()).toHaveBeenCalledTimes(2);
+      
+      rerender(<DataTable {...defaultProps} features={{ search: true, pagination: true }} />);
+      expect(getMockedDataTableCore()).toHaveBeenCalledTimes(3);
     });
   });
 });