agentic-qe 1.2.0 → 1.3.0

package/.claude/skills/test-design-techniques/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: test-design-techniques
+description: Systematic test design with boundary value analysis, equivalence partitioning, decision tables, state transition testing, and combinatorial testing. Use when designing comprehensive test cases, reducing redundant tests, or ensuring systematic coverage.
+version: 1.0.0
+category: testing-methodologies
+tags: [test-design, bva, equivalence-partitioning, decision-tables, combinatorial-testing, pairwise]
+difficulty: intermediate
+estimated_time: 75 minutes
+author: agentic-qe
+---
+
+# Test Design Techniques
+
+## Core Principle
+
+**Systematic test design finds more bugs with fewer tests.**
+
+Random testing is inefficient. Proven test design techniques (40+ years of research) systematically identify high-value test cases, reduce redundancy, and maximize bug detection.
+
+## Boundary Value Analysis (BVA)
+
+**Principle:** Bugs cluster at boundaries of valid input ranges.
+
+**Test at:**
+- Minimum valid value
+- Just below minimum (invalid)
+- Just above minimum (valid)
+- Maximum valid value
+- Just above maximum (invalid)
+- Just below maximum (valid)
+
+**Example: Age field (18-120)**
+```
+Test Cases:
+✓ 17  - Just below min (invalid, reject)
+✓ 18  - Minimum valid (accept)
+✓ 19  - Just above min (accept)
+✓ 119 - Just below max (accept)
+✓ 120 - Maximum valid (accept)
+✓ 121 - Just above max (invalid, reject)
+```
+
+**With Agents:**
+```typescript
+// qe-test-generator automatically identifies boundaries
+const tests = await agent.generateBVATests({
+  field: 'age',
+  dataType: 'integer',
+  constraints: { min: 18, max: 120 }
+});
+// Returns: 6 boundary test cases
+```
+
+## Equivalence Partitioning (EP)
+
+**Principle:** Divide input into partitions where all values behave the same.
+
+**Example: Discount based on quantity**
+```
+Quantity Rules:
+1-10:    No discount
+11-100:  10% discount
+101+:    20% discount
+
+Partitions:
+1. Invalid: quantity ≤ 0
+2. Valid, no discount: 1-10
+3. Valid, 10% discount: 11-100
+4. Valid, 20% discount: 101+
+
+Test Cases (1 per partition):
+✓ -1   → Reject
+✓ 5    → 0% discount
+✓ 50   → 10% discount
+✓ 200  → 20% discount
+```
+
+## Decision Tables
+
+**Use for:** Complex business rules with multiple conditions.
+
+**Example: Loan Approval**
+```
+Conditions:
+- Age ≥ 18
+- Credit Score ≥ 700
+- Income ≥ $50k
+
+Rule 1 | Rule 2 | Rule 3 | Rule 4 | Rule 5
+-------|--------|--------|--------|-------
+Yes    | Yes    | Yes    | No     | Yes
+Yes    | Yes    | No     | Yes    | No
+Yes    | No     | Yes    | Yes    | Yes
+-------+--------+--------+--------+-------
+Approve| Approve| Reject | Reject | Reject
+```
+
+**Test Cases:** 5 tests cover all decision combinations.
+
+## State Transition Testing
+
+**Model state changes:**
+```
+States: Logged Out → Logged In → Premium → Suspended
+
+Transitions:
+Login: Logged Out → Logged In
+Upgrade: Logged In → Premium
+Payment Fail: Premium → Suspended
+Logout: Any → Logged Out
+
+Invalid Transitions to Test:
+Logged Out → Premium (should reject)
+Suspended → Premium (should reject)
+```
+
+## Pairwise (Combinatorial) Testing
+
+**Problem:** Testing all combinations explodes.
+
+**Example: Cross-browser testing**
+```
+Browser: Chrome, Firefox, Safari (3)
+OS: Windows, Mac, Linux (3)
+Screen: Desktop, Tablet, Mobile (3)
+
+All combinations: 3 × 3 × 3 = 27 tests
+
+Pairwise: 9 tests cover all pairs
+```
+
+**With Agents:**
+```typescript
+// qe-test-generator does pairwise reduction
+const tests = await agent.generatePairwiseTests({
+  parameters: {
+    browser: ['Chrome', 'Firefox', 'Safari'],
+    os: ['Windows', 'Mac', 'Linux'],
+    screen: ['Desktop', 'Tablet', 'Mobile']
+  }
+});
+// Returns: 9-12 tests (vs 27 full combination)
+```
+
+## Related Skills
+
+- [agentic-quality-engineering](../agentic-quality-engineering/)
+- [test-automation-strategy](../test-automation-strategy/)
+- [risk-based-testing](../risk-based-testing/)
+
+## Remember
+
+**Systematic design > Random testing**
+
+- BVA finds boundary bugs
+- EP reduces redundant tests
+- Decision tables handle complexity
+- Pairwise reduces combinatorial explosion
+
+**With Agents:** `qe-test-generator` applies these techniques automatically, generating optimal test suites with maximum coverage and minimum redundancy.

package/.claude/skills/test-environment-management/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: test-environment-management
+description: Test environment provisioning, infrastructure as code for testing, Docker/Kubernetes for test environments, service virtualization, and cost optimization. Use when managing test infrastructure, ensuring environment parity, or optimizing testing costs.
+version: 1.0.0
+category: testing-infrastructure
+tags: [test-environments, docker, kubernetes, infrastructure-as-code, service-virtualization, environment-parity]
+difficulty: advanced
+estimated_time: 75 minutes
+author: agentic-qe
+---
+
+# Test Environment Management
+
+## Core Principle
+
+**Unstable test environments = unreliable tests.**
+
+Test environment management ensures consistent, reproducible environments for testing while optimizing cost and maintenance.
+
+## Environment Types
+
+### Local Development
+```
+Developer machine
+- Fast feedback
+- Full control
+- May differ from production
+```
+
+### CI Environment
+```
+GitHub Actions, Jenkins, etc.
+- Automated tests
+- Ephemeral (created per build)
+- Must match production closely
+```
+
+### Staging/QA Environment
+```
+Pre-production mirror
+- Integration testing
+- User acceptance testing
+- Should match production exactly
+```
+
+### Production (Testing in Prod)
+```
+Real environment
+- Canary deployments
+- Feature flags
+- Synthetic monitoring
+```
+
+## Docker for Test Environments
+
+**Containerize test dependencies:**
+```yaml
+# docker-compose.test.yml
+version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      NODE_ENV: test
+      DATABASE_URL: postgres://postgres:password@db:5432/test
+    depends_on:
+      - db
+      - redis
+
+  db:
+    image: postgres:15
+    environment:
+      POSTGRES_DB: test
+      POSTGRES_PASSWORD: password
+    ports:
+      - "5432:5432"
+
+  redis:
+    image: redis:7
+    ports:
+      - "6379:6379"
+```
+
+**Run tests in container:**
+```bash
+docker-compose -f docker-compose.test.yml up -d
+docker-compose -f docker-compose.test.yml exec app npm test
+docker-compose -f docker-compose.test.yml down
+```
+
+## Infrastructure as Code
+
+**Terraform for test environments:**
+```hcl
+# test-environment.tf
+resource "aws_instance" "test_server" {
+  ami           = "ami-0c55b159cbfafe1f0"
+  instance_type = "t3.medium"
+
+  tags = {
+    Name        = "test-environment"
+    Environment = "test"
+    AutoShutdown = "20:00" # Cost optimization
+  }
+}
+
+resource "aws_rds_instance" "test_db" {
+  allocated_storage = 20
+  engine           = "postgres"
+  engine_version   = "15"
+  instance_class   = "db.t3.micro"
+  db_name          = "test"
+  username         = "testuser"
+  password         = var.db_password
+
+  backup_retention_period = 0 # No backups needed for test
+  skip_final_snapshot    = true
+}
+```
+
+## Service Virtualization
+
+**Mock external services:**
+```javascript
+// Use WireMock for API mocking
+import { WireMock } from 'wiremock-captain';
+
+const wiremock = new WireMock('http://localhost:8080');
+
+// Mock payment gateway
+await wiremock.register({
+  request: {
+    method: 'POST',
+    url: '/charge'
+  },
+  response: {
+    status: 200,
+    jsonBody: {
+      transactionId: '12345',
+      status: 'approved'
+    }
+  }
+});
+
+// Tests use mock instead of real gateway
+```
+
+## Environment Parity
+
+**Dev/Prod Parity Checklist:**
+- [ ] Same OS and versions
+- [ ] Same database type and version
+- [ ] Same dependency versions
+- [ ] Same configuration structure
+- [ ] Same environment variables
+
+**12-Factor App principles for parity**
+
+## Cost Optimization
+
+**Auto-shutdown test environments:**
+```bash
+# Shutdown test environments after hours
+0 20 * * * aws ec2 stop-instances --instance-ids $(aws ec2 describe-instances --filters "Name=tag:Environment,Values=test" --query "Reservations[].Instances[].InstanceId" --output text)
+
+# Start before work hours
+0 7 * * 1-5 aws ec2 start-instances --instance-ids $(aws ec2 describe-instances --filters "Name=tag:Environment,Values=test" --query "Reservations[].Instances[].InstanceId" --output text)
+```
+
+**Use spot instances for test workloads:**
+```hcl
+resource "aws_instance" "test_runner" {
+  instance_type        = "c5.2xlarge"
+  instance_market_options {
+    market_type = "spot"
+    spot_options {
+      max_price = "0.10" # Save 70% vs on-demand
+    }
+  }
+}
+```
+
+## Related Skills
+
+- [test-data-management](../test-data-management/)
+- [continuous-testing-shift-left](../continuous-testing-shift-left/)
+- [test-automation-strategy](../test-automation-strategy/)
+
+## Remember
+
+**Environment inconsistency = flaky tests.**
+
+"Works on my machine" problems from:
+- Different OS/versions
+- Missing dependencies
+- Configuration differences
+- Data differences
+
+**Infrastructure as Code ensures repeatability.**
+
+**With Agents:** Agents automatically provision test environments, ensure parity with production, and optimize costs by auto-scaling and auto-shutdown.

package/.claude/skills/test-reporting-analytics/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: test-reporting-analytics
+description: Advanced test reporting, quality dashboards, predictive analytics, trend analysis, and executive reporting for QE metrics. Use when communicating quality status, tracking trends, or making data-driven decisions.
+version: 1.0.0
+category: quality-management
+tags: [test-reporting, analytics, dashboards, metrics, kpis, executive-reporting]
+difficulty: intermediate
+estimated_time: 60 minutes
+author: agentic-qe
+---
+
+# Test Reporting & Analytics
+
+## Core Principle
+
+**Measure to improve. Report to communicate.**
+
+Test reporting transforms raw test data into actionable insights. Analytics enable data-driven quality decisions.
+
+## Key Metrics
+
+### Test Execution Metrics
+- Pass/Fail rate
+- Flaky test percentage
+- Execution time (total, per test)
+- Test coverage (code, requirements)
+
+### Quality Metrics
+- Defect density
+- Defect detection rate
+- Escaped defects
+- Mean time to detect (MTTD)
+- Mean time to resolve (MTTR)
+
+### Efficiency Metrics
+- Automation rate
+- Test maintenance cost
+- ROI of automation
+- Velocity (features tested/sprint)
+
+## Dashboards
+
+**Real-Time Quality Dashboard:**
+```
++------------------+------------------+------------------+
+| Tests Passed     | Code Coverage    | Flaky Tests      |
+| 1,247 / 1,250    | 82.3%           | 1.2%            |
+| 99.76% ✅       | ⬆️ +2.1%        | ⬇️ -0.3%        |
++------------------+------------------+------------------+
+
++------------------+------------------+------------------+
+| Critical Bugs    | Test Velocity    | Deploy Freq     |
+| 0 open           | 47 tests/sprint  | 12x/day         |
+| ✅              | ⬆️ +5           | ⬆️ +2x          |
++------------------+------------------+------------------+
+
+Recent Trends (30 days):
+[Graph showing pass rate, coverage, flaky tests over time]
+```
+
+## Trend Analysis
+
+```javascript
+// Identify trends
+const testResults = await fetchTestResults(30); // 30 days
+
+const trend = analyzeTrend(testResults, 'passRate');
+if (trend === 'declining') {
+  alert('⚠️ Test pass rate declining for 7 days');
+}
+
+const coverage = analyzeTrend(testResults, 'coverage');
+if (coverage === 'stagnant') {
+  alert('ℹ️ Code coverage unchanged. Add tests for new code.');
+}
+```
+
+## Predictive Analytics
+
+```typescript
+// Predict test failures
+const prediction = await agent.predictTestFailures({
+  historicalData: testResults,
+  codeChanges: prDiff,
+  teamMetrics: velocityData
+});
+
+// Returns:
+// {
+//   probabilityOfFailure: 0.73,
+//   likelyFailingTests: ['payment.test.ts', 'checkout.test.ts'],
+//   suggestedAction: 'Review payment module changes carefully',
+//   confidence: 0.89
+// }
+```
+
+## Executive Reporting
+
+**Monthly Quality Report:**
+```markdown
+## Quality Report - October 2025
+
+### Executive Summary
+✅ Production: 99.97% uptime (target: 99.95%)
+✅ Deployment: 12x/day (up from 8x/day)
+⚠️ Test Coverage: 82.3% (target: 85%)
+
+### Key Achievements
+- Reduced flaky tests from 3.2% to 1.2%
+- Automated 47 new tests (95% automation rate)
+- 0 critical bugs escaped to production
+
+### Action Items
+- Increase coverage for new payment module
+- Address 3 long-running flaky tests
+- Train team on performance testing
+
+### ROI
+- Automation saves 120 hours/month
+- Bug detection cost: $150/bug vs $5,000 in production
+- Estimated annual savings: $450k
+```
+
+## Related Skills
+
+- [quality-metrics](../quality-metrics/)
+- [agentic-quality-engineering](../agentic-quality-engineering/)
+- [continuous-testing-shift-left](../continuous-testing-shift-left/)
+
+## Remember
+
+**Track metrics to improve quality.**
+
+Report:
+- Test results (pass/fail trends)
+- Code coverage (gaps and trends)
+- Flaky test rate (reliability)
+- Defect metrics (escaped bugs)
+- ROI of testing (business value)
+
+**Make data actionable, not just visible.**
+
+**With Agents:** `qe-quality-analyzer` aggregates metrics, generates insights, predicts trends, and creates executive reports automatically.

package/.claude/skills/visual-testing-advanced/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: visual-testing-advanced
+description: Advanced visual regression testing with pixel-perfect comparison, AI-powered diff analysis, responsive design validation, and cross-browser visual consistency. Use when detecting UI regressions, validating designs, or ensuring visual consistency.
+version: 1.0.0
+category: specialized-testing
+tags: [visual-testing, visual-regression, pixel-perfect, screenshot-testing, ui-testing]
+difficulty: intermediate
+estimated_time: 60 minutes
+author: agentic-qe
+---
+
+# Advanced Visual Testing
+
+## Core Principle
+
+**Visual bugs are bugs. Test what users see.**
+
+Visual testing catches UI regressions that functional tests miss: layout shifts, color changes, font rendering, alignment issues.
+
+## Visual Regression Testing
+
+**Process:**
+1. Capture baseline screenshots
+2. Make code changes
+3. Capture new screenshots
+4. Compare pixel-by-pixel
+5. Flag differences for review
+
+**With Playwright:**
+```javascript
+import { test, expect } from '@playwright/test';
+
+test('homepage visual regression', async ({ page }) => {
+  await page.goto('https://example.com');
+
+  // Capture screenshot
+  await expect(page).toHaveScreenshot('homepage.png');
+  // First run: saves baseline
+  // Subsequent runs: compares to baseline
+});
+
+test('responsive design on mobile', async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 667 }); // iPhone
+
+  await page.goto('https://example.com');
+  await expect(page).toHaveScreenshot('homepage-mobile.png');
+});
+```
+
+**Configuration:**
+```javascript
+// playwright.config.js
+export default {
+  expect: {
+    toHaveScreenshot: {
+      maxDiffPixels: 100, // Allow 100 pixel difference
+      threshold: 0.2, // 20% similarity threshold
+      animations: 'disabled', // Disable animations
+      caret: 'hide' // Hide cursor
+    }
+  }
+};
+```
+
+## AI-Powered Visual Testing
+
+**Percy (BrowserStack):**
+```javascript
+import percySnapshot from '@percy/playwright';
+
+test('homepage visual test', async ({ page }) => {
+  await page.goto('https://example.com');
+
+  // AI-powered comparison (ignores minor anti-aliasing differences)
+  await percySnapshot(page, 'Homepage');
+});
+```
+
+## Cross-Browser Visual Testing
+
+```javascript
+test.describe('cross-browser visual consistency', () => {
+  test('Chrome vs Firefox', async ({ browser }) => {
+    const chromePage = await browser.newPage();
+    await chromePage.goto('https://example.com');
+    const chromeScreenshot = await chromePage.screenshot();
+
+    // Compare Chrome vs Firefox rendering
+    expect(chromeScreenshot).toMatchSnapshot('chrome-homepage.png');
+  });
+});
+```
+
+## Dynamic Content Handling
+
+**Mask dynamic elements:**
+```javascript
+test('ignore dynamic content', async ({ page }) => {
+  await page.goto('https://example.com');
+
+  await expect(page).toHaveScreenshot({
+    mask: [
+      page.locator('.timestamp'),   // Mask timestamps
+      page.locator('.user-count'),  // Mask dynamic counters
+      page.locator('.advertisement') // Mask ads
+    ]
+  });
+});
+```
+
+## With qe-visual-tester Agent
+
+```typescript
+// Agent performs comprehensive visual testing
+const results = await agent.visualRegressionTest({
+  baseline: 'main-branch',
+  current: 'feature-branch',
+  pages: ['homepage', 'product', 'checkout'],
+  devices: ['desktop', 'tablet', 'mobile'],
+  browsers: ['chrome', 'firefox', 'safari']
+});
+
+// Returns:
+// {
+//   totalPages: 3,
+//   totalDevices: 3,
+//   totalBrowsers: 3,
+//   comparisons: 27, // 3 × 3 × 3
+//   differences: 2,
+//   report: 'visual-regression-report.html'
+// }
+```
+
+## Remember
+
+**Functional tests don't catch visual bugs.**
+
+Visual regressions include:
+- Layout shifts
+- Color changes
+- Font rendering
+- Alignment issues
+- Missing images
+- Broken CSS
+
+**AI-powered tools reduce false positives.**
+
+**With Agents:** `qe-visual-tester` automates visual regression across browsers and devices, uses AI to ignore insignificant differences, and generates visual diff reports.