samaro-uitest 1.0.0

package/scripts/check-allure-results.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-test Allure results checker
+ * 
+ * This script checks for existing Allure result data and prompts the user
+ * to either clean it, keep it, or cancel the test run.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const readline = require('readline');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+// Allure result directories to check
+const ALLURE_DIRS = [
+  { name: 'Unit Tests', dir: 'allure-unit-results', type: 'unit' },
+  { name: 'E2E Tests', dir: 'allure-e2e-results', type: 'e2e' },
+  { name: 'Component Tests', dir: 'allure-ct-results', type: 'ct' },
+];
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+/**
+ * Check if a directory exists and get its contents
+ */
+function checkDirectory(dirPath) {
+  const fullPath = path.join(process.cwd(), dirPath);
+  
+  if (!fs.existsSync(fullPath)) {
+    return { exists: false, count: 0, lastModified: null };
+  }
+
+  try {
+    const files = fs.readdirSync(fullPath);
+    const stats = fs.statSync(fullPath);
+    
+    return {
+      exists: true,
+      count: files.length,
+      lastModified: stats.mtime,
+    };
+  } catch (error) {
+    return { exists: false, count: 0, lastModified: null, error: error.message };
+  }
+}
+
+/**
+ * Format the last modified time
+ */
+function formatTime(date) {
+  if (!date) return '-';
+  
+  const now = new Date();
+  const diff = now - date;
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+  
+  if (minutes < 1) return 'Just now';
+  if (minutes < 60) return `${minutes} min ago`;
+  if (hours < 24) return `${hours} hour${hours > 1 ? 's' : ''} ago`;
+  return `${days} day${days > 1 ? 's' : ''} ago`;
+}
+
+/**
+ * Clean all Allure result directories
+ */
+function cleanAllureResults() {
+  console.log(`${colors.cyan}🧹 Cleaning Allure results...${colors.reset}\n`);
+  
+  let cleanedCount = 0;
+  
+  for (const { dir } of ALLURE_DIRS) {
+    const fullPath = path.join(process.cwd(), dir);
+    if (fs.existsSync(fullPath)) {
+      try {
+        fs.rmSync(fullPath, { recursive: true, force: true });
+        console.log(`  ${colors.green}✓${colors.reset} Removed ${dir}/`);
+        cleanedCount++;
+      } catch (error) {
+        console.log(`  ${colors.red}✗${colors.reset} Failed to remove ${dir}/: ${error.message}`);
+      }
+    }
+  }
+  
+  // Also clean the reports directory
+  const reportsPath = path.join(process.cwd(), 'allure-reports');
+  if (fs.existsSync(reportsPath)) {
+    try {
+      fs.rmSync(reportsPath, { recursive: true, force: true });
+      console.log(`  ${colors.green}✓${colors.reset} Removed allure-reports/`);
+      cleanedCount++;
+    } catch (error) {
+      console.log(`  ${colors.red}✗${colors.reset} Failed to remove allure-reports/: ${error.message}`);
+    }
+  }
+  
+  console.log(`${colors.green}\n✅ Cleanup complete!${colors.reset}\n`);
+  return cleanedCount;
+}
+
+/**
+ * Run the actual test command
+ */
+function runTestCommand(command) {
+  console.log(`${colors.cyan}▶️  Running: ${command}${colors.reset}\n`);
+  
+  const parts = command.split(' ');
+  const cmd = parts[0];
+  const args = parts.slice(1);
+  
+  const isWindows = process.platform === 'win32';
+  
+  const child = spawn(cmd, args, {
+    stdio: 'inherit',
+    shell: isWindows,
+    cwd: process.cwd(),
+  });
+  
+  child.on('close', (code) => {
+    process.exit(code);
+  });
+  
+  child.on('error', (error) => {
+    console.error(`${colors.red}Failed to run command: ${error.message}${colors.reset}`);
+    process.exit(1);
+  });
+}
+
+/**
+ * Show the prompt and handle user input
+ */
+function showPrompt(hasExistingResults, testCommand) {
+  console.log(`${colors.bright}What would you like to do?${colors.reset}\n`);
+  
+  if (hasExistingResults) {
+    console.log(`   ${colors.green}[1]${colors.reset} 🧹 Clean all results and run tests (recommended)`);
+    console.log(`   ${colors.yellow}[2]${colors.reset} ▶️  Keep results and run tests (will accumulate)`);
+  } else {
+    console.log(`   ${colors.green}[1]${colors.reset} ▶️  Run tests`);
+  }
+  console.log(`   ${colors.red}[3]${colors.reset} ❌ Cancel\n`);
+  
+  const promptText = hasExistingResults 
+    ? `Select option (1-3): `
+    : `Select option (1 or 3): `;
+  
+  rl.question(promptText, (answer) => {
+    const choice = answer.trim();
+    
+    if (choice === '1') {
+      // Clean and run
+      if (hasExistingResults) {
+        cleanAllureResults();
+      }
+      rl.close();
+      runTestCommand(testCommand);
+    } else if (choice === '2' && hasExistingResults) {
+      // Keep results and run
+      console.log(`${colors.yellow}\n⚠️  Proceeding with existing results. Reports will show duplicates.${colors.reset}\n`);
+      rl.close();
+      runTestCommand(testCommand);
+    } else if (choice === '3') {
+      // Cancel
+      console.log(`${colors.gray}\n❌ Test run cancelled.${colors.reset}`);
+      rl.close();
+      process.exit(0);
+    } else {
+      // Invalid input
+      console.log(`${colors.red}\n❌ Invalid option. Please try again.${colors.reset}\n`);
+      showPrompt(hasExistingResults, testCommand);
+    }
+  });
+}
+
+/**
+ * Auto mode - clean and run without prompting (for CI)
+ */
+function autoMode(testCommand) {
+  console.log(`${colors.cyan}🧹 Auto-cleaning Allure results (CI mode)...${colors.reset}\n`);
+  cleanAllureResults();
+  runTestCommand(testCommand);
+}
+
+/**
+ * Main function
+ */
+function main() {
+  // Get the test command from arguments
+  const testCommand = process.argv.slice(2).join(' ');
+  
+  if (!testCommand) {
+    console.error(`${colors.red}Error: No test command provided${colors.reset}`);
+    console.error(`Usage: node check-allure-results.js "<test-command>"`);
+    console.error(`Example: node check-allure-results.js "vitest"`);
+    process.exit(1);
+  }
+  
+  // Check if in CI mode
+  if (process.env.CI || process.env.SAMARO_AUTO_CLEAN) {
+    autoMode(testCommand);
+    return;
+  }
+  
+  console.log(`\n${colors.bright}🔍 Checking for existing Allure results...${colors.reset}\n`);
+  
+  // Check all directories
+  const results = ALLURE_DIRS.map(({ name, dir }) => ({
+    name,
+    dir,
+    ...checkDirectory(dir),
+  }));
+  
+  const hasExistingResults = results.some(r => r.exists && r.count > 0);
+  
+  if (!hasExistingResults) {
+    console.log(`${colors.green}✅ No existing Allure results found.${colors.reset}`);
+    console.log(`${colors.gray}   Starting with a clean slate.${colors.reset}\n`);
+    showPrompt(false, testCommand);
+    return;
+  }
+  
+  // Show warning
+  console.log(`${colors.yellow}⚠️  WARNING: Found existing result data from previous runs:${colors.reset}\n`);
+  
+  // Print table header
+  console.log(`   ${colors.bright}Directory${colors.reset}                    Files    Last Run`);
+  console.log(`   ${colors.gray}────────────────────────────────────────────────${colors.reset}`);
+  
+  // Print results
+  results.forEach(({ name, dir, exists, count, lastModified }) => {
+    if (exists) {
+      const namePadded = name.padEnd(28);
+      const countPadded = String(count).padStart(5);
+      const time = formatTime(lastModified);
+      console.log(`   ${namePadded} ${countPadded}    ${time}`);
+    }
+  });
+  
+  console.log(`\n${colors.cyan}💡 Not cleaning will cause duplicate entries in reports.${colors.reset}\n`);
+  
+  showPrompt(true, testCommand);
+}
+
+// Handle Ctrl+C gracefully
+rl.on('SIGINT', () => {
+  console.log(`\n${colors.gray}\n❌ Cancelled by user.${colors.reset}`);
+  rl.close();
+  process.exit(0);
+});
+
+// Run the script
+main();

package/types/allure.d.ts

@@ -0,0 +1,76 @@
+// Type definitions for Allure metadata in tests
+
+export interface AllureLabel {
+  name: string;
+  value: string;
+}
+
+export interface AllureLink {
+  name?: string;
+  url: string;
+  type?: string;
+}
+
+export interface AllureParameter {
+  name: string;
+  value: string;
+}
+
+export interface AllureStep {
+  name: string;
+  status: 'passed' | 'failed' | 'broken' | 'skipped';
+}
+
+export interface AllureAttachment {
+  name: string;
+  type: string;
+  source: string;
+}
+
+export interface AllureTestCase {
+  name: string;
+  fullName: string;
+  historyId: string;
+  testCaseId?: string;
+  labels: AllureLabel[];
+  links: AllureLink[];
+  parameters: AllureParameter[];
+  steps: AllureStep[];
+  attachments: AllureAttachment[];
+  status: 'passed' | 'failed' | 'broken' | 'skipped';
+  statusDetails?: {
+    known?: boolean;
+    muted?: boolean;
+    flaky?: boolean;
+    message?: string;
+    trace?: string;
+  };
+  stage: 'scheduled' | 'running' | 'finished';
+  description?: string;
+  descriptionHtml?: string;
+  start?: number;
+  stop?: number;
+}
+
+// Severity levels
+export type Severity = 'blocker' | 'critical' | 'normal' | 'minor' | 'trivial';
+
+// Label names
+export type LabelName =
+  | 'epic'
+  | 'feature'
+  | 'story'
+  | 'suite'
+  | 'parentSuite'
+  | 'subSuite'
+  | 'owner'
+  | 'severity'
+  | 'tag'
+  | 'layer'
+  | 'host'
+  | 'thread'
+  | 'language'
+  | 'framework'
+  | 'package'
+  | 'testClass'
+  | 'testMethod';

package/types/global.d.ts

@@ -0,0 +1,49 @@
+// Global type definitions for SamaroUItest
+
+declare global {
+  interface Window {
+    /**
+     * Debug interface for accessing Angular app state during tests
+     */
+    __app_debug__?: {
+      getToken(): string | null;
+      getAuthState(): 'authenticated' | 'unauthenticated' | 'unavailable' | 'loading';
+      getCurrentUser(): {
+        username: string;
+        email: string;
+        bio: string | null;
+        image: string | null;
+        token: string;
+      } | null;
+    };
+
+    /**
+     * Angular testability interface
+     */
+    getAngularTestability?(element: Element): {
+      isStable(): boolean;
+      whenStable(callback: () => void): void;
+    };
+  }
+
+  /**
+   * Environment variables
+   */
+  namespace NodeJS {
+    interface ProcessEnv {
+      CI?: string;
+      API_MODE?: string;
+      API_BASE?: string;
+      DEBUG_INTERFACE_NAME?: string;
+      TIMEOUT_NAVIGATION?: string;
+      TIMEOUT_ACTION?: string;
+      TIMEOUT_EXPECTATION?: string;
+      SAMARO_AUTO_CLEAN?: string;
+      NG_API_URL?: string;
+      DEBUG?: string;
+      PWDEBUG?: string;
+    }
+  }
+}
+
+export {};