@assertrx/dino 1.0.10 → 1.0.11

package/skills/generating-tests-from-openapi/reference/openapi-auth-mapping.md

@@ -0,0 +1,247 @@
+# OpenAPI Security Scheme to k6 Mapping
+
+## Security Scheme Types
+
+### HTTP Bearer
+
+```yaml
+components:
+  securitySchemes:
+    bearerAuth:
+      type: http
+      scheme: bearer
+      bearerFormat: JWT    # Optional, informational
+```
+
+**k6 mapping:**
+```javascript
+export function setup() {
+  // Obtain token (login endpoint must be identified separately)
+  const res = http.post(`${BASE_URL}/auth/login`,
+    JSON.stringify({ username: __ENV.USERNAME, password: __ENV.PASSWORD }),
+    { headers: { 'Content-Type': 'application/json' } }
+  );
+  return { token: res.json('access_token') };
+}
+
+export default function (data) {
+  http.get(`${BASE_URL}/resource`, {
+    headers: { 'Authorization': `Bearer ${data.token}` },
+  });
+}
+```
+
+### HTTP Basic
+
+```yaml
+components:
+  securitySchemes:
+    basicAuth:
+      type: http
+      scheme: basic
+```
+
+**k6 mapping:**
+```javascript
+import encoding from 'k6/encoding';
+
+const credentials = encoding.b64encode(
+  `${__ENV.USERNAME}:${__ENV.PASSWORD}`
+);
+
+export default function () {
+  http.get(`${BASE_URL}/resource`, {
+    headers: { 'Authorization': `Basic ${credentials}` },
+  });
+}
+```
+
+### API Key (Header)
+
+```yaml
+components:
+  securitySchemes:
+    apiKeyAuth:
+      type: apiKey
+      in: header
+      name: X-API-Key
+```
+
+**k6 mapping:**
+```javascript
+const API_KEY = __ENV.API_KEY;
+
+export default function () {
+  http.get(`${BASE_URL}/resource`, {
+    headers: { 'X-API-Key': API_KEY },
+  });
+}
+```
+
+### API Key (Query)
+
+```yaml
+components:
+  securitySchemes:
+    apiKeyQuery:
+      type: apiKey
+      in: query
+      name: api_key
+```
+
+**k6 mapping:**
+```javascript
+const API_KEY = __ENV.API_KEY;
+
+export default function () {
+  http.get(`${BASE_URL}/resource?api_key=${API_KEY}`);
+}
+```
+
+### API Key (Cookie)
+
+```yaml
+components:
+  securitySchemes:
+    apiKeyCookie:
+      type: apiKey
+      in: cookie
+      name: session_id
+```
+
+**k6 mapping:**
+```javascript
+export default function () {
+  http.get(`${BASE_URL}/resource`, {
+    cookies: { session_id: __ENV.SESSION_ID },
+  });
+}
+```
+
+### OAuth2 — Client Credentials
+
+```yaml
+components:
+  securitySchemes:
+    oauth2:
+      type: oauth2
+      flows:
+        clientCredentials:
+          tokenUrl: https://auth.example.com/oauth/token
+          scopes:
+            read: Read access
+            write: Write access
+```
+
+**k6 mapping:**
+```javascript
+import encoding from 'k6/encoding';
+
+const TOKEN_URL = 'https://auth.example.com/oauth/token';
+const CLIENT_ID = __ENV.CLIENT_ID;
+const CLIENT_SECRET = __ENV.CLIENT_SECRET;
+
+export function setup() {
+  const res = http.post(TOKEN_URL,
+    'grant_type=client_credentials&scope=read write',
+    {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Authorization': `Basic ${encoding.b64encode(`${CLIENT_ID}:${CLIENT_SECRET}`)}`,
+      },
+    }
+  );
+  check(res, { 'token obtained': (r) => r.status === 200 });
+  return { token: res.json('access_token') };
+}
+
+export default function (data) {
+  http.get(`${BASE_URL}/resource`, {
+    headers: { 'Authorization': `Bearer ${data.token}` },
+  });
+}
+```
+
+### OAuth2 — Password (Resource Owner)
+
+```yaml
+components:
+  securitySchemes:
+    oauth2:
+      type: oauth2
+      flows:
+        password:
+          tokenUrl: https://auth.example.com/oauth/token
+          scopes:
+            read: Read access
+```
+
+**k6 mapping:**
+```javascript
+export function setup() {
+  const res = http.post(TOKEN_URL,
+    `grant_type=password&username=${__ENV.USERNAME}&password=${__ENV.PASSWORD}&scope=read`,
+    { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
+  );
+  return { token: res.json('access_token') };
+}
+```
+
+### OAuth2 — Authorization Code
+
+Not directly applicable for automated load testing since it requires browser-based user interaction. Alternatives:
+1. Use a pre-obtained token via environment variable
+2. Use the password flow if the auth server supports it
+3. Use client credentials flow for service-to-service testing
+
+```javascript
+// Pre-obtained token approach
+const TOKEN = __ENV.OAUTH_TOKEN;
+
+export default function () {
+  http.get(`${BASE_URL}/resource`, {
+    headers: { 'Authorization': `Bearer ${TOKEN}` },
+  });
+}
+```
+
+### OpenID Connect
+
+```yaml
+components:
+  securitySchemes:
+    openId:
+      type: openIdConnect
+      openIdConnectUrl: https://auth.example.com/.well-known/openid-configuration
+```
+
+**k6 mapping:** Similar to OAuth2. Fetch the OpenID configuration to discover the token endpoint, then use the appropriate OAuth2 flow.
+
+## Per-Endpoint Security
+
+```yaml
+security:
+  - bearerAuth: []    # Global default
+
+paths:
+  /public/health:
+    get:
+      security: []    # No auth required (overrides global)
+
+  /users:
+    get:
+      security:
+        - bearerAuth: []
+        - apiKeyAuth: []  # Either bearer OR API key
+
+  /admin/settings:
+    put:
+      security:
+        - bearerAuth: [admin]  # Bearer with admin scope
+```
+
+**k6 mapping strategy:**
+1. Public endpoints → No auth headers
+2. Multiple schemes (OR) → Use the simplest one for testing
+3. Scoped access → Ensure test credentials have required scopes
+4. Generate separate scenarios for different auth levels if needed

package/skills/generating-tests-from-openapi/reference/openapi-parsing.md

@@ -0,0 +1,194 @@
+# OpenAPI Spec Parsing Reference
+
+## Spec Structure Overview
+
+```yaml
+openapi: '3.1.0'
+info: { title, version, description }
+servers: [{ url, description }]
+security: [{ schemeName: [] }]          # Global security
+paths:
+  /resource:
+    get/post/put/patch/delete:
+      operationId: string
+      tags: [string]
+      summary: string
+      parameters: [Parameter]
+      requestBody: RequestBody
+      responses: { statusCode: Response }
+      security: [{ schemeName: [scope] }]  # Per-operation override
+components:
+  schemas: { SchemaName: Schema }
+  securitySchemes: { SchemeName: SecurityScheme }
+  parameters: { ParameterName: Parameter }
+  requestBodies: { BodyName: RequestBody }
+```
+
+## Extracting Paths and Operations
+
+For each entry in `paths`:
+
+1. **Path** → URL path (e.g., `/users/{id}`)
+2. **HTTP method** → `get`, `post`, `put`, `patch`, `delete`
+3. **Operation** → The operation object under the method
+
+### Path Parameters
+
+```yaml
+parameters:
+  - name: id
+    in: path            # path | query | header | cookie
+    required: true
+    schema:
+      type: integer
+```
+
+Map to k6:
+- `in: path` → Replace in URL: `/users/${id}`
+- `in: query` → Append: `?page=1&limit=10`
+- `in: header` → Add to headers: `{ 'X-Custom': 'value' }`
+
+### Request Body
+
+```yaml
+requestBody:
+  required: true
+  content:
+    application/json:
+      schema:
+        $ref: '#/components/schemas/CreateUser'
+    multipart/form-data:
+      schema:
+        type: object
+        properties:
+          file:
+            type: string
+            format: binary
+```
+
+Map to k6:
+- `application/json` → `JSON.stringify(body)` with `Content-Type` header
+- `multipart/form-data` → Use `http.file()` for binary fields
+- `application/x-www-form-urlencoded` → URL-encoded string body
+
+## Resolving $ref References
+
+```yaml
+# Reference
+$ref: '#/components/schemas/User'
+
+# Resolves to the object at components.schemas.User
+```
+
+Follow `$ref` chains:
+1. Parse the JSON pointer path
+2. Navigate to the target object
+3. Replace the `$ref` with the resolved object
+4. Handle circular references (stop at 2 levels deep)
+
+## Schema to Example Value Generation
+
+### Primitive Types
+
+| Schema | Generated Example |
+|--------|------------------|
+| `type: string` | `"test-string"` |
+| `type: string, format: email` | `"test@example.com"` |
+| `type: string, format: date` | `"2024-01-15"` |
+| `type: string, format: date-time` | `"2024-01-15T10:30:00Z"` |
+| `type: string, format: uuid` | `"550e8400-e29b-41d4-a716-446655440000"` |
+| `type: string, format: uri` | `"https://example.com"` |
+| `type: string, format: password` | `"password123"` |
+| `type: string, enum: [A, B, C]` | `"A"` (first value) |
+| `type: string, minLength: 5` | `"test-string"` (at least minLength) |
+| `type: integer` | `1` |
+| `type: integer, minimum: 10` | `10` |
+| `type: number` | `1.0` |
+| `type: boolean` | `true` |
+
+### Complex Types
+
+```yaml
+# Object
+type: object
+required: [name, email]
+properties:
+  name: { type: string }
+  email: { type: string, format: email }
+  age: { type: integer }
+# → { "name": "test-string", "email": "test@example.com", "age": 1 }
+
+# Array
+type: array
+items: { type: string }
+# → ["test-string"]
+
+# Array of objects
+type: array
+items:
+  $ref: '#/components/schemas/User'
+# → [{ ...user example }]
+```
+
+### Using Existing Examples
+
+Prefer spec-provided examples over generated ones:
+
+```yaml
+schema:
+  type: object
+  properties:
+    name: { type: string }
+  example:
+    name: "John Doe"
+# Use the example value: { "name": "John Doe" }
+```
+
+Check in order:
+1. `example` field on the schema
+2. `examples` field on the media type
+3. `default` field on the schema
+4. Generate from type/format
+
+## Response Status Codes
+
+Map response codes to k6 checks:
+
+```yaml
+responses:
+  '200': { description: Success }
+  '201': { description: Created }
+  '204': { description: No Content }
+  '400': { description: Bad Request }
+  '401': { description: Unauthorized }
+  '404': { description: Not Found }
+```
+
+For primary success responses, generate checks:
+- `2xx` responses → `check(res, { 'status 200': (r) => r.status === 200 })`
+- Use `http.expectedStatuses()` if testing error scenarios
+
+## Grouping by Tags
+
+```yaml
+paths:
+  /users:
+    get:
+      tags: [Users]
+  /products:
+    get:
+      tags: [Products]
+```
+
+Map tags to k6 `group()`:
+
+```javascript
+group('Users', () => {
+  // All operations tagged 'Users'
+});
+group('Products', () => {
+  // All operations tagged 'Products'
+});
+```
+
+Operations without tags → group as `'Default'` or by path prefix.

package/skills/operating-k6-in-ci-cd/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: operating-k6-in-ci-cd
+description: Use when setting up k6 in CI/CD pipelines (GitHub Actions, GitLab CI, Jenkins), configuring distributed testing with k6-operator on Kubernetes, or managing k6 extensions (xk6). Use when the user wants to automate performance tests in a pipeline or run distributed load tests.
+---
+
+# Operating k6 in CI/CD
+
+Configure k6 for CI/CD pipelines, distributed testing on Kubernetes, and extension management.
+
+## Choose Your Path
+
+- **CI/CD Pipeline Setup** → See [reference/ci-cd-pipelines.md](reference/ci-cd-pipelines.md)
+  - GitHub Actions, GitLab CI, Jenkins
+  - Docker-based execution
+  - Threshold-based pass/fail in pipelines
+
+- **Distributed Testing (Kubernetes)** → See [reference/k6-operator.md](reference/k6-operator.md)
+  - k6-operator installation
+  - TestRun CRD configuration
+  - Scaling load across pods
+
+- **Extensions (xk6)** → See [reference/extensions.md](reference/extensions.md)
+  - Building custom k6 binaries
+  - Official and community extensions
+  - Automatic extension resolution
+
+## Quick Start: GitHub Actions
+
+```yaml
+name: k6 Load Test
+on: [push]
+jobs:
+  k6:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: grafana/setup-k6-action@v1
+      - uses: grafana/run-k6-action@v1
+        with:
+          path: tests/load-test.js
+```
+
+## Quick Start: Docker
+
+```bash
+docker run --rm -i grafana/k6 run - < script.js
+
+# With local script file
+docker run --rm -v $(pwd):/scripts grafana/k6 run /scripts/test.js
+
+# With environment variables
+docker run --rm -v $(pwd):/scripts \
+  -e BASE_URL=https://staging.example.com \
+  grafana/k6 run /scripts/test.js
+```
+
+## Key Concepts
+
+### Threshold-Based Pass/Fail
+
+k6 exits with code 99 if thresholds fail. CI/CD pipelines use this to pass/fail the build:
+
+```javascript
+export const options = {
+  thresholds: {
+    http_req_duration: ['p(95)<500'],  // Fails pipeline if p95 > 500ms
+    http_req_failed: ['rate<0.01'],    // Fails pipeline if error rate > 1%
+  },
+};
+```
+
+### Environment-Specific Configuration
+
+```javascript
+const BASE_URL = __ENV.BASE_URL || 'https://api.example.com';
+const TARGET_VUS = parseInt(__ENV.TARGET_VUS) || 10;
+
+export const options = {
+  vus: TARGET_VUS,
+  duration: __ENV.DURATION || '5m',
+};
+```
+
+### Grafana Cloud k6 Integration
+
+```bash
+# Run locally, send results to cloud
+K6_CLOUD_TOKEN=$TOKEN k6 cloud run --local-execution script.js
+
+# Run entirely in cloud
+K6_CLOUD_TOKEN=$TOKEN k6 cloud run script.js
+```
+
+## Related Skills
+
+- For generating test scripts: `/k6:generating-api-load-tests`
+- For analyzing results: `/k6:analyzing-test-results`
+- For resilience testing on Kubernetes: `/k6:testing-resilience`