@codyswann/lisa 1.0.0

package/typescript/copy-overwrite/.github/k6/examples/customer-deploy-integration.yml

@@ -0,0 +1,115 @@
+name: Deploy and Test
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: 'Deployment environment'
+        required: true
+        type: choice
+        options:
+          - staging
+          - production
+        default: staging
+
+jobs:
+  # Example: Using the release workflow
+  release:
+    uses: ./.github/workflows/release.yml
+    with:
+      environment: ${{ github.event.inputs.environment || 'staging' }}
+    secrets: inherit
+
+  # Customer-specific deployment steps
+  deploy:
+    needs: release
+    runs-on: ubuntu-latest
+    outputs:
+      app_url: ${{ steps.deploy.outputs.url }}
+    steps:
+      - name: Deploy to environment
+        id: deploy
+        run: |
+          # Your deployment logic here
+          echo "Deploying to ${{ github.event.inputs.environment || 'staging' }}..."
+
+          # Example output - replace with actual deployment URL
+          if [ "${{ github.event.inputs.environment || 'staging' }}" = "production" ]; then
+            echo "url=https://api.example.com" >> $GITHUB_OUTPUT
+          else
+            echo "url=https://staging.api.example.com" >> $GITHUB_OUTPUT
+          fi
+
+  # Run smoke test immediately after deployment
+  smoke_test:
+    needs: deploy
+    uses: ./.github/workflows/k6-load-test.yml
+    with:
+      environment: ${{ github.event.inputs.environment || 'staging' }}
+      test_scenario: smoke
+      base_url: ${{ needs.deploy.outputs.app_url }}
+      fail_on_threshold: true
+    secrets: inherit
+
+  # Run load test only if smoke test passes
+  load_test:
+    needs: [deploy, smoke_test]
+    uses: ./.github/workflows/k6-load-test.yml
+    with:
+      environment: ${{ github.event.inputs.environment || 'staging' }}
+      test_scenario: load
+      base_url: ${{ needs.deploy.outputs.app_url }}
+      fail_on_threshold: false # Don't fail deployment, just report
+      virtual_users: 20 # Override default VUs
+    secrets: inherit
+
+  # Optional: Run stress test for staging only
+  stress_test:
+    if: github.event.inputs.environment != 'production'
+    needs: [deploy, smoke_test]
+    uses: ./.github/workflows/k6-load-test.yml
+    with:
+      environment: ${{ github.event.inputs.environment || 'staging' }}
+      test_scenario: stress
+      base_url: ${{ needs.deploy.outputs.app_url }}
+      fail_on_threshold: false
+      upload_results: true
+    secrets: inherit
+
+  # Summary of all tests
+  test_summary:
+    needs: [smoke_test, load_test, stress_test]
+    if: always()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Test Results Summary
+        run: |
+          echo "## 📊 Performance Test Summary" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+
+          echo "### Smoke Test" >> $GITHUB_STEP_SUMMARY
+          if [ "${{ needs.smoke_test.outputs.test_passed }}" = "true" ]; then
+            echo "✅ **PASSED**" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "❌ **FAILED**" >> $GITHUB_STEP_SUMMARY
+          fi
+          echo "" >> $GITHUB_STEP_SUMMARY
+
+          echo "### Load Test" >> $GITHUB_STEP_SUMMARY
+          if [ "${{ needs.load_test.outputs.test_passed }}" = "true" ]; then
+            echo "✅ **PASSED**" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "⚠️ **FAILED** (non-blocking)" >> $GITHUB_STEP_SUMMARY
+          fi
+          echo "" >> $GITHUB_STEP_SUMMARY
+
+          if [ "${{ github.event.inputs.environment }}" != "production" ]; then
+            echo "### Stress Test" >> $GITHUB_STEP_SUMMARY
+            if [ "${{ needs.stress_test.outputs.test_passed }}" = "true" ]; then
+              echo "✅ **PASSED**" >> $GITHUB_STEP_SUMMARY
+            else
+              echo "⚠️ **FAILED** (non-blocking)" >> $GITHUB_STEP_SUMMARY
+            fi
+          fi

package/typescript/copy-overwrite/.github/k6/examples/data-driven-test.js

@@ -0,0 +1,268 @@
+import http from "k6/http";
+import { check, group } from "k6";
+import { SharedArray } from "k6/data";
+import papaparse from "https://jslib.k6.io/papaparse/5.1.1/index.js";
+import { randomItem } from "https://jslib.k6.io/k6-utils/1.2.0/index.js";
+
+// Load test data from CSV file
+const testUsers = new SharedArray("users", function () {
+  // In a real scenario, this would load from a CSV file
+  // For this example, we'll create sample data
+  return [
+    { username: "user1", password: "pass1", role: "admin" },
+    { username: "user2", password: "pass2", role: "user" },
+    { username: "user3", password: "pass3", role: "user" },
+    { username: "user4", password: "pass4", role: "moderator" },
+    { username: "user5", password: "pass5", role: "user" },
+  ];
+});
+
+// Load test scenarios from JSON
+const testScenarios = new SharedArray("scenarios", function () {
+  return [
+    {
+      name: "Browse Products",
+      endpoints: ["/products", "/products/featured", "/products/categories"],
+      expectedStatus: 200,
+    },
+    {
+      name: "Search Products",
+      endpoints: ["/search?q=laptop", "/search?q=phone", "/search?q=tablet"],
+      expectedStatus: 200,
+    },
+    {
+      name: "View Product Details",
+      endpoints: ["/products/1", "/products/2", "/products/3"],
+      expectedStatus: 200,
+    },
+    {
+      name: "Add to Cart",
+      endpoints: ["/cart/add"],
+      method: "POST",
+      expectedStatus: 201,
+    },
+  ];
+});
+
+// Environment-specific configuration
+const environments = {
+  dev: {
+    baseUrl: "https://dev.example.com",
+    timeout: "30s",
+    thinkTime: 1,
+  },
+  staging: {
+    baseUrl: "https://staging.example.com",
+    timeout: "20s",
+    thinkTime: 2,
+  },
+  production: {
+    baseUrl: "https://api.example.com",
+    timeout: "10s",
+    thinkTime: 3,
+  },
+};
+
+const ENV = __ENV.K6_ENVIRONMENT || "staging";
+const config = environments[ENV];
+
+export const options = {
+  scenarios: {
+    data_driven: {
+      executor: "ramping-arrival-rate",
+      startRate: 10,
+      timeUnit: "1m",
+      preAllocatedVUs: 10,
+      maxVUs: 50,
+      stages: [
+        { duration: "2m", target: 30 },
+        { duration: "5m", target: 30 },
+        { duration: "2m", target: 0 },
+      ],
+    },
+  },
+  thresholds: {
+    http_req_failed: ["rate<0.1"],
+    http_req_duration: [`p(95)<${parseInt(config.timeout) * 100}`],
+  },
+};
+
+// Helper function to login and get auth token
+function authenticateUser(user) {
+  const loginResponse = http.post(
+    `${config.baseUrl}/auth/login`,
+    JSON.stringify({
+      username: user.username,
+      password: user.password,
+    }),
+    {
+      headers: { "Content-Type": "application/json" },
+      timeout: config.timeout,
+    }
+  );
+
+  if (check(loginResponse, { "login successful": r => r.status === 200 })) {
+    const body = JSON.parse(loginResponse.body);
+    return body.token || body.access_token;
+  }
+
+  return null;
+}
+
+export default function () {
+  // Select random user and scenario
+  const user = randomItem(testUsers);
+  const scenario = randomItem(testScenarios);
+
+  // Authenticate if needed
+  let authToken = null;
+  if (user.role !== "guest") {
+    authToken = authenticateUser(user);
+
+    if (!authToken) {
+      console.error(`Failed to authenticate user: ${user.username}`);
+      return;
+    }
+  }
+
+  // Execute scenario
+  group(`${scenario.name} - ${user.role}`, () => {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": `k6-test/${ENV}`,
+    };
+
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+
+    scenario.endpoints.forEach(endpoint => {
+      const method = scenario.method || "GET";
+      const url = `${config.baseUrl}${endpoint}`;
+
+      let response;
+      if (method === "POST") {
+        // Generate dynamic payload based on endpoint
+        const payload = generatePayload(endpoint, user);
+        response = http.post(url, JSON.stringify(payload), {
+          headers,
+          timeout: config.timeout,
+        });
+      } else {
+        response = http.get(url, { headers, timeout: config.timeout });
+      }
+
+      check(response, {
+        [`${scenario.name} - status is ${scenario.expectedStatus}`]: r =>
+          r.status === scenario.expectedStatus,
+        "response time acceptable": r =>
+          r.timings.duration < parseInt(config.timeout) * 100,
+      });
+
+      // Custom validation based on role
+      if (user.role === "admin") {
+        check(response, {
+          "admin data present": r => {
+            try {
+              const body = JSON.parse(r.body);
+              return (
+                body.adminData !== undefined || body.permissions !== undefined
+              );
+            } catch (e) {
+              return true; // Skip check if not JSON
+            }
+          },
+        });
+      }
+    });
+  });
+
+  // Dynamic think time based on environment
+  sleep(config.thinkTime + Math.random() * 2);
+}
+
+// Generate dynamic payload based on endpoint and user
+function generatePayload(endpoint, user) {
+  if (endpoint.includes("/cart/add")) {
+    return {
+      productId: Math.floor(Math.random() * 100) + 1,
+      quantity: Math.floor(Math.random() * 3) + 1,
+      userId: user.username,
+    };
+  }
+
+  if (endpoint.includes("/order")) {
+    return {
+      items: [
+        {
+          productId: Math.floor(Math.random() * 100) + 1,
+          quantity: Math.floor(Math.random() * 3) + 1,
+        },
+      ],
+      shippingAddress: {
+        street: "123 Test St",
+        city: "Test City",
+        country: "Test Country",
+      },
+      paymentMethod: "test_card",
+    };
+  }
+
+  return {};
+}
+
+export function handleSummary(data) {
+  const { metrics } = data;
+
+  // Group results by user role
+  const roleMetrics = {};
+  testUsers.forEach(user => {
+    // This is simplified - in reality, you'd parse metrics by tags
+    roleMetrics[user.role] = {
+      requests: Math.floor(
+        (metrics.http_reqs?.values?.count || 0) / testUsers.length
+      ),
+      errors: Math.floor(
+        (metrics.http_req_failed?.values?.passes || 0) / testUsers.length
+      ),
+    };
+  });
+
+  const summary = {
+    environment: ENV,
+    timestamp: new Date().toISOString(),
+    total_requests: metrics.http_reqs?.values?.count || 0,
+    failed_requests: metrics.http_req_failed?.values?.passes || 0,
+    avg_response_time: Math.round(metrics.http_req_duration?.values?.avg || 0),
+    by_role: roleMetrics,
+    scenarios_tested: testScenarios.length,
+    users_tested: testUsers.length,
+  };
+
+  return {
+    "k6-results/data-driven-summary.json": JSON.stringify(summary, null, 2),
+    stdout: createDataDrivenSummary(summary),
+  };
+}
+
+function createDataDrivenSummary(summary) {
+  let text = "\n=== Data-Driven Test Summary ===\n\n";
+  text += `Environment: ${summary.environment}\n`;
+  text += `Timestamp: ${summary.timestamp}\n`;
+  text += `Scenarios Tested: ${summary.scenarios_tested}\n`;
+  text += `Users Tested: ${summary.users_tested}\n\n`;
+
+  text += "Overall Results:\n";
+  text += `  Total Requests: ${summary.total_requests}\n`;
+  text += `  Failed Requests: ${summary.failed_requests}\n`;
+  text += `  Avg Response Time: ${summary.avg_response_time}ms\n\n`;
+
+  text += "Results by Role:\n";
+  Object.entries(summary.by_role).forEach(([role, metrics]) => {
+    text += `  ${role}:\n`;
+    text += `    Requests: ${metrics.requests}\n`;
+    text += `    Errors: ${metrics.errors}\n`;
+  });
+
+  return text;
+}

package/typescript/copy-overwrite/.github/k6/scenarios/load.js

@@ -0,0 +1,142 @@
+import http from "k6/http";
+import { check, group, sleep } from "k6";
+import { Rate } from "k6/metrics";
+
+// Custom metrics
+const errorRate = new Rate("errors");
+const apiErrors = new Rate("api_errors");
+
+export const options = {
+  stages: [
+    { duration: "2m", target: 10 }, // Ramp up to 10 users
+    { duration: "5m", target: 10 }, // Stay at 10 users
+    { duration: "2m", target: 0 }, // Ramp down to 0 users
+  ],
+  thresholds: {
+    http_req_failed: ["rate<0.05"], // http errors should be less than 5%
+    http_req_duration: ["p(95)<500"], // 95% of requests should be below 500ms
+    http_req_duration: ["p(99)<1000"], // 99% of requests should be below 1s
+    errors: ["rate<0.05"], // custom errors should be less than 5%
+    api_errors: ["rate<0.02"], // API errors should be less than 2%
+  },
+};
+
+const BASE_URL = __ENV.K6_BASE_URL || "http://localhost:3000";
+const CUSTOM_HEADERS = __ENV.K6_CUSTOM_HEADERS
+  ? JSON.parse(__ENV.K6_CUSTOM_HEADERS)
+  : {};
+
+export default function () {
+  const headers = {
+    "Content-Type": "application/json",
+    ...CUSTOM_HEADERS,
+  };
+
+  // User flow simulation
+  group("Homepage Load", () => {
+    const homeResponse = http.get(`${BASE_URL}/`, {
+      headers,
+      tags: { name: "Home" },
+    });
+    check(homeResponse, {
+      "homepage status is 200": r => r.status === 200,
+      "homepage loads quickly": r => r.timings.duration < 300,
+    }) || errorRate.add(1);
+    sleep(1);
+  });
+
+  group("API Health Check", () => {
+    const healthResponse = http.get(`${BASE_URL}/health`, {
+      headers,
+      tags: { name: "Health" },
+    });
+    check(healthResponse, {
+      "health check is healthy": r => r.status === 200,
+      "health check is fast": r => r.timings.duration < 100,
+    }) || errorRate.add(1);
+    sleep(0.5);
+  });
+
+  group("API Operations", () => {
+    // GET request
+    const getResponse = http.get(`${BASE_URL}/api/items`, {
+      headers,
+      tags: { name: "API_GET" },
+    });
+
+    const getCheck = check(getResponse, {
+      "GET status is 200": r => r.status === 200,
+      "GET response has data": r => {
+        try {
+          const body = JSON.parse(r.body);
+          return body && (Array.isArray(body) || body.data);
+        } catch (e) {
+          return false;
+        }
+      },
+      "GET response time OK": r => r.timings.duration < 500,
+    });
+
+    if (!getCheck) {
+      apiErrors.add(1);
+    }
+
+    sleep(1);
+
+    // POST request (if applicable)
+    const payload = JSON.stringify({
+      name: `Test Item ${Date.now()}`,
+      value: Math.random() * 100,
+    });
+
+    const postResponse = http.post(`${BASE_URL}/api/items`, payload, {
+      headers,
+      tags: { name: "API_POST" },
+    });
+
+    const postCheck = check(postResponse, {
+      "POST status is 201 or 200": r => r.status === 201 || r.status === 200,
+      "POST returns created item": r => {
+        try {
+          const body = JSON.parse(r.body);
+          return body && body.id;
+        } catch (e) {
+          return false;
+        }
+      },
+      "POST response time OK": r => r.timings.duration < 800,
+    });
+
+    if (!postCheck) {
+      apiErrors.add(1);
+    }
+
+    sleep(2);
+  });
+
+  // Simulate user think time between iterations
+  sleep(Math.random() * 3 + 2); // 2-5 seconds
+}
+
+export function handleSummary(data) {
+  return {
+    "k6-results/load-summary.json": JSON.stringify(data),
+    stdout: textSummary(data, { indent: " ", enableColors: true }),
+  };
+}
+
+function textSummary(data, options) {
+  // Custom summary function for better console output
+  const { metrics } = data;
+  let summary = "\n=== Load Test Summary ===\n\n";
+
+  if (metrics) {
+    summary += `Total Requests: ${metrics.http_reqs?.values?.count || 0}\n`;
+    summary += `Failed Requests: ${metrics.http_req_failed?.values?.passes || 0}\n`;
+    summary += `Avg Response Time: ${Math.round(metrics.http_req_duration?.values?.avg || 0)}ms\n`;
+    summary += `95th Percentile: ${Math.round(metrics.http_req_duration?.values["p(95)"] || 0)}ms\n`;
+    summary += `99th Percentile: ${Math.round(metrics.http_req_duration?.values["p(99)"] || 0)}ms\n`;
+  }
+
+  return summary;
+}

package/typescript/copy-overwrite/.github/k6/scenarios/load.json

@@ -0,0 +1,27 @@
+{
+  "name": "load",
+  "description": "Standard load test with normal expected traffic",
+  "executor": "ramping-vus",
+  "startVUs": 0,
+  "stages": [
+    { "duration": "2m", "target": 10 },
+    { "duration": "5m", "target": 10 },
+    { "duration": "2m", "target": 0 }
+  ],
+  "gracefulStop": "30s",
+  "thresholds": {
+    "http_req_failed": ["rate<0.05"],
+    "http_req_duration": ["p(95)<500", "p(99)<1000"],
+    "http_req_receiving": ["p(95)<300"],
+    "checks": ["rate>0.9"],
+    "iterations": ["count>100"]
+  },
+  "env": {
+    "SCENARIO_NAME": "load",
+    "STEADY_STATE_DURATION": "5m"
+  },
+  "tags": {
+    "test_type": "load",
+    "environment": "${K6_ENVIRONMENT}"
+  }
+}

package/typescript/copy-overwrite/.github/k6/scenarios/smoke.js

@@ -0,0 +1,26 @@
+import http from "k6/http";
+import { check, sleep } from "k6";
+
+export const options = {
+  vus: 1,
+  duration: "1m",
+  thresholds: {
+    http_req_failed: ["rate<0.01"], // http errors should be less than 1%
+    http_req_duration: ["p(95)<300"], // 95% of requests should be below 300ms
+  },
+};
+
+const BASE_URL = __ENV.K6_BASE_URL || "http://localhost:3000";
+
+export default function () {
+  // Smoke test - minimal load to verify system is working
+  const response = http.get(`${BASE_URL}/health`);
+
+  check(response, {
+    "status is 200": r => r.status === 200,
+    "response time < 300ms": r => r.timings.duration < 300,
+    "response has body": r => r.body.length > 0,
+  });
+
+  sleep(1);
+}

package/typescript/copy-overwrite/.github/k6/scenarios/smoke.json

@@ -0,0 +1,20 @@
+{
+  "name": "smoke",
+  "description": "Minimal load test to verify basic functionality",
+  "executor": "constant-vus",
+  "vus": 1,
+  "duration": "1m",
+  "thresholds": {
+    "http_req_failed": ["rate<0.01"],
+    "http_req_duration": ["p(95)<300", "p(99)<500"],
+    "checks": ["rate>0.95"]
+  },
+  "env": {
+    "SCENARIO_NAME": "smoke",
+    "RAMP_TIME": "10s"
+  },
+  "tags": {
+    "test_type": "smoke",
+    "environment": "${K6_ENVIRONMENT}"
+  }
+}