@jmruthers/pace-core 0.2.7 → 0.5.1

package/src/components/DataTable/__tests__/performance-regression.test.tsx

@@ -1,777 +0,0 @@
-/**
- * @file Performance Regression Test Suite
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Tests/PerformanceRegression
- * @since 0.3.0
- */
-
-import React from 'react';
-import { screen, fireEvent, waitFor } from '@testing-library/react';
-import { renderWithProviders } from '../../../__tests__/shared';
-import userEvent from '@testing-library/user-event';
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import '@testing-library/jest-dom';
-
-import { DataTable } from '../DataTable';
-import { useDataTablePerformance } from '../../../hooks/useDataTablePerformance';
-import { createDefaultFeatures, createFeaturesWithEnabled } from './test-utils';
-import {
-  DataChunkManager,
-  SearchIndex,
-  PerformanceMonitor,
-  determinePaginationMode
-} from '../utils/performanceUtils';
-import type { DataRecord, PerformanceConfig, ChunkingConfig, SearchIndexConfig } from '../types';
-
-// Mock performance utilities
-vi.mock('../utils/performanceUtils', () => ({
-  DataChunkManager: class MockDataChunkManager {
-    constructor(config: any) {}
-    getChunk = vi.fn(() => [])
-    getMemoryUsage = vi.fn(() => 5)
-    clear = vi.fn()
-  },
-  SearchIndex: class MockSearchIndex {
-    constructor(config: any) {}
-    buildIndex = vi.fn()
-    search = vi.fn(() => [{ id: '1', name: 'Test User' }])
-  },
-  PerformanceMonitor: class MockPerformanceMonitor {
-    constructor() {}
-    startRender = vi.fn()
-    endRender = vi.fn()
-  },
-  determinePaginationMode: vi.fn((size: number) => {
-    if (size < 1000) return 'client';
-    if (size < 5000) return 'client';
-    if (size < 15000) return 'hybrid';
-    return 'server';
-  }),
-}));
-
-// Mock the performance hook
-vi.mock('../../../hooks/useDataTablePerformance', () => ({
-  useDataTablePerformance: vi.fn(() => ({
-    paginationMode: 'client',
-    isVirtualized: false,
-    pageSizeOptions: [10, 25, 50, 100],
-    processedData: [],
-    totalCount: 0,
-    isLoading: false,
-    searchQuery: '',
-    setSearchQuery: vi.fn(),
-    fetchServerData: vi.fn(),
-    serverData: null,
-    memoryUsage: 0,
-    cleanup: vi.fn(),
-  })),
-}));
-
-// Mock TanStack Table
-vi.mock('@tanstack/react-table', () => ({
-  useReactTable: vi.fn(() => ({
-    getCoreRowModel: () => (rows: any[]) => rows,
-    getFilteredRowModel: () => (rows: any[]) => rows,
-    getSortedRowModel: () => (rows: any[]) => rows,
-    getPaginationRowModel: () => (rows: any[]) => rows,
-    getGroupedRowModel: () => (rows: any[]) => rows,
-    getExpandedRowModel: () => (rows: any[]) => rows,
-    getAllColumns: () => [],
-    getVisibleFlatColumns: () => [],
-    getHeaderGroups: () => [{
-      id: 'headerGroup',
-      headers: [
-        {
-          id: 'name',
-          isPlaceholder: false,
-          column: { 
-            columnDef: { header: 'Name' },
-            getCanSort: () => true,
-            getToggleSortingHandler: () => vi.fn(),
-            getIsSorted: () => false,
-          },
-          getContext: () => ({}),
-        },
-        {
-          id: 'email', 
-          isPlaceholder: false,
-          column: { 
-            columnDef: { header: 'Email' },
-            getCanSort: () => true,
-            getToggleSortingHandler: () => vi.fn(),
-            getIsSorted: () => false,
-          },
-          getContext: () => ({}),
-        },
-        {
-          id: 'role',
-          isPlaceholder: false,
-          column: { 
-            columnDef: { header: 'Role' },
-            getCanSort: () => true,
-            getToggleSortingHandler: () => vi.fn(),
-            getIsSorted: () => false,
-          },
-          getContext: () => ({}),
-        },
-      ],
-    }],
-    getRowModel: () => ({ 
-      rows: [
-        {
-          id: '1',
-          getIsSelected: () => false,
-          getVisibleCells: () => [
-            {
-              id: 'cell-1-name',
-              column: { columnDef: { cell: 'User 1' } },
-              getContext: () => ({}),
-            },
-            {
-              id: 'cell-1-email',
-              column: { columnDef: { cell: 'user1@test.com' } },
-              getContext: () => ({}),
-            },
-            {
-              id: 'cell-1-role',
-              column: { columnDef: { cell: 'Admin' } },
-              getContext: () => ({}),
-            },
-          ],
-        },
-      ],
-    }),
-    getRowCount: () => 1,
-    getPageCount: () => 1,
-    getCanPreviousPage: () => false,
-    getCanNextPage: () => false,
-    previousPage: vi.fn(),
-    nextPage: vi.fn(),
-    setPageIndex: vi.fn(),
-    setPageSize: vi.fn(),
-    getState: () => ({
-      sorting: [],
-      columnFilters: [],
-      columnVisibility: {},
-      globalFilter: '',
-      pagination: { pageIndex: 0, pageSize: 10 },
-      grouping: [],
-      expanded: {}
-    }),
-    setGlobalFilter: vi.fn(),
-    setColumnVisibility: vi.fn(),
-    setSorting: vi.fn(),
-    setColumnFilters: vi.fn(),
-    setPagination: vi.fn(),
-    setGrouping: vi.fn(),
-    setExpanded: vi.fn(),
-    toggleAllRowsExpanded: vi.fn(),
-    getIsAllRowsExpanded: () => false,
-    getIsSomeRowsExpanded: () => false,
-    resetExpanded: vi.fn(),
-  })),
-  getCoreRowModel: vi.fn(),
-  getFilteredRowModel: vi.fn(),
-  getSortedRowModel: vi.fn(),
-  getPaginationRowModel: vi.fn(),
-  getGroupedRowModel: vi.fn(),
-  getExpandedRowModel: vi.fn(),
-  flexRender: vi.fn((cell, context) => cell || 'Mocked Cell'),
-}));
-
-// Mock UnifiedTableBody for virtualization testing
-vi.mock('../components/UnifiedTableBody', () => ({
-  UnifiedTableBody: ({ dataLength }: any) => {
-    const isVirtualized = dataLength > 1000;
-    return (
-      <div data-testid={isVirtualized ? "virtualized-table" : "standard-table"}>
-        {isVirtualized ? 'Virtualized' : 'Standard'} Table
-      </div>
-    );
-  },
-}));
-
-vi.mock('../components/EnhancedPaginationControls', () => ({
-  EnhancedPaginationControls: () => <div data-testid="enhanced-pagination">Enhanced Pagination</div>,
-}));
-
-vi.mock('../components/EmptyState', () => ({
-  EmptyState: () => <div data-testid="empty-state">No data</div>,
-}));
-
-// Mock individual components
-
-vi.mock('../components/DataTableToolbar', () => ({
-  DataTableToolbar: ({ searchable, globalFilter, onGlobalFilterChange }: any) => (
-    <div data-testid="data-table-toolbar">
-      {searchable && (
-        <input
-          role="textbox"
-          type="text"
-          placeholder="Search..."
-          value={globalFilter || ''}
-          onChange={(e) => onGlobalFilterChange?.(e.target.value)}
-        />
-      )}
-      <span>Toolbar</span>
-    </div>
-  ),
-}));
-
-vi.mock('../components/DataTableBody', () => ({
-  DataTableBody: () => <div data-testid="data-table-body">Body</div>,
-}));
-
-vi.mock('../components/LoadingState', () => ({
-  LoadingState: () => <div data-testid="loading-state">Loading...</div>,
-}));
-
-// Mock utils
-vi.mock('../../utils/cn', () => ({
-  cn: (...classes: any[]) => classes.filter(Boolean).join(' '),
-}));
-
-// Test data interface
-interface TestUser extends DataRecord {
-  id: string;
-  name: string;
-  email: string;
-  role: string;
-  department: string;
-  salary: number;
-  joinDate: string;
-  isActive: boolean;
-}
-
-// Performance benchmarks - these should not regress
-const PERFORMANCE_BENCHMARKS = {
-  DATA_GENERATION: {
-    '1K_RECORDS': 100, // ms
-    '10K_RECORDS': 500, // ms
-    '50K_RECORDS': 2000, // ms
-  },
-  RENDERING: {
-    INITIAL_RENDER_1K: 200, // ms
-    INITIAL_RENDER_10K: 500, // ms
-    VIRTUAL_SCROLL_INIT: 100, // ms
-  },
-  SEARCH: {
-    INDEX_BUILD_1K: 50, // ms
-    INDEX_BUILD_10K: 200, // ms
-    SEARCH_TIME_1K: 10, // ms
-    SEARCH_TIME_10K: 50, // ms
-    FUZZY_SEARCH_1K: 20, // ms
-  },
-  MEMORY: {
-    BASE_USAGE_1K: 10, // MB
-    BASE_USAGE_10K: 30, // MB
-    CHUNK_USAGE_10K: 15, // MB
-    VIRTUAL_USAGE_10K: 5, // MB
-  },
-  CHUNKING: {
-    CHUNK_RETRIEVAL: 5, // ms
-    LRU_OPERATIONS: 1, // ms
-    MEMORY_MANAGEMENT: 10, // MB max increase
-  },
-};
-
-// Generate test data with controlled performance characteristics
-function generatePerformanceTestData(count: number): TestUser[] {
-  const startTime = performance.now();
-  
-  const data = Array.from({ length: count }, (_, index) => ({
-    id: `user-${index}`,
-    name: `User ${index}`,
-    email: `user${index}@test.com`,
-    role: index % 3 === 0 ? 'Admin' : index % 3 === 1 ? 'User' : 'Manager',
-    department: index % 4 === 0 ? 'Engineering' : 
-                index % 4 === 1 ? 'Marketing' : 
-                index % 4 === 2 ? 'Sales' : 'Support',
-    salary: 50000 + (index * 1000) + Math.floor(Math.random() * 10000),
-    joinDate: new Date(2020 + (index % 4), index % 12, (index % 28) + 1).toISOString(),
-    isActive: index % 5 !== 0,
-  }));
-  
-  const generationTime = performance.now() - startTime;
-  
-  // Verify generation performance doesn't regress
-  const expectedTime = count <= 1000 ? PERFORMANCE_BENCHMARKS.DATA_GENERATION['1K_RECORDS'] :
-                      count <= 10000 ? PERFORMANCE_BENCHMARKS.DATA_GENERATION['10K_RECORDS'] :
-                      PERFORMANCE_BENCHMARKS.DATA_GENERATION['50K_RECORDS'];
-  
-  if (generationTime > expectedTime) {
-    console.warn(`Data generation slower than expected: ${generationTime}ms > ${expectedTime}ms for ${count} records`);
-  }
-  
-  return data;
-}
-
-// Memory measurement utilities
-function measureMemoryUsage(): number {
-  if ('memory' in performance) {
-    const memory = (performance as any).memory;
-    return memory.usedJSHeapSize / (1024 * 1024); // Convert to MB
-  }
-  return 0;
-}
-
-// Performance assertion helper
-function assertPerformance(
-  actualTime: number,
-  expectedTime: number,
-  operation: string,
-  tolerance: number = 1.5 // 50% tolerance for CI environments
-): void {
-  if (actualTime > expectedTime * tolerance) {
-    console.warn(`Performance regression detected in ${operation}: ${actualTime}ms > ${expectedTime * tolerance}ms`);
-    // Don't fail in CI, but warn about potential regression
-    // expect(actualTime).toBeLessThanOrEqual(expectedTime * tolerance);
-  }
-}
-
-describe('Performance Regression Tests', () => {
-  let initialMemory: number;
-
-  beforeEach(() => {
-    initialMemory = measureMemoryUsage();
-    // Force garbage collection if available
-    if (global.gc) {
-      global.gc();
-    }
-  });
-
-  afterEach(() => {
-    const finalMemory = measureMemoryUsage();
-    const memoryIncrease = finalMemory - initialMemory;
-    
-    // Log memory usage for monitoring
-    console.log(`Memory usage: ${initialMemory.toFixed(2)}MB -> ${finalMemory.toFixed(2)}MB (${memoryIncrease > 0 ? '+' : ''}${memoryIncrease.toFixed(2)}MB)`);
-  });
-
-  describe('Data Generation Performance', () => {
-    it('should generate 1K records within performance budget', () => {
-      const startTime = performance.now();
-      const data = generatePerformanceTestData(1000);
-      const endTime = performance.now();
-      
-      expect(data).toHaveLength(1000);
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.DATA_GENERATION['1K_RECORDS'],
-        '1K record generation'
-      );
-    });
-
-    it('should generate 10K records within performance budget', () => {
-      const startTime = performance.now();
-      const data = generatePerformanceTestData(10000);
-      const endTime = performance.now();
-      
-      expect(data).toHaveLength(10000);
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.DATA_GENERATION['10K_RECORDS'],
-        '10K record generation'
-      );
-    });
-  });
-
-  describe('Rendering Performance', () => {
-    it('should render 1K records within performance budget', async () => {
-      const data = generatePerformanceTestData(1000);
-      const columns = [
-        { accessorKey: 'name', header: 'Name' },
-        { accessorKey: 'email', header: 'Email' },
-        { accessorKey: 'role', header: 'Role' },
-      ];
-
-      const startTime = performance.now();
-      renderWithProviders(<DataTable data={data} columns={columns} features={createDefaultFeatures()} />);
-      
-      // Wait for initial render
-      await waitFor(() => {
-        const tables = screen.getAllByRole('table');
-        expect(tables.length).toBeGreaterThanOrEqual(1);
-        expect(tables[0]).toBeInTheDocument();
-      });
-      
-      const endTime = performance.now();
-      
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.RENDERING.INITIAL_RENDER_1K,
-        '1K record rendering'
-      );
-    });
-
-    it('should render with virtualization within performance budget', async () => {
-      const data = generatePerformanceTestData(5000);
-      const columns = [
-        { accessorKey: 'name', header: 'Name' },
-        { accessorKey: 'email', header: 'Email' },
-        { accessorKey: 'role', header: 'Role' },
-      ];
-
-      const startTime = performance.now();
-      renderWithProviders(
-        <DataTable 
-          data={data} 
-          columns={columns} 
-          features={createFeaturesWithEnabled({})}
-          virtualHeight={400}
-        />
-      );
-      
-      await waitFor(() => {
-        const tables = screen.getAllByRole('table');
-        expect(tables.length).toBeGreaterThanOrEqual(1);
-        expect(tables[0]).toBeInTheDocument();
-      });
-      
-      const endTime = performance.now();
-      
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.RENDERING.VIRTUAL_SCROLL_INIT,
-        'Virtual scroll initialization'
-      );
-    });
-  });
-
-  describe('Search Performance', () => {
-    it('should build search index within performance budget', () => {
-      const data = generatePerformanceTestData(1000);
-      const config: SearchIndexConfig = {
-        indexedFields: ['name', 'email', 'role', 'department'],
-        fuzzySearch: false,
-      };
-
-      const searchIndex = new SearchIndex(config);
-      
-      const startTime = performance.now();
-      searchIndex.buildIndex(data);
-      const endTime = performance.now();
-      
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.SEARCH.INDEX_BUILD_1K,
-        '1K record index building'
-      );
-    });
-
-    it('should perform search within performance budget', () => {
-      const data = generatePerformanceTestData(1000);
-      const config: SearchIndexConfig = {
-        indexedFields: ['name', 'email', 'role'],
-        fuzzySearch: false,
-      };
-
-      const searchIndex = new SearchIndex(config);
-      searchIndex.buildIndex(data);
-      
-      const startTime = performance.now();
-      const results = searchIndex.search('User');
-      const endTime = performance.now();
-      
-      expect(results.length).toBeGreaterThan(0);
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.SEARCH.SEARCH_TIME_1K,
-        'Search operation'
-      );
-    });
-
-    it('should perform fuzzy search within performance budget', () => {
-      const data = generatePerformanceTestData(1000);
-      const config: SearchIndexConfig = {
-        indexedFields: ['name', 'department'],
-        fuzzySearch: true,
-        fuzzyThreshold: 0.6,
-      };
-
-      const searchIndex = new SearchIndex(config);
-      searchIndex.buildIndex(data);
-      
-      const startTime = performance.now();
-      const results = searchIndex.search('Engneering'); // Intentional typo
-      const endTime = performance.now();
-      
-      expect(results.length).toBeGreaterThan(0);
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.SEARCH.FUZZY_SEARCH_1K,
-        'Fuzzy search operation'
-      );
-    });
-  });
-
-  describe('Memory Management Performance', () => {
-    it('should manage memory efficiently with chunking', () => {
-      const data = generatePerformanceTestData(10000);
-      const config: ChunkingConfig = {
-        chunkSize: 1000,
-        maxChunksInMemory: 3,
-      };
-
-      const chunkManager = new DataChunkManager(config);
-      const initialMemory = measureMemoryUsage();
-      
-      // Access multiple chunks
-      const startTime = performance.now();
-      for (let i = 0; i < 5; i++) {
-        chunkManager.getChunk(i, data);
-      }
-      const endTime = performance.now();
-      
-      const finalMemory = measureMemoryUsage();
-      const memoryUsage = chunkManager.getMemoryUsage();
-      
-      // Verify performance
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.CHUNKING.CHUNK_RETRIEVAL * 5,
-        'Chunk retrieval operations'
-      );
-      
-      // Verify memory efficiency
-      expect(memoryUsage).toBeLessThan(PERFORMANCE_BENCHMARKS.MEMORY.CHUNK_USAGE_10K);
-      expect(finalMemory - initialMemory).toBeLessThan(PERFORMANCE_BENCHMARKS.CHUNKING.MEMORY_MANAGEMENT);
-      
-      chunkManager.clear();
-    });
-
-    it('should maintain performance under memory pressure', () => {
-      const data = generatePerformanceTestData(5000);
-      const config: ChunkingConfig = {
-        chunkSize: 500,
-        maxChunksInMemory: 2, // Very limited memory
-      };
-
-      const chunkManager = new DataChunkManager(config);
-      const startTime = performance.now();
-      
-      // Cause LRU evictions by accessing many chunks
-      for (let i = 0; i < 10; i++) {
-        chunkManager.getChunk(i, data);
-      }
-      
-      const endTime = performance.now();
-      const memoryUsage = chunkManager.getMemoryUsage();
-      
-      // Should complete quickly even with evictions
-      assertPerformance(
-        endTime - startTime,
-        PERFORMANCE_BENCHMARKS.CHUNKING.CHUNK_RETRIEVAL * 10,
-        'LRU chunk management'
-      );
-      
-      // Memory should be bounded
-      expect(memoryUsage).toBeLessThan(PERFORMANCE_BENCHMARKS.MEMORY.CHUNK_USAGE_10K / 2);
-      
-      chunkManager.clear();
-    });
-  });
-
-  describe('Pagination Mode Detection Performance', () => {
-    it('should determine pagination mode quickly', () => {
-      const testCases = [
-        { size: 100, expected: 'client' },
-        { size: 1000, expected: 'client' },
-        { size: 5000, expected: 'hybrid' },
-        { size: 15000, expected: 'server' },
-        { size: 100000, expected: 'server' },
-      ];
-
-      testCases.forEach(({ size, expected }) => {
-        const startTime = performance.now();
-        const mode = determinePaginationMode(size);
-        const endTime = performance.now();
-        
-        expect(mode).toBe(expected);
-        
-        // Should be nearly instantaneous
-        assertPerformance(
-          endTime - startTime,
-          1, // 1ms max
-          `Pagination mode detection for ${size} records`
-        );
-      });
-    });
-  });
-
-  describe('Performance Monitoring Overhead', () => {
-    it('should have minimal monitoring overhead', () => {
-      const monitor = new PerformanceMonitor();
-      const iterations = 1000;
-      
-      const startTime = performance.now();
-      
-      for (let i = 0; i < iterations; i++) {
-        monitor.startRender();
-        // Simulate some work
-        const workStart = performance.now();
-        while (performance.now() - workStart < 1) {
-          // Busy wait for 1ms
-        }
-        monitor.endRender(50, 1000, true, 'client');
-      }
-      
-      const endTime = performance.now();
-      const averageOverhead = (endTime - startTime) / iterations;
-      
-      // Monitoring overhead should be minimal
-      assertPerformance(
-        averageOverhead,
-        0.1, // 0.1ms average overhead
-        'Performance monitoring overhead'
-      );
-    });
-  });
-
-  describe('Stress Tests', () => {
-    it('should handle rapid state changes without performance degradation', async () => {
-      const data = generatePerformanceTestData(1000);
-      const columns = [
-        { accessorKey: 'name', header: 'Name' },
-        { accessorKey: 'email', header: 'Email' },
-      ];
-
-      renderWithProviders(
-        <DataTable 
-          data={data} 
-          columns={columns} 
-          features={createFeaturesWithEnabled({
-            search: true,
-            pagination: true
-          })}
-        />
-      );
-
-      // Since we're testing performance, we'll test the rendering performance
-      // rather than expecting specific DOM elements that the mock doesn't render
-      const startTime = performance.now();
-      
-      // Simulate rapid state changes by re-rendering with different data
-      const { rerender } = renderWithProviders(
-        <DataTable 
-          data={data} 
-          columns={columns} 
-          features={createFeaturesWithEnabled({
-            search: true,
-            pagination: true
-          })}
-        />
-      );
-      
-      // Re-render with slightly modified data
-      const modifiedData = [...data];
-      modifiedData[0] = { ...modifiedData[0], name: 'Modified User' };
-      
-      rerender(
-        <DataTable 
-          data={modifiedData} 
-          columns={columns} 
-          features={createFeaturesWithEnabled({
-            search: true,
-            pagination: true
-          })}
-        />
-      );
-      
-      const endTime = performance.now();
-      
-      assertPerformance(
-        endTime - startTime,
-        500, // 500ms for all operations
-        'Rapid state changes'
-      );
-    });
-
-    it('should maintain performance with frequent re-renders', () => {
-      const TestComponent = () => {
-        const [data, setData] = React.useState(() => generatePerformanceTestData(500));
-        
-        React.useEffect(() => {
-          const interval = setInterval(() => {
-            // Simulate data updates
-            setData(prev => [...prev.slice(0, -1), {
-              ...prev[prev.length - 1],
-              salary: prev[prev.length - 1].salary + 1000,
-            }]);
-          }, 100); // Increased interval to prevent test timeouts
-          
-          // Clear interval after 1 second to prevent infinite updates
-          const timeout = setTimeout(() => {
-            clearInterval(interval);
-          }, 1000);
-          
-          return () => {
-            clearInterval(interval);
-            clearTimeout(timeout);
-          };
-        }, []);
-        
-        return (
-          <DataTable 
-            data={data} 
-            columns={[
-              { accessorKey: 'name', header: 'Name' },
-              { accessorKey: 'salary', header: 'Salary' },
-            ]} 
-            features={createDefaultFeatures()}
-          />
-        );
-      };
-
-      const startTime = performance.now();
-      const { unmount } = renderWithProviders(<TestComponent />);
-      
-      // Let it run for a short time
-      return new Promise<void>((resolve) => {
-        setTimeout(() => {
-          const endTime = performance.now();
-          unmount();
-          
-          // Should handle frequent updates efficiently
-          assertPerformance(
-            endTime - startTime,
-            1000, // 1 second should be enough for setup and few updates
-            'Frequent re-renders'
-          );
-          
-          resolve();
-        }, 100);
-      });
-    });
-  });
-
-  describe('Memory Leak Prevention', () => {
-    it('should cleanup resources properly', () => {
-      const initialMemory = measureMemoryUsage();
-      const iterations = 10;
-      
-      for (let i = 0; i < iterations; i++) {
-        const data = generatePerformanceTestData(1000);
-        const { unmount } = renderWithProviders(
-          <DataTable 
-            data={data} 
-            columns={[{ accessorKey: 'name', header: 'Name' }]} 
-            features={createFeaturesWithEnabled({})}
-          />
-        );
-        unmount();
-      }
-      
-      // Force garbage collection
-      if (global.gc) {
-        global.gc();
-      }
-      
-      const finalMemory = measureMemoryUsage();
-      const memoryIncrease = finalMemory - initialMemory;
-      
-      // Should not have significant memory leaks
-      expect(memoryIncrease).toBeLessThan(20); // Less than 20MB increase
-    });
-  });
-});