laboratori-cloud/.planning/phases/04-lab-03-compute-ec2/04-01-PLAN.md

---
phase: 04-lab-03-compute-ec2
plan: 01
type: execute
wave: 0
depends_on: []
files_modified:
  - labs/lab-03-compute/tests/01-resource-limits-test.sh
  - labs/lab-03-compute/tests/02-healthcheck-test.sh
  - labs/lab-03-compute/tests/03-enforcement-test.sh
  - labs/lab-03-compute/tests/99-final-verification.sh
  - labs/lab-03-compute/tests/run-all-tests.sh
  - labs/lab-03-compute/tests/quick-test.sh
autonomous: true
requirements:
  - TEST-01
  - TEST-05
  - INF-03
  - LAB-03
user_setup: []

must_haves:
  truths:
    - "Test scripts exist and validate resource limits before implementation"
    - "Tests verify INF-03 compliance (all containers have CPU/memory limits)"
    - "Tests verify healthcheck implementation"
    - "Tests can enforce resource limits and verify with docker stats"
    - "Final verification script provides clear pass/fail report"
  artifacts:
    - path: "labs/lab-03-compute/tests/01-resource-limits-test.sh"
      provides: "Resource limits validation"
      min_lines: 80
    - path: "labs/lab-03-compute/tests/02-healthcheck-test.sh"
      provides: "Healthcheck testing"
      min_lines: 100
    - path: "labs/lab-03-compute/tests/03-enforcement-test.sh"
      provides: "Resource enforcement verification"
      min_lines: 120
    - path: "labs/lab-03-compute/tests/99-final-verification.sh"
      provides: "Student double-check command"
      min_lines: 100
    - path: "labs/lab-03-compute/tests/run-all-tests.sh"
      provides: "Test orchestration with fail-fast"
      min_lines: 50
    - path: "labs/lab-03-compute/tests/quick-test.sh"
      provides: "Quick validation for development"
      min_lines: 30
  key_links:
    - from: "tests/01-resource-limits-test.sh"
      to: "docker-compose.yml resources"
      via: "yq or grep for deploy.resources.limits"
      pattern: "deploy:.*resources:.*limits"
    - from: "tests/02-healthcheck-test.sh"
      to: "docker-compose.yml healthcheck"
      via: "grep for healthcheck section"
      pattern: "healthcheck:"
    - from: "tests/03-enforcement-test.sh"
      to: "docker stats"
      via: "docker stats --no-stream for verification"
      pattern: "docker.*stats"
    - from: "tests/99-final-verification.sh"
      to: "INF-03 requirement"
      via: "Verify all services have cpu and memory limits"
      pattern: "INF-03"
---

<objective>
Create comprehensive test infrastructure for Lab 03 (Compute & EC2) following TDD RED phase methodology. Tests validate Docker Compose resource limits (CPU/memory), healthcheck implementation, and INF-03 compliance (all containers must have resource limits).

Purpose: Establish verification foundation before implementing compute infrastructure. Tests fail initially (RED phase) and pass after implementation (GREEN phase in Plan 04-03).

Output: 6 bash test scripts covering resource limits validation, healthcheck testing, enforcement verification, and final verification for students.
</objective>

<execution_context>
@/home/luca/.claude/get-shit-done/workflows/execute-plan.md
@/home/luca/.claude/get-shit-done/templates/summary.md
</execution_context>

<context>
@.planning/REQUIREMENTS.md
@.planning/phases/04-lab-03-compute-ec2/04-RESEARCH.md
@.planning/phases/04-lab-03-compute-ec2/04-VALIDATION.md
@.planning/phases/03-lab-02-network-vpc/03-01-PLAN.md

# Test Patterns from Phase 2 and 3

From labs/lab-01-iam/tests/run-all-tests.sh:
- Use `set -euo pipefail` for error handling
- Color-coded output (GREEN for pass, RED for fail, BLUE for info)
- Summary with pass/fail counts
- Exit code 0 for all pass, 1 for any failure

From labs/lab-02-network/tests/04-verify-infrastructure.sh:
- Parse docker-compose.yml with `docker compose config`
- Use jq for JSON parsing when needed
- Verify compliance with grep patterns
- Use awk for robust counting

# Key Docker Commands for Testing

## Resource Limits Verification
```bash
# Check if service has CPU limit
docker compose config | grep -A 10 "service_name:" | grep -c "cpus:"

# Check if service has memory limit
docker compose config | grep -A 10 "service_name:" | grep -c "memory:"

# Get container limits
docker inspect container_name --format '{{.HostConfig.NanoCpus}}'
docker inspect container_name --format '{{.HostConfig.Memory}}'
```

## Healthcheck Verification
```bash
# Check if service has healthcheck
docker compose config | grep -A 20 "service_name:" | grep -c "healthcheck:"

# Get container health status
docker inspect container_name --format '{{.State.Health.Status}}'
```

## Resource Monitoring
```bash
# Get live stats
docker stats --no-stream

# Get specific container stats
docker stats container_name --no-stream --format "{{.CPUPerc}}\t{{.MemUsage}}"
```

# Testing Strategy

## Test 1: Resource Limits Configuration
**Purpose:** Verify docker-compose.yml has resource limits defined
**Expected Result:** FAIL initially (no limits configured)
**Pass Criteria After Implementation:** All services have cpus and memory limits

## Test 2: Healthcheck Configuration
**Purpose:** Verify services have healthchecks defined
**Expected Result:** FAIL initially (no healthchecks configured)
**Pass Criteria After Implementation:** All services have valid healthchecks

## Test 3: Resource Enforcement
**Purpose:** Deploy test container and verify limits are enforced
**Expected Result:** FAIL initially (no test container defined)
**Pass Criteria After Implementation:** docker stats shows enforcement

## Test 4: INF-03 Compliance
**Purpose:** Verify mandatory resource limits for all services
**Expected Result:** FAIL initially
**Pass Criteria After Implementation:** 100% compliance

# Implementation Notes

1. **Directory Structure:**
```
labs/lab-03-compute/
├── tests/
│   ├── 01-resource-limits-test.sh
│   ├── 02-healthcheck-test.sh
│   ├── 03-enforcement-test.sh
│   ├── 99-final-verification.sh
│   ├── run-all-tests.sh
│   └── quick-test.sh
├── docker-compose.yml  (created in 04-03)
└── README.md
```

2. **Test Execution Order:**
   - 01-resource-limits-test.sh: Parse compose file for limits
   - 02-healthcheck-test.sh: Parse compose file for healthchecks
   - 03-enforcement-test.sh: Deploy test and verify enforcement
   - 99-final-verification.sh: End-to-end student verification

3. **Error Handling:**
   - Each test should be independent
   - Use descriptive error messages
   - Provide remediation hints

4. **Color Coding:**
   ```bash
   RED='\033[0;31m'
   GREEN='\033[0;32m'
   BLUE='\033[0;34m'
   BOLD='\033[1m'
   NC='\033[0m'
   ```

# Success Criteria

Plan 04-01 is complete when:
1. All 6 test scripts created
2. Each script meets minimum line requirements
3. Tests fail when executed on empty/non-existent lab-03-compute
4. run-all-tests.sh executes all tests in sequence
5. Tests cover: resource limits, healthchecks, enforcement, INF-03
</context>

<tasks>
1. Create labs/lab-03-compute/tests/ directory
2. Create 01-resource-limits-test.sh (80+ lines)
   - Parse docker-compose.yml for deploy.resources.limits
   - Verify cpus and memory for all services
   - Report missing limits
3. Create 02-healthcheck-test.sh (100+ lines)
   - Parse docker-compose.yml for healthcheck sections
   - Verify test, interval, timeout, retries
   - Report missing healthchecks
4. Create 03-enforcement-test.sh (120+ lines)
   - Deploy test container with stress image
   - Verify CPU limit enforcement with docker stats
   - Verify memory OOM on exceed
   - Cleanup test container
5. Create 99-final-verification.sh (100+ lines)
   - Combine all checks into student-facing verification
   - INF-03 compliance report
   - Healthcheck status report
   - Clear pass/fail summary
6. Create run-all-tests.sh (50+ lines)
   - Execute all test scripts in sequence
   - Fail-fast on first failure
   - Summary report
7. Create quick-test.sh (30+ lines)
   - Fast validation (< 30 seconds)
   - Essential checks only
</tasks>