sofia-cli 0.1.1

package/tests/unit/develop/templateRegistry.spec.ts

@@ -0,0 +1,106 @@
+/**
+ * Unit tests for templateRegistry.
+ *
+ * T033: selectTemplate returns python-pytest for Python plans
+ * T034: selectTemplate returns node-ts-vitest for TypeScript plans
+ * T035: selectTemplate returns default for ambiguous plans
+ */
+import { describe, it, expect } from 'vitest';
+
+import {
+  selectTemplate,
+  createDefaultRegistry,
+  NODE_TS_VITEST_TEMPLATE,
+  PYTHON_PYTEST_TEMPLATE,
+} from '../../../src/develop/templateRegistry.js';
+
+describe('selectTemplate', () => {
+  const registry = createDefaultRegistry();
+
+  it('returns python-pytest for plans mentioning "Python"', () => {
+    const result = selectTemplate(registry, 'Python 3.11 + FastAPI backend');
+    expect(result.id).toBe('python-pytest');
+  });
+
+  it('returns python-pytest for plans mentioning "FastAPI"', () => {
+    const result = selectTemplate(registry, 'A FastAPI-based REST API');
+    expect(result.id).toBe('python-pytest');
+  });
+
+  it('returns python-pytest for plans with "flask" in dependencies', () => {
+    const result = selectTemplate(registry, undefined, ['flask', 'redis']);
+    expect(result.id).toBe('python-pytest');
+  });
+
+  it('returns python-pytest for plans with "django" dependency', () => {
+    const result = selectTemplate(registry, undefined, ['django']);
+    expect(result.id).toBe('python-pytest');
+  });
+
+  it('returns node-ts-vitest for plans mentioning "TypeScript"', () => {
+    const result = selectTemplate(registry, 'TypeScript + Express backend');
+    expect(result.id).toBe('node-ts-vitest');
+  });
+
+  it('returns node-ts-vitest for plans mentioning "Node"', () => {
+    const result = selectTemplate(registry, 'Node.js microservice');
+    expect(result.id).toBe('node-ts-vitest');
+  });
+
+  it('returns node-ts-vitest for plans with no architecture notes (default)', () => {
+    const result = selectTemplate(registry);
+    expect(result.id).toBe('node-ts-vitest');
+  });
+
+  it('returns default node-ts-vitest for ambiguous plans', () => {
+    const result = selectTemplate(registry, 'A machine learning pipeline using GPT');
+    expect(result.id).toBe('node-ts-vitest');
+  });
+
+  it('performs case-insensitive matching', () => {
+    const result = selectTemplate(registry, 'PYTHON and FASTAPI');
+    expect(result.id).toBe('python-pytest');
+  });
+});
+
+describe('NODE_TS_VITEST_TEMPLATE', () => {
+  it('has correct id and match patterns', () => {
+    expect(NODE_TS_VITEST_TEMPLATE.id).toBe('node-ts-vitest');
+    expect(NODE_TS_VITEST_TEMPLATE.installCommand).toBe('npm install');
+    expect(NODE_TS_VITEST_TEMPLATE.testCommand).toBe('npm test -- --reporter=json');
+    expect(NODE_TS_VITEST_TEMPLATE.matchPatterns).toContain('typescript');
+  });
+
+  it('includes .sofia-metadata.json in files', () => {
+    const paths = NODE_TS_VITEST_TEMPLATE.files.map((f) => f.path);
+    expect(paths).toContain('.sofia-metadata.json');
+  });
+});
+
+describe('PYTHON_PYTEST_TEMPLATE', () => {
+  it('has correct id and match patterns', () => {
+    expect(PYTHON_PYTEST_TEMPLATE.id).toBe('python-pytest');
+    expect(PYTHON_PYTEST_TEMPLATE.installCommand).toBe('pip install -r requirements.txt');
+    expect(PYTHON_PYTEST_TEMPLATE.matchPatterns).toContain('python');
+    expect(PYTHON_PYTEST_TEMPLATE.matchPatterns).toContain('fastapi');
+  });
+
+  it('includes required Python files', () => {
+    const paths = PYTHON_PYTEST_TEMPLATE.files.map((f) => f.path);
+    expect(paths).toContain('requirements.txt');
+    expect(paths).toContain('pytest.ini');
+    expect(paths).toContain('src/__init__.py');
+    expect(paths).toContain('src/main.py');
+    expect(paths).toContain('tests/test_main.py');
+    expect(paths).toContain('.sofia-metadata.json');
+  });
+});
+
+describe('createDefaultRegistry', () => {
+  it('contains both built-in templates', () => {
+    const registry = createDefaultRegistry();
+    expect(registry.size).toBe(2);
+    expect(registry.has('node-ts-vitest')).toBe(true);
+    expect(registry.has('python-pytest')).toBe(true);
+  });
+});

package/tests/unit/develop/testRunner.spec.ts

@@ -0,0 +1,294 @@
+/**
+ * T012: Unit tests for TestRunner.
+ *
+ * Verifies test runner spawns npm test with --reporter=json,
+ * parses JSON output into TestResults schema, handles timeout,
+ * handles non-zero exit code, truncates rawOutput.
+ */
+import { describe, it, expect } from 'vitest';
+
+import { TestRunner } from '../../../src/develop/testRunner.js';
+
+// ── Fake test runner that overrides spawnTests ────────────────────────────────
+
+class FakeTestRunner extends TestRunner {
+  private fakeOutput: string;
+  private fakeTimedOut: boolean;
+  private fakeError: Error | null;
+
+  constructor(
+    fakeOutput: string,
+    options?: { timedOut?: boolean; error?: Error; timeoutMs?: number },
+  ) {
+    super({ timeoutMs: options?.timeoutMs ?? 60_000 });
+    this.fakeOutput = fakeOutput;
+    this.fakeTimedOut = options?.timedOut ?? false;
+    this.fakeError = options?.error ?? null;
+  }
+
+  // Override the run method to inject fake output
+  async run(_outputDir: string): Promise<import('../../../src/shared/schemas/session.js').TestResults> {
+    if (this.fakeError) throw this.fakeError;
+
+    if (this.fakeTimedOut) {
+      return {
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        total: 0,
+        durationMs: 60000,
+        failures: [],
+        rawOutput: `Test runner timed out after 60000ms`,
+      };
+    }
+
+    // Use the public run interface but with fake underlying behavior
+    // We'll test the parsing logic directly
+    const parsed = this.parseOutputPublic(this.fakeOutput, Date.now() - 100, this.fakeOutput);
+    return parsed;
+  }
+
+  // Expose internal parsing for testing (parseOutput is protected in TestRunner)
+  parseOutputPublic(
+    output: string,
+    startTime: number,
+    rawOutput: string,
+  ): import('../../../src/shared/schemas/session.js').TestResults {
+    return this.parseOutput(output, startTime, rawOutput);
+  }
+}
+
+// ── Vitest JSON output fixtures ───────────────────────────────────────────────
+
+const PASSING_JSON = JSON.stringify({
+  numPassedTests: 3,
+  numFailedTests: 0,
+  numPendingTests: 0,
+  numTotalTests: 3,
+  success: true,
+  startTime: Date.now() - 500,
+  endTime: Date.now(),
+  testResults: [
+    {
+      testFilePath: 'tests/index.test.ts',
+      status: 'passed',
+      assertionResults: [
+        { title: 'should work', fullName: 'suite > should work', status: 'passed', duration: 10 },
+        { title: 'test 2', fullName: 'suite > test 2', status: 'passed', duration: 5 },
+        { title: 'test 3', fullName: 'suite > test 3', status: 'passed', duration: 8 },
+      ],
+    },
+  ],
+});
+
+const FAILING_JSON = JSON.stringify({
+  numPassedTests: 1,
+  numFailedTests: 2,
+  numPendingTests: 0,
+  numTotalTests: 3,
+  success: false,
+  testResults: [
+    {
+      testFilePath: 'tests/index.test.ts',
+      status: 'failed',
+      assertionResults: [
+        { title: 'should work', fullName: 'suite > should work', status: 'passed', duration: 10 },
+        {
+          title: 'test 2',
+          fullName: 'suite > test 2',
+          status: 'failed',
+          duration: 5,
+          failureMessages: ['Expected 3 but got 5'],
+        },
+        {
+          title: 'test 3',
+          fullName: 'suite > test 3',
+          status: 'failed',
+          duration: 8,
+          failureMessages: ['AssertionError: undefined is not a function'],
+        },
+      ],
+    },
+  ],
+});
+
+const INVALID_OUTPUT = 'This is not JSON output from vitest\nSome stderr text\n';
+
+describe('TestRunner', () => {
+  describe('JSON output parsing via FakeTestRunner', () => {
+    it('parses passing test results', async () => {
+      const runner = new FakeTestRunner(PASSING_JSON);
+      const result = await runner.run('/fake/dir');
+
+      expect(result.passed).toBe(3);
+      expect(result.failed).toBe(0);
+      expect(result.skipped).toBe(0);
+      expect(result.total).toBe(3);
+      expect(result.failures).toHaveLength(0);
+    });
+
+    it('parses failing test results with failure details', async () => {
+      const runner = new FakeTestRunner(FAILING_JSON);
+      const result = await runner.run('/fake/dir');
+
+      expect(result.passed).toBe(1);
+      expect(result.failed).toBe(2);
+      expect(result.total).toBe(3);
+      expect(result.failures).toHaveLength(2);
+
+      const firstFailure = result.failures[0];
+      expect(firstFailure.testName).toContain('test 2');
+      expect(firstFailure.message).toContain('Expected 3 but got 5');
+      expect(firstFailure.file).toBe('tests/index.test.ts');
+    });
+
+    it('handles non-JSON output gracefully', async () => {
+      const runner = new FakeTestRunner(INVALID_OUTPUT);
+      const result = await runner.run('/fake/dir');
+
+      expect(result.passed).toBe(0);
+      expect(result.failed).toBe(0);
+      expect(result.total).toBe(0);
+      expect(result.failures).toHaveLength(0);
+    });
+
+    it('handles timeout by returning zero counts', async () => {
+      const runner = new FakeTestRunner('', { timedOut: true, timeoutMs: 60_000 });
+      const result = await runner.run('/fake/dir');
+
+      expect(result.passed).toBe(0);
+      expect(result.failed).toBe(0);
+      expect(result.rawOutput).toContain('timed out');
+    });
+
+    it('truncates rawOutput to 2000 chars', async () => {
+      const longOutput = PASSING_JSON + '\n' + 'x'.repeat(5000);
+      const runner = new FakeTestRunner(longOutput);
+      const result = await runner.run('/fake/dir');
+
+      expect(result.rawOutput).toBeDefined();
+      expect(result.rawOutput!.length).toBeLessThanOrEqual(2000);
+    });
+
+    it('limits failures to 10 max', async () => {
+      // Create a JSON with 15 failures
+      const manyFailures = {
+        numPassedTests: 0,
+        numFailedTests: 15,
+        numPendingTests: 0,
+        numTotalTests: 15,
+        success: false,
+        testResults: [
+          {
+            testFilePath: 'tests/index.test.ts',
+            status: 'failed',
+            assertionResults: Array.from({ length: 15 }, (_, i) => ({
+              title: `test ${i}`,
+              fullName: `suite > test ${i}`,
+              status: 'failed',
+              failureMessages: [`Error in test ${i}`],
+            })),
+          },
+        ],
+      };
+
+      const runner = new FakeTestRunner(JSON.stringify(manyFailures));
+      const result = await runner.run('/fake/dir');
+
+      expect(result.failures.length).toBeLessThanOrEqual(10);
+    });
+
+    it('handles non-zero exit code with partial JSON', async () => {
+      // Mix of stderr text and JSON (vitest may output to stderr)
+      const mixedOutput = `Error: Test failed\n${FAILING_JSON}\n`;
+      const runner = new FakeTestRunner(mixedOutput);
+      const result = await runner.run('/fake/dir');
+
+      // Should find JSON in the mixed output
+      expect(result.total).toBe(3);
+    });
+  });
+
+  describe('TestRunner constructor', () => {
+    it('uses default timeout of 60000ms', () => {
+      const runner = new TestRunner();
+      // The timeout is used internally; we can't directly inspect it,
+      // but we verify the runner is instantiated correctly
+      expect(runner).toBeDefined();
+    });
+
+    it('accepts custom timeout', () => {
+      const runner = new TestRunner({ timeoutMs: 30_000 });
+      expect(runner).toBeDefined();
+    });
+
+    it('accepts custom testCommand', () => {
+      const runner = new TestRunner({ testCommand: 'pytest --tb=short' });
+      expect(runner).toBeDefined();
+    });
+  });
+
+  // ── T045: extractJson fallback path ─────────────────────────────────────
+
+  describe('extractJson fallback path (T045)', () => {
+    it('extracts JSON from mixed console + JSON output', () => {
+      const mixed = `
+Some console output here
+Warning: something happened
+${PASSING_JSON}
+More console output after
+`;
+      const runner = new FakeTestRunner(mixed);
+      const result = runner.parseOutputPublic(mixed, Date.now() - 100, mixed);
+      expect(result.passed).toBe(3);
+      expect(result.failed).toBe(0);
+      expect(result.total).toBe(3);
+    });
+
+    it('uses first-brace to last-brace fallback when JSON spans mixed output', () => {
+      // Construct output where JSON is embedded in non-JSON text
+      const embedded = `npm warn something\n{"numPassedTests":1,"numFailedTests":0,"numPendingTests":0,"numTotalTests":1,"success":true,"testResults":[]}\nDone`;
+      const runner = new FakeTestRunner(embedded);
+      const result = runner.parseOutputPublic(embedded, Date.now() - 100, embedded);
+      expect(result.passed).toBe(1);
+      expect(result.total).toBe(1);
+    });
+  });
+
+  // ── T046: extractJson returns null for no valid JSON ────────────────────
+
+  describe('extractJson null return (T046)', () => {
+    it('returns zero-count result for output with no valid JSON', () => {
+      const noJson = 'This is just plain text output\nNo JSON here at all\nERROR: something failed';
+      const runner = new FakeTestRunner(noJson);
+      const result = runner.parseOutputPublic(noJson, Date.now() - 100, noJson);
+      expect(result.passed).toBe(0);
+      expect(result.failed).toBe(0);
+      expect(result.total).toBe(0);
+    });
+  });
+
+  // ── T047: buildErrorResult ──────────────────────────────────────────────
+
+  describe('buildErrorResult (T047)', () => {
+    it('produces correct zero-count result with error message on timeout', () => {
+      const runner = new FakeTestRunner('', { timedOut: true });
+      // Run returns timeout result
+      const resultPromise = runner.run('/tmp/fake');
+      return resultPromise.then((result) => {
+        expect(result.passed).toBe(0);
+        expect(result.failed).toBe(0);
+        expect(result.skipped).toBe(0);
+        expect(result.total).toBe(0);
+        expect(result.rawOutput).toContain('timed out');
+      });
+    });
+
+    it('produces correct zero-count result with error message on spawn error', () => {
+      const runner = new FakeTestRunner('', { error: new Error('ENOENT: npm not found') });
+      return runner.run('/tmp/fake').catch((err: Error) => {
+        expect(err.message).toContain('ENOENT');
+      });
+    });
+  });
+});

package/tests/unit/infraBicep.spec.ts

@@ -0,0 +1,116 @@
+/**
+ * Bicep template structure tests (T008, T013, T014).
+ *
+ * Validates the Bicep template:
+ * - Contains all 5 expected resource types
+ * - All parameters have @description() decorators (T013)
+ * - Parameters have correct defaults per data-model.md (T014)
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const BICEP_PATH = resolve(__dirname, '../../infra/main.bicep');
+const RESOURCES_BICEP_PATH = resolve(__dirname, '../../infra/resources.bicep');
+const BICEPPARAM_PATH = resolve(__dirname, '../../infra/main.bicepparam');
+
+describe('Bicep template structure (T008)', () => {
+  const bicep = readFileSync(BICEP_PATH, 'utf-8');
+  const resourcesBicep = readFileSync(RESOURCES_BICEP_PATH, 'utf-8');
+  const allBicep = bicep + '\n' + resourcesBicep;
+
+  describe('required resource types', () => {
+    it('defines a Cognitive Services account (AIServices)', () => {
+      expect(allBicep).toContain("Microsoft.CognitiveServices/accounts");
+      expect(allBicep).toMatch(/kind:\s*'AIServices'/);
+    });
+
+    it('defines a model deployment', () => {
+      expect(allBicep).toContain("Microsoft.CognitiveServices/accounts/deployments");
+    });
+
+    it('defines a project', () => {
+      expect(allBicep).toContain("Microsoft.CognitiveServices/accounts/projects");
+    });
+
+    it('defines an account-level capability host', () => {
+      expect(allBicep).toContain("Microsoft.CognitiveServices/accounts/capabilityHosts");
+    });
+
+    it('defines a project-level capability host', () => {
+      expect(allBicep).toContain("Microsoft.CognitiveServices/accounts/projects/capabilityHosts");
+    });
+
+    it('uses subscription target scope', () => {
+      expect(allBicep).toMatch(/targetScope\s*=\s*'subscription'/);
+    });
+  });
+
+  describe('resource configuration', () => {
+    it('enables project management on the account', () => {
+      expect(allBicep).toContain('allowProjectManagement');
+    });
+
+    it('configures custom subdomain name', () => {
+      expect(allBicep).toContain('customSubDomainName');
+    });
+
+    it('uses GlobalStandard SKU for model deployment', () => {
+      expect(allBicep).toContain('GlobalStandard');
+    });
+
+    it('configures Agents capability kind', () => {
+      expect(allBicep).toContain("'Agents'");
+    });
+  });
+});
+
+describe('Bicep parameter descriptions (T013)', () => {
+  const bicep = readFileSync(BICEP_PATH, 'utf-8');
+
+  it('every param in main.bicep has a preceding @description() decorator', () => {
+    // Extract all param declarations
+    const paramLines = bicep.split('\n');
+    const paramIndices = paramLines
+      .map((line, idx) => ({ line: line.trim(), idx }))
+      .filter(({ line }) => line.startsWith('param '));
+
+    expect(paramIndices.length).toBeGreaterThan(0);
+
+    for (const { line, idx } of paramIndices) {
+      // Check that at least one of the preceding lines (within 5 lines) has @description
+      const precedingLines = paramLines.slice(Math.max(0, idx - 5), idx).join('\n');
+      const paramName = line.split(/\s+/)[1];
+      expect(
+        precedingLines,
+        `Parameter '${paramName}' at line ${idx + 1} should have a preceding @description() decorator`,
+      ).toMatch(/@description\(/);
+    }
+  });
+});
+
+describe('Bicep parameter defaults (T014)', () => {
+  const bicep = readFileSync(BICEP_PATH, 'utf-8');
+  const bicepparam = readFileSync(BICEPPARAM_PATH, 'utf-8');
+
+  it('defaults location to swedencentral', () => {
+    // Check either in bicep or bicepparam
+    const combined = bicep + bicepparam;
+    expect(combined).toContain('swedencentral');
+  });
+
+  it('defaults model deployment name to gpt-4.1-mini', () => {
+    const combined = bicep + bicepparam;
+    expect(combined).toContain('gpt-4.1-mini');
+  });
+
+  it('defaults model version to 2025-04-14', () => {
+    const combined = bicep + bicepparam;
+    expect(combined).toContain('2025-04-14');
+  });
+
+  it('defaults model SKU to GlobalStandard', () => {
+    const combined = bicep + bicepparam;
+    expect(combined).toContain('GlobalStandard');
+  });
+});

package/tests/unit/infraDeploy.spec.ts

@@ -0,0 +1,102 @@
+/**
+ * Deploy script tests (T007).
+ *
+ * Tests for infra/deploy.sh:
+ * - Parameter parsing (subscription, resource-group, location, account-name, model)
+ * - Default values for optional parameters
+ * - Missing required arguments
+ * - Script file properties (executable, shebang, error handling)
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync, accessSync, constants } from 'node:fs';
+import { resolve } from 'node:path';
+
+const DEPLOY_SCRIPT_PATH = resolve(__dirname, '../../infra/deploy.sh');
+
+describe('deploy.sh (T007)', () => {
+  const script = readFileSync(DEPLOY_SCRIPT_PATH, 'utf-8');
+
+  describe('script file properties', () => {
+    it('has bash shebang', () => {
+      expect(script.startsWith('#!/usr/bin/env bash')).toBe(true);
+    });
+
+    it('is executable', () => {
+      expect(() => accessSync(DEPLOY_SCRIPT_PATH, constants.X_OK)).not.toThrow();
+    });
+
+    it('uses strict error handling (set -euo pipefail)', () => {
+      expect(script).toContain('set -euo pipefail');
+    });
+  });
+
+  describe('parameter parsing', () => {
+    it('supports --subscription / -s flag', () => {
+      expect(script).toMatch(/--subscription\b|-s\b/);
+    });
+
+    it('supports --resource-group / -g flag', () => {
+      expect(script).toMatch(/--resource-group\b|-g\b/);
+    });
+
+    it('supports --location / -l flag', () => {
+      expect(script).toMatch(/--location\b|-l\b/);
+    });
+
+    it('supports --account-name / -n flag', () => {
+      expect(script).toMatch(/--account-name\b|-n\b/);
+    });
+
+    it('supports --model / -m flag', () => {
+      expect(script).toMatch(/--model\b|-m\b/);
+    });
+  });
+
+  describe('default values', () => {
+    it('defaults location to swedencentral', () => {
+      expect(script).toContain('swedencentral');
+    });
+
+    it('defaults account name to sofia-foundry', () => {
+      expect(script).toContain('sofia-foundry');
+    });
+
+    it('defaults model to gpt-4.1-mini', () => {
+      expect(script).toContain('gpt-4.1-mini');
+    });
+  });
+
+  describe('prerequisite validation', () => {
+    it('checks for az CLI installation', () => {
+      expect(script).toMatch(/command -v az|which az/);
+    });
+
+    it('checks for Azure login status', () => {
+      expect(script).toContain('az account show');
+    });
+  });
+
+  describe('exit codes', () => {
+    it('uses exit code 1 for prerequisite failures', () => {
+      expect(script).toContain('exit 1');
+    });
+
+    it('uses exit code 2 for deployment failures', () => {
+      expect(script).toContain('exit 2');
+    });
+  });
+
+  describe('output', () => {
+    it('outputs FOUNDRY_PROJECT_ENDPOINT env var instruction', () => {
+      expect(script).toContain('FOUNDRY_PROJECT_ENDPOINT');
+    });
+
+    it('outputs FOUNDRY_MODEL_DEPLOYMENT_NAME env var instruction', () => {
+      expect(script).toContain('FOUNDRY_MODEL_DEPLOYMENT_NAME');
+    });
+
+    it('references teardown script', () => {
+      expect(script).toContain('teardown.sh');
+    });
+  });
+});

package/tests/unit/infraTeardown.spec.ts

@@ -0,0 +1,77 @@
+/**
+ * Teardown script tests (T032).
+ *
+ * Tests for infra/teardown.sh:
+ * - Required --resource-group flag
+ * - Script file properties (executable, shebang, error handling)
+ * - Exit codes (0=success/not-found, 1=prereq fail, 2=deletion fail)
+ * - Handles non-existent resource group gracefully
+ * - Supports --yes flag for non-interactive confirmation
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync, accessSync, constants } from 'node:fs';
+import { resolve } from 'node:path';
+
+const TEARDOWN_SCRIPT_PATH = resolve(__dirname, '../../infra/teardown.sh');
+
+describe('teardown.sh (T032)', () => {
+  const script = readFileSync(TEARDOWN_SCRIPT_PATH, 'utf-8');
+
+  describe('script file properties', () => {
+    it('has bash shebang', () => {
+      expect(script.startsWith('#!/usr/bin/env bash')).toBe(true);
+    });
+
+    it('is executable', () => {
+      expect(() => accessSync(TEARDOWN_SCRIPT_PATH, constants.X_OK)).not.toThrow();
+    });
+
+    it('uses strict error handling (set -euo pipefail)', () => {
+      expect(script).toContain('set -euo pipefail');
+    });
+  });
+
+  describe('parameter parsing', () => {
+    it('supports --resource-group / -g flag', () => {
+      expect(script).toMatch(/--resource-group\b|-g\b/);
+    });
+
+    it('supports --yes flag for non-interactive confirmation', () => {
+      expect(script).toMatch(/--yes\b/);
+    });
+  });
+
+  describe('prerequisite validation', () => {
+    it('checks for az CLI installation', () => {
+      expect(script).toMatch(/command -v az|which az/);
+    });
+  });
+
+  describe('exit codes', () => {
+    it('uses exit code 0 for success or not-found', () => {
+      expect(script).toContain('exit 0');
+    });
+
+    it('uses exit code 1 for prerequisite failures', () => {
+      expect(script).toContain('exit 1');
+    });
+
+    it('uses exit code 2 for deletion failures', () => {
+      expect(script).toContain('exit 2');
+    });
+  });
+
+  describe('resource group handling', () => {
+    it('checks if resource group exists', () => {
+      expect(script).toContain('az group exists');
+    });
+
+    it('uses az group delete for deletion', () => {
+      expect(script).toContain('az group delete');
+    });
+
+    it('uses --no-wait for non-blocking deletion', () => {
+      expect(script).toContain('--no-wait');
+    });
+  });
+});