qa-skills 3.0.0

package/skills/qa-junit5-writer/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: qa-junit5-writer
+description: Generate JUnit 5 unit and integration tests for Java with parameterized tests, nested classes, extensions, Mockito mocking, and AssertJ assertions.
+output_dir: tests/unit
+---
+
+# QA JUnit 5 Writer
+
+## Purpose
+
+Write JUnit 5 unit and integration tests from test case specifications. Transform structured test cases into executable JUnit 5 test classes with parameterized tests, nested classes for organization, extensions, Mockito mocking, and AssertJ assertions.
+
+## Trigger Phrases
+
+- "Write JUnit 5 tests for [class/feature]"
+- "Generate unit tests with JUnit 5"
+- "Create parameterized tests for [method]"
+- "Add JUnit 5 tests with Mockito"
+- "JUnit 5 tests with AssertJ assertions"
+- "Nested test classes for [feature]"
+- "JUnit 5 @ParameterizedTest for [scenarios]"
+- "Mockito mocks in JUnit 5 tests"
+- "Heal my failing JUnit 5 tests"
+
+## Key Features
+
+| Feature | Description |
+| ------- | ----------- |
+| **@Test** | Standard test methods |
+| **@ParameterizedTest** | Data-driven tests with @CsvSource, @MethodSource, @EnumSource |
+| **@Nested** | Logical grouping; inner classes with @BeforeEach per level |
+| **@ExtendWith** | Extensions (MockitoExtension, custom) |
+| **Mockito** | @Mock, @InjectMocks, when().thenReturn(), verify() |
+| **AssertJ** | Fluent assertions: assertThat().isEqualTo(), containsExactly() |
+| **@TestInstance** | PER_CLASS for shared setup; PER_METHOD default |
+| **@Tag** | Categorization for selective execution |
+| **@DisplayName** | Human-readable test names |
+
+## Workflow
+
+1. **Read test cases** — From specs, requirements, or manual test designs
+2. **Analyze Java code** — Inspect classes, methods, dependencies
+3. **Generate test classes** — Produce `{Class}Test.java` with appropriate structure
+4. **Add mocks/fixtures** — Use Mockito for dependencies; fixtures for test data
+5. **Run** — User runs `mvn test` or `./gradlew test`
+
+## Key Patterns
+
+| Pattern | Usage |
+| ------- | ----- |
+| `@Test` | JUnit 5 test method |
+| `@ParameterizedTest` | Data-driven test |
+| `@CsvSource({"a,1", "b,2"})` | Inline CSV data |
+| `@MethodSource("provideData")` | Method-provided data |
+| `@Nested` | Group related tests |
+| `@ExtendWith(MockitoExtension.class)` | Enable Mockito |
+| `@Mock` | Mock dependency |
+| `@InjectMocks` | Inject mocks into SUT |
+| `when(mock.method()).thenReturn(value)` | Stub mock |
+| `verify(mock, times(1)).method()` | Verify interaction |
+| `assertThat(actual).isEqualTo(expected)` | AssertJ assertion |
+
+## Parameterized Tests
+
+```java
+@ParameterizedTest
+@CsvSource({"admin, true", "user, false"})
+void shouldCheckAccess(String role, boolean expected) {
+    assertThat(service.hasAccess(role)).isEqualTo(expected);
+}
+
+@ParameterizedTest
+@MethodSource("provideInvalidInputs")
+void shouldRejectInvalidInput(String input) {
+    assertThatThrownBy(() -> validator.validate(input))
+        .isInstanceOf(ValidationException.class);
+}
+```
+
+## Nested Classes
+
+Use @Nested for logical grouping; each nested class gets its own @BeforeEach:
+
+```java
+@DisplayName("UserService")
+class UserServiceTest {
+    @Nested
+    @DisplayName("when user exists")
+    class WhenUserExists {
+        @Test
+        void shouldReturnUser() { ... }
+    }
+    @Nested
+    @DisplayName("when user not found")
+    class WhenUserNotFound {
+        @Test
+        void shouldThrowException() { ... }
+    }
+}
+```
+
+## File Naming
+
+- `{Class}Test.java` — Test classes (e.g., `UserServiceTest.java`, `OrderValidatorTest.java`)
+- Place in `src/test/java` mirroring production package structure
+
+## Scope
+
+**Can do (autonomous):**
+- Generate JUnit 5 unit and integration tests from test case specs
+- Use @ParameterizedTest for data-driven scenarios
+- Apply @Nested for logical grouping
+- Use Mockito for mocking dependencies
+- Use AssertJ for fluent assertions
+- Add @Tag, @DisplayName for organization
+- Configure @TestInstance when shared setup needed
+- Use Context7 MCP for JUnit 5/Mockito docs
+- Delegate to qa-test-healer when tests fail (Heal Mode)
+
+**Cannot do (requires confirmation):**
+- Change production code structure
+- Add dependencies not in pom.xml/build.gradle
+- Override project JUnit/Mockito config without approval
+
+**Will not do (out of scope):**
+- Execute tests (user runs `mvn test`)
+- Write Spring integration tests (use qa-spring-test-writer)
+- Modify CI/CD pipelines
+
+## References
+
+- `references/patterns.md` — Parameterized, nested, extensions, lifecycle
+- `references/assertions.md` — AssertJ assertion reference
+- `references/config.md` — Maven/Gradle JUnit 5 config, Surefire plugin
+
+## Quality Checklist
+
+- [ ] @DisplayName used for readability
+- [ ] @ParameterizedTest for multiple inputs; avoid duplicate test methods
+- [ ] @Nested for logical grouping where beneficial
+- [ ] Mockito used for external dependencies; avoid over-mocking
+- [ ] AssertJ used for assertions
+- [ ] Tests independent (no shared mutable state)
+- [ ] One assertion focus per test where practical
+- [ ] Traceability to test case IDs where applicable
+- [ ] File naming follows `{Class}Test.java` convention
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+| ------- | ------------ | --- |
+| Mock not injected | Wrong extension or order | Use @ExtendWith(MockitoExtension.class); @InjectMocks before @Mock |
+| ParameterizedTest fails | Invalid CSV/method source | Check @CsvSource format; ensure @MethodSource returns Stream |
+| Nested @BeforeEach runs twice | Misunderstanding lifecycle | Each @Nested level has own lifecycle; @BeforeEach runs per test in that level |
+| AssertJ import error | Wrong static import | Use `import static org.assertj.core.api.Assertions.assertThat` |
+| Test order dependent | Shared state | Ensure test isolation; use @TestInstance(PER_METHOD) or fresh fixtures |
+| Surefire skips tests | JUnit 4 engine conflict | Exclude junit-vintage; use junit-platform-surefire-provider |

package/skills/qa-junit5-writer/references/assertions.md

@@ -0,0 +1,118 @@
+# AssertJ Assertion Reference
+
+## Basic Assertions
+
+```java
+import static org.assertj.core.api.Assertions.*;
+
+// Equality
+assertThat(actual).isEqualTo(expected);
+assertThat(actual).isNotEqualTo(unexpected);
+
+// Null
+assertThat(value).isNull();
+assertThat(value).isNotNull();
+
+// Boolean
+assertThat(condition).isTrue();
+assertThat(condition).isFalse();
+
+// Same instance
+assertThat(actual).isSameAs(expected);
+assertThat(actual).isNotSameAs(other);
+```
+
+## String Assertions
+
+```java
+assertThat(str).isEqualTo("expected");
+assertThat(str).contains("substring");
+assertThat(str).startsWith("prefix");
+assertThat(str).endsWith("suffix");
+assertThat(str).matches("regex.*");
+assertThat(str).isBlank();
+assertThat(str).isNotEmpty();
+assertThat(str).hasSize(10);
+```
+
+## Collection Assertions
+
+```java
+assertThat(list).isEmpty();
+assertThat(list).isNotEmpty();
+assertThat(list).hasSize(3);
+assertThat(list).contains("a", "b");
+assertThat(list).containsExactly("a", "b", "c");
+assertThat(list).containsExactlyInAnyOrder("c", "a", "b");
+assertThat(list).containsAnyOf("a", "x");
+assertThat(list).doesNotContain("x");
+assertThat(list).startsWith("a", "b");
+assertThat(list).endsWith("b", "c");
+assertThat(list).allMatch(e -> e.length() > 0);
+assertThat(list).anyMatch(e -> e.equals("target"));
+assertThat(list).noneMatch(e -> e.isBlank());
+```
+
+## Map Assertions
+
+```java
+assertThat(map).isEmpty();
+assertThat(map).containsKey("key");
+assertThat(map).containsValue("value");
+assertThat(map).containsEntry("key", "value");
+assertThat(map).hasSize(3);
+```
+
+## Number Assertions
+
+```java
+assertThat(number).isEqualTo(42);
+assertThat(number).isGreaterThan(10);
+assertThat(number).isGreaterThanOrEqualTo(10);
+assertThat(number).isLessThan(100);
+assertThat(number).isBetween(1, 100);
+assertThat(number).isPositive();
+assertThat(number).isNegative();
+assertThat(number).isZero();
+```
+
+## Exception Assertions
+
+```java
+assertThatThrownBy(() -> service.doSomething())
+    .isInstanceOf(ValidationException.class)
+    .hasMessage("Invalid input")
+    .hasMessageContaining("input")
+    .hasCauseInstanceOf(IOException.class);
+
+assertThatCode(() -> service.validCall()).doesNotThrowAnyException();
+```
+
+## Optional Assertions
+
+```java
+assertThat(optional).isPresent();
+assertThat(optional).isEmpty();
+assertThat(optional).hasValue("expected");
+assertThat(optional).contains("expected");
+```
+
+## Object Assertions
+
+```java
+assertThat(obj).hasFieldOrProperty("name");
+assertThat(obj).hasFieldOrPropertyWithValue("name", "value");
+assertThat(obj).extracting("name").isEqualTo("value");
+assertThat(obj).extracting("name", "age").containsExactly("John", 30);
+```
+
+## Soft Assertions
+
+Collect multiple failures:
+```java
+assertSoftly(softly -> {
+    softly.assertThat(a).isEqualTo(1);
+    softly.assertThat(b).isEqualTo(2);
+    softly.assertThat(c).isEqualTo(3);
+});
+```

package/skills/qa-junit5-writer/references/config.md

@@ -0,0 +1,97 @@
+# JUnit 5 Configuration
+
+## Maven Dependencies
+
+```xml
+<dependencies>
+    <dependency>
+        <groupId>org.junit.jupiter</groupId>
+        <artifactId>junit-jupiter</artifactId>
+        <version>5.10.2</version>
+        <scope>test</scope>
+    </dependency>
+    <dependency>
+        <groupId>org.mockito</groupId>
+        <artifactId>mockito-junit-jupiter</artifactId>
+        <version>5.11.0</version>
+        <scope>test</scope>
+    </dependency>
+    <dependency>
+        <groupId>org.assertj</groupId>
+        <artifactId>assertj-core</artifactId>
+        <version>3.25.3</version>
+        <scope>test</scope>
+    </dependency>
+</dependencies>
+```
+
+## Surefire Plugin
+
+```xml
+<plugin>
+    <groupId>org.apache.maven.plugins</groupId>
+    <artifactId>maven-surefire-plugin</artifactId>
+    <version>3.2.5</version>
+    <configuration>
+        <includes>
+            <include>**/*Test.java</include>
+            <include>**/*Tests.java</include>
+        </includes>
+        <excludes>
+            <exclude>**/*IntegrationTest.java</exclude>
+        </excludes>
+        <properties>
+            <includeTags>unit</includeTags>
+            <excludeTags>slow,integration</excludeTags>
+        </properties>
+        <parallel>methods</parallel>
+        <threadCount>4</threadCount>
+    </configuration>
+</plugin>
+```
+
+## Gradle
+
+```groovy
+dependencies {
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
+    testImplementation 'org.mockito:mockito-junit-jupiter:5.11.0'
+    testImplementation 'org.assertj:assertj-core:3.25.3'
+}
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        events "passed", "skipped", "failed"
+    }
+    systemProperty 'junit.jupiter.execution.parallel.enabled', 'true'
+    systemProperty 'junit.jupiter.execution.parallel.config.strategy', 'dynamic'
+}
+```
+
+## Excluding JUnit 4
+
+If JUnit 4 is on classpath, exclude vintage engine:
+```xml
+<dependency>
+    <groupId>org.junit.jupiter</groupId>
+    <artifactId>junit-jupiter</artifactId>
+    <version>5.10.2</version>
+    <scope>test</scope>
+    <exclusions>
+        <exclusion>
+            <groupId>org.junit.vintage</groupId>
+            <artifactId>junit-vintage-engine</artifactId>
+        </exclusion>
+    </exclusions>
+</dependency>
+```
+
+## junit-platform.properties
+
+Place in `src/test/resources/junit-platform.properties`:
+```properties
+junit.jupiter.execution.parallel.enabled=true
+junit.jupiter.execution.parallel.config.strategy=dynamic
+junit.jupiter.execution.parallel.config.dynamic.factor=1
+```

package/skills/qa-junit5-writer/references/patterns.md

@@ -0,0 +1,162 @@
+# JUnit 5 Patterns
+
+## Parameterized Tests
+
+### @CsvSource
+Inline CSV data for simple cases:
+```java
+@ParameterizedTest
+@CsvSource({"1, one", "2, two", "3, three"})
+void mapNumberToWord(int num, String word) {
+    assertThat(converter.toWord(num)).isEqualTo(word);
+}
+
+@ParameterizedTest
+@CsvSource(value = {"null;null", "'';empty"}, delimiter = ';')
+void handleEdgeCases(String input, String expected) {
+    assertThat(processor.process(input)).isEqualTo(expected);
+}
+```
+
+### @MethodSource
+Method or factory provides data:
+```java
+static Stream<Arguments> provideValidEmails() {
+    return Stream.of(
+        Arguments.of("user@example.com", true),
+        Arguments.of("admin@company.org", true)
+    );
+}
+
+@ParameterizedTest
+@MethodSource("provideValidEmails")
+void validateEmail(String email, boolean expected) {
+    assertThat(validator.isValid(email)).isEqualTo(expected);
+}
+```
+
+### @EnumSource
+Iterate over enum values:
+```java
+@ParameterizedTest
+@EnumSource(Status.class)
+void eachStatusHasCode(Status status) {
+    assertThat(status.getCode()).isNotNull();
+}
+
+@ParameterizedTest
+@EnumSource(value = Status.class, names = {"ACTIVE", "PENDING"})
+void activeStatuses(Status status) {
+    assertThat(status.isProcessable()).isTrue();
+}
+```
+
+### @ValueSource
+Single-value primitives and strings:
+```java
+@ParameterizedTest
+@ValueSource(ints = {1, 2, 3, 5, 8})
+void fibonacciNumbers(int n) {
+    assertThat(fib(n)).isPositive();
+}
+
+@ParameterizedTest
+@NullAndEmptySource
+@ValueSource(strings = {"  ", "\t"})
+void blankStrings(String input) {
+    assertThat(StringUtils.isBlank(input)).isTrue();
+}
+```
+
+## Nested Classes
+
+Logical grouping with independent lifecycle:
+```java
+@DisplayName("OrderService")
+class OrderServiceTest {
+    @InjectMocks OrderService orderService;
+    @Mock OrderRepository repository;
+
+    @Nested
+    @DisplayName("createOrder")
+    class CreateOrder {
+        @Test
+        void shouldCreateValidOrder() { ... }
+        @Test
+        void shouldRejectInvalidItems() { ... }
+    }
+
+    @Nested
+    @DisplayName("cancelOrder")
+    class CancelOrder {
+        @BeforeEach
+        void setupExistingOrder() {
+            when(repository.findById(1L)).thenReturn(Optional.of(existingOrder));
+        }
+        @Test
+        void shouldCancelWhenAllowed() { ... }
+    }
+}
+```
+
+## Extensions
+
+### MockitoExtension
+```java
+@ExtendWith(MockitoExtension.class)
+class ServiceTest {
+    @Mock Dependency dependency;
+    @InjectMocks ServiceUnderTest service;
+}
+```
+
+### Custom Extension
+```java
+@ExtendWith(DatabaseExtension.class)
+class RepositoryTest {
+    // Extension provides @Container, cleanup
+}
+```
+
+## Lifecycle
+
+### @TestInstance(PER_CLASS)
+Share instance state across tests (e.g., expensive setup):
+```java
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class ExpensiveSetupTest {
+    private HeavyResource resource;
+    @BeforeAll
+    void init() {
+        resource = new HeavyResource(); // Once for all tests
+    }
+}
+```
+
+### @BeforeEach / @AfterEach
+Per-test setup and teardown:
+```java
+@BeforeEach
+void setUp() {
+    driver = new ChromeDriver();
+}
+@AfterEach
+void tearDown() {
+    if (driver != null) driver.quit();
+}
+```
+
+## Tags and Filtering
+
+```java
+@Tag("slow")
+@Test
+void longRunningTest() { ... }
+
+@Tag("integration")
+@Tag("database")
+@Test
+void databaseIntegrationTest() { ... }
+```
+
+Run with: `mvn test -Dgroups=integration` or `-DexcludedGroups=slow`

package/skills/qa-k6-writer/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: qa-k6-writer
+description: Generate k6 performance tests in JavaScript for load, stress, soak, and spike testing with thresholds, scenarios, checks, and CI-friendly output.
+output_dir: tests/performance
+---
+
+# QA k6 Writer
+
+## Purpose
+
+Write k6 performance tests from test case specifications and performance plans. Transform structured performance requirements (from qa-nfr-analyst, qa-plan-creator performance plans) into executable k6 scripts with scenarios, thresholds, checks, and CI-friendly output.
+
+## Trigger Phrases
+
+- "Write k6 tests for [API/endpoint]"
+- "Generate k6 load tests from performance plan"
+- "Create k6 stress tests for [service]"
+- "Add k6 soak tests with thresholds"
+- "k6 spike test for [endpoint]"
+- "Performance tests with k6 scenarios"
+- "k6 smoke test for [API]"
+- "Breakpoint testing with k6"
+- "k6 tests with custom metrics"
+- "k6 CI integration for GitHub Actions"
+
+## Test Types
+
+| Type | Purpose | Key Characteristics |
+|------|---------|---------------------|
+| **Load testing** | Validate behavior under expected load | Steady VUs, target throughput |
+| **Stress testing** | Find breaking point | Ramp up until failure |
+| **Soak testing** | Detect memory leaks, degradation | Sustained load over hours |
+| **Spike testing** | Sudden traffic surge | Sharp ramp up/down |
+| **Smoke testing** | Quick sanity check | 1–5 VUs, minimal duration |
+| **Breakpoint testing** | Find capacity limit | Incremental load until threshold fails |
+
+## Key Features
+
+| Feature | Description |
+|---------|-------------|
+| **JavaScript ES6** | Standard JS syntax; no transpilation required |
+| **Scenarios** | Multiple executors: shared-iterations, per-vu-iterations, constant-arrival-rate, ramping-arrival-rate, externally-controlled |
+| **Thresholds** | Pass/fail criteria: `http_req_duration`, `http_req_failed`, custom metrics |
+| **Checks** | Assertions: `check(res, { 'status is 200': (r) => r.status === 200 })` |
+| **Stages** | Ramp-up, steady, ramp-down for realistic load profiles |
+| **Custom metrics** | Trend, Rate, Counter, Gauge for business metrics |
+| **Protocols** | HTTP, WebSocket, gRPC |
+
+## Workflow
+
+1. **Read performance test plan** — From qa-plan-creator (performance plan) or qa-nfr-analyst (NFR specs)
+2. **Define scenarios** — Map load profiles to k6 scenarios with appropriate executors
+3. **Set thresholds** — Translate SLAs (p95, error rate) into threshold expressions
+4. **Generate k6 script** — Produce `.js` file with `export default function`, HTTP calls, checks, groups
+5. **Configure output** — JSON, CSV, InfluxDB, Prometheus, or CI-friendly summary
+
+## Context7 MCP
+
+Use **Context7 MCP** for k6 documentation when:
+- Scenario executor options or syntax are uncertain
+- Threshold expressions or custom metrics need verification
+- WebSocket, gRPC, or advanced options require clarification
+- Output format or CI integration details are needed
+
+## Key Patterns
+
+| Pattern | Usage |
+|---------|-------|
+| `export default function(options)` | Main entry; receives `options` (env, etc.) |
+| `http.get(url)` / `http.post(url, body)` | HTTP requests; returns response |
+| `check(res, assertions)` | Assertions; returns boolean; does not fail test |
+| `sleep(duration)` | Think time between actions |
+| `group(name, fn)` | Logical grouping; metrics tagged by group |
+| `Trend`, `Rate`, `Counter`, `Gauge` | Custom metrics |
+| `scenarios` in options | Define executor-based scenarios |
+
+### Threshold Examples
+
+```javascript
+thresholds: {
+  'http_req_duration': ['p(95)<200', 'p(99)<500'],
+  'http_req_failed': ['rate<0.01'],
+  'http_reqs': ['count>1000'],
+}
+```
+
+### Scenario Executors
+
+| Executor | Use Case |
+|----------|----------|
+| `shared-iterations` | Fixed total iterations across all VUs |
+| `per-vu-iterations` | Each VU runs N iterations |
+| `constant-arrival-rate` | Fixed request rate (RPS) |
+| `ramping-arrival-rate` | Ramping RPS (stress/spike) |
+| `externally-controlled` | Control VUs from external source |
+
+See `references/patterns.md` for load profiles, scenario executors, thresholds, custom metrics, groups.
+
+## Output
+
+- **k6 scripts** — `.js` files in `tests/` or `performance/` per project convention
+- **CI config** — GitHub Actions workflow for `k6 run`, threshold pass/fail
+
+## Scope
+
+**Can do (autonomous):**
+- Generate k6 scripts from performance plans and NFR specs
+- Define scenarios with appropriate executors (load, stress, soak, spike)
+- Set thresholds from SLAs (p95, p99, error rate)
+- Add checks for status codes and response validation
+- Use stages for ramping; custom metrics (Trend, Rate, Counter, Gauge)
+- Support HTTP, WebSocket, gRPC
+- Generate GitHub Actions CI workflow for k6
+- Use Context7 MCP for k6 docs
+
+**Cannot do (requires confirmation):**
+- Change production service configuration
+- Add dependencies not in package.json
+- Override project k6 config without approval
+- Target production without explicit consent
+
+**Will not do (out of scope):**
+- Execute tests (user runs `k6 run script.js`)
+- Write E2E functional tests (use qa-playwright-ts-writer)
+- Modify CI/CD pipelines beyond k6 integration
+- Provision load infrastructure (k6 Cloud, etc.)
+
+## References
+
+- `references/patterns.md` — Load profiles, scenario executors, thresholds, custom metrics, groups
+- `references/config.md` — options, scenarios, stages, thresholds, output formats
+- `references/best-practices.md` — Realistic load, correlation, parameterization, CI integration
+
+## Quality Checklist
+
+- [ ] Scenarios match performance plan load profiles
+- [ ] Thresholds reflect SLAs (p95, p99, error rate)
+- [ ] Checks validate critical responses; use `threshold` for pass/fail
+- [ ] Think time (sleep) between requests where realistic
+- [ ] No hardcoded secrets; use `__ENV` or options
+- [ ] Groups used for logical metric segmentation
+- [ ] Output format suitable for CI (JSON summary or exit code)
+- [ ] Stages/ramping match test type (stress = ramp up, soak = steady)
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| Thresholds fail in CI | Different baseline or env | Align thresholds with target env; use env-specific config |
+| High `http_req_failed` | Timeouts, 5xx, or wrong assertions | Increase timeout; fix check logic; verify endpoint |
+| VUs not ramping as expected | Wrong executor or stage config | Use `ramping-vus` or `ramping-arrival-rate` for stress |
+| Metrics not tagged | Missing groups | Wrap logic in `group('name', () => { ... })` |
+| Script fails to run | ES module or import error | Use `export default`; ensure k6-compatible imports |
+| WebSocket/gRPC errors | Protocol-specific setup | Use `k6/experimental/grpc` or `k6/ws`; check Context7 docs |
+| CI exit code 0 despite failures | Thresholds not enforced | Ensure `--threshold` or options.thresholds set; k6 exits non-zero on threshold fail |