agentic-qe 2.0.0 → 2.1.1

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

@@ -1,154 +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.
+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
 
-## Core Principle
+<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 |
 
-**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.
+**Principle:** Bugs cluster at boundaries.
 
-**Test at:**
+**Test at boundaries:**
 - 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)
+```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
+];
 ```
 
-**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.
+**Principle:** One test per equivalent class.
 
-**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
+```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.
 
-**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
+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
 ```
 
-**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
+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)
+- Logged Out → Premium (should reject)
+- Suspended → Premium (should reject)
 ```
 
-## Pairwise (Combinatorial) Testing
+```javascript
+test('cannot upgrade without login', async () => {
+  const result = await user.upgrade(); // While logged out
+  expect(result.error).toBe('Login required');
+});
+```
 
-**Problem:** Testing all combinations explodes.
+---
 
-**Example: Cross-browser testing**
+## 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
 ```
-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
-```
+## Agent-Driven Test Design
 
-**With Agents:**
 ```typescript
-// qe-test-generator does pairwise reduction
-const tests = await agent.generatePairwiseTests({
+// 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
 
-- [agentic-quality-engineering](../agentic-quality-engineering/)
-- [test-automation-strategy](../test-automation-strategy/)
-- [risk-based-testing](../risk-based-testing/)
+---
 
 ## Remember
 
-**Systematic design > Random testing**
+**Systematic design > Random testing.** 40+ years of research shows these techniques find more bugs with fewer tests than ad-hoc approaches.
 
-- BVA finds boundary bugs
-- EP reduces redundant tests
-- Decision tables handle complexity
-- Pairwise reduces combinatorial explosion
+**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.
+**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/.claude/skills/test-environment-management/SKILL.md

@@ -1,53 +1,70 @@
 ---
 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.
+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
 
-## Core Principle
+<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 |
 
-**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'
@@ -69,13 +86,9 @@ services:
     environment:
       POSTGRES_DB: test
       POSTGRES_PASSWORD: password
-    ports:
-      - "5432:5432"
 
   redis:
     image: redis:7
-    ports:
-      - "6379:6379"
 ```
 
 **Run tests in container:**
@@ -85,9 +98,10 @@ 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" {
@@ -95,31 +109,27 @@ resource "aws_instance" "test_server" {
   instance_type = "t3.medium"
 
   tags = {
-    Name        = "test-environment"
-    Environment = "test"
+    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
-
+  engine                  = "postgres"
+  engine_version          = "15"
+  instance_class          = "db.t3.micro"
   backup_retention_period = 0 # No backups needed for test
-  skip_final_snapshot    = true
+  skip_final_snapshot     = true
 }
 ```
 
+---
+
 ## Service Virtualization
 
-**Mock external services:**
 ```javascript
-// Use WireMock for API mocking
+// Mock external services with WireMock
 import { WireMock } from 'wiremock-captain';
 
 const wiremock = new WireMock('http://localhost:8080');
@@ -132,67 +142,102 @@ await wiremock.register({
   },
   response: {
     status: 200,
-    jsonBody: {
-      transactionId: '12345',
-      status: 'approved'
-    }
+    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)
+# 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)
+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:**
+**Use spot instances (70% savings):**
 ```hcl
 resource "aws_instance" "test_runner" {
-  instance_type        = "c5.2xlarge"
+  instance_type = "c5.2xlarge"
   instance_market_options {
     market_type = "spot"
     spot_options {
-      max_price = "0.10" # Save 70% vs on-demand
+      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
 
-- [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
+**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.**
+**Infrastructure as Code ensures repeatability.** Version control your environment configurations. Spin up identical environments on demand.
 
-**With Agents:** Agents automatically provision test environments, ensure parity with production, and optimize costs by auto-scaling and auto-shutdown.
+**With Agents:** Agents automatically provision test environments matching production, ensure parity, mock external services, and optimize costs with auto-scaling and auto-shutdown.