@codyswann/lisa 1.0.0

package/typescript/copy-overwrite/.github/workflows/k6-load-test-README.md

@@ -0,0 +1,230 @@
+# K6 Load Testing Workflow
+
+## Overview
+
+The `k6-load-test.yml` is a reusable GitHub Actions workflow designed to run k6 performance tests as part of your CI/CD pipeline. It supports multiple test scenarios, flexible configuration, and both local and cloud execution.
+
+## Quick Start
+
+```yaml
+name: Deploy and Test
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    # Your deployment steps
+    
+  performance-test:
+    needs: deploy
+    uses: ./.github/workflows/k6-load-test.yml
+    with:
+      environment: production
+      test_scenario: smoke
+      base_url: https://api.example.com
+    secrets: inherit
+```
+
+## Workflow Inputs
+
+| Input | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `environment` | string | Yes | - | Target environment (staging, production) |
+| `test_scenario` | string | No | smoke | Test type: smoke, load, stress, spike, soak |
+| `base_url` | string | Yes | - | Base URL of application to test |
+| `k6_version` | string | No | latest | k6 version to use |
+| `test_duration` | string | No | - | Override test duration (e.g., 5m, 1h) |
+| `virtual_users` | number | No | - | Override number of virtual users |
+| `thresholds_config` | string | No | - | Path to custom thresholds JSON |
+| `test_script` | string | No | .github/k6/scripts/default-test.js | Path to k6 test script |
+| `fail_on_threshold` | boolean | No | true | Fail workflow if thresholds not met |
+| `upload_results` | boolean | No | true | Upload test results as artifacts |
+| `cloud_run` | boolean | No | false | Run tests on k6 Cloud |
+
+## Workflow Outputs
+
+| Output | Description |
+|--------|-------------|
+| `test_passed` | Whether the test passed all thresholds (true/false) |
+| `results_url` | URL to test results artifact |
+| `summary` | Test execution summary |
+
+## Workflow Secrets
+
+| Secret | Required | Description |
+|--------|----------|-------------|
+| `K6_CLOUD_TOKEN` | No | k6 Cloud API token for cloud runs |
+| `CUSTOM_HEADERS` | No | Custom headers for authenticated endpoints (JSON) |
+
+## Test Scenarios
+
+### Available Scenarios
+
+- **smoke**: Quick validation (1 min, 1 VU)
+- **load**: Normal traffic (9 min, 10 VUs)
+- **stress**: Find breaking points (33 min, up to 200 VUs)
+- **spike**: Sudden traffic changes (8 min, 5→100→5 VUs)
+- **soak**: Extended duration (30+ min, 10 VUs)
+
+### Selecting a Scenario
+
+See the [Scenario Selection Guide](../k6/SCENARIO_SELECTION_GUIDE.md) for detailed guidance.
+
+## Authentication
+
+For testing protected endpoints:
+
+```yaml
+uses: ./.github/workflows/k6-load-test.yml
+with:
+  base_url: https://api.example.com
+secrets:
+  CUSTOM_HEADERS: |
+    {
+      "Authorization": "Bearer ${{ secrets.API_TOKEN }}",
+      "X-API-Key": "${{ secrets.API_KEY }}"
+    }
+```
+
+## Custom Test Scripts
+
+Use your own test script:
+
+```yaml
+with:
+  test_script: .github/k6/scripts/my-custom-test.js
+```
+
+## Custom Thresholds
+
+Use environment-specific thresholds:
+
+```yaml
+with:
+  thresholds_config: .github/k6/thresholds/production.json
+```
+
+## k6 Cloud Integration
+
+For high-concurrency tests:
+
+```yaml
+uses: ./.github/workflows/k6-load-test.yml
+with:
+  cloud_run: true
+secrets:
+  K6_CLOUD_TOKEN: ${{ secrets.K6_CLOUD_TOKEN }}
+```
+
+## Artifacts
+
+Test results are automatically uploaded as artifacts including:
+- JSON results (`results.json`)
+- CSV results (`results.csv`)
+- HTML report (`report.html`)
+- Scenario-specific summaries
+
+Artifacts are retained for 30 days.
+
+## Error Handling
+
+The workflow handles various error scenarios:
+- Base URL not accessible
+- Test script not found
+- Threshold failures
+- k6 installation issues
+
+See the [Troubleshooting Guide](../k6/INTEGRATION_GUIDE.md#troubleshooting) for solutions.
+
+## Integration Patterns
+
+For comprehensive integration examples, see the [Integration Guide](../k6/INTEGRATION_GUIDE.md).
+
+### Integration with Release and Deployment Workflows
+
+The k6 load testing workflow is designed to integrate seamlessly with your release and deployment processes. Here's the recommended pattern:
+
+```yaml
+# deploy.yml.example - Complete release and deployment with load testing
+name: 🚀 Release and Deploy
+
+on:
+  push:
+    branches: [main, staging, dev]
+
+jobs:
+  # Step 1: Create a release
+  release:
+    uses: ./.github/workflows/release.yml
+    with:
+      environment: ${{ github.ref_name }}
+      # ... other inputs
+    
+  # Step 2: Deploy to your infrastructure
+  deploy:
+    needs: release
+    runs-on: ubuntu-latest
+    outputs:
+      environment_url: ${{ steps.deploy.outputs.environment_url }}
+    steps:
+      # Your deployment logic here
+      
+  # Step 3: Run load tests (staging only)
+  load_testing:
+    needs: [release, deploy]
+    if: |
+      needs.deploy.result == 'success' && 
+      github.ref_name == 'staging'
+    uses: ./.github/workflows/load-test.yml
+    with:
+      environment: staging
+      test_scenario: smoke
+      base_url: ${{ needs.deploy.outputs.environment_url }}
+      fail_on_threshold: false  # Don't fail the deployment
+    secrets: inherit
+```
+
+This pattern ensures:
+- Releases are created first with proper versioning
+- Deployments happen after successful releases
+- Load tests run automatically for staging deployments
+- Production deployments skip load testing (run manually if needed)
+
+## File Structure
+
+```
+.github/
+├── workflows/
+│   └── k6-load-test.yml      # This workflow
+└── k6/
+    ├── scripts/              # Test scripts
+    ├── scenarios/            # Scenario configs
+    ├── thresholds/           # Threshold configs
+    └── examples/             # Usage examples
+```
+
+## Workflow Steps
+
+1. **Checkout**: Get repository code
+2. **Setup k6**: Install specified k6 version
+3. **Prepare Environment**: Set up test variables
+4. **Run Test**: Execute k6 with parameters
+5. **Generate Summary**: Create test report
+6. **Upload Results**: Store artifacts
+7. **Comment on PR**: Add results to PR (if applicable)
+
+## Best Practices
+
+1. Start with smoke tests
+2. Use appropriate scenarios per environment
+3. Set realistic thresholds
+4. Monitor resource usage during tests
+5. Review results regularly
+6. Update tests as application evolves
+
+## Support
+
+- [k6 Documentation](https://k6.io/docs/)
+- [GitHub Actions Documentation](https://docs.github.com/en/actions)
+- Project-specific guides in `.github/k6/`

package/typescript/copy-overwrite/.github/workflows/lighthouse.yml

@@ -0,0 +1,68 @@
+name: 💡 Lighthouse CI
+
+on:
+  workflow_call:
+    inputs:
+      node_version:
+        description: 'Node.js version to use'
+        required: false
+        default: '20.x'
+        type: string
+      package_manager:
+        description: 'Package manager to use (npm, yarn, or bun)'
+        required: false
+        default: 'yarn'
+        type: string
+      target_branch:
+        description: 'Target branch for the PR (used to determine environment)'
+        required: false
+        default: 'staging'
+        type: string
+
+jobs:
+  lighthouse:
+    name: 💡 Performance Budget Check
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: 📥 Checkout repository
+        uses: actions/checkout@v4
+
+      - name: 🔧 Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ inputs.node_version }}
+          cache: ${{ inputs.package_manager != 'bun' && inputs.package_manager || '' }}
+
+      - name: 🍞 Setup Bun
+        if: inputs.package_manager == 'bun'
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: 📦 Install dependencies
+        run: |
+          if [ "${{ inputs.package_manager }}" = "npm" ]; then
+            npm ci
+          elif [ "${{ inputs.package_manager }}" = "yarn" ]; then
+            yarn install --frozen-lockfile
+          elif [ "${{ inputs.package_manager }}" = "bun" ]; then
+            bun install --frozen-lockfile
+          fi
+
+      - name: 🏗️ Build web export
+        run: ${{ inputs.package_manager }} run export:web
+        env:
+          TARGET_BRANCH: ${{ inputs.target_branch }}
+
+      - name: 💡 Run Lighthouse CI
+        run: ${{ inputs.package_manager }} run lighthouse:check
+
+      - name: 📊 Upload Lighthouse reports
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: lighthouse-reports
+          path: .lighthouseci/
+          retention-days: 30

package/typescript/copy-overwrite/.github/workflows/load-test.yml

@@ -0,0 +1,282 @@
+name: K6 Load Testing
+
+on:
+  workflow_call:
+    inputs:
+      environment:
+        description: 'Target environment to test'
+        required: true
+        type: string
+      test_scenario:
+        description: 'Test scenario to run (smoke, load, stress, spike, soak)'
+        required: false
+        type: string
+        default: 'smoke'
+      base_url:
+        description: 'Base URL of the application to test'
+        required: true
+        type: string
+      k6_version:
+        description: 'k6 version to use'
+        required: false
+        type: string
+        default: 'latest'
+      test_duration:
+        description: 'Override test duration (e.g., 5m, 1h)'
+        required: false
+        type: string
+      virtual_users:
+        description: 'Override number of virtual users'
+        required: false
+        type: number
+      thresholds_config:
+        description: 'Path to custom thresholds configuration'
+        required: false
+        type: string
+      test_script:
+        description: 'Path to custom k6 test script'
+        required: false
+        type: string
+        default: '.github/k6/scripts/default-test.js'
+      fail_on_threshold:
+        description: 'Fail workflow if thresholds are not met'
+        required: false
+        type: boolean
+        default: true
+      upload_results:
+        description: 'Upload test results as artifacts'
+        required: false
+        type: boolean
+        default: true
+      cloud_run:
+        description: 'Run tests on k6 Cloud (requires K6_CLOUD_TOKEN secret)'
+        required: false
+        type: boolean
+        default: false
+    outputs:
+      test_passed:
+        description: 'Whether the test passed all thresholds'
+        value: ${{ jobs.k6_test.outputs.passed }}
+      results_url:
+        description: 'URL to test results (if uploaded)'
+        value: ${{ jobs.k6_test.outputs.results_url }}
+      summary:
+        description: 'Test execution summary'
+        value: ${{ jobs.k6_test.outputs.summary }}
+    secrets:
+      K6_CLOUD_TOKEN:
+        required: false
+        description: 'k6 Cloud API token for cloud runs'
+      CUSTOM_HEADERS:
+        required: false
+        description: 'Custom headers for authenticated endpoints (JSON format)'
+
+jobs:
+  k6_test:
+    name: K6 Load Test - ${{ inputs.test_scenario }}
+    runs-on: ubuntu-latest
+    outputs:
+      passed: ${{ steps.run_test.outputs.passed }}
+      results_url: ${{ steps.upload_results.outputs.artifact-url }}
+      summary: ${{ steps.generate_summary.outputs.summary }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up k6
+        run: |
+          if [ "${{ inputs.k6_version }}" = "latest" ]; then
+            sudo gpg -k
+            sudo gpg --no-default-keyring \
+              --keyring /usr/share/keyrings/k6-archive-keyring.gpg \
+              --keyserver hkp://keyserver.ubuntu.com:80 \
+              --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
+            echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" \
+              | sudo tee /etc/apt/sources.list.d/k6.list
+            sudo apt-get update
+            sudo apt-get install k6
+          else
+            K6_VERSION="${{ inputs.k6_version }}"
+            wget "https://github.com/grafana/k6/releases/download/v${K6_VERSION}/k6-v${K6_VERSION}-linux-amd64.tar.gz"
+            tar -xzf "k6-v${K6_VERSION}-linux-amd64.tar.gz"
+            sudo mv "k6-v${K6_VERSION}-linux-amd64/k6" /usr/local/bin/
+          fi
+          k6 version
+
+      - name: Prepare test environment
+        id: prepare_test
+        run: |
+          # Create results directory
+          mkdir -p k6-results
+
+          # Export environment variables for k6
+          {
+            echo "K6_BASE_URL=${{ inputs.base_url }}"
+            echo "K6_SCENARIO=${{ inputs.test_scenario }}"
+            echo "K6_ENVIRONMENT=${{ inputs.environment }}"
+          } >> "$GITHUB_ENV"
+
+          # Set custom duration if provided
+          if [ -n "${{ inputs.test_duration }}" ]; then
+            echo "K6_DURATION=${{ inputs.test_duration }}" >> "$GITHUB_ENV"
+          fi
+
+          # Set custom VUs if provided
+          if [ -n "${{ inputs.virtual_users }}" ]; then
+            echo "K6_VUS=${{ inputs.virtual_users }}" >> "$GITHUB_ENV"
+          fi
+
+          # Set custom headers if provided
+          if [ -n "${{ secrets.CUSTOM_HEADERS }}" ]; then
+            echo "K6_CUSTOM_HEADERS=${{ secrets.CUSTOM_HEADERS }}" >> "$GITHUB_ENV"
+          fi
+
+          # Set cloud token if cloud run is enabled
+          if [ "${{ inputs.cloud_run }}" = "true" ] && [ -n "${{ secrets.K6_CLOUD_TOKEN }}" ]; then
+            echo "K6_CLOUD_TOKEN=${{ secrets.K6_CLOUD_TOKEN }}" >> "$GITHUB_ENV"
+          fi
+
+      - name: Run k6 test
+        id: run_test
+        run: |
+          set +e  # Don't exit immediately on error
+
+          # Use the shared runner script if a scenario is specified, otherwise use custom script
+          if [ "${{ inputs.test_script }}" = ".github/k6/scripts/default-test.js" ]; then
+            # Use shared runner for standard scenarios
+            RUNNER_ARGS="--scenario ${{ inputs.test_scenario }} --url ${{ inputs.base_url }} --json --csv"
+
+            # Add cloud option if enabled
+            if [ "${{ inputs.cloud_run }}" = "true" ]; then
+              RUNNER_ARGS="$RUNNER_ARGS --cloud"
+            fi
+
+            # Add duration override if provided
+            if [ -n "${{ inputs.test_duration }}" ]; then
+              RUNNER_ARGS="$RUNNER_ARGS --duration ${{ inputs.test_duration }}"
+            fi
+
+            # Add VUs override if provided
+            if [ -n "${{ inputs.virtual_users }}" ]; then
+              RUNNER_ARGS="$RUNNER_ARGS --vus ${{ inputs.virtual_users }}"
+            fi
+
+            # Add no-thresholds flag if needed
+            if [ "${{ inputs.fail_on_threshold }}" != "true" ]; then
+              RUNNER_ARGS="$RUNNER_ARGS --no-thresholds"
+            fi
+
+            echo "Running shared k6 runner: ./scripts/k6-run.sh $RUNNER_ARGS"
+            ./scripts/k6-run.sh $RUNNER_ARGS
+            TEST_EXIT_CODE=$?
+          else
+            # Use custom script directly with k6
+            TEST_SCRIPT="${{ inputs.test_script }}"
+
+            # Build k6 command
+            K6_CMD="k6 run"
+
+            # Add cloud option if enabled
+            if [ "${{ inputs.cloud_run }}" = "true" ]; then
+              K6_CMD="$K6_CMD --cloud"
+            fi
+
+            # Add output options for local runs
+            if [ "${{ inputs.cloud_run }}" != "true" ]; then
+              K6_CMD="$K6_CMD --out json=k6-results/results.json --out csv=k6-results/results.csv"
+            fi
+
+            # Add thresholds config if provided
+            if [ -n "${{ inputs.thresholds_config }}" ]; then
+              K6_CMD="$K6_CMD --config ${{ inputs.thresholds_config }}"
+            fi
+
+            # Add test script
+            K6_CMD="$K6_CMD $TEST_SCRIPT"
+
+            echo "Running k6 command: $K6_CMD"
+            $K6_CMD
+            TEST_EXIT_CODE=$?
+          fi
+
+          echo "exit_code=$TEST_EXIT_CODE" >> "$GITHUB_OUTPUT"
+
+          # Determine if test passed
+          if [ $TEST_EXIT_CODE -eq 0 ]; then
+            echo "passed=true" >> "$GITHUB_OUTPUT"
+            echo "✅ Test passed all thresholds" >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "passed=false" >> "$GITHUB_OUTPUT"
+            echo "❌ Test failed thresholds" >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+          # Exit with appropriate code based on fail_on_threshold setting
+          if [ "${{ inputs.fail_on_threshold }}" = "true" ] && [ $TEST_EXIT_CODE -ne 0 ]; then
+            exit $TEST_EXIT_CODE
+          fi
+
+      - name: Generate test summary
+        id: generate_summary
+        if: always()
+        run: |
+          # Create summary content
+          SUMMARY="# K6 Load Test Results\n\n"
+          SUMMARY+="**Environment:** ${{ inputs.environment }}\n"
+          SUMMARY+="**Test Scenario:** ${{ inputs.test_scenario }}\n"
+          SUMMARY+="**Base URL:** ${{ inputs.base_url }}\n"
+          SUMMARY+="**Test Status:** "
+
+          if [ "${{ steps.run_test.outputs.passed }}" = "true" ]; then
+            SUMMARY+="✅ PASSED\n"
+          else
+            SUMMARY+="❌ FAILED\n"
+          fi
+
+          # Add summary to GitHub Step Summary
+          echo -e "$SUMMARY" >> "$GITHUB_STEP_SUMMARY"
+
+          # Extract key metrics from results if available
+          if [ -f "k6-results/results.json" ]; then
+            echo -e "\n## Key Metrics\n" >> "$GITHUB_STEP_SUMMARY"
+
+            # Parse JSON results for key metrics (simplified example)
+            # In a real implementation, you'd use jq or similar to extract detailed metrics
+            echo "📊 Detailed metrics available in artifacts" >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+          # Output summary for workflow output
+          {
+            echo "summary<<EOF"
+            echo -e "$SUMMARY"
+            echo "EOF"
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Upload test results
+        id: upload_results
+        if: always() && inputs.upload_results
+        uses: actions/upload-artifact@v4
+        with:
+          name: k6-results-${{ inputs.environment }}-${{ inputs.test_scenario }}-${{ github.run_id }}
+          path: k6-results/
+          retention-days: 30
+
+      - name: Comment on PR
+        if: github.event_name == 'pull_request' && always()
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const summary = `${{ steps.generate_summary.outputs.summary }}`;
+            const resultsUrl = '${{ steps.upload_results.outputs.artifact-url }}';
+
+            let comment = summary;
+            if (resultsUrl) {
+              comment += `\n\n[📊 View detailed results](${resultsUrl})`;
+            }
+
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: comment
+            });