/integration-test

allowed-tools: Task, Read, Write, Edit, MultiEdit, Bash(fd:*), Bash(rg:*), Bash(bat:*), Bash(eza:*), Bash(jq:*), Bash(gdate:*), Bash(docker:*), Bash(wc:*), Bash(head:*), Bash(mvn:*), Bash(gradle:*), Bash(cargo:*), Bash(go:*), Bash(npm:*), Bash(deno:*)
name: "Integration Test"
description: "Comprehensive integration testing orchestrator with parallel technology analysis and strategy generation"
author: "wcygan"
tags: ["test","generate"]
version: "1.0.0"
created_at: "2025-07-14T00:00:00Z"
updated_at: "2025-07-14T00:00:00Z"

Context

• Session ID: !`gdate +%s%N 2>/dev/null || date +%s%N 2>/dev/null || echo "$(date +%s)$(jot -r 1 100000 999999 2>/dev/null || shuf -i 100000-999999 -n 1 2>/dev/null || echo $RANDOM$RANDOM)"`
• Target project: $ARGUMENTS
• Current directory: !`pwd`
• Build files detected: !`fd "(package\.json|Cargo\.toml|go\.mod|deno\.json|pom\.xml|build\.gradle)" . -d 3 | head -5 || echo "No build files detected"`
• Codebase size: !`fd "\.(js|ts|jsx|tsx|rs|go|java|py|rb|php|c|cpp|h|hpp|cs|kt|swift|scala)" . | wc -l | tr -d ' '` files
• Project structure: !`eza -la --tree --level=2 2>/dev/null | head -10 || fd . -t d -d 2 | head -10`
• Test directories: !`fd "(test|tests|spec|__tests__|integration)" . -t d -d 3 | head -5 || echo "No test directories found"`
• Database configs: !`rg "(postgres|mysql|redis|mongo|sqlite)" . --type-add 'config:*.{json,yaml,yml,toml,env}' --type config -l | head -3 || echo "No database configs detected"`
• Service definitions: !`fd "(docker-compose|compose)" . -e yml -e yaml | head -3 || echo "No service compositions found"`

Your Task

STEP 1: Initialize comprehensive integration testing session with technology analysis

• CREATE session state file: `/tmp/integration-test-session-$SESSION_ID.json`
• ANALYZE project structure and technology stack from Context section
• DETERMINE testing complexity based on codebase size and architecture patterns
• IDENTIFY integration points, external dependencies, and service boundaries

# Initialize integration testing session state
echo '{
  "sessionId": "'$SESSION_ID'",
  "targetProject": "'$ARGUMENTS'",
  "detectedTechnologies": [],
  "architecturePattern": "auto-detect",
  "integrationPoints": [],
  "testingStrategy": "comprehensive",
  "frameworkRecommendations": []
}' > /tmp/integration-test-session-$SESSION_ID.json

STEP 2: Parallel technology stack analysis with sub-agent coordination

TRY:

IF codebase_size > 50 files OR multiple_technologies_detected:

LAUNCH parallel sub-agents for comprehensive technology analysis:

• **Agent 1: Backend Framework Analysis**: Analyze server-side technologies and frameworks
• Focus: Go/ConnectRPC, Rust/Axum, Java/Spring Boot, Node.js patterns, Python/FastAPI
• Tools: fd for configuration discovery, rg for framework pattern detection
• Output: Backend technology manifest with integration testing requirements

• **Agent 2: Database & Storage Analysis**: Identify data persistence layers and testing strategies
• Focus: PostgreSQL, Redis alternatives (DragonflyDB), NoSQL, in-memory databases
• Tools: rg for connection strings, configuration file analysis
• Output: Database testing strategy with TestContainers and mock implementations

• **Agent 3: Message Queue & Event Systems**: Analyze asynchronous communication patterns
• Focus: Kafka alternatives (RedPanda), RabbitMQ, event sourcing, CQRS patterns
• Tools: rg for message queue configurations, event pattern detection
• Output: Event-driven testing strategy with embedded brokers and message verification

• **Agent 4: External Service Integration**: Map third-party dependencies and API integrations
• Focus: HTTP APIs, GraphQL endpoints, payment systems, authentication providers
• Tools: rg for API endpoints, configuration analysis, service discovery
• Output: Service virtualization strategy with WireMock, MSW, contract testing

• **Agent 5: Infrastructure & Deployment**: Analyze containerization and deployment patterns
• Focus: Docker configurations, Kubernetes manifests, service mesh integration
• Tools: fd for infrastructure files, Docker/K8s configuration analysis
• Output: Infrastructure testing strategy with TestContainers and embedded services

**Sub-Agent Coordination:**

# Each agent reports findings to session state under respective domains
echo "Parallel technology analysis launched for comprehensive integration testing strategy..."
echo "Results will be synthesized into tailored testing recommendations"

ELSE:

EXECUTE streamlined single-technology analysis:

# Single-technology analysis for smaller projects
echo "🔍 Analyzing focused integration testing requirements..."

STEP 3: Architecture pattern recognition and integration point mapping

**Architecture Pattern Detection:**

# Microservices detection
if fd "docker-compose" . -e yml -e yaml | head -1 >/dev/null; then
  echo "🏗️ Microservices architecture detected - service-to-service testing required"
fi

# Monolithic pattern detection
if fd "(main\.rs|main\.go|app\.py|Application\.java)" . | head -1 >/dev/null; then
  echo "🏛️ Monolithic architecture detected - module integration testing focus"
fi

# Event-driven pattern detection
if rg "(kafka|rabbitmq|event|saga|cqrs)" . --ignore-case -l | head -1 >/dev/null; then
  echo "⚡ Event-driven architecture detected - event flow testing required"
fi

**Integration Point Discovery:**

# API endpoint discovery
echo "🔍 Discovering API integration points:"
rg "(POST|GET|PUT|DELETE|PATCH).*[\"']\/.*[\"']" . --type-add 'code:*.{js,ts,rs,go,java,py}' --type code -o | head -10

# Database connection analysis
echo "🗄️ Analyzing database integration requirements:"
rg "(connection.*string|database.*url|db.*host)" . --ignore-case -l | head -5

# External service detection
echo "🌐 Identifying external service dependencies:"
rg "(api\..*\.com|\.googleapis\.|stripe\.|paypal\.|oauth)" . -l | head -5

STEP 4: Framework-specifi