@freshworks/shiftleft-tools 1.1.8

package/templates/skills/run-test-suite/SKILL-java.md

@@ -0,0 +1,186 @@
+# Run Tests Skill — Java Spring Boot
+
+Execute the appropriate test suite for the project.
+
+> **Library scripts are staged from the package.** `./postman/scripts/run-all.sh`
+> (and `shiftleft test`) stage the latest scripts automatically before running.
+> The individual scripts referenced below (`report-generators/*`, `runners/*`) are
+> part of that gitignored, staged cache — if you invoke one directly, run
+> `shiftleft stage-scripts` first (or just use `run-all.sh`). Never copy or commit them.
+
+## When to Use
+
+Invoke this skill when the user says:
+- "run tests", "run the tests", "execute tests"
+- "check tests", "verify tests"
+- "run unit tests", "run mutation tests"
+- "run the full test suite"
+- "check coverage", "API coverage"
+- "run postman tests", "run against staging"
+
+## Test Commands
+
+### Unit Tests Only
+
+```bash
+mvn test
+```
+
+Runs all JUnit tests. Fast (~30 seconds).
+
+### Mutation Tests (PIT)
+
+```bash
+./postman/scripts/report-generators/mutation-report.sh
+```
+
+Runs PIT mutation testing to verify test quality. Takes 2-3 minutes.
+- Target score: **60%+**
+- Generates HTML report in `postman/reports/`
+- Identifies weak assertions that let mutants survive
+
+Or run directly with Maven:
+
+```bash
+# Single-module:
+mvn org.pitest:pitest-maven:mutationCoverage -Pmutation-tests
+
+# Multi-module (replace 'installation' with module name):
+mvn -pl installation org.pitest:pitest-maven:mutationCoverage -Pmutation-tests
+```
+
+### Postman Tests - Local
+
+```bash
+cd postman/scripts && ./runners/run-tests-local.sh
+```
+
+Runs all Postman collections against local environment:
+- Uses H2 in-memory database
+- Uses WireMock for external service mocks
+- No real JWT needed (hardcoded test token)
+
+Options:
+- `./run-tests-local.sh --v3` — run only V3 API tests
+- `./run-tests-local.sh --v2` — run only V2 API tests
+- `./run-tests-local.sh --coverage` — run tests with JaCoCo coverage
+- `./run-tests-local.sh --skip-services` — skip starting services (if already running)
+
+### Postman Tests - Staging
+
+```bash
+cd postman/scripts && ./run-tests-staging.sh
+# or with AWS profile for local use:
+AWS_PROFILE=staging ./run-tests-staging.sh
+```
+
+Runs all Postman collections against staging environment:
+- Uses real MySQL database
+- Uses real external services
+- Requires AWS credentials for JWT generation (via IRSA in Jenkins, AWS_PROFILE locally)
+
+Options:
+- `./run-tests-staging.sh --v3` — run only V3 tests
+- `./run-tests-staging.sh --multi-product` — test all products
+
+### Full Test Suite
+
+```bash
+cd postman/scripts && ./run-all.sh
+```
+
+Runs everything in sequence:
+1. Unit tests + JaCoCo coverage
+2. PIT mutation testing
+3. Postman API integration tests (local)
+4. API coverage matrix
+5. Combined quality report
+
+### Full Test Suite — Staging
+
+```bash
+cd postman/scripts && ./run-all.sh --env staging
+```
+
+Same as above but runs Postman tests against staging environment.
+
+### Skipping Phases (for faster iteration)
+
+```bash
+./run-all.sh --skip-mutation        # Skip slow mutation tests
+./run-all.sh --skip-unit            # Skip unit tests (use existing results)
+./run-all.sh --skip-postman         # Skip Postman tests (use existing results)
+./run-all.sh --skip-coverage        # Skip API coverage matrix
+./run-all.sh --skip-report          # Skip quality report generation
+./run-all.sh --no-delay             # Skip countdown delays (useful in CI)
+```
+
+Combined examples:
+```bash
+# Run only mutation tests (reuse existing unit test results):
+./run-all.sh --skip-unit --skip-postman --skip-coverage --skip-report --no-delay
+
+# Run only Postman + quality report (reuse unit + mutation results):
+./run-all.sh --skip-unit --skip-mutation --no-delay
+
+# Jenkins: generate quality report only (reuse all existing results):
+./run-all.sh --skip-unit --skip-mutation --skip-postman --skip-coverage --no-delay
+```
+
+### API Coverage Report
+
+```bash
+./postman/scripts/report-generators/java-api-coverage-matrix.sh
+```
+
+Generates coverage matrix showing:
+- Which endpoints have tests
+- Which status codes are tested
+- Coverage gaps to address
+
+## Workflow
+
+1. **Determine what to run** based on user request:
+   - Quick check → `mvn test`
+   - Test quality → `./postman/scripts/report-generators/mutation-report.sh`
+   - API tests local → `./postman/scripts/runners/run-tests-local.sh`
+   - API tests staging → `AWS_PROFILE=staging ./postman/scripts/runners/run-tests-staging.sh`
+   - Everything → `./postman/scripts/run-all.sh`
+   - Everything + staging → `./postman/scripts/run-all.sh --env staging`
+
+2. **Execute the command** and monitor output
+
+3. **Report results**:
+   - Number of tests passed/failed
+   - Coverage percentage (if applicable)
+   - Mutation score (if applicable)
+   - Location of generated reports
+
+4. **If failures occur**:
+   - Parse error messages
+   - Identify failing tests
+   - Suggest fixes based on error type
+
+## Before Merge Checklist
+
+Run these commands before any PR:
+
+```bash
+# 1. Unit tests pass
+mvn test
+
+# 2. Postman tests pass
+cd postman/scripts && ./runners/run-tests-local.sh
+
+# 3. 100% 2xx API coverage
+./postman/scripts/report-generators/java-api-coverage-matrix.sh
+
+# 4. Mutation score >= 60%
+./postman/scripts/report-generators/mutation-report.sh
+```
+
+Or run everything at once:
+
+```bash
+cd postman/scripts && ./run-all.sh
+```

package/templates/skills/run-test-suite/SKILL-node.md

@@ -0,0 +1,191 @@
+# Run Tests Skill — Node.js / Express
+
+Execute the appropriate test suite for the project.
+
+> **Library scripts are staged from the package.** `./postman/scripts/run-all.sh`
+> (and `shiftleft test`) stage the latest scripts automatically before running.
+> The individual scripts referenced below (`report-generators/*`, `runners/*`) are
+> part of that gitignored, staged cache — if you invoke one directly, run
+> `shiftleft stage-scripts` first (or just use `run-all.sh`). Never copy or commit them.
+
+## When to Use
+
+Invoke this skill when the user says:
+- "run tests", "run the tests", "execute tests"
+- "check tests", "verify tests"
+- "run unit tests", "run mutation tests"
+- "run the full test suite"
+- "check coverage", "API coverage"
+- "run postman tests", "run against staging"
+
+## Test Commands
+
+### Unit Tests Only
+
+```bash
+yarn test
+```
+
+Runs all Mocha/Jest unit tests. Fast (~30 seconds).
+
+### Unit Tests + Coverage
+
+```bash
+yarn test:coverage
+```
+
+Runs unit tests with nyc/Istanbul coverage. Generates report in `coverage/unit/`.
+
+### Mutation Tests — Since Mode (fast, for local dev)
+
+```bash
+yarn mutation-tests
+```
+
+Runs Stryker in `since` mode: **only mutates files changed vs `origin/master`**.
+
+This is the key insight for Node — Stryker on a large codebase takes 10-20 minutes on ALL files. The `since` mode makes it practical for local development by only testing what you've changed. If no scoped files changed, exits immediately (0 seconds).
+
+Use this:
+- During active development (only tests your changed files)
+- Before pushing a PR (verifies your changes haven't weakened tests)
+
+Expected output when no relevant files changed:
+```
+[INFO] No scoped source files changed vs origin/master; skipping Stryker.
+```
+
+### Mutation Tests — Full Mode (for Jenkins CI only)
+
+```bash
+yarn mutation-tests:full
+```
+
+Runs Stryker on ALL scoped files. Takes 10-20 minutes on a large codebase.
+
+Use this:
+- In Jenkins CI only (runs as part of the Mutation Tests stage)
+- When you want to see the complete mutation score
+- When you've made broad refactoring changes
+
+**Do not run full mode locally during active development** — it's too slow. Use `since` mode instead.
+
+### Postman Tests - Local
+
+```bash
+cd postman && ./scripts/run-tests.sh
+# or
+cd postman/scripts && ./run-all.sh --skip-mutation
+```
+
+Runs all Postman collections against local environment.
+
+### Postman Tests - Staging
+
+```bash
+cd postman/scripts && ./run-all.sh --env staging --skip-mutation --skip-unit
+```
+
+Runs Postman tests against staging environment. Requires AWS credentials (via IRSA in Jenkins, AWS_PROFILE locally).
+
+### Full Test Suite
+
+```bash
+cd postman/scripts && ./run-all.sh
+```
+
+Runs everything in sequence:
+1. Unit tests + coverage
+2. Stryker mutation testing (since mode — only changed files)
+3. Postman API integration tests (local)
+4. API coverage matrix
+5. Combined quality report
+
+### Full Test Suite — Staging
+
+```bash
+cd postman/scripts && ./run-all.sh --env staging
+```
+
+Same as above but runs Postman tests against staging environment.
+
+### Skipping Phases (for faster iteration)
+
+```bash
+./run-all.sh --skip-mutation        # Skip mutation tests (use existing results)
+./run-all.sh --skip-unit            # Skip unit tests (use existing results)
+./run-all.sh --skip-postman         # Skip Postman tests (use existing results)
+./run-all.sh --skip-coverage        # Skip API coverage matrix
+./run-all.sh --skip-report          # Skip quality report generation
+./run-all.sh --no-delay             # Skip countdown delays (useful in CI)
+```
+
+Combined examples:
+```bash
+# Run only Postman tests locally (skip everything else):
+./run-all.sh --skip-unit --skip-mutation --skip-coverage --skip-report --no-delay
+
+# Run only quality report (reuse all existing results):
+./run-all.sh --skip-unit --skip-mutation --skip-postman --skip-coverage --no-delay
+
+# Quick API coverage check (reuse existing Postman results):
+./run-all.sh --skip-unit --skip-mutation --skip-postman --skip-report --no-delay
+```
+
+### API Coverage Report
+
+```bash
+./postman/scripts/report-generators/node-api-coverage-matrix.sh
+# or with explicit routes dir:
+./postman/scripts/report-generators/node-api-coverage-matrix.sh ./src/controllers ./postman
+```
+
+Generates coverage matrix showing:
+- Which Express routes have Postman tests
+- Which HTTP methods and status codes are tested
+- Coverage gaps to address
+
+## Workflow
+
+1. **Determine what to run** based on user request:
+   - Quick check → `yarn test`
+   - Test quality (local) → `yarn mutation-tests` (since mode — only changed files)
+   - Test quality (complete) → `yarn mutation-tests:full` (all scoped files, slow)
+   - API tests → `cd postman/scripts && ./run-all.sh --skip-unit --skip-mutation`
+   - Everything → `cd postman/scripts && ./run-all.sh`
+   - Everything + staging → `cd postman/scripts && ./run-all.sh --env staging`
+
+2. **Execute the command** and monitor output
+
+3. **Report results**:
+   - Number of tests passed/failed
+   - Coverage percentage (if applicable)
+   - Mutation score (if applicable)
+   - Location of generated reports
+
+4. **If failures occur**:
+   - Parse error messages
+   - Identify failing tests
+   - Suggest fixes based on error type
+
+## Before Merge Checklist
+
+```bash
+# 1. Unit tests pass
+yarn test
+
+# 2. Mutation score is acceptable (only your changed files)
+yarn mutation-tests
+
+# 3. Postman tests pass locally
+cd postman/scripts && ./run-all.sh --skip-mutation
+
+# 4. API coverage check
+./postman/scripts/report-generators/node-api-coverage-matrix.sh
+```
+
+Or run everything at once:
+
+```bash
+cd postman/scripts && ./run-all.sh
+```

package/templates/skills/run-test-suite/SKILL.md

@@ -0,0 +1,9 @@
+# Run Test Suite Skill
+
+## Detect Project Type First
+
+Before doing anything, detect the stack:
+
+1. `pom.xml` in project root → **Java Spring Boot** → read `SKILL-java.md` in this folder and follow it completely
+2. `package.json` (no `pom.xml`) → **Node.js** → read `SKILL-node.md` in this folder and follow it completely
+3. If unsure → ask the user: "Is this a Java or Node.js project?"