create-qa-architect 5.0.0 → 5.0.6

package/templates/integration-tests/api-service.test.js

@@ -0,0 +1,244 @@
+/**
+ * API Service Integration Test Template
+ * Real database and HTTP integration testing
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest'
+import request from 'supertest'
+
+// Example: Adjust imports based on your API framework
+// import app from '../src/app.js'
+// import { setupTestDatabase, cleanupTestDatabase } from './helpers/database'
+
+describe('API Service Integration Tests', () => {
+  let testApp
+  let _testDb
+
+  beforeAll(async () => {
+    // Setup test database with real connection
+    // testDb = await setupTestDatabase()
+    // testApp = createApp(testDb)
+
+    console.log('🔧 API Integration Test Setup:')
+    console.log('  1. Initialize test database (PostgreSQL/MySQL/SQLite)')
+    console.log('  2. Run migrations and seed test data')
+    console.log('  3. Configure test environment variables')
+    console.log('  4. Start test server on random port')
+  })
+
+  afterAll(async () => {
+    // Cleanup test database
+    // await cleanupTestDatabase(testDb)
+    console.log('🧹 Cleaned up test database and connections')
+  })
+
+  beforeEach(async () => {
+    // Reset test data before each test
+    // await testDb.truncate(['users', 'sessions'])
+  })
+
+  describe('Authentication Flow', () => {
+    it('should complete full authentication cycle', async () => {
+      // Register user
+      const registerResponse = await request(testApp)
+        .post('/api/auth/register')
+        .send({
+          email: 'test@example.com',
+          password: 'SecurePassword123!',
+          name: 'Test User',
+        })
+        .expect(201)
+
+      expect(registerResponse.body).toMatchObject({
+        user: { email: 'test@example.com' },
+        token: expect.any(String),
+      })
+
+      // Login with credentials
+      const loginResponse = await request(testApp)
+        .post('/api/auth/login')
+        .send({
+          email: 'test@example.com',
+          password: 'SecurePassword123!',
+        })
+        .expect(200)
+
+      const { token } = loginResponse.body
+
+      // Access protected resource
+      const protectedResponse = await request(testApp)
+        .get('/api/user/profile')
+        .set('Authorization', `Bearer ${token}`)
+        .expect(200)
+
+      expect(protectedResponse.body.email).toBe('test@example.com')
+    })
+
+    it('should handle invalid credentials properly', async () => {
+      await request(testApp)
+        .post('/api/auth/login')
+        .send({
+          email: 'nonexistent@example.com',
+          password: 'wrongpassword',
+        })
+        .expect(401)
+    })
+
+    it('should enforce rate limiting on login attempts', async () => {
+      const credentials = {
+        email: 'test@example.com',
+        password: 'wrongpassword',
+      }
+
+      // Make multiple failed attempts
+      for (let i = 0; i < 5; i++) {
+        await request(testApp)
+          .post('/api/auth/login')
+          .send(credentials)
+          .expect(401)
+      }
+
+      // 6th attempt should be rate limited
+      await request(testApp)
+        .post('/api/auth/login')
+        .send(credentials)
+        .expect(429)
+    })
+  })
+
+  describe('Database Operations', () => {
+    it('should handle concurrent user creation', async () => {
+      const users = [
+        { email: 'user1@test.com', password: 'Pass123!', name: 'User 1' },
+        { email: 'user2@test.com', password: 'Pass123!', name: 'User 2' },
+        { email: 'user3@test.com', password: 'Pass123!', name: 'User 3' },
+      ]
+
+      // Create users concurrently
+      const promises = users.map(user =>
+        request(testApp).post('/api/auth/register').send(user)
+      )
+
+      const responses = await Promise.all(promises)
+
+      // All should succeed
+      responses.forEach(response => {
+        expect(response.status).toBe(201)
+        expect(response.body.user).toBeDefined()
+      })
+
+      // Verify database consistency
+      const allUsers = await request(testApp)
+        .get('/api/admin/users')
+        .set('Authorization', 'Bearer admin_token')
+        .expect(200)
+
+      expect(allUsers.body.users).toHaveLength(3)
+    })
+
+    it('should maintain data integrity during transactions', async () => {
+      // Test database transactions and rollbacks
+      // Example: Transfer operation that must be atomic
+      const response = await request(testApp)
+        .post('/api/transfer')
+        .send({
+          fromAccount: 'account1',
+          toAccount: 'account2',
+          amount: 100.0,
+        })
+        .expect(200)
+
+      expect(response.body.transaction).toMatchObject({
+        status: 'completed',
+        fromAccount: 'account1',
+        toAccount: 'account2',
+        amount: 100.0,
+      })
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should handle database connection errors gracefully', async () => {
+      // Simulate database disconnection
+      // await testDb.disconnect()
+
+      const response = await request(testApp).get('/api/users').expect(503)
+
+      expect(response.body).toMatchObject({
+        error: 'Service temporarily unavailable',
+        code: 'DATABASE_UNAVAILABLE',
+      })
+
+      // Reconnect for cleanup
+      // await testDb.reconnect()
+    })
+
+    it('should validate request payloads properly', async () => {
+      await request(testApp)
+        .post('/api/auth/register')
+        .send({
+          // Missing required fields
+          email: 'invalid-email',
+        })
+        .expect(400)
+        .expect(res => {
+          expect(res.body.errors).toContain('Valid email required')
+          expect(res.body.errors).toContain('Password is required')
+        })
+    })
+  })
+
+  describe('Performance', () => {
+    it('should handle reasonable load', async () => {
+      const startTime = Date.now()
+
+      // Make 50 concurrent requests
+      const promises = Array.from({ length: 50 }, () =>
+        request(testApp).get('/api/health')
+      )
+
+      const responses = await Promise.all(promises)
+      const endTime = Date.now()
+
+      // All should succeed
+      responses.forEach(response => {
+        expect(response.status).toBe(200)
+      })
+
+      // Should complete within reasonable time (adjust threshold)
+      expect(endTime - startTime).toBeLessThan(5000)
+    })
+  })
+})
+
+// Example test helpers (create in tests/helpers/)
+/*
+// tests/helpers/database.js
+export async function setupTestDatabase() {
+  // Create test database connection
+  // Run migrations
+  // Seed test data
+}
+
+export async function cleanupTestDatabase(db) {
+  // Clean up test data
+  // Close connections
+}
+
+// tests/helpers/auth.js
+export async function createTestUser(app, userData) {
+  const response = await request(app)
+    .post('/api/auth/register')
+    .send(userData)
+
+  return response.body.user
+}
+
+export async function loginTestUser(app, credentials) {
+  const response = await request(app)
+    .post('/api/auth/login')
+    .send(credentials)
+
+  return response.body.token
+}
+*/

package/templates/integration-tests/frontend-app.test.js

@@ -0,0 +1,267 @@
+/**
+ * Frontend Application Integration Test Template
+ * Real browser testing with user interactions
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { test } from '@playwright/test'
+
+// Example: Adjust imports based on your frontend framework
+// React Testing Library example
+// import { render, screen, fireEvent, waitFor } from '@testing-library/react'
+// import userEvent from '@testing-library/user-event'
+// import { BrowserRouter } from 'react-router-dom'
+
+describe('Frontend Application Integration Tests', () => {
+  beforeAll(async () => {
+    console.log('🔧 Frontend Integration Test Setup:')
+    console.log('  1. Start development server')
+    console.log('  2. Setup test database/mock APIs')
+    console.log('  3. Configure test environment')
+    console.log('  4. Launch browser for E2E tests')
+  })
+
+  afterAll(async () => {
+    console.log('🧹 Cleaned up test environment')
+  })
+
+  describe('User Authentication Flow', () => {
+    it('should complete full authentication journey', async () => {
+      // Example using React Testing Library
+      /*
+      const user = userEvent.setup()
+
+      render(
+        <BrowserRouter>
+          <App />
+        </BrowserRouter>
+      )
+
+      // Navigate to login
+      const loginButton = screen.getByRole('button', { name: /sign in/i })
+      await user.click(loginButton)
+
+      // Fill login form
+      const emailInput = screen.getByLabelText(/email/i)
+      const passwordInput = screen.getByLabelText(/password/i)
+
+      await user.type(emailInput, 'test@example.com')
+      await user.type(passwordInput, 'SecurePassword123!')
+
+      const submitButton = screen.getByRole('button', { name: /log in/i })
+      await user.click(submitButton)
+
+      // Verify successful login
+      await waitFor(() => {
+        expect(screen.getByText(/welcome back/i)).toBeInTheDocument()
+      })
+
+      // Verify navigation to dashboard
+      expect(screen.getByRole('heading', { name: /dashboard/i })).toBeInTheDocument()
+      */
+
+      expect(true).toBe(true) // Replace with actual test
+    })
+
+    it('should handle login validation errors', async () => {
+      // Test form validation, API errors, network issues
+      expect(true).toBe(true) // Replace with actual test
+    })
+
+    it('should persist authentication across page refreshes', async () => {
+      // Test token persistence, automatic login restoration
+      expect(true).toBe(true) // Replace with actual test
+    })
+  })
+
+  describe('Component Integration', () => {
+    it('should handle complex form interactions', async () => {
+      // Example: Multi-step form with validation
+      /*
+      const user = userEvent.setup()
+
+      render(<UserRegistrationForm />)
+
+      // Step 1: Basic information
+      await user.type(screen.getByLabelText(/first name/i), 'John')
+      await user.type(screen.getByLabelText(/last name/i), 'Doe')
+      await user.type(screen.getByLabelText(/email/i), 'john@example.com')
+
+      await user.click(screen.getByRole('button', { name: /next/i }))
+
+      // Step 2: Additional details
+      await user.selectOptions(screen.getByLabelText(/country/i), 'US')
+      await user.type(screen.getByLabelText(/phone/i), '+1234567890')
+
+      await user.click(screen.getByRole('button', { name: /submit/i }))
+
+      // Verify submission
+      await waitFor(() => {
+        expect(screen.getByText(/registration successful/i)).toBeInTheDocument()
+      })
+      */
+
+      expect(true).toBe(true) // Replace with actual test
+    })
+
+    it('should handle API loading states properly', async () => {
+      // Test loading spinners, skeleton UI, error states
+      expect(true).toBe(true) // Replace with actual test
+    })
+
+    it('should update UI based on real-time data', async () => {
+      // Test WebSocket connections, polling, state updates
+      expect(true).toBe(true) // Replace with actual test
+    })
+  })
+
+  describe('Navigation and Routing', () => {
+    it('should handle complex navigation flows', async () => {
+      // Test protected routes, redirects, deep linking
+      expect(true).toBe(true) // Replace with actual test
+    })
+
+    it('should preserve state during navigation', async () => {
+      // Test form data persistence, scroll position, etc.
+      expect(true).toBe(true) // Replace with actual test
+    })
+  })
+
+  describe('Accessibility Integration', () => {
+    it('should support keyboard navigation', async () => {
+      // Test tab order, keyboard shortcuts, focus management
+      expect(true).toBe(true) // Replace with actual test
+    })
+
+    it('should work with screen readers', async () => {
+      // Test aria labels, semantic HTML, announcements
+      expect(true).toBe(true) // Replace with actual test
+    })
+
+    it('should handle color contrast and visual requirements', async () => {
+      // Test color contrast ratios, font sizes, visual indicators
+      expect(true).toBe(true) // Replace with actual test
+    })
+  })
+})
+
+// Playwright E2E Tests (real browser testing)
+test.describe('Frontend E2E Tests', () => {
+  test.beforeEach(async ({ page }) => {
+    // Navigate to app
+    await page.goto('http://localhost:3000')
+  })
+
+  test('should complete user signup and onboarding', async ({ page }) => {
+    // Click signup button
+    await page.click('text=Sign Up')
+
+    // Fill registration form
+    await page.fill('[data-testid=email-input]', 'test@example.com')
+    await page.fill('[data-testid=password-input]', 'SecurePassword123!')
+    await page.fill(
+      '[data-testid=confirm-password-input]',
+      'SecurePassword123!'
+    )
+
+    // Submit form
+    await page.click('[data-testid=signup-button]')
+
+    // Wait for redirect to onboarding
+    await page.waitForURL('**/onboarding')
+
+    // Complete onboarding steps
+    await page.fill('[data-testid=first-name]', 'Test')
+    await page.fill('[data-testid=last-name]', 'User')
+    await page.click('[data-testid=continue-button]')
+
+    // Verify dashboard access
+    await page.waitForURL('**/dashboard')
+    await expect(page.locator('h1')).toContainText('Welcome, Test!')
+  })
+
+  test('should handle responsive design across devices', async ({ page }) => {
+    // Test mobile viewport
+    await page.setViewportSize({ width: 375, height: 667 })
+
+    // Mobile navigation should be collapsed
+    await expect(page.locator('[data-testid=mobile-menu-button]')).toBeVisible()
+    await expect(page.locator('[data-testid=desktop-nav]')).not.toBeVisible()
+
+    // Test tablet viewport
+    await page.setViewportSize({ width: 768, height: 1024 })
+
+    // Test desktop viewport
+    await page.setViewportSize({ width: 1920, height: 1080 })
+
+    // Desktop navigation should be visible
+    await expect(page.locator('[data-testid=desktop-nav]')).toBeVisible()
+  })
+
+  test('should handle network failures gracefully', async ({ page }) => {
+    // Simulate offline mode
+    await page.context().setOffline(true)
+
+    // Try to navigate or perform action
+    await page.click('[data-testid=load-data-button]')
+
+    // Should show offline message
+    await expect(page.locator('[data-testid=offline-banner]')).toContainText(
+      'You are offline'
+    )
+
+    // Restore connection
+    await page.context().setOffline(false)
+
+    // Should automatically retry and succeed
+    await expect(page.locator('[data-testid=data-loaded]')).toBeVisible()
+  })
+
+  test('should maintain performance under load', async ({ page }) => {
+    // Navigate to data-heavy page
+    await page.goto('http://localhost:3000/dashboard/analytics')
+
+    // Measure page load performance
+    const navigationPromise = page.waitForLoadState('networkidle')
+    await navigationPromise
+
+    // Check that page loaded within reasonable time
+    const metrics = await page.evaluate(() =>
+      JSON.stringify(window.performance.timing)
+    )
+    const timing = JSON.parse(metrics)
+
+    const loadTime = timing.loadEventEnd - timing.navigationStart
+    expect(loadTime).toBeLessThan(3000) // 3 seconds max
+  })
+})
+
+// Example test helpers (create in tests/helpers/)
+/*
+// tests/helpers/render.js
+export function renderWithProviders(ui, options) {
+  // Wrap with providers (Router, Theme, Auth, etc.)
+  return render(
+    <BrowserRouter>
+      <ThemeProvider>
+        <AuthProvider>
+          {ui}
+        </AuthProvider>
+      </ThemeProvider>
+    </BrowserRouter>,
+    options
+  )
+}
+
+// tests/helpers/api.js
+export function mockApiCalls() {
+  // Setup MSW or similar mocking
+}
+
+// tests/helpers/accessibility.js
+export async function checkAccessibility(container) {
+  const { axe } = await import('axe-core')
+  const results = await axe(container)
+  expect(results.violations).toHaveLength(0)
+}
+*/

package/templates/scripts/smart-test-strategy.sh

@@ -0,0 +1,109 @@
+#!/bin/bash
+# Smart Test Strategy - {{PROJECT_NAME}}
+# Generated by create-qa-architect (Pro/Team/Enterprise feature)
+# https://vibebuildlab.com/tools/qa-architect
+set -e
+
+echo "🧠 Analyzing changes for optimal test strategy..."
+
+# Environment variable overrides
+if [[ "$SKIP_SMART" == "1" ]]; then
+  echo "⚠️  SKIP_SMART=1 - Running comprehensive tests"
+  npm run test:comprehensive
+  exit 0
+fi
+
+if [[ "$FORCE_COMPREHENSIVE" == "1" ]]; then
+  echo "🔴 FORCE_COMPREHENSIVE=1 - Running all tests"
+  npm run test:comprehensive
+  exit 0
+fi
+
+if [[ "$FORCE_MINIMAL" == "1" ]]; then
+  echo "⚪ FORCE_MINIMAL=1 - Running lint only"
+  npm run lint && npm run format:check
+  exit 0
+fi
+
+# Collect metrics
+CHANGED_FILES=$(git diff --name-only HEAD~1..HEAD 2>/dev/null | wc -l | tr -d ' ')
+CHANGED_LINES=$(git diff --stat HEAD~1..HEAD 2>/dev/null | tail -1 | grep -o '[0-9]* insertions' | grep -o '[0-9]*' || echo "0")
+CURRENT_BRANCH=$(git branch --show-current)
+HOUR=$(date +%H)
+DAY_OF_WEEK=$(date +%u)
+
+# Project-specific high-risk patterns (customized per project type)
+# {{HIGH_RISK_PATTERN}}
+HIGH_RISK_FILES=$(git diff --name-only HEAD~1..HEAD 2>/dev/null | grep -E "{{HIGH_RISK_REGEX}}" || true)
+API_FILES=$(git diff --name-only HEAD~1..HEAD 2>/dev/null | grep -E "api/|routes/|endpoints/" || true)
+CONFIG_FILES=$(git diff --name-only HEAD~1..HEAD 2>/dev/null | grep -E "(package\.json|\.env|config|tsconfig)" || true)
+SECURITY_FILES=$(git diff --name-only HEAD~1..HEAD 2>/dev/null | grep -E "(auth|security|crypto|payment|billing)" || true)
+TEST_FILES=$(git diff --name-only HEAD~1..HEAD 2>/dev/null | grep -E "test|spec|__tests__" || true)
+
+# Calculate risk score (0-10)
+RISK_SCORE=0
+
+# File-based risk
+[[ -n "$HIGH_RISK_FILES" ]] && RISK_SCORE=$((RISK_SCORE + 4))
+[[ -n "$SECURITY_FILES" ]] && RISK_SCORE=$((RISK_SCORE + 3))
+[[ -n "$API_FILES" ]] && RISK_SCORE=$((RISK_SCORE + 2))
+[[ -n "$CONFIG_FILES" ]] && RISK_SCORE=$((RISK_SCORE + 2))
+
+# Size-based risk
+[[ $CHANGED_FILES -gt 10 ]] && RISK_SCORE=$((RISK_SCORE + 2))
+[[ $CHANGED_FILES -gt 20 ]] && RISK_SCORE=$((RISK_SCORE + 3))
+[[ $CHANGED_LINES -gt 200 ]] && RISK_SCORE=$((RISK_SCORE + 2))
+
+# Branch-based risk
+case $CURRENT_BRANCH in
+  main|master|production) RISK_SCORE=$((RISK_SCORE + 3)) ;;
+  hotfix/*) RISK_SCORE=$((RISK_SCORE + 4)) ;;
+  release/*) RISK_SCORE=$((RISK_SCORE + 2)) ;;
+  develop) RISK_SCORE=$((RISK_SCORE + 1)) ;;
+esac
+
+# Time pressure adjustment (strip leading zeros for arithmetic)
+HOUR_NUM=$((10#$HOUR))
+if [[ $HOUR_NUM -ge 9 && $HOUR_NUM -le 17 && $DAY_OF_WEEK -le 5 ]]; then
+  echo "⏰ Work hours - Optimizing for speed"
+  SPEED_BONUS=true
+else
+  SPEED_BONUS=false
+fi
+
+# Display analysis
+echo ""
+echo "📊 Analysis Results:"
+echo "   📁 Files changed: $CHANGED_FILES"
+echo "   📏 Lines changed: $CHANGED_LINES"
+echo "   🌿 Branch: $CURRENT_BRANCH"
+echo "   🎯 Risk Score: $RISK_SCORE/10"
+echo "   ⚡ Speed Bonus: $SPEED_BONUS"
+echo ""
+
+# Test tier selection based on risk score
+if [[ $RISK_SCORE -ge 7 ]]; then
+  echo "🔴 HIGH RISK - Comprehensive validation"
+  echo "   • All tests + security audit"
+  # {{COMPREHENSIVE_COMMAND}}
+  {{TEST_COMPREHENSIVE}}
+elif [[ $RISK_SCORE -ge 4 ]]; then
+  echo "🟡 MEDIUM RISK - Standard validation"
+  echo "   • Fast tests + integration (excludes slow tests)"
+  # {{MEDIUM_COMMAND}}
+  {{TEST_MEDIUM}}
+elif [[ $RISK_SCORE -ge 2 || "$SPEED_BONUS" == "false" ]]; then
+  echo "🟢 LOW RISK - Fast validation"
+  echo "   • Unit tests only"
+  # {{FAST_COMMAND}}
+  {{TEST_FAST}}
+else
+  echo "⚪ MINIMAL RISK - Quality checks only"
+  echo "   • Lint + format check"
+  # {{MINIMAL_COMMAND}}
+  {{TEST_MINIMAL}}
+fi
+
+echo ""
+echo "💡 Tip: Run 'npm run test:comprehensive' locally for full validation"
+echo "💎 Smart Test Strategy powered by QA Architect Pro"

package/templates/test-stubs/e2e.smoke.test.js

@@ -0,0 +1,12 @@
+import { describe, it } from 'vitest'
+
+// Replace this stub with Playwright/Cypress flows for your app.
+describe.skip('smoke: homepage renders', () => {
+  it('runs a placeholder e2e flow', async () => {
+    // TODO: add real browser automation (Playwright/Cypress/Webdriver)
+    // Example:
+    // const page = await chromium.launch().newPage()
+    // await page.goto('http://localhost:3000')
+    // await page.getByText('Welcome').isVisible()
+  })
+})

package/templates/test-stubs/unit.test.js

@@ -0,0 +1,7 @@
+import { describe, it, expect } from 'vitest'
+
+describe('sample unit test', () => {
+  it('runs and asserts truthy values', () => {
+    expect(true).toBe(true)
+  })
+})