claude-autopm 2.12.3 → 3.0.1

package/packages/plugin-devops/test/commands/deployment-rollback.test.js

@@ -0,0 +1,299 @@
+/**
+ * Jest TDD Tests for /devops:deployment-rollback Command
+ *
+ * Tests validate the command structure, Context7 integration,
+ * rollback strategies, and platform support for deployment rollback.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+describe('/devops:deployment-rollback Command Structure Tests', () => {
+  const commandPath = path.join(__dirname, '../../commands/devops:deployment-rollback.md');
+  let commandContent;
+
+  beforeAll(() => {
+    // This test will initially fail (TDD Red phase)
+    if (fs.existsSync(commandPath)) {
+      commandContent = fs.readFileSync(commandPath, 'utf8');
+    }
+  });
+
+  test('command file should exist', () => {
+    expect(fs.existsSync(commandPath)).toBe(true);
+  });
+
+  describe('Required Sections', () => {
+    test('should have command title heading', () => {
+      expect(commandContent).toContain('# deployment-rollback');
+    });
+
+    test('should have Description section', () => {
+      expect(commandContent).toMatch(/## Description/i);
+    });
+
+    test('should have Required Documentation Access section', () => {
+      expect(commandContent).toContain('## Required Documentation Access');
+    });
+
+    test('should have Usage section', () => {
+      expect(commandContent).toMatch(/## Usage/i);
+    });
+
+    test('should have Options section', () => {
+      expect(commandContent).toMatch(/## Options/i);
+    });
+
+    test('should have Examples section', () => {
+      expect(commandContent).toMatch(/## Examples/i);
+    });
+
+    test('should have Implementation section', () => {
+      expect(commandContent).toMatch(/## Implementation/i);
+    });
+
+    test('should have Rollback Strategies section', () => {
+      expect(commandContent).toMatch(/## Rollback Strategies/i);
+    });
+  });
+
+  describe('Context7 Documentation Queries', () => {
+    test('should have MANDATORY documentation access statement', () => {
+      expect(commandContent).toContain('**MANDATORY:**');
+    });
+
+    test('should have Documentation Queries subsection', () => {
+      expect(commandContent).toContain('**Documentation Queries:**');
+    });
+
+    test('should include Kubernetes rollback documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/kubernetes\/deployments/);
+    });
+
+    test('should include Docker rollback documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/docker\/deployment/);
+    });
+
+    test('should include GitHub Actions deployment documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/github-actions\/deployment/);
+    });
+
+    test('should include AWS CodeDeploy documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/aws\/code-deploy/);
+    });
+
+    test('should include blue-green deployment documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/devops\/blue-green-deployment/);
+    });
+
+    test('should have "Why This is Required" explanation', () => {
+      expect(commandContent).toContain('**Why This is Required:**');
+    });
+  });
+
+  describe('Command Options', () => {
+    test('should support --strategy option for rollback strategy selection', () => {
+      expect(commandContent).toMatch(/--strategy.*rolling|instant|blue-green|canary/i);
+    });
+
+    test('should support --platform option for deployment platform', () => {
+      expect(commandContent).toMatch(/--platform.*kubernetes|docker|aws|azure|github/i);
+    });
+
+    test('should support --target version option', () => {
+      expect(commandContent).toMatch(/--target/i);
+    });
+
+    test('should support --namespace option for Kubernetes namespace', () => {
+      expect(commandContent).toMatch(/--namespace/i);
+    });
+
+    test('should support --reason option for rollback reason', () => {
+      expect(commandContent).toMatch(/--reason/i);
+    });
+
+    test('should support --dry-run option for validation', () => {
+      expect(commandContent).toMatch(/--dry-run/i);
+    });
+
+    test('should support --canary percentage option', () => {
+      expect(commandContent).toMatch(/--canary/i);
+    });
+
+    test('should support --duration option for gradual rollback', () => {
+      expect(commandContent).toMatch(/--duration/i);
+    });
+  });
+
+  describe('Rollback Strategies', () => {
+    test('should describe rolling rollback strategy', () => {
+      expect(commandContent).toMatch(/rolling.*rollback/i);
+      expect(commandContent).toMatch(/zero.*downtime|gradual/i);
+    });
+
+    test('should describe instant rollback strategy', () => {
+      expect(commandContent).toMatch(/instant.*rollback|emergency/i);
+    });
+
+    test('should describe blue-green switch strategy', () => {
+      expect(commandContent).toMatch(/blue.*green|traffic.*shift/i);
+    });
+
+    test('should describe canary rollback strategy', () => {
+      expect(commandContent).toMatch(/canary.*rollback|partial.*traffic/i);
+    });
+  });
+
+  describe('Platform Support', () => {
+    test('should include Kubernetes rollback implementation', () => {
+      expect(commandContent).toMatch(/kubectl.*rollout.*undo/i);
+    });
+
+    test('should include Docker service rollback implementation', () => {
+      expect(commandContent).toMatch(/docker.*service.*update.*--rollback/i);
+    });
+
+    test('should include GitHub Actions rerun implementation', () => {
+      expect(commandContent).toMatch(/re-run.*workflow|previous.*successful/i);
+    });
+
+    test('should include AWS deployment rollback implementation', () => {
+      expect(commandContent).toMatch(/aws.*deploy.*stop-deployment|redeploy/i);
+    });
+  });
+
+  describe('Pre-Rollback Checks', () => {
+    test('should verify target version exists', () => {
+      expect(commandContent).toMatch(/verify.*target.*version|version.*exists/i);
+    });
+
+    test('should check target version health', () => {
+      expect(commandContent).toMatch(/health.*target|historical.*metrics/i);
+    });
+
+    test('should estimate rollback impact', () => {
+      expect(commandContent).toMatch(/estimate.*impact|affected.*users/i);
+    });
+
+    test('should validate dependencies compatibility', () => {
+      expect(commandContent).toMatch(/dependenc.*compatibility|conflict/i);
+    });
+  });
+
+  describe('Post-Rollback Validation', () => {
+    test('should run automated smoke tests', () => {
+      expect(commandContent).toMatch(/smoke.*test|health.*check/i);
+    });
+
+    test('should monitor error rates', () => {
+      expect(commandContent).toMatch(/error.*rate|monitor/i);
+    });
+
+    test('should verify metrics returned to baseline', () => {
+      expect(commandContent).toMatch(/metrics.*baseline|verify.*metrics/i);
+    });
+
+    test('should check traffic distribution for canary', () => {
+      expect(commandContent).toMatch(/traffic.*distribution|canary/i);
+    });
+  });
+
+  describe('Examples Coverage', () => {
+    test('should provide basic rollback example', () => {
+      expect(commandContent).toMatch(/\/devops:deployment-rollback.*v\d+\.\d+\.\d+/);
+    });
+
+    test('should provide instant rollback example', () => {
+      expect(commandContent).toMatch(/\/devops:deployment-rollback.*--strategy.*instant/i);
+    });
+
+    test('should provide Kubernetes rollback example', () => {
+      expect(commandContent).toMatch(/\/devops:deployment-rollback.*--platform.*kubernetes/i);
+    });
+
+    test('should provide dry-run example', () => {
+      expect(commandContent).toMatch(/\/devops:deployment-rollback.*--dry-run/i);
+    });
+
+    test('should provide canary rollback example', () => {
+      expect(commandContent).toMatch(/\/devops:deployment-rollback.*--canary/i);
+    });
+  });
+
+  describe('Output Format', () => {
+    test('should show current and target version', () => {
+      expect(commandContent).toMatch(/Current.*v\d+|Target.*v\d+/);
+    });
+
+    test('should display pre-flight check results', () => {
+      expect(commandContent).toMatch(/Pre-Flight.*Check|✓.*target.*version/i);
+    });
+
+    test('should show rollback strategy and estimated time', () => {
+      expect(commandContent).toMatch(/Rollback.*Strategy/i);
+      expect(commandContent).toMatch(/estimated.*time/i);
+    });
+
+    test('should display rollback progress', () => {
+      expect(commandContent).toMatch(/Executing.*Rollback|progress|pods.*updated/i);
+    });
+
+    test('should show validation metrics', () => {
+      expect(commandContent).toMatch(/Error.*rate.*→|Latency.*p95/i);
+    });
+
+    test('should indicate documentation location', () => {
+      expect(commandContent).toMatch(/Report.*saved.*incident/i);
+    });
+  });
+
+  describe('Implementation Details', () => {
+    test('should reference github-operations-specialist agent', () => {
+      expect(commandContent).toMatch(/@github-operations-specialist/i);
+    });
+
+    test('should reference kubernetes-orchestrator agent', () => {
+      expect(commandContent).toMatch(/@kubernetes-orchestrator/i);
+    });
+
+    test('should reference aws-cloud-architect agent', () => {
+      expect(commandContent).toMatch(/@aws-cloud-architect/i);
+    });
+
+    test('should include rollback timeline tracking', () => {
+      expect(commandContent).toMatch(/timeline|Duration|duration/);
+    });
+
+    test('should include rollback documentation generation', () => {
+      expect(commandContent).toMatch(/Generate.*report|documentation/i);
+    });
+  });
+
+  describe('Best Practices', () => {
+    test('should mention zero-downtime rollback', () => {
+      expect(commandContent).toMatch(/zero.*downtime/i);
+    });
+
+    test('should include automated validation', () => {
+      expect(commandContent).toMatch(/automated.*validation|smoke.*test/i);
+    });
+
+    test('should mention incident documentation', () => {
+      expect(commandContent).toMatch(/incident.*report|documentation/i);
+    });
+
+    test('should include rollback verification', () => {
+      expect(commandContent).toMatch(/verif.*rollback|validation/i);
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should address rollback failure scenarios', () => {
+      expect(commandContent).toMatch(/rollback.*fail|emergency|manual/i);
+    });
+
+    test('should provide troubleshooting guidance', () => {
+      expect(commandContent).toMatch(/troubleshoot/i);
+    });
+  });
+});

package/packages/plugin-devops/test/commands/incident-response.test.js

@@ -0,0 +1,285 @@
+/**
+ * Jest TDD Tests for /devops:incident-response Command
+ *
+ * Tests validate the command structure, Context7 integration,
+ * incident severity workflows, and automated diagnostics completeness.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+describe('/devops:incident-response Command Structure Tests', () => {
+  const commandPath = path.join(__dirname, '../../commands/devops:incident-response.md');
+  let commandContent;
+
+  beforeAll(() => {
+    // This test will initially fail (TDD Red phase)
+    if (fs.existsSync(commandPath)) {
+      commandContent = fs.readFileSync(commandPath, 'utf8');
+    }
+  });
+
+  test('command file should exist', () => {
+    expect(fs.existsSync(commandPath)).toBe(true);
+  });
+
+  describe('Required Sections', () => {
+    test('should have command title heading', () => {
+      expect(commandContent).toContain('# devops:incident-response');
+    });
+
+    test('should have Description section', () => {
+      expect(commandContent).toMatch(/## Description/i);
+    });
+
+    test('should have Required Documentation Access section', () => {
+      expect(commandContent).toContain('## Required Documentation Access');
+    });
+
+    test('should have Usage section', () => {
+      expect(commandContent).toMatch(/## Usage/i);
+    });
+
+    test('should have Options section', () => {
+      expect(commandContent).toMatch(/## Options/i);
+    });
+
+    test('should have Examples section', () => {
+      expect(commandContent).toMatch(/## Examples/i);
+    });
+
+    test('should have Implementation section', () => {
+      expect(commandContent).toMatch(/## Implementation/i);
+    });
+  });
+
+  describe('Context7 Documentation Queries', () => {
+    test('should have MANDATORY documentation access statement', () => {
+      expect(commandContent).toContain('**MANDATORY:**');
+    });
+
+    test('should have Documentation Queries subsection', () => {
+      expect(commandContent).toContain('**Documentation Queries:**');
+    });
+
+    test('should include incident management documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/observability\/incident-management/);
+    });
+
+    test('should include Kubernetes troubleshooting documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/kubernetes\/troubleshooting/);
+    });
+
+    test('should include Prometheus alerting documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/prometheus\/alerting/);
+    });
+
+    test('should include distributed tracing documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/distributed-tracing\/debugging/);
+    });
+
+    test('should include runbook automation documentation query', () => {
+      expect(commandContent).toMatch(/mcp:\/\/context7\/devops\/runbooks/);
+    });
+
+    test('should have "Why This is Required" explanation', () => {
+      expect(commandContent).toContain('**Why This is Required:**');
+    });
+  });
+
+  describe('Severity Classification Options', () => {
+    test('should support --severity option for P0/P1/P2/P3 classification', () => {
+      expect(commandContent).toMatch(/--severity.*critical|high|medium|low/i);
+    });
+
+    test('should document P0 (Critical) severity workflow', () => {
+      expect(commandContent).toMatch(/P0.*Critical/i);
+    });
+
+    test('should document P1 (High) severity workflow', () => {
+      expect(commandContent).toMatch(/P1.*High/i);
+    });
+
+    test('should document P2 (Medium) severity workflow', () => {
+      expect(commandContent).toMatch(/P2.*Medium/i);
+    });
+
+    test('should document P3 (Low) severity workflow', () => {
+      expect(commandContent).toMatch(/P3.*Low/i);
+    });
+  });
+
+  describe('Command Options', () => {
+    test('should support --service option for specifying affected service', () => {
+      expect(commandContent).toMatch(/--service/i);
+    });
+
+    test('should support --symptoms option for describing incident symptoms', () => {
+      expect(commandContent).toMatch(/--symptoms/i);
+    });
+
+    test('should support --analyze-deployment option for deployment analysis', () => {
+      expect(commandContent).toMatch(/--analyze-deployment/i);
+    });
+
+    test('should support --rollback option for automated rollback', () => {
+      expect(commandContent).toMatch(/--rollback/i);
+    });
+
+    test('should support --target option for rollback target version', () => {
+      expect(commandContent).toMatch(/--target/i);
+    });
+
+    test('should support --namespace option for Kubernetes namespace', () => {
+      expect(commandContent).toMatch(/--namespace/i);
+    });
+  });
+
+  describe('Automated Diagnostics Features', () => {
+    test('should include service health checks (K8s pods)', () => {
+      expect(commandContent).toMatch(/service.*health.*check|pod.*status/i);
+    });
+
+    test('should include deployment analysis (last 4 hours)', () => {
+      expect(commandContent).toMatch(/deployment.*analysis|recent.*deployment/i);
+    });
+
+    test('should include error log correlation', () => {
+      expect(commandContent).toMatch(/error.*log|log.*correlation/i);
+    });
+
+    test('should include metrics anomaly detection', () => {
+      expect(commandContent).toMatch(/metrics.*anomaly|anomaly.*detection/i);
+    });
+
+    test('should include distributed tracing analysis', () => {
+      expect(commandContent).toMatch(/distributed.*tracing|trace.*analysis/i);
+    });
+
+    test('should include dependency health checks', () => {
+      expect(commandContent).toMatch(/dependency.*health|dependency.*check/i);
+    });
+  });
+
+  describe('Decision Logic and Troubleshooting', () => {
+    test('should include rollback vs hotfix recommendation logic', () => {
+      expect(commandContent).toMatch(/rollback.*recommendation|rollback.*hotfix/i);
+    });
+
+    test('should include impact assessment (affected users)', () => {
+      expect(commandContent).toMatch(/impact.*assessment|affected.*user/i);
+    });
+
+    test('should include timeline documentation', () => {
+      expect(commandContent).toMatch(/timeline|incident.*timeline/i);
+    });
+
+    test('should include decision tree based on symptoms', () => {
+      expect(commandContent).toMatch(/decision.*tree|troubleshoot.*workflow/i);
+    });
+  });
+
+  describe('Implementation Details', () => {
+    test('should reference observability-engineer agent', () => {
+      expect(commandContent).toMatch(/@observability-engineer/);
+    });
+
+    test('should reference kubernetes-orchestrator agent', () => {
+      expect(commandContent).toMatch(/@kubernetes-orchestrator/);
+    });
+
+    test('should reference docker-containerization-expert agent', () => {
+      expect(commandContent).toMatch(/@docker-containerization-expert/);
+    });
+
+    test('should include kubectl commands for pod diagnostics', () => {
+      expect(commandContent).toMatch(/kubectl.*get.*pods|kubectl.*logs/i);
+    });
+
+    test('should include Prometheus queries for metrics', () => {
+      expect(commandContent).toMatch(/Prometheus.*quer/i);
+    });
+
+    test('should include deployment history analysis', () => {
+      expect(commandContent).toMatch(/git.*log|deployment.*history/i);
+    });
+  });
+
+  describe('Examples Coverage', () => {
+    test('should provide critical severity incident example', () => {
+      expect(commandContent).toMatch(/\/devops:incident-response.*--severity.*critical/i);
+    });
+
+    test('should provide service-specific incident example', () => {
+      expect(commandContent).toMatch(/\/devops:incident-response.*--service/i);
+    });
+
+    test('should provide deployment analysis example', () => {
+      expect(commandContent).toMatch(/\/devops:incident-response.*--analyze-deployment/i);
+    });
+
+    test('should provide rollback example', () => {
+      expect(commandContent).toMatch(/\/devops:incident-response.*--rollback/i);
+    });
+  });
+
+  describe('Output Format', () => {
+    test('should include incident severity in output format', () => {
+      expect(commandContent).toMatch(/INCIDENT RESPONSE.*P0.*CRITICAL/i);
+    });
+
+    test('should include service health status in output', () => {
+      expect(commandContent).toMatch(/Service Health/i);
+    });
+
+    test('should include timeline in output', () => {
+      expect(commandContent).toMatch(/Timeline/i);
+    });
+
+    test('should include recommended action in output', () => {
+      expect(commandContent).toMatch(/Recommended Action|ROLLBACK/i);
+    });
+
+    test('should include investigation findings in output', () => {
+      expect(commandContent).toMatch(/Investigation Findings/i);
+    });
+
+    test('should include next steps checklist in output', () => {
+      expect(commandContent).toMatch(/Next Steps/i);
+    });
+  });
+
+  describe('Post-Mortem Features', () => {
+    test('should include RCA (Root Cause Analysis) documentation', () => {
+      expect(commandContent).toMatch(/RCA|root.*cause.*analysis|post.*mortem/i);
+    });
+
+    test('should include communication templates for stakeholders', () => {
+      expect(commandContent).toMatch(/communication.*template|status.*update/i);
+    });
+  });
+
+  describe('Best Practices', () => {
+    test('should mention incident command structure', () => {
+      expect(commandContent).toMatch(/incident.*command|on-call/i);
+    });
+
+    test('should include escalation workflows', () => {
+      expect(commandContent).toMatch(/escalation/i);
+    });
+
+    test('should mention automated remediation', () => {
+      expect(commandContent).toMatch(/automated.*remediation|auto.*rollback/i);
+    });
+
+    test('should include confidence scoring for recommendations', () => {
+      expect(commandContent).toMatch(/confidence|probability/i);
+    });
+  });
+
+  describe('Related Commands', () => {
+    test('should reference related monitoring commands', () => {
+      expect(commandContent).toMatch(/Related Commands/i);
+    });
+  });
+});