# One-line install (Linux/macOS)
curl -fsSL https://raw.githubusercontent.com/zlrrr/middleware-chaos-testing/main/install.sh | bash

# Verify installation
mct version

# Pull images
docker pull ghcr.io/zlrrr/middleware-chaos-testing/mct-server:latest
docker pull ghcr.io/zlrrr/middleware-chaos-testing/mct-web:latest

# Download and run with docker-compose
curl -O https://raw.githubusercontent.com/zlrrr/middleware-chaos-testing/main/docker-compose.release.yml
docker-compose -f docker-compose.release.yml up -d

# Clone the repository
git clone https://github.com/zlrrr/middleware-chaos-testing.git
cd middleware-chaos-testing

# Build CLI tool
go build -o bin/mct ./cmd/mct

# Build API server
go build -o bin/mct-server ./cmd/mct-server

# Build web UI
cd web
npm install
npm run build
cd ..

# Or use the startup script to build and run everything
./scripts/start-platform.sh

# Start all services (frontend, backend, and 7 middlewares)
./scripts/start-platform.sh

# Or use docker-compose directly
docker-compose up -d

# Clone repository (if not already done)
git clone https://github.com/zlrrr/middleware-chaos-testing.git
cd middleware-chaos-testing

# Start all services
./scripts/start-platform.sh

# Create a Redis test task
curl -X POST http://localhost:8080/api/v1/tasks \
  -H "Content-Type: application/json" \
  -d '{
    "middleware": "redis",
    "config": {
      "host": "redis",
      "port": 6379,
      "db": 0
    }
  }'

# Run the task (replace with your task ID)
curl -X POST http://localhost:8080/api/v1/tasks/{task-id}/run

# Check status
curl http://localhost:8080/api/v1/tasks/{task-id}

# Get test result
curl http://localhost:8080/api/v1/tasks/{task-id}/result | jq

# Output example:
{
  "code": 0,
  "message": "success",
  "data": {
    "task_id": "task-123",
    "score": 87.5,
    "grade": "B",
    "dimensions": {
      "availability": 92.0,
      "performance": 85.0,
      "resilience": 88.0,
      "data_integrity": 95.0,
      "recovery": 77.5
    },
    ...
  }
}

# Test Redis cluster
curl -X POST http://localhost:8080/api/v1/tasks \
  -H "Content-Type: application/json" \
  -d '{
    "middleware": "redis",
    "config": {"host": "redis", "port": 6379}
  }'

# If score >= 80: Safe to deploy ✅
# If score < 80: Review recommendations ⚠️

# Automated daily test
#!/bin/bash
for middleware in redis kafka mongodb; do
  TASK_ID=$(curl -s -X POST http://localhost:8080/api/v1/tasks \
    -H "Content-Type: application/json" \
    -d "{\"middleware\":\"$middleware\",\"config\":{}}" \
    | jq -r '.data.id')

  curl -X POST http://localhost:8080/api/v1/tasks/$TASK_ID/run
  echo "Started test for $middleware: $TASK_ID"
done

# Check service status
docker-compose ps

# Check logs
docker-compose logs mct-server
docker-compose logs mct-web

# Restart specific service
docker-compose restart mct-server

# Check mct-server logs for errors
docker-compose logs -f mct-server

# Check if middleware service is healthy
docker-compose ps | grep redis

# Check if mct-web is running
docker-compose ps mct-web

# Restart web service
docker-compose restart mct-web

# Clear browser cache and reload

./scripts/stop-platform.sh

# Or use docker-compose directly
docker-compose down

# Test Redis
./bin/mct test --middleware redis --host localhost --duration 30s --operations 5000

# Test Kafka
./bin/mct test --middleware kafka --host localhost --duration 60s --operations 10000

# Test MongoDB
./bin/mct test --middleware mongodb --host localhost --duration 30s

# Test all 7 middleware types
./bin/mct test --middleware redis|kafka|mongodb|rocketmq|rabbitmq|emqx|nacos

# Console output (human-readable)
./bin/mct test --middleware redis --output console

# JSON output (machine-readable)
./bin/mct test --middleware kafka --output json

# Markdown report
./bin/mct test --middleware mongodb --output markdown --report-path ./report.md

# Use a YAML configuration file
./bin/mct test --config configs/test-redis.yaml

# Build for current platform
go build -o bin/mct ./cmd/mct

# Build with optimizations (smaller binary)
go build -ldflags="-s -w" -o bin/mct ./cmd/mct

# Cross-compile for Linux (from macOS/Windows)
GOOS=linux GOARCH=amd64 go build -o bin/mct-linux ./cmd/mct

# Cross-compile for Windows
GOOS=windows GOARCH=amd64 go build -o bin/mct.exe ./cmd/mct

# Build binary
make build

# Build and install to $GOPATH/bin
make install

# Clean build artifacts
make clean

# Check binary
./bin/mct version

# Show help
./bin/mct --help

# Using Docker
docker run -d --name redis-test \
  -p 6379:6379 \
  redis:7-alpine

# Or using Docker Compose
docker-compose up -d redis

# Basic test (30 seconds, 5000 operations)
./bin/mct test \
  --middleware redis \
  --host localhost \
  --port 6379 \
  --duration 30s \
  --operations 5000

# Advanced test with custom configuration
./bin/mct test \
  --middleware redis \
  --host localhost \
  --port 6379 \
  --duration 60s \
  --operations 10000 \
  --concurrency 10 \
  --password "your-redis-password"

# Using Docker Compose (with ZooKeeper)
docker-compose up -d zookeeper kafka

# Or standalone Kafka (KRaft mode)
docker run -d --name kafka-test \
  -p 9092:9092 \
  -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092 \
  apache/kafka:latest

# Basic test
./bin/mct test \
  --middleware kafka \
  --brokers localhost:9092 \
  --topic test-topic \
  --duration 30s \
  --operations 5000

# Advanced test with consumer groups
./bin/mct test \
  --middleware kafka \
  --brokers localhost:9092,localhost:9093 \
  --topic test-topic \
  --producer-group test-producer \
  --consumer-group test-consumer \
  --duration 60s \
  --operations 10000 \
  --concurrency 5

# Using Docker
docker run -d --name mongodb-test \
  -p 27017:27017 \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=password \
  mongo:4.4.13

# Or using Docker Compose
docker-compose up -d mongodb

# Basic test
./bin/mct test \
  --middleware mongodb \
  --host localhost \
  --port 27017 \
  --database testdb \
  --collection testcol \
  --duration 30s \
  --operations 5000

# With authentication
./bin/mct test \
  --middleware mongodb \
  --uri "mongodb://admin:password@localhost:27017/testdb?authSource=admin" \
  --collection testcol \
  --duration 60s \
  --operations 10000 \
  --concurrency 10

# Using Docker
docker run -d --name rocketmq-namesrv \
  -p 9876:9876 \
  apache/rocketmq:5.1.3 sh mqnamesrv

docker run -d --name rocketmq-broker \
  -p 10909:10909 -p 10911:10911 \
  -e NAMESRV_ADDR=localhost:9876 \
  apache/rocketmq:5.1.3 sh mqbroker

# Basic test (Remoting protocol - default)
./bin/mct test \
  --middleware rocketmq \
  --nameservers localhost:9876 \
  --topic test-topic \
  --duration 30s \
  --operations 5000

# Using gRPC protocol (RocketMQ 5.x recommended)
./bin/mct test \
  --middleware rocketmq \
  --nameservers localhost:9876 \
  --topic test-topic \
  --protocol grpc \
  --producer-group test-producer \
  --consumer-group test-consumer \
  --duration 60s \
  --operations 10000

# Using Docker with management plugin
docker run -d --name rabbitmq-test \
  -p 5672:5672 \
  -p 15672:15672 \
  -e RABBITMQ_DEFAULT_USER=admin \
  -e RABBITMQ_DEFAULT_PASS=password \
  rabbitmq:3.12.7-management

# Access management UI: http://localhost:15672

# Basic test
./bin/mct test \
  --middleware rabbitmq \
  --host localhost \
  --port 5672 \
  --user admin \
  --password password \
  --duration 30s \
  --operations 5000

# Advanced test with routing
./bin/mct test \
  --middleware rabbitmq \
  --uri "amqp://admin:password@localhost:5672/" \
  --exchange test-exchange \
  --queue test-queue \
  --routing-key test-key \
  --duration 60s \
  --operations 10000 \
  --concurrency 10

# Using Docker
docker run -d --name emqx-test \
  -p 1883:1883 \
  -p 18083:18083 \
  emqx/emqx:5.8

# Access dashboard: http://localhost:18083
# Default credentials: admin / public

# Basic MQTT test
./bin/mct test \
  --middleware emqx \
  --broker tcp://localhost:1883 \
  --client-id test-client \
  --topic test/topic \
  --duration 30s \
  --operations 5000

# MQTT with QoS levels
./bin/mct test \
  --middleware emqx \
  --broker tcp://localhost:1883 \
  --topic test/topic \
  --qos 1 \
  --clean-session true \
  --duration 60s \
  --operations 10000

# MQTT over TLS
./bin/mct test \
  --middleware emqx \
  --broker ssl://localhost:8883 \
  --topic test/topic \
  --ca-cert /path/to/ca.crt \
  --client-cert /path/to/client.crt \
  --client-key /path/to/client.key \
  --duration 60s

# Using Docker (standalone mode)
docker run -d --name nacos-test \
  -p 8848:8848 \
  -p 9848:9848 \
  -e MODE=standalone \
  nacos/nacos-server:v2.4.3

# Access console: http://localhost:8848/nacos
# Default credentials: nacos / nacos

# Service Registry test
./bin/mct test \
  --middleware nacos \
  --servers localhost:8848 \
  --service-name test-service \
  --namespace public \
  --duration 30s \
  --operations 5000

# Configuration Management test
./bin/mct test \
  --middleware nacos \
  --servers localhost:8848 \
  --data-id test-config \
  --group DEFAULT_GROUP \
  --namespace public \
  --duration 60s \
  --operations 10000

# With authentication (Nacos 2.x)
./bin/mct test \
  --middleware nacos \
  --servers localhost:8848 \
  --service-name test-service \
  --username nacos \
  --password nacos \
  --namespace dev \
  --duration 60s

# Run all unit tests
go test ./tests/unit/... -v

# Run tests for specific middleware
go test ./tests/unit/middleware/redis_client_test.go -v
go test ./tests/unit/middleware/kafka_client_test.go -v
go test ./tests/unit/middleware/mongodb_client_test.go -v
go test ./tests/unit/middleware/rocketmq_client_test.go -v
go test ./tests/unit/middleware/rabbitmq_client_test.go -v
go test ./tests/unit/middleware/emqx_client_test.go -v
go test ./tests/unit/middleware/nacos_client_test.go -v

# Run with coverage
go test ./tests/unit/... -cover -coverprofile=coverage.out

# View coverage report
go tool cover -html=coverage.out

# Run integration tests (requires running middleware services)
go test ./tests/integration/... -v

# Run specific integration test
go test ./tests/integration/redis_integration_test.go -v

# Run E2E tests
go test ./tests/e2e/... -v

# Run with timeout
go test ./tests/e2e/... -v -timeout 10m

# Run unit tests
make test-unit

# Run integration tests
make test-integration

# Run all tests
make test

# Generate coverage report
make coverage

# Run tests with race detector
make test-race

./bin/mct test --config configs/test-redis.yaml

# Install development tools
go install golang.org/x/tools/cmd/goimports@latest
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# Download dependencies
go mod download

# Start development environment (all middleware)
docker-compose up -d

# Format code
go fmt ./...
goimports -w .

# Lint code
golangci-lint run

# Run all checks
go fmt ./... && golangci-lint run && go test ./tests/unit/... -cover