Refactor code structure and remove redundant changes

src-old/lib/integrationTests/suites/performanceTests.ts

@@ -0,0 +1,275 @@
+/**
+ * Performance & Scalability Integration Tests
+ * 
+ * Tests for system performance under various conditions.
+ */
+
+import { supabase } from '@/lib/supabaseClient';
+import type { TestSuite, TestResult } from '../testRunner';
+import { TestDataTracker } from '../TestDataTracker';
+
+export const performanceTestSuite: TestSuite = {
+  id: 'performance',
+  name: 'Performance & Scalability',
+  description: 'Tests for system performance and query efficiency',
+  tests: [
+    {
+      id: 'perf-001',
+      name: 'Entity Query Performance',
+      description: 'Measures query performance for entity lists',
+      run: async (): Promise<TestResult> => {
+        const startTime = Date.now();
+
+        try {
+          // Test parks query performance
+          const parksStart = Date.now();
+          const { data: parks, error: parksError } = await supabase
+            .from('parks')
+            .select('id, name, slug, park_type, status')
+            .limit(50);
+
+          const parksDuration = Date.now() - parksStart;
+
+          if (parksError) throw new Error(`Parks query failed: ${parksError.message}`);
+
+          // Test rides query performance
+          const ridesStart = Date.now();
+          const { data: rides, error: ridesError } = await supabase
+            .from('rides')
+            .select('id, name, slug, category, status, park_id')
+            .limit(50);
+
+          const ridesDuration = Date.now() - ridesStart;
+
+          if (ridesError) throw new Error(`Rides query failed: ${ridesError.message}`);
+
+          // Test companies query performance
+          const companiesStart = Date.now();
+          const { data: companies, error: companiesError } = await supabase
+            .from('companies')
+            .select('id, name, slug, company_type')
+            .limit(50);
+
+          const companiesDuration = Date.now() - companiesStart;
+
+          if (companiesError) throw new Error(`Companies query failed: ${companiesError.message}`);
+
+          // Set performance thresholds (in milliseconds)
+          const threshold = 1000; // 1 second
+          const warnings: string[] = [];
+
+          if (parksDuration > threshold) {
+            warnings.push(`Parks query slow: ${parksDuration}ms`);
+          }
+          if (ridesDuration > threshold) {
+            warnings.push(`Rides query slow: ${ridesDuration}ms`);
+          }
+          if (companiesDuration > threshold) {
+            warnings.push(`Companies query slow: ${companiesDuration}ms`);
+          }
+
+          const totalDuration = Date.now() - startTime;
+
+          return {
+            id: 'perf-001',
+            name: 'Entity Query Performance',
+            suite: 'Performance & Scalability',
+            status: warnings.length === 0 ? 'pass' : 'fail',
+            duration: totalDuration,
+            timestamp: new Date().toISOString(),
+            error: warnings.length > 0 ? warnings.join('; ') : undefined,
+            details: {
+              parksDuration,
+              ridesDuration,
+              companiesDuration,
+              threshold,
+              parksCount: parks?.length || 0,
+              ridesCount: rides?.length || 0,
+              companiesCount: companies?.length || 0
+            }
+          };
+
+        } catch (error) {
+          return {
+            id: 'perf-001',
+            name: 'Entity Query Performance',
+            suite: 'Performance & Scalability',
+            status: 'fail',
+            duration: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error),
+            timestamp: new Date().toISOString()
+          };
+        }
+      }
+    },
+    {
+      id: 'perf-002',
+      name: 'Version History Query Performance',
+      description: 'Measures performance of version history queries',
+      run: async (): Promise<TestResult> => {
+        const startTime = Date.now();
+        const tracker = new TestDataTracker();
+        let parkId: string | null = null;
+
+        try {
+          // Create test park
+          const parkSlug = `test-park-perf-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+          const { data: park, error: parkError } = await supabase
+            .from('parks')
+            .insert({
+              name: 'Test Park Performance',
+              slug: parkSlug,
+              park_type: 'theme_park',
+              status: 'operating',
+              is_test_data: true
+            })
+            .select('id')
+            .single();
+
+          if (parkError) throw parkError;
+          parkId = park.id;
+          tracker.track('parks', parkId);
+
+          // Create multiple versions (updates)
+          for (let i = 0; i < 10; i++) {
+            await supabase
+              .from('parks')
+              .update({ description: `Version ${i + 1}` })
+              .eq('id', parkId);
+            
+            // Small delay to ensure versions are created
+            await new Promise(resolve => setTimeout(resolve, 50));
+          }
+
+          // Measure version history query
+          const versionStart = Date.now();
+          const { data: versions, error: versionError } = await supabase
+            .from('park_versions')
+            .select('version_id, version_number, change_type, created_at')
+            .eq('park_id', parkId)
+            .order('version_number', { ascending: false });
+
+          const versionDuration = Date.now() - versionStart;
+
+          if (versionError) throw new Error(`Version query failed: ${versionError.message}`);
+
+          // Performance threshold: 500ms for version history
+          const threshold = 500;
+          const isSlow = versionDuration > threshold;
+
+          const totalDuration = Date.now() - startTime;
+
+          return {
+            id: 'perf-002',
+            name: 'Version History Query Performance',
+            suite: 'Performance & Scalability',
+            status: isSlow ? 'fail' : 'pass',
+            duration: totalDuration,
+            timestamp: new Date().toISOString(),
+            error: isSlow ? `Version query took ${versionDuration}ms (threshold: ${threshold}ms)` : undefined,
+            details: {
+              versionDuration,
+              threshold,
+              versionsFound: versions?.length || 0,
+              isSlow
+            }
+          };
+
+        } catch (error) {
+          return {
+            id: 'perf-002',
+            name: 'Version History Query Performance',
+            suite: 'Performance & Scalability',
+            status: 'fail',
+            duration: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error),
+            timestamp: new Date().toISOString()
+          };
+        } finally {
+          await tracker.cleanup();
+          const remaining = await tracker.verifyCleanup();
+          if (remaining.length > 0) {
+            console.warn('perf-002 cleanup incomplete:', remaining);
+          }
+        }
+      }
+    },
+    {
+      id: 'perf-003',
+      name: 'Database Function Performance',
+      description: 'Measures performance of database functions',
+      run: async (): Promise<TestResult> => {
+        const startTime = Date.now();
+
+        try {
+          const { data: userData } = await supabase.auth.getUser();
+          if (!userData.user) throw new Error('No authenticated user');
+
+          // Test is_moderator function performance
+          const modStart = Date.now();
+          const { data: isMod, error: modError } = await supabase
+            .rpc('is_moderator', {
+              _user_id: userData.user.id
+            });
+
+          const modDuration = Date.now() - modStart;
+
+          if (modError) throw modError;
+
+          // Test is_user_banned function performance
+          const banStart = Date.now();
+          const { data: isBanned, error: banError } = await supabase
+            .rpc('is_user_banned', {
+              p_user_id: userData.user.id
+            });
+
+          const banDuration = Date.now() - banStart;
+
+          if (banError) throw banError;
+
+          // Performance threshold: 200ms for simple functions
+          const threshold = 200;
+          const warnings: string[] = [];
+
+          if (modDuration > threshold) {
+            warnings.push(`is_moderator slow: ${modDuration}ms`);
+          }
+          if (banDuration > threshold) {
+            warnings.push(`is_user_banned slow: ${banDuration}ms`);
+          }
+
+          const totalDuration = Date.now() - startTime;
+
+          return {
+            id: 'perf-003',
+            name: 'Database Function Performance',
+            suite: 'Performance & Scalability',
+            status: warnings.length === 0 ? 'pass' : 'fail',
+            duration: totalDuration,
+            timestamp: new Date().toISOString(),
+            error: warnings.length > 0 ? warnings.join('; ') : undefined,
+            details: {
+              isModerator: isMod,
+              isBanned,
+              modDuration,
+              banDuration,
+              threshold,
+              allFast: warnings.length === 0
+            }
+          };
+
+        } catch (error) {
+          return {
+            id: 'perf-003',
+            name: 'Database Function Performance',
+            suite: 'Performance & Scalability',
+            status: 'fail',
+            duration: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error),
+            timestamp: new Date().toISOString()
+          };
+        }
+      }
+    }
+  ]
+};