Workersio Skills

https://github.com/workersio/skills
Admin
Workersio Skills provides coding agents with a comprehensive testing workflow to identify and...
Tokens:41,584
Snippets:582
Trust Score:7.2
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Check browser runner setup with ripgrep

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/user-behavior-testing/tools.md

Lists files and filters for common browser automation framework configurations.

```bash
rg --files | rg "playwright|cypress|selenium|webdriver|appium"
```

--------------------------------

### Install Workersio Skills

Source: https://github.com/workersio/skills/blob/main/README.md

Commands to install the skills package via various CLI tools or local paths.

```bash
npx skills add workersio/skills
```

```bash
codex plugin marketplace add workersio/skills
```

```bash
claude plugin marketplace add workersio/skills
claude plugin install wio@workersio-skills
```

```bash
codex plugin marketplace add .
```

--------------------------------

### Workersio Command Usage

Source: https://github.com/workersio/skills/blob/main/README.md

Examples of using the wio CLI tool for scanning, testing, and maintaining test suites.

```bash
$wio scan checkout
```

```bash
$wio test billing eligibility regression
```

```bash
$wio workload onboarding session
```

```bash
$wio review tests/billing_eligibility_test.py
```

```bash
$wio doctor API test suite
```

--------------------------------

### Enable Codex Agents for Current Project

Source: https://github.com/workersio/skills/blob/main/README.md

Creates the local project agents directory and copies configuration files from the skills path.

```bash
mkdir -p .codex/agents
cp /path/to/wio-skills/.codex/agents/wio-*.toml .codex/agents/
```

--------------------------------

### Configure and Run FsCheck Property Tests in C#

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/property-based-testing/tools.md

Demonstrates using FsCheck with xUnit to verify idempotency and character constraints on a slug normalization function.

```csharp
using System.Linq;
using FsCheck;
using Xunit;
public class SlugProperties
{
    [Fact]
    public void NormalizeSlugIsIdempotent()
    {
        var config = Config.QuickThrowOnFailure
            .WithMaxTest(300)
            .WithQuietOnSuccess(true);
        Prop.ForAll<string>(input =>
        {
            var once = Slug.Normalize(input ?? "");
            return Slug.Normalize(once) == once
                && once.All(c =>
                    c == '-' || ('a' <= c && c <= 'z') || ('0' <= c && c <= '9'));
        }).Check(config);
    }
}
```

--------------------------------

### Run Stryker.NET for .NET

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/mutation-testing/tools.md

Execute mutation testing for C# projects by specifying source and test project paths with threshold gates.

```bash
dotnet stryker \
  --project src/Billing/Billing.csproj \
  --test-project tests/Billing.Tests/Billing.Tests.csproj \
  --threshold-high 80 \
  --threshold-low 70 \
  --threshold-break 70 \
  --reporter html
```

--------------------------------

### Integration Testing with Testcontainers

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/test-automation-pyramid/tools.md

Example of an integration test using Testcontainers to manage a PostgreSQL database instance during test execution.

```java
import org.junit.jupiter.api.Test;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import java.sql.DriverManager;
import static org.junit.jupiter.api.Assertions.assertEquals;
@Testcontainers
class AccountRepositoryIT {
    @Container
    static PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>("postgres:16-alpine");
    @Test
    void storesAndReadsAccountRows() throws Exception {
        try (var connection = DriverManager.getConnection(
                postgres.getJdbcUrl(), postgres.getUsername(), postgres.getPassword())) {
            connection.createStatement()
                .execute("create table accounts(id int primary key, email text)");
            connection.createStatement()
                .execute("insert into accounts values (1, 'a@example.com')");
            var rows = connection.createStatement()
                .executeQuery("select count(*) from accounts");
            rows.next();
            assertEquals(1, rows.getInt(1));
        }
    }
}
```

--------------------------------

### Configure and Run Gitleaks

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/security-testing-beyond-sast/tools.md

Creates a custom configuration file to allowlist test fixtures and performs a secret scan on the current Git commit range.

```bash
cat > .gitleaks.toml <<'EOF'
[extend]
useDefault = true
[[allowlists]]
description = "checked-in test fixtures"
paths = ['''(^|/)testdata/fixtures/''']
EOF
git fetch --depth=50 origin main:refs/remotes/origin/main
gitleaks git --log-opts="origin/main..HEAD" \
  --config .gitleaks.toml --redact \
  --report-format sarif --report-path gitleaks.sarif \
  --exit-code 1 .
```

--------------------------------

### Unit Testing with Jest

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/test-automation-pyramid/tools.md

Example of a unit test using Jest to verify invoice calculation and event publishing with mock functions.

```javascript
// invoice.test.js
const { calculateInvoice } = require('./invoice');
test('publishes invoice event with calculated total', () => {
  const publish = jest.fn();
  const invoice = calculateInvoice(
    [{ sku: 'A-1', priceCents: 1000, quantity: 2 }],
    { publish }
  );
  expect(invoice.totalCents).toBe(2000);
  expect(publish).toHaveBeenCalledWith(expect.objectContaining({
    type: 'invoice.created',
    totalCents: 2000,
  }));
});
```

--------------------------------

### Implement Go Fuzzing with testing.F

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/fuzz-testing-continuous-fuzzing/tools.md

Uses the standard Go testing package to perform coverage-guided fuzzing on query parsing logic.

```go
package query
import (
	"net/url"
	"reflect"
	"testing"
)
func FuzzParseQueryRoundTrip(f *testing.F) {
	f.Add("user=alice&role=admin")
	f.Add("q=a%2Bb&empty=")
	f.Fuzz(func(t *testing.T, raw string) {
		values, err := url.ParseQuery(raw)
		if err != nil {
			return
		}
		reparsed, err := url.ParseQuery(values.Encode())
		if err != nil {
			t.Fatalf("encoded query is not parseable: %v", err)
		}
		if !reflect.DeepEqual(values, reparsed) {
			t.Fatalf("round trip changed values: %#v != %#v", values, reparsed)
		}
	})
}
// CI smoke run:
// go test ./... -run=FuzzParseQueryRoundTrip -fuzz=FuzzParseQueryRoundTrip -fuzztime=60s
```

--------------------------------

### Inspect CI loops

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/test-feedback-loops/tools.md

Search CI configuration files for keywords related to testing, coverage, and execution strategies.

```bash
rg "test|coverage|junit|artifact|matrix|schedule|retry|allow_failure|continue-on-error|shard|parallel" .github .gitlab-ci.yml buildkite* .circleci azure-pipelines.yml
```

--------------------------------

### Enable Codex Hook Config for Current Project

Source: https://github.com/workersio/skills/blob/main/README.md

Creates the local .codex directory and copies the hooks configuration file.

```bash
mkdir -p .codex
cp /path/to/wio-skills/.codex/hooks.json .codex/hooks.json
```

--------------------------------

### Configure and Run mutmut for Python

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/mutation-testing/tools.md

Set mutation paths in pyproject.toml and execute mutation testing or result browsing.

```toml
# pyproject.toml
[tool.mutmut]
paths_to_mutate = ["src/"]
pytest_add_cli_args_test_selection = ["tests/"]

mutmut run
mutmut browse
```

--------------------------------

### Run OWASP ZAP Baseline Scans in Docker

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/risk-based-testing/tools.md

Use these commands to generate a baseline configuration file and subsequently execute a scan with custom rules for CI/CD gating.

```bash
# Generate once, then edit selected rules from WARN to FAIL or IGNORE:
docker run --rm -v "$(pwd):/zap/wrk/:rw" ghcr.io/zaproxy/zaproxy:stable \
  zap-baseline.py -t "$APP_URL" -g zap-rules.conf
# CI gate:
docker run --rm -v "$(pwd):/zap/wrk/:rw" ghcr.io/zaproxy/zaproxy:stable \
  zap-baseline.py -t "$APP_URL" -c zap-rules.conf -r zap-report.html
```

--------------------------------

### Enable Codex Agents Globally

Source: https://github.com/workersio/skills/blob/main/README.md

Creates the global agents directory and copies configuration files to enable Codex agents for the user.

```bash
mkdir -p ~/.codex/agents
cp .codex/agents/wio-*.toml ~/.codex/agents/
```

--------------------------------

### Configure and Run StrykerJS

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/mutation-testing/tools.md

Define mutation testing parameters in stryker.conf.json and execute the runner.

```json
// stryker.conf.json
{
  "$schema": "./node_modules/@stryker-mutator/core/schema/stryker-schema.json",
  "packageManager": "npm",
  "testRunner": "vitest",
  "mutate": ["src/**/*.ts", "!src/**/*.d.ts"],
  "reporters": ["html", "clear-text", "progress"],
  "thresholds": {
    "high": 80,
    "low": 70,
    "break": 70
  }
}

npx stryker run
```

--------------------------------

### Find concept documentation

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/testing-core-concepts/tools.md

Search for documentation related to testing concepts like assertions, invariants, and property-based testing.

```bash
rg -n "assertion|assertions|invariant|invariants|safety propert|liveness|property-based|metamorphic|oracle" docs references README* .
```

--------------------------------

### Configure ESLint for JavaScript

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/static-testing-static-analysis/tools.md

Define linting rules and file patterns in the flat configuration format. Use the provided CI command to enforce zero-warning thresholds.

```javascript
// eslint.config.js
import { defineConfig } from "eslint/config";
export default defineConfig([
  {
    files: ["src/**/*.js"],
    ignores: ["dist/**"],
    rules: {
      "no-console": ["error", { allow: ["warn", "error"] }],
    },
  },
]);
// CI: npx eslint src --max-warnings 0
```

--------------------------------

### Define k6 Load Test Scenario and Thresholds

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/performance-load-and-stress-testing/tools.md

Configures a ramping virtual user scenario and performance thresholds for API testing. Requires the k6 environment to execute the exported default function.

```javascript
import http from 'k6/http';
import { check, sleep } from 'k6';
export const options = {
  scenarios: {
    steady_api_load: {
      executor: 'ramping-vus',
      startVUs: 0,
      stages: [
        { duration: '30s', target: 20 },
        { duration: '2m', target: 20 },
        { duration: '30s', target: 0 },
      ],
    },
  },
  thresholds: {
    http_req_failed: ['rate<0.01'],
    http_req_duration: ['p(95)<400'],
    checks: ['rate>0.95'],
  },
};
export default function () {
  const baseUrl = __ENV.BASE_URL || 'https://staging.example.com';
  const res = http.get(`${baseUrl}/api/products?limit=20`);
  check(res, {
    'status is 200': (r) => r.status === 200,
    'returns JSON': (r) =>
      String(r.headers['Content-Type']).includes('application/json'),
  });
  sleep(1);
}
```

--------------------------------

### Workload Documentation Template

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/SKILL.md

Use this markdown template to document the design, coverage, and implementation details of a new workload.

```markdown
## Workload
Actor: [...]
Goal: [...]
Shape: [browser/API/CLI/job/load/synthetic/stateful]
References used: [...]

## Existing Coverage
Existing workloads found: [...]
What they cover: [...]
Gap this workload fills: [...]
Why this is not only a wrapper/runner/seed sweep: [...]

## Coverage
Interactions: [...]
Bug-prone areas: [...]
New failure surface/adversarial class/oracle: [...]
Invariants/assertions: [...]

## Adversarial Model
Misuse paths: [...]
Invalid transitions: [...]
Boundary inputs: [...]
Duplicate/replayed actions: [...]
Permission/tenant edges: [...]
Dependency/time/concurrency faults: [...]

## Variance And Replay
Seed: [...]
Variable inputs/branches/timing/scale: [...]
Replay command or notes: [...]

## Implementation And Validation
Tooling: [...]
Files changed: [...]
Command/result: [...]

## Falsification Check
Plausible bug caught: [...]
Assertion/invariant that fails: [...]
Manual mutation or fault tried, if any: [...]

## Limits
[environment, data, dependency, runtime, cleanup, or flake risk]
```

--------------------------------

### Defining Performance Thresholds in k6

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/risk-based-testing/tools.md

Configure scenario-specific thresholds to enforce SLOs and trigger non-zero exit codes upon failure.

```javascript
import http from 'k6/http';
import { check } from 'k6';
export const options = {
  scenarios: {
    checkout: { executor: 'constant-vus', vus: 20, duration: '3m' },
  },
  thresholds: {
    http_req_failed: ['rate<0.01'],
    'http_req_duration{scenario:checkout}': ['p(95)<500'],
    checks: ['rate>0.99'],
  },
};
export default function () {
  const res = http.post(`${__ENV.BASE_URL}/checkout`, JSON.stringify({ sku: 'plan-pro' }), {
    headers: { 'Content-Type': 'application/json' },
  });
  check(res, {
    'checkout accepted': (r) => r.status === 201,
  });
}
```

--------------------------------

### Find property tests

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/testing-core-concepts/tools.md

Search for property-based testing frameworks and patterns within the source code.

```bash
rg -n "@given|hypothesis|forAll|fc\.property|quickcheck|proptest|jqwik|invariant" test tests src
```

--------------------------------

### Configure and Run PIT for JVM

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/mutation-testing/tools.md

Configure PIT via Maven plugin settings and execute mutation coverage analysis.

```xml
<!-- pom.xml -->
<plugin>
  <groupId>org.pitest</groupId>
  <artifactId>pitest-maven</artifactId>
  <configuration>
    <targetClasses>
      <param>com.acme.billing.service*</param>
    </targetClasses>
    <targetTests>
      <param>com.acme.billing*</param>
    </targetTests>
    <mutationThreshold>75</mutationThreshold>
    <coverageThreshold>80</coverageThreshold>
    <outputFormats>
      <param>HTML</param>
      <param>XML</param>
    </outputFormats>
    <withHistory>true</withHistory>
  </configuration>
</plugin>

mvn test-compile org.pitest:pitest-maven:mutationCoverage
```

--------------------------------

### Configure Ruff for Python

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/static-testing-static-analysis/tools.md

Set target versions and linting rules within the pyproject.toml file. The CI command supports GitHub-specific output formats.

```toml
# pyproject.toml
[tool.ruff]
target-version = "py311"
line-length = 100
exclude = ["build", "dist", ".venv"]
[tool.ruff.lint]
select = ["E4", "E7", "E9", "F", "B"]
ignore = ["E501"]
unfixable = ["B"]
# CI: ruff check . --output-format=github
```

--------------------------------

### Configure ChaosEngine with LitmusChaos

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/resilience-testing-and-fault-injection/tools.md

Sets up a network latency experiment for the checkout-api deployment using a specific chaos service account.

```yaml
apiVersion: litmuschaos.io/v1alpha1
kind: ChaosEngine
metadata:
  name: checkout-network-latency
  namespace: checkout
spec:
  engineState: "active"
  annotationCheck: "false"
  appinfo:
    appns: "checkout"
    applabel: "app=checkout-api"
    appkind: "deployment"
  chaosServiceAccount: pod-network-latency-sa
  experiments:
  - name: pod-network-latency
    spec:
      components:
        env:
        - name: NETWORK_LATENCY
          value: '2000'
        - name: TOTAL_CHAOS_DURATION
          value: '60'
```

--------------------------------

### Configure SpotBugs for Java

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/static-testing-static-analysis/tools.md

Integrate the SpotBugs Maven plugin to enforce build failures on detected violations. Use an exclude filter file to suppress specific warnings.

```xml
<!-- pom.xml -->
<plugin>
  <groupId>com.github.spotbugs</groupId>
  <artifactId>spotbugs-maven-plugin</artifactId>
  <configuration>
    <failOnError>true</failOnError>
    <maxAllowedViolations>0</maxAllowedViolations>
    <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
  </configuration>
  <executions>
    <execution>
      <goals><goal>check</goal></goals>
    </execution>
  </executions>
</plugin>
```

--------------------------------

### Configure golangci-lint for Go

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/static-testing-static-analysis/tools.md

Define enabled linters and execution timeouts in the configuration file. The CI command allows checking only new issues from the latest revision.

```yaml
# .golangci.yml
version: "2"
linters:
  default: none
  enable:
    - govet
    - staticcheck
    - errcheck
    - gosec
issues:
  max-issues-per-linter: 0
  max-same-issues: 0
run:
  timeout: 5m
  modules-download-mode: readonly
# CI: golangci-lint run ./... --new-from-rev=HEAD~
```

--------------------------------

### Configure pytest with Coverage and Reporting

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/test-suite-health-diagnostics/tools.md

Sets up pytest options in pyproject.toml for duration profiling, branch coverage, and XML report generation.

```toml
# pyproject.toml
[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = [
  "-ra",
  "--durations=10",
  "--durations-min=0.5",
  "--cov=src/payments",
  "--cov-branch",
  "--cov-report=term-missing:skip-covered",
  "--cov-report=xml:reports/coverage.xml",
  "--cov-fail-under=85",
  "--junitxml=reports/pytest.xml"
]
```

--------------------------------

### Run OWASP Dependency-Check via CLI

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/security-testing-beyond-sast/tools.md

Executes a vulnerability scan on the current directory and generates both HTML and JUnit reports with a CVSS failure threshold.

```bash
dependency-check.sh \
  --project "payments-api" \
  --scan . \
  --format HTML \
  --format JUNIT \
  --out build/dependency-check \
  --nvdApiKey "$NVD_API_KEY" \
  --junitFailOnCVSS 7 \
  --failOnCVSS 7
```

--------------------------------

### $wio test [target]

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/SKILL.md

Discovers a valuable candidate, selects a strategy, writes one test, validates, reviews, and keeps only if valuable.

```APIDOC
## $wio test [target]

### Description
Discovers a valuable candidate, picks a strategy, writes one test, validates, reviews, and keeps only if valuable.

### Parameters
- **target** (string) - Required - The behavior, code path, or regression risk to test.
```

--------------------------------

### Execute @workersio/skills command modes

Source: https://github.com/workersio/skills/blob/main/README.md

List of available command modes for the wio CLI tool to manage testing workflows.

```text
$wio scan      # Find high-value tests to add next.
$wio test      # Run candidate discovery, strategy, implementation, and review.
$wio workload  # Generate realistic, replayable workloads with new bug-finding value.
$wio review    # Judge whether a test should be kept, redone, or removed.
$wio doctor    # Audit suite health, weak assertions, flakes, mocks, and CI blind spots.
```

--------------------------------

### Execute Gradle tests with build cache

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/regression-test/tools.md

Runs tests with build cache enabled and fail-fast behavior for faster CI feedback.

```bash
# Preserve Gradle User Home between CI runs so test outputs can be reused.
./gradlew test --build-cache --fail-fast
```

--------------------------------

### Find routes and workflows with ripgrep

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/user-behavior-testing/tools.md

Searches source and application directories for routing and controller definitions.

```bash
rg "router|route|Controller|Handler|screen|page|endpoint|mutation|command" src app
```

--------------------------------

### Configure and Run OWASP ZAP Baseline Scan

Source: https://github.com/workersio/skills/blob/main/plugins/wio/skills/wio/references/security-testing-beyond-sast/tools.md

Defines custom alert rules in a configuration file and executes a passive baseline scan against a target URL using the official Docker image.

```bash
cat > zap-rules.conf <<'EOF'
10020	FAIL	(X-Frame-Options Header Scanner)
10021	FAIL	(X-Content-Type-Options Header Missing)
10015	WARN	(Cache-control headers)
*	OUTOFSCOPE	.*\.(png|jpg|css|js)$
EOF
docker run --rm -v "$PWD:/zap/wrk:rw" ghcr.io/zaproxy/zaproxy:stable \
  zap-baseline.py -t "$APP_URL" -c zap-rules.conf -I -J zap-report.json -m 3 -s
```
Tokens:
Raw