@agentic-qe/v3 3.0.0-alpha.10

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

@@ -0,0 +1,244 @@
+---
+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."
+category: specialized-testing
+priority: high
+tokenEstimate: 900
+agents: [qe-test-generator, qe-coverage-analyzer, qe-quality-analyzer]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [test-design, bva, equivalence-partitioning, decision-tables, pairwise, state-transition]
+---
+
+# Test Design Techniques
+
+<default_to_action>
+When designing test cases systematically:
+1. APPLY Boundary Value Analysis (test at min, max, edges)
+2. USE Equivalence Partitioning (one test per partition)
+3. CREATE Decision Tables (for complex business rules)
+4. MODEL State Transitions (for stateful behavior)
+5. REDUCE with Pairwise Testing (for combinations)
+
+**Quick Design Selection:**
+- Numeric ranges → BVA + EP
+- Multiple conditions → Decision Tables
+- Workflows → State Transition
+- Many parameters → Pairwise Testing
+
+**Critical Success Factors:**
+- Systematic design finds more bugs with fewer tests
+- Random testing is inefficient
+- 40+ years of research backs these techniques
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Designing new test suites
+- Optimizing existing tests
+- Complex business rules
+- Reducing test redundancy
+
+### Technique Selection Guide
+| Scenario | Technique |
+|----------|-----------|
+| **Numeric input ranges** | BVA + EP |
+| **Multiple conditions** | Decision Tables |
+| **Stateful workflows** | State Transition |
+| **Many parameter combinations** | Pairwise |
+| **All combinations critical** | Full Factorial |
+
+---
+
+## Boundary Value Analysis (BVA)
+
+**Principle:** Bugs cluster at boundaries.
+
+**Test at boundaries:**
+- Minimum valid value
+- Just below minimum (invalid)
+- Just above minimum (valid)
+- Maximum valid value
+- Just above maximum (invalid)
+
+```javascript
+// Age field: 18-120 valid
+const boundaryTests = [
+  { input: 17, expected: 'invalid' },  // Below min
+  { input: 18, expected: 'valid' },    // Min boundary
+  { input: 19, expected: 'valid' },    // Above min
+  { input: 119, expected: 'valid' },   // Below max
+  { input: 120, expected: 'valid' },   // Max boundary
+  { input: 121, expected: 'invalid' }  // Above max
+];
+```
+
+---
+
+## Equivalence Partitioning (EP)
+
+**Principle:** One test per equivalent class.
+
+```javascript
+// Discount rules:
+// 1-10:  No discount
+// 11-100: 10% discount
+// 101+:   20% discount
+
+const partitionTests = [
+  { quantity: -1, expected: 'invalid' },  // Invalid partition
+  { quantity: 5, expected: 0 },           // Partition 1: 1-10
+  { quantity: 50, expected: 0.10 },       // Partition 2: 11-100
+  { quantity: 200, expected: 0.20 }       // Partition 3: 101+
+];
+
+// 4 tests cover all behavior (vs 200+ if testing every value)
+```
+
+---
+
+## Decision Tables
+
+**Use for:** Complex business rules with multiple conditions.
+
+```
+Loan Approval Rules:
+┌──────────────┬───────┬───────┬───────┬───────┬───────┐
+│ Conditions   │ R1    │ R2    │ R3    │ R4    │ R5    │
+├──────────────┼───────┼───────┼───────┼───────┼───────┤
+│ Age ≥ 18     │ Yes   │ Yes   │ Yes   │ No    │ Yes   │
+│ Credit ≥ 700 │ Yes   │ Yes   │ No    │ Yes   │ No    │
+│ Income ≥ 50k │ Yes   │ No    │ Yes   │ Yes   │ Yes   │
+├──────────────┼───────┼───────┼───────┼───────┼───────┤
+│ Result       │Approve│Approve│Reject │Reject │Reject │
+└──────────────┴───────┴───────┴───────┴───────┴───────┘
+
+// 5 tests cover all decision combinations
+```
+
+---
+
+## State Transition Testing
+
+**Model state changes:**
+
+```
+States: Logged Out → Logged In → Premium → Suspended
+
+Valid 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)
+```
+
+```javascript
+test('cannot upgrade without login', async () => {
+  const result = await user.upgrade(); // While logged out
+  expect(result.error).toBe('Login required');
+});
+```
+
+---
+
+## Pairwise (Combinatorial) Testing
+
+**Problem:** All combinations explode exponentially.
+
+```javascript
+// Parameters:
+// 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
+
+const pairwiseTests = [
+  { browser: 'Chrome', os: 'Windows', screen: 'Desktop' },
+  { browser: 'Chrome', os: 'Mac', screen: 'Tablet' },
+  { browser: 'Chrome', os: 'Linux', screen: 'Mobile' },
+  { browser: 'Firefox', os: 'Windows', screen: 'Tablet' },
+  { browser: 'Firefox', os: 'Mac', screen: 'Mobile' },
+  { browser: 'Firefox', os: 'Linux', screen: 'Desktop' },
+  { browser: 'Safari', os: 'Windows', screen: 'Mobile' },
+  { browser: 'Safari', os: 'Mac', screen: 'Desktop' },
+  { browser: 'Safari', os: 'Linux', screen: 'Tablet' }
+];
+// Each pair appears at least once
+```
+
+---
+
+## Agent-Driven Test Design
+
+```typescript
+// Auto-generate BVA tests
+await Task("Generate BVA Tests", {
+  field: 'age',
+  dataType: 'integer',
+  constraints: { min: 18, max: 120 }
+}, "qe-test-generator");
+// Returns: 6 boundary test cases
+
+// Auto-generate pairwise tests
+await Task("Generate Pairwise Tests", {
+  parameters: {
+    browser: ['Chrome', 'Firefox', 'Safari'],
+    os: ['Windows', 'Mac', 'Linux'],
+    screen: ['Desktop', 'Tablet', 'Mobile']
+  }
+}, "qe-test-generator");
+// Returns: 9-12 tests (vs 27 full combination)
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/test-design/
+├── bva-analysis/*       - Boundary value tests
+├── partitions/*         - Equivalence partitions
+├── decision-tables/*    - Decision table tests
+└── pairwise/*           - Combinatorial reduction
+```
+
+### Fleet Coordination
+```typescript
+const designFleet = await FleetManager.coordinate({
+  strategy: 'systematic-test-design',
+  agents: [
+    'qe-test-generator',    // Apply design techniques
+    'qe-coverage-analyzer', // Analyze coverage
+    'qe-quality-analyzer'   // Assess test quality
+  ],
+  topology: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [agentic-quality-engineering](../agentic-quality-engineering/) - Agent-driven testing
+- [risk-based-testing](../risk-based-testing/) - Prioritize by risk
+- [mutation-testing](../mutation-testing/) - Validate test effectiveness
+
+---
+
+## Remember
+
+**Systematic design > Random testing.** 40+ years of research shows these techniques find more bugs with fewer tests than ad-hoc approaches.
+
+**Combine techniques for comprehensive coverage.** BVA for boundaries, EP for partitions, decision tables for rules, pairwise for combinations.
+
+**With Agents:** `qe-test-generator` applies these techniques automatically, generating optimal test suites with maximum coverage and minimum redundancy. Agents identify boundaries, partitions, and combinations from code analysis.

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

@@ -0,0 +1,243 @@
+---
+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."
+category: specialized-testing
+priority: medium
+tokenEstimate: 900
+agents: [qe-test-executor, qe-performance-tester, qe-chaos-engineer]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [environment, docker, kubernetes, infrastructure, parity, cost-optimization]
+---
+
+# Test Environment Management
+
+<default_to_action>
+When managing test environments:
+1. DEFINE environment types (local, CI, staging, prod)
+2. CONTAINERIZE with Docker for consistency
+3. ENSURE parity with production (same versions, configs)
+4. MOCK external services (service virtualization)
+5. OPTIMIZE costs (auto-shutdown, spot instances)
+
+**Quick Environment Checklist:**
+- Same OS/versions as production
+- Same database type and version
+- Same configuration structure
+- Containers for reproducibility
+- Auto-shutdown after hours
+
+**Critical Success Factors:**
+- "Works on my machine" = environment inconsistency
+- Infrastructure as Code = repeatable environments
+- Service virtualization = test without external dependencies
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Setting up test infrastructure
+- Debugging environment-specific failures
+- Reducing test infrastructure costs
+- Ensuring dev/prod parity
+
+### Environment Types
+| Type | Purpose | Lifetime |
+|------|---------|----------|
+| **Local** | Fast feedback | Developer session |
+| **CI** | Automated tests | Per build (ephemeral) |
+| **Staging** | Pre-prod validation | Persistent |
+| **Production** | Canary/synthetic | Continuous |
+
+### Dev/Prod Parity Checklist
+| Item | Must Match |
+|------|------------|
+| OS | Same version |
+| Database | Same type + version |
+| Dependencies | Same versions |
+| Config | Same structure |
+| Env vars | Same names |
+
+---
+
+## Docker for Test Environments
+
+```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
+
+  redis:
+    image: redis:7
+```
+
+**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
+
+```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" {
+  engine                  = "postgres"
+  engine_version          = "15"
+  instance_class          = "db.t3.micro"
+  backup_retention_period = 0 # No backups needed for test
+  skip_final_snapshot     = true
+}
+```
+
+---
+
+## Service Virtualization
+
+```javascript
+// Mock external services with WireMock
+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
+```
+
+---
+
+## Cost Optimization
+
+```bash
+# Auto-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 (70% savings):**
+```hcl
+resource "aws_instance" "test_runner" {
+  instance_type = "c5.2xlarge"
+  instance_market_options {
+    market_type = "spot"
+    spot_options {
+      max_price = "0.10"
+    }
+  }
+}
+```
+
+---
+
+## Agent-Driven Environment Management
+
+```typescript
+// Provision test environment
+await Task("Environment Provisioning", {
+  type: 'integration-testing',
+  services: ['app', 'db', 'redis', 'mocks'],
+  parity: 'production',
+  lifetime: '2h'
+}, "qe-test-executor");
+
+// Chaos testing in isolated environment
+await Task("Chaos Test Environment", {
+  baseline: 'staging',
+  isolate: true,
+  injectFaults: ['network-delay', 'pod-failure']
+}, "qe-chaos-engineer");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/environment-management/
+├── configs/*            - Environment configurations
+├── parity-checks/*      - Dev/prod parity results
+├── cost-reports/*       - Infrastructure costs
+└── service-mocks/*      - Service virtualization configs
+```
+
+### Fleet Coordination
+```typescript
+const envFleet = await FleetManager.coordinate({
+  strategy: 'environment-management',
+  agents: [
+    'qe-test-executor',       // Provision environments
+    'qe-performance-tester',  // Environment performance
+    'qe-chaos-engineer'       // Resilience testing
+  ],
+  topology: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [test-data-management](../test-data-management/) - Data for environments
+- [continuous-testing-shift-left](../continuous-testing-shift-left/) - CI/CD environments
+- [chaos-engineering-resilience](../chaos-engineering-resilience/) - Environment resilience
+
+---
+
+## Remember
+
+**Environment inconsistency = flaky tests.** "Works on my machine" problems come from: different OS/versions, missing dependencies, configuration differences, data differences.
+
+**Infrastructure as Code ensures repeatability.** Version control your environment configurations. Spin up identical environments on demand.
+
+**With Agents:** Agents automatically provision test environments matching production, ensure parity, mock external services, and optimize costs with auto-scaling and auto-shutdown.

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

@@ -0,0 +1,214 @@
+---
+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."
+category: analytics
+priority: high
+tokenEstimate: 850
+agents: [qe-quality-analyzer, qe-quality-gate, qe-deployment-readiness]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-03
+dependencies: []
+quick_reference_card: true
+tags: [reporting, analytics, dashboards, metrics, trends, predictive]
+---
+
+# Test Reporting & Analytics
+
+<default_to_action>
+When building test reports:
+1. DEFINE audience (dev team vs executives)
+2. CHOOSE key metrics (max 5-7)
+3. SHOW trends (not just snapshots)
+4. HIGHLIGHT actions (what to do about it)
+5. AUTOMATE generation
+
+**Dashboard Quick Setup:**
+```
++------------------+------------------+------------------+
+| Tests Passed     | Code Coverage    | Flaky Tests      |
+| 1,247/1,250 ✅   | 82.3% ⬆️ +2.1%  | 1.2% ⬇️ -0.3%   |
++------------------+------------------+------------------+
+| Critical Bugs    | Deploy Freq      | MTTR             |
+| 0 open ✅        | 12x/day ⬆️       | 2.3h ⬇️          |
++------------------+------------------+------------------+
+```
+
+**Key Metrics by Audience:**
+- **Dev Team**: Pass rate, flaky %, execution time, coverage gaps
+- **QE Team**: Defect detection rate, test velocity, automation ROI
+- **Leadership**: Escaped defects, deployment frequency, quality cost
+</default_to_action>
+
+## Quick Reference Card
+
+### Essential Metrics
+
+| Category | Metric | Target |
+|----------|--------|--------|
+| **Execution** | Pass Rate | >98% |
+| **Execution** | Flaky Test % | <2% |
+| **Execution** | Suite Duration | <10 min |
+| **Coverage** | Line Coverage | >80% |
+| **Coverage** | Branch Coverage | >70% |
+| **Quality** | Escaped Defects | <5/release |
+| **Quality** | MTTR | <4 hours |
+| **Efficiency** | Automation Rate | >90% |
+
+### Trend Indicators
+
+| Symbol | Meaning | Action |
+|--------|---------|--------|
+| ⬆️ | Improving | Continue current approach |
+| ⬇️ | Declining | Investigate root cause |
+| ➡️ | Stable | Maintain or improve |
+| ⚠️ | Threshold breach | Immediate attention |
+
+---
+
+## Report Types
+
+### Real-Time Dashboard
+```
+Live quality status for CI/CD
+- Build status (green/red)
+- Test results (pass/fail counts)
+- Coverage delta
+- Flaky test alerts
+```
+
+### Sprint Summary
+```markdown
+## Sprint 47 Quality Summary
+
+### Metrics
+| Metric | Value | Trend |
+|--------|-------|-------|
+| Tests Added | +47 | ⬆️ |
+| Coverage | 82.3% | ⬆️ +2.1% |
+| Bugs Found | 12 | ➡️ |
+| Escaped | 0 | ✅ |
+
+### Highlights
+- ✅ Zero escaped defects
+- ⚠️ E2E suite now 45min (target: 30min)
+
+### Actions
+1. Optimize slow E2E tests
+2. Add coverage for payment module
+```
+
+### Executive Report
+```markdown
+## Monthly Quality Report - Oct 2025
+
+### Executive Summary
+✅ Production uptime: 99.97% (target: 99.95%)
+✅ Deploy frequency: 12x/day (up from 8x)
+⚠️ Coverage: 82.3% (target: 85%)
+
+### Business Impact
+- Automation saves 120 hrs/month
+- Bug cost: $150/bug found vs $5,000 escaped
+- Estimated annual savings: $450K
+
+### Recommendations
+1. Invest in performance testing tooling
+2. Hire senior QE for mobile coverage
+```
+
+---
+
+## Predictive Analytics
+
+```typescript
+// Predict test failures
+const prediction = await Task("Predict Failures", {
+  codeChanges: prDiff,
+  historicalData: last90Days,
+  model: 'gradient-boosting'
+}, "qe-quality-analyzer");
+
+// Returns:
+// {
+//   failureProbability: 0.73,
+//   likelyFailingTests: ['payment.test.ts'],
+//   suggestedAction: 'Review payment module carefully',
+//   confidence: 0.89
+// }
+
+// Trend analysis with anomaly detection
+const trends = await Task("Analyze Trends", {
+  metrics: ['passRate', 'coverage', 'flakyRate'],
+  period: '30d',
+  detectAnomalies: true
+}, "qe-quality-analyzer");
+```
+
+---
+
+## Agent Integration
+
+```typescript
+// Generate comprehensive quality report
+const report = await Task("Generate Quality Report", {
+  period: 'sprint',
+  audience: 'executive',
+  includeROI: true,
+  includeTrends: true
+}, "qe-quality-analyzer");
+
+// Real-time quality gate check
+const gateResult = await Task("Quality Gate Check", {
+  metrics: currentMetrics,
+  thresholds: qualityPolicy,
+  environment: 'production'
+}, "qe-quality-gate");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/reporting/
+├── dashboards/*      - Dashboard configurations
+├── reports/*         - Generated reports
+├── trends/*          - Trend analysis data
+└── predictions/*     - Predictive model outputs
+```
+
+### Fleet Coordination
+```typescript
+const reportingFleet = await FleetManager.coordinate({
+  strategy: 'quality-reporting',
+  agents: [
+    'qe-quality-analyzer',      // Metrics aggregation
+    'qe-quality-gate',          // Threshold validation
+    'qe-deployment-readiness'   // Release readiness
+  ],
+  topology: 'parallel'
+});
+```
+
+---
+
+## Related Skills
+- [quality-metrics](../quality-metrics/) - Metric definitions
+- [shift-right-testing](../shift-right-testing/) - Production metrics
+- [consultancy-practices](../consultancy-practices/) - Client reporting
+
+---
+
+## Remember
+
+**Measure to improve. Report to communicate.**
+
+Good reports:
+- Answer "so what?" (actionable insights)
+- Show trends (not just snapshots)
+- Match audience needs
+- Automate where possible
+
+**Data without action is noise. Action without data is guessing.**