fix: Refactor log logic for tests

Author: cyaiox

tests/e2e/config/testConfig.ts

@@ -4,69 +4,17 @@ import { config } from 'dotenv';
 // Load .env.e2e file for E2E test configuration
 config({ path: '.env.e2e' });
 
-export interface TestConfig {
-  // Environment settings
-  environment: {
-    tempDir: string;
-    isolatedPort: number;
-    clearCache: boolean;
-    mockData: boolean;
-    clearStorage: boolean;
-  };
-
-  // App settings
-  app: {
-    timeout: number;
-    retryAttempts: number;
-    waitForSelectorTimeout: number;
-  };
-
-  // Test data settings
-  testData: {
-    mockProjectName: string;
-    mockSceneTitle: string;
-    mockSceneDescription: string;
-  };
-}
-
-export const testConfig: TestConfig = {
-  environment: {
-    // Use absolute path to tests/temp/ directory for all test data
-    tempDir: join(resolve(process.cwd()), 'tests', 'temp'),
-    isolatedPort: 3001,
-    clearCache: true,
-    mockData: true,
-    clearStorage: true,
-  },
-
-  app: {
-    timeout: parseInt(process.env.E2E_TIMEOUT || '10000', 10),
-    retryAttempts: 3,
-    waitForSelectorTimeout: 5000,
-  },
-
-  testData: {
-    mockProjectName: 'test-scene',
-    mockSceneTitle: process.env.E2E_SCENE_NAME || 'E2E test scene',
-    mockSceneDescription: 'A test scene for E2E testing',
-  },
-};
-
-// Helper function to get test-specific temp directory
-export const getTestTempDir = (): string => {
-  return join(testConfig.environment.tempDir);
-};
-
+// Helper function to get scene directory path (actually used)
 export const getTestScenesDir = (sceneName: string): string => {
-  return join(testConfig.environment.tempDir, 'scenes', sceneName);
+  return join(resolve(process.cwd()), 'tests', 'temp', 'scenes', sceneName);
 };
 
 // Helper function to get environment variables for tests
 export const getTestEnv = (): Record<string, string> => ({
   NODE_ENV: 'test',
   ELECTRON_ENABLE_LOGGING: 'false',
   ELECTRON_ENABLE_STACK_DUMPING: 'false',
-  PORT: testConfig.environment.isolatedPort.toString(),
+  PORT: '3001',
   DISABLE_ANALYTICS: 'true',
   DISABLE_TELEMETRY: 'true',
   DISABLE_AUTO_UPDATE: 'true',
@@ -78,4 +26,6 @@ export const getTestEnv = (): Record<string, string> => ({
   // Include E2E-specific environment variables
   E2E: process.env.E2E || 'true',
   ...(process.env.E2E_NAME ? { E2E_NAME: process.env.E2E_NAME } : {}),
+  // Debug logging control
+  DEBUG: process.env.DEBUG || 'false',
 });

tests/e2e/features/scenes/preview.spec.ts

@@ -45,6 +45,7 @@ test.describe('when previewing a scene', () => {
       await Promise.race([
         app.waitForEvent('window', {
           predicate: page => page.getByTestId('debugger').isVisible({ timeout: 10_000 }),
+          timeout: 30_000,
         }),
         setup.editorPage.isInstallClientModalVisible(),
       ]);

tests/e2e/globalSetup.ts

@@ -1,42 +1,19 @@
-import { mkdir } from 'fs/promises';
-import { join, resolve } from 'path';
 import { ElectronUtils } from './utils/electron';
-import { TestEnvironment } from './utils/testEnvironment';
 import { ensureTempDir } from './scripts/ensureTempDir';
+import { getTestEnv } from './config/testConfig';
+import { log } from './utils/logger';
 
 async function globalSetup() {
   // Global setup before all tests
-  console.log('Setting up e2e test environment...');
+  log.info('Setting up e2e test environment...');
 
   // Ensure base /temp directory exists
   await ensureTempDir();
 
-  // Create the specific paths that the Electron app expects in E2E mode
-  const tempDir = join(resolve(process.cwd()), 'tests', 'temp');
-  const userDataPath = join(tempDir, 'userData');
-  const homePath = join(tempDir, 'home');
-
-  try {
-    // Create userData directory
-    await mkdir(userDataPath, { recursive: true, mode: 0o755 });
-    console.log(`✅ Created userData directory: ${userDataPath}`);
-
-    // Create home directory
-    await mkdir(homePath, { recursive: true, mode: 0o755 });
-    console.log(`✅ Created home directory: ${homePath}`);
-
-    // Create scenes directory
-    const scenesPath = join(tempDir, 'scenes');
-    await mkdir(scenesPath, { recursive: true, mode: 0o755 });
-    console.log(`✅ Created scenes directory: ${scenesPath}`);
-  } catch (error) {
-    console.error(`❌ Failed to create required directories: ${error}`);
-    throw error;
-  }
-
-  // Set up clean, isolated test environment
-  const testEnvironment = new TestEnvironment();
-  await testEnvironment.setup();
+  // Set up isolated environment variables
+  const testEnv = getTestEnv();
+  Object.assign(process.env, testEnv);
+  log.info('Environment variables configured');
 
   // Reset any existing Electron instances
   await ElectronUtils.resetGlobalInstance();

tests/e2e/globalTeardown.ts

@@ -1,10 +1,11 @@
 import { rm } from 'fs/promises';
 import { join, resolve } from 'path';
 import { ElectronUtils } from './utils/electron';
+import { log } from './logger';
 
 async function globalTeardown() {
   // Global cleanup after all tests
-  console.log('Cleaning up e2e test environment...');
+  log.info('Cleaning up e2e test environment...');
 
   // Ensure Electron app is closed
   const electronUtils = new ElectronUtils();
@@ -19,21 +20,17 @@ async function globalTeardown() {
   try {
     // Clean up userData directory
     await rm(userDataPath, { recursive: true, force: true });
-    console.log(`🗑️ Cleaned up userData directory: ${userDataPath}`);
+    log.info(`Cleaned up userData directory: ${userDataPath}`);
 
     // Clean up home directory
     await rm(homePath, { recursive: true, force: true });
-    console.log(`🗑️ Cleaned up home directory: ${homePath}`);
+    log.info(`Cleaned up home directory: ${homePath}`);
 
     // Clean up scenes directory
     await rm(scenesPath, { recursive: true, force: true });
-    console.log(`🗑️ Cleaned up scenes directory: ${scenesPath}`);
-
-    // Optionally clean up the entire temp directory
-    // await rm(tempDir, { recursive: true, force: true });
-    // console.log(`🗑️ Cleaned up temp directory: ${tempDir}`);
+    log.info(`Cleaned up scenes directory: ${scenesPath}`);
   } catch (error) {
-    console.warn(`⚠️ Could not clean up directories: ${error}`);
+    log.warn(`Could not clean up directories: ${error}`);
   }
 }
 

tests/e2e/utils/electron.ts

@@ -3,6 +3,7 @@ import { rm } from 'fs/promises';
 import type { ElectronApplication, Page } from 'playwright';
 import { _electron as electron } from 'playwright';
 import dotenv from 'dotenv';
+import { log } from './logger';
 
 dotenv.config({ path: '.env.e2e' });
 
@@ -88,9 +89,9 @@ export class ElectronUtils {
       // Only clear cookies, which is usually safe
       await page.context().clearCookies();
 
-      console.log('🧹 Cleared cookies safely');
+      log.info('Cleared cookies safely');
     } catch (error) {
-      console.warn('⚠️ Could not clear cookies:', error);
+      log.warn('Could not clear cookies:', error);
     }
   }
 
@@ -108,9 +109,9 @@ export class ElectronUtils {
         // Clear cookies
         await this.page.context().clearCookies();
 
-        console.log('🔄 Reset page state');
+        log.info('Reset page state');
       } catch (error) {
-        console.warn('⚠️ Could not reset page state:', error);
+        log.warn('Could not reset page state:', error);
       }
     }
   }
@@ -120,14 +121,14 @@ export class ElectronUtils {
     try {
       const singletonLockPath = path.join(userDataPath, 'SingletonLock');
       await rm(singletonLockPath, { force: true });
-      console.log('🔓 Cleaned up singleton lock');
+      log.info('Cleaned up singleton lock');
     } catch (error) {
       // Singleton lock doesn't exist, which is fine
     }
   }
 
   // Static method for backward compatibility (deprecated)
   static async resetGlobalInstance(): Promise<void> {
-    console.warn('⚠️ resetGlobalInstance is deprecated. Use instance-based approach instead.');
+    log.warn('resetGlobalInstance is deprecated. Use instance-based approach instead.');
   }
 }

tests/e2e/utils/logger.ts

@@ -0,0 +1,72 @@
+/**
+ * Logger utility for E2E tests
+ * Only prints when DEBUG=true environment variable is set
+ */
+
+export type LogLevel = 'info' | 'warn' | 'error' | 'debug';
+
+interface LogMessage {
+  level: LogLevel;
+  message: string;
+  emoji?: string;
+  timestamp?: string;
+}
+
+class Logger {
+  private isDebugEnabled: boolean;
+
+  constructor() {
+    this.isDebugEnabled = process.env.DEBUG === 'true';
+  }
+
+  private formatMessage({ level, message, emoji, timestamp }: LogMessage): string {
+    const time = timestamp || new Date().toISOString();
+    const emojiPrefix = emoji ? `${emoji} ` : '';
+    const levelPrefix = `[${level.toUpperCase()}]`;
+
+    return `${levelPrefix} ${time} ${emojiPrefix}${message}`;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    if (!this.isDebugEnabled) {
+      return false;
+    }
+
+    // Allow error logs even when DEBUG is false for critical issues
+    if (level === 'error') {
+      return true;
+    }
+
+    return this.isDebugEnabled;
+  }
+
+  info(message: string, emoji?: string): void {
+    if (this.shouldLog('info')) {
+      console.log(this.formatMessage({ level: 'info', message, emoji }));
+    }
+  }
+
+  warn(message: string, emoji?: string): void {
+    if (this.shouldLog('warn')) {
+      console.warn(this.formatMessage({ level: 'warn', message, emoji }));
+    }
+  }
+
+  error(message: string, emoji?: string): void {
+    if (this.shouldLog('error')) {
+      console.error(this.formatMessage({ level: 'error', message, emoji }));
+    }
+  }
+
+  debug(message: string, emoji?: string): void {
+    if (this.shouldLog('debug')) {
+      console.log(this.formatMessage({ level: 'debug', message, emoji }));
+    }
+  }
+}
+
+// Export singleton instance
+export const log = new Logger();
+
+// Export the class for testing purposes
+export { Logger };