@jamie-tam/forge 6.0.0

package/skills/quality-test-plan/templates/integration-test-plan.md

@@ -0,0 +1,74 @@
+# Integration Test Plan
+
+## Integration Point: {component A} <-> {component B}
+
+### Test Scenario: {scenario_name}
+
+- **Components Involved**: {list of components/services being tested together}
+- **Description**: {what interaction this test verifies}
+
+#### Setup Requirements
+- {Database seeded with: specific test data}
+- {Service X running on: port/URL}
+- {Environment variable: VALUE}
+- {External service mock: configured to return...}
+
+#### Test Steps
+1. {Action}: {what to do}
+   - **Expected**: {what should happen}
+2. {Action}: {what to do}
+   - **Expected**: {what should happen}
+3. {Verify}: {what to check}
+   - **Expected**: {the final state or response}
+
+#### Expected Behavior
+- {Component A sends X to Component B}
+- {Component B responds with Y}
+- {Database state after: describe expected records}
+
+#### Error Scenarios
+- **{Component B is unavailable}**: {expected behavior — retry, fallback, error response}
+- **{Invalid data from Component A}**: {expected behavior — validation error, rejection}
+- **{Timeout}**: {expected behavior — timeout handling, circuit breaker}
+
+#### Cleanup
+- {Delete test records from database}
+- {Reset external service mocks}
+- {Restore original configuration}
+
+---
+
+### Test Scenario: {next_scenario_name}
+
+- **Components Involved**: {list}
+- **Description**: {what this tests}
+
+#### Setup Requirements
+- {list setup needs}
+
+#### Test Steps
+1. {step}
+2. {step}
+
+#### Expected Behavior
+- {expected outcome}
+
+#### Cleanup
+- {cleanup steps}
+
+---
+
+## Integration Matrix
+
+| Component A | Component B | Scenarios | Status |
+|------------|------------|-----------|--------|
+| {API} | {Database} | {count} | Planned |
+| {API} | {Auth Service} | {count} | Planned |
+| {Worker} | {Queue} | {count} | Planned |
+
+## Test Summary
+
+| Integration Point | Happy Path | Error Handling | Timeout/Retry | Total |
+|------------------|-----------|---------------|---------------|-------|
+| {point} | {count} | {count} | {count} | {count} |
+| **Total** | {count} | {count} | {count} | {count} |

package/skills/quality-test-plan/templates/load-test-plan.md

@@ -0,0 +1,111 @@
+# Load Test Plan
+
+## Scenario: {scenario_name}
+
+### Description
+{What user behavior or system load this scenario simulates.}
+
+### Configuration
+
+| Parameter | Value |
+|-----------|-------|
+| Virtual Users (VUs) | {number, e.g., 100} |
+| Ramp-up Period | {duration, e.g., 2 minutes} |
+| Sustained Duration | {duration, e.g., 10 minutes} |
+| Ramp-down Period | {duration, e.g., 1 minute} |
+| Total Duration | {total, e.g., 13 minutes} |
+
+### Load Profile
+```
+VUs
+ ^
+ |        _______________
+ |       /               \
+ |      /                 \
+ |     /                   \
+ |    /                     \
+ |___/                       \___
+ +------------------------------> Time
+  0   2min   12min   13min
+      ramp   sustain  down
+```
+
+### Endpoints Under Test
+
+| Endpoint | Method | Weight | Payload |
+|----------|--------|--------|---------|
+| {/path} | GET | {e.g., 60%} | — |
+| {/path} | POST | {e.g., 25%} | {description of payload} |
+| {/path} | GET | {e.g., 15%} | — |
+
+### Thresholds (Pass/Fail Criteria)
+
+| Metric | Target | Fail If |
+|--------|--------|---------|
+| Throughput | {e.g., >= 500 req/s} | {< 400 req/s} |
+| Latency p50 | {e.g., < 100ms} | {>= 200ms} |
+| Latency p95 | {e.g., < 500ms} | {>= 1000ms} |
+| Latency p99 | {e.g., < 1000ms} | {>= 3000ms} |
+| Error Rate | {e.g., < 0.1%} | {>= 1%} |
+| CPU Usage | {e.g., < 70%} | {>= 90%} |
+| Memory Usage | {e.g., < 80%} | {>= 95%} |
+
+### Think Time
+- Between requests: {e.g., 1-3 seconds, randomized}
+- Simulates: {realistic user behavior / worst case / sustained pressure}
+
+---
+
+## Scenario: {stress_test_scenario_name}
+
+### Description
+{Push beyond normal capacity to find breaking points.}
+
+### Configuration
+
+| Parameter | Value |
+|-----------|-------|
+| Virtual Users (VUs) | {higher number, e.g., 500} |
+| Ramp-up Period | {duration} |
+| Sustained Duration | {duration} |
+
+### Thresholds
+
+| Metric | Target | Notes |
+|--------|--------|-------|
+| Breaking point | {identify VU count where errors exceed 5%} | Document the limit |
+| Recovery time | {after load drops, how fast does the system recover?} | Should be < {time} |
+| Graceful degradation | {system returns errors, does not crash} | No 5xx cascades |
+
+---
+
+## Scenario Summary
+
+| Scenario | VUs | Duration | Purpose |
+|----------|-----|----------|---------|
+| {normal load} | {N} | {duration} | Verify baseline performance |
+| {peak load} | {N} | {duration} | Verify peak handling |
+| {stress test} | {N} | {duration} | Find breaking points |
+| {soak test} | {N} | {long duration} | Check for memory leaks, connection exhaustion |
+
+## Run Instructions
+
+```bash
+# Run with k6
+k6 run --vus {N} --duration {time} {script.js}
+
+# Run with specific scenario
+k6 run --env SCENARIO={name} {script.js}
+```
+
+## Results Template
+
+After running, fill in:
+
+| Metric | Target | Actual | Status |
+|--------|--------|--------|--------|
+| Throughput | {target} | {actual} | PASS / FAIL |
+| p50 Latency | {target} | {actual} | PASS / FAIL |
+| p95 Latency | {target} | {actual} | PASS / FAIL |
+| p99 Latency | {target} | {actual} | PASS / FAIL |
+| Error Rate | {target} | {actual} | PASS / FAIL |

package/skills/quality-test-plan/templates/smoke-test-plan.md

@@ -0,0 +1,68 @@
+# Smoke Test Plan
+
+Critical paths only. Run after every deployment to verify the system is functional.
+
+## Test: {test_name}
+
+- **Endpoint/Page**: {METHOD} {/path} or {URL}
+- **Description**: {what critical functionality this verifies}
+- **Expected Response**: {status code, key fields in response body, page element visible}
+- **Max Response Time**: {e.g., 2000ms}
+- **Run After Deploy**: Yes
+
+### Verification
+```
+Request:  {METHOD} {base_url}{/path}
+Headers:  {required headers}
+Body:     {request body if applicable}
+Expect:   Status {code}, body contains "{key field or value}"
+Timeout:  {max ms}
+```
+
+---
+
+## Test: {test_name}
+
+- **Endpoint/Page**: {METHOD} {/path}
+- **Description**: {what this verifies}
+- **Expected Response**: {expected result}
+- **Max Response Time**: {e.g., 1000ms}
+- **Run After Deploy**: Yes
+
+### Verification
+```
+Request:  {METHOD} {base_url}{/path}
+Expect:   Status {code}
+Timeout:  {max ms}
+```
+
+---
+
+## Smoke Test Checklist
+
+| # | Test | Endpoint/Page | Expected | Max Time | Status |
+|---|------|--------------|----------|----------|--------|
+| 1 | Health check | GET /health | 200 OK | 500ms | — |
+| 2 | Homepage loads | GET / | 200, title present | 2000ms | — |
+| 3 | Auth works | POST /auth/login | 200, token returned | 1000ms | — |
+| 4 | Primary API works | GET /api/{resource} | 200, data returned | 1000ms | — |
+| 5 | Database connected | GET /health/db | 200, connected: true | 500ms | — |
+| 6 | {critical path} | {endpoint} | {expected} | {time} | — |
+
+## Run Instructions
+
+```bash
+# Run all smoke tests
+{command to run smoke tests}
+
+# Run against specific environment
+{command} --env={staging|production}
+```
+
+## Failure Protocol
+
+If any smoke test fails after deployment:
+1. **Do NOT proceed** with further deployments
+2. Check application logs for errors
+3. If critical: initiate rollback (see deploy runbook)
+4. If non-critical: assess impact, decide rollback vs. hotfix

package/skills/quality-test-plan/templates/unit-test-plan.md

@@ -0,0 +1,56 @@
+# Unit Test Plan
+
+## Module: {module/file name}
+
+### Function: {function_name}
+
+#### Test: {test_name}
+- **Description**: {what behavior this test verifies}
+- **Input**: {input values or setup}
+- **Expected Output**: {expected return value or side effect}
+- **Type**: Happy path / Edge case / Error case
+
+#### Test: {test_name} — Edge Cases
+- **Description**: {what edge case this tests}
+- **Input**: {edge case input — null, empty, boundary, overflow, etc.}
+- **Expected Output**: {expected behavior for edge case}
+- **Type**: Edge case
+
+#### Test: {test_name} — Error Handling
+- **Description**: {what error scenario this tests}
+- **Input**: {invalid input or error condition}
+- **Expected Output**: {expected error type, message, or behavior}
+- **Type**: Error case
+
+#### Mocking Requirements
+- {Dependency to mock}: {why it needs mocking — external service, database, etc.}
+- {Dependency to mock}: {why it needs mocking}
+
+---
+
+### Function: {next_function_name}
+
+#### Test: {test_name}
+- **Description**: {what behavior this test verifies}
+- **Input**: {input values}
+- **Expected Output**: {expected output}
+- **Type**: Happy path / Edge case / Error case
+
+#### Mocking Requirements
+- {none / list dependencies}
+
+---
+
+## Coverage Targets
+
+| Module | Target Coverage | Critical Paths (100%) |
+|--------|----------------|----------------------|
+| {module} | 80% | {list functions requiring 100% coverage} |
+| {module} | 80% | {list functions requiring 100% coverage} |
+
+## Test Summary
+
+| Module | Happy Path | Edge Cases | Error Cases | Total |
+|--------|-----------|------------|-------------|-------|
+| {module} | {count} | {count} | {count} | {count} |
+| **Total** | {count} | {count} | {count} | {count} |