AutoMock 🧪⚡

AutoMock is a cloud-native CLI tool that generates and deploys production-ready mock API servers from natural language descriptions, API collections, or an interactive builder. Spin up fully managed mock servers on AWS with auto-scaling, monitoring, and built-in load testing support.

Cloud provider support is currently AWS-only. GCP and Azure are planned but not yet available.

🌟 Highlights

🤖 AI-Generated Mocks — Describe your API in natural language, get complete MockServer configurations
☁️ Cloud-Native Deployment — One command deploys ECS Fargate + ALB + Auto-scaling
📦 Multi-Format Import — Postman, Bruno, Insomnia collections → MockServer expectations
🔧 Interactive Builder — 7-step guided builder for precise control
⚡ Auto-Scaling — CPU/Memory/Request-based (configurable; defaults: 10–200 tasks)
💾 Cloud Storage — S3-backed, versioned, team-accessible expectations
🎭 Advanced Features — Progressive delays, GraphQL, response templates, response limits
🧪 Load Testing — Locust bundle generation and managed AWS deployment
🔐 Production-Ready — ALB health checks, CloudWatch monitoring, IAM best practices

🗺️ Installation

Option A — Homebrew (macOS / Linux)

brew tap hemantobora/tap
brew install automock
automock --version

Or directly: brew install hemantobora/tap/automock

Option B — Scoop (Windows)

scoop bucket add hemantobora https://github.com/hemantobora/scoop-bucket
scoop install automock
automock --version

Option C — Download release binary

Go to the Releases page
Download the archive for your OS/arch (e.g., automock_darwin_arm64.tar.gz)
Extract and place the binary on your PATH:

tar -xzf automock_*.tar.gz
sudo mv automock /usr/local/bin/
automock --version

Option D — Build from source

Requires Go 1.22+:

git clone https://github.com/hemantobora/auto-mock.git
cd auto-mock
go build -o automock ./cmd/auto-mock

Upgrading

Homebrew: brew upgrade automock
Scoop: scoop update automock
Binary: download the newer version and replace the existing binary

🚀 Quick Start

# Set your AI provider key (choose one)
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."

# Generate mock expectations
automock init --project user-api --provider anthropic

# Deploy to AWS
automock deploy --project user-api

Your mock API is now live at the ALB endpoint shown after deploy.

📖 Documentation

Document	Description
GETTING_STARTED.md	Complete setup guide, tutorials, examples
`automock help`	CLI reference

✨ Key Features

🤖 AI-Powered Generation

Generate complete MockServer configurations from natural language:

automock init --project my-api --provider anthropic

Prompt: "User management API with registration, login, profile CRUD, password reset, and admin functions"

AI generates:

All CRUD endpoints (GET /users, POST /users, PUT /users/{id}, etc.)
Authentication flows (login, logout, token refresh)
Admin-only endpoints with authorization
Error responses (400, 401, 403, 404, 500)
Realistic test data with proper types
Request validation rules
Multiple scenarios per endpoint

Supported AI Providers:

Anthropic (Claude Sonnet 4.5)
OpenAI (GPT-4)
Template (no AI, fallback mode)

📦 Collection Import

Import existing API definitions from popular tools:

automock init \
  --project api-mock \
  --collection-file api.postman_collection.json \
  --collection-type postman

Supported Formats:

Postman Collection v2.1 (.json)
Bruno Collection (.json)
Insomnia Workspace (.json)

Features:

Sequential API execution with variable resolution
Interactive matching configuration (guided; no automatic scenario inference)
Auto-incremented priorities to avoid collisions
Pre/post-script processing (Postman-like JS via embedded engine)
Auth mapping to headers when provided in the collection

Example: Multi-Scenario Configuration

GET /api/users/123:
  Priority 100: Anonymous → 401 Unauthorized
  Priority 200: Authenticated → 200 OK (user data)
  Priority 300: Admin → 200 OK (admin view)
  Priority 400: Rate limited → 429 Too Many Requests

🔧 Interactive Builder

Precision-controlled, step-by-step expectation creation:

automock init --project my-api
# Select: interactive

7-Step Process:

Basic Info — Description, priority, tags
Request Matching — Method, path, query params, headers
Response Configuration — Status code, headers, body templates
Advanced Features — Delays, caching, compression
Connection Options — Socket config, keep-alive
Response Limits — Serve unlimited times or expire after N requests
Review & Confirm — Validate before saving

Advanced Request Matching:

Path parameters: /users/{id}/orders/{orderId}
Regex paths: /api/.*/status
Query string matching: ?status=active&limit=10
Header validation: Authorization: Bearer *
Body matching: exact, partial, regex, JSONPath

Response Features:

Template variables: $!uuid, $!now_epoch, $!request.headers['X-Request-ID'][0]
Progressive delays: 100ms → 150ms → 200ms…
Multiple response bodies per expectation

☁️ Cloud Deployment

Deploy production-ready infrastructure with one command:

automock deploy --project my-api

What Gets Deployed:

┌─────────────────────────────────────────┐
│  Application Load Balancer (Public)     │
│  https://automock-{project}-{id}.elb…  │
└─────────────┬───────────────────────────┘
              │
    ┌─────────┴──────────┐
    │  Target Groups      │
    │  • API (/)          │
    │  • Dashboard        │
    └─────────┬───────────┘
              │
┌─────────────┴────────────────────────────┐
│  ECS Fargate Cluster                     │
│  • MockServer (port 1080)                │
│  • Config Loader (sidecar)               │
│  • Auto-scaling: configurable            │
│    (defaults: 10–200 tasks)              │
└──────────────────────────────────────────┘
              │
    ┌─────────┴──────────┐
    │  S3 Bucket          │
    │  expectations.json  │
    │  (versioned)        │
    └─────────────────────┘

Infrastructure Features:

Auto-Scaling — CPU/Memory/Request-based (10–200 tasks by default)
Monitoring — CloudWatch metrics, logs, alarms
Health Checks — ALB target health, /mockserver/status
Security — IAM roles, security groups, private subnets
Custom Domain — ACM certificate + Route53 (optional, prompted at deploy time)
Private ALB — Optional internal ALB for VPC-internal clients (e.g., Locust)
BYO Networking — Use existing VPC, subnets, IGW, NAT, IAM roles, and security groups

Accessing Your Mock:

# API endpoint
curl https://automock-my-api-123.us-east-1.elb.amazonaws.com/api/users

# MockServer Dashboard
open https://automock-my-api-123.us-east-1.elb.amazonaws.com/mockserver/dashboard

📊 Project Management

Manage expectations throughout their lifecycle:

# View / add / edit / remove / replace / download / delete
automock init --project my-api
# → Select the desired action from the menu

Action	Description
`view`	List all expectations
`add`	Add new expectations (any generation mode)
`edit`	Edit specific expectations
`remove`	Remove selected expectations
`replace`	Replace all expectations
`download`	Save to `{project}-expectations.json`
`delete`	Tear down project and all infrastructure

🧪 Load Testing — Local

Generate Locust load testing bundles from a collection:

automock load \
  --collection-file api.json \
  --collection-type postman \
  --dir ./load-tests \
  --distributed

cd load-tests
./run_locust_ui.sh
# Browser opens at http://localhost:8089

Generated Files:

locustfile.py — Test scenarios
requirements.txt — Python dependencies
run_locust_ui.sh / .ps1 — Start with web UI
run_locust_headless.sh / .ps1 — Run without UI
run_locust_master.sh / .ps1 — Distributed master
run_locust_worker.sh / .ps1 — Distributed worker

Variable substitution:

${env.VAR} — Expanded at load-time across the spec
${data.<field>} and ${user.id|index} — Expanded at runtime in path, headers, params, and body
In auth.mode: shared, only ${env.*} expands; in auth.mode: per_user, ${data.*} and ${user.*} also expand in the login path/headers/body

☁️ Managed Locust on AWS

Deploy a Locust cluster to AWS via the same deploy command. The stack provisions an ECS Fargate cluster (master + configurable workers), an ALB for the Locust UI, and Cloud Map service discovery between master and workers.

Deploy:

# Upload your load test bundle first
automock load --project my-api --upload --dir ./load-tests

# Deploy infrastructure (prompts for sizing and optional BYO networking)
automock deploy --project my-api

Scale workers:

automock deploy --project my-api
# → When already deployed, prompts for new worker count

Destroy:

automock destroy --project my-api
# → Select: mocks, loadtest, or both

What you get:

Public ALB with HTTP and HTTPS access to the Locust master UI (self-signed cert)
ECS task definitions for master and workers
Cloud Map private namespace for master–worker discovery
CloudWatch log groups with configurable retention
Security groups with least-privilege rules

Custom Locust image (optional):

By default the module uses public images (locustio/locust:2.31.2 + python:3.11-slim init sidecar). If you prefer faster cold-starts without runtime installs, build a derived image with Locust and boto3 pre-installed and set the locust_container_image Terraform variable before deploying.

Troubleshooting — locustfile.py not found:

If Locust logs show Could not find '/workspace/locustfile.py', check:

No bundle has been uploaded yet — run automock load --project <name> --upload --dir ./load-tests
The pointer file current.json is missing — re-uploading a bundle recreates it
IAM permissions missing: the task role needs s3:GetObject and s3:ListBucket on the project bucket

🎯 Use Cases

Frontend Development

Mock backend APIs before they exist:

automock init --project frontend-mock --provider anthropic
# Describe: "REST API for blog app: posts, comments, users"
automock deploy --project frontend-mock

Integration Testing

Consistent, controlled test environments in CI/CD:

automock deploy --project test-api --skip-confirmation
npm run test:integration -- --api-url https://automock-test-api-123.elb.amazonaws.com
automock destroy --project test-api --force

Third-Party API Simulation

Test against external APIs without rate limits or costs:

automock init \
  --project stripe-mock \
  --collection-file stripe-api.postman_collection.json \
  --collection-type postman

Performance Testing

Generate and deploy load tests against your mock:

automock load \
  --collection-file prod-api.json \
  --collection-type postman \
  --dir ./load-tests
automock load --project prod-api --upload --dir ./load-tests
automock deploy --project prod-api

💰 Cost Estimates

Default AWS Infrastructure (10 tasks, 24/7)

min_tasks and max_tasks are both configurable at deploy time. The table below reflects the defaults. Using BYO networking (existing VPC, subnets, and NAT) eliminates the NAT Gateway cost.

Component	Monthly Cost
ECS Fargate (0.25 vCPU, 0.5 GB)	~$35
Application Load Balancer	~$16
NAT Gateway	~$32
Data Transfer	~$9
CloudWatch Logs	~$0.50
S3 Storage	~$0.30
Total	~$93

Rough estimates; varies by region, traffic, and log volume. Validate with the AWS Pricing Calculator.

Hourly rate (10 tasks): ~$0.13/hour

AI Generation Costs

Provider	Cost per Generation
Claude Sonnet 4.5	$0.05 – $0.20
GPT-4	$0.10 – $0.30

Cost tips: Destroy when not in use (automock destroy --project <name>), reduce task count for smaller APIs, or use BYO networking to share existing NAT Gateways.

🏗️ Infrastructure Details

Auto-Scaling Policies

Scale Up (Aggressive):

CPU 70–80% → +50% tasks
CPU 80–90% → +100% tasks
CPU 90%+ → +200% tasks
Memory thresholds follow the same pattern
Requests/min: 500–1000 → +50%, 1000+ → +100%

Scale Down (Conservative):

CPU < 40% for 5 minutes → −25% tasks
Cooldown: 5 minutes between scale events

Limits: minimum 10 tasks, maximum 200 tasks (both configurable)

Monitoring & Alerts

CloudWatch Metrics: ECS CPU/memory/task count, ALB request count/response time/4xx/5xx errors

Alarms: unhealthy host count > 0, 5XX errors > 10/min, CPU > 70% for 10 min, Memory > 80% for 10 min

Security

IAM — Least-privilege, separate task execution and task roles, no hardcoded credentials; optional permissions boundary and custom role path
Networking — ECS tasks in private subnets, NAT for outbound only, security groups restrict traffic to ALB
Data — S3 server-side encryption (AES-256), versioning enabled, CloudWatch Logs retention: 30 days

🔧 Advanced Features

Progressive Response Delays

Simulate degrading performance:

{
  "progressive": {
    "base": 100,
    "step": 50,
    "cap": 500
  }
}

Request 1: 100ms → Request 2: 150ms → … → capped at 500ms

Response Templates

Dynamic values in responses:

{
  "id": "$!uuid",
  "timestamp": "$!now_epoch",
  "requestId": "$!request.headers['x-request-id'][0]",
  "userId": "$!request.pathParameters['userId'][0]",
  "randomScore": "$!rand_int_100"
}

Available variables: $!uuid, $!now_epoch, $!rand_int_100, $!rand_bytes_64, $!request.path, $!request.method, $!request.headers['X-Header'][0], $!request.pathParameters['param'][0], $!request.queryStringParameters['query'][0]

GraphQL Support

Basic GraphQL request matching (no schema validation):

{
  "httpRequest": {
    "method": "POST",
    "path": "/graphql",
    "body": {
      "query": {"contains": "query GetUser"},
      "variables": {"userId": "123"}
    }
  },
  "httpResponse": {
    "body": {"data": {"user": {"id": "123", "name": "John"}}}
  }
}

Supported: query string contains, operation name matching, optional variables matching (exact).

📂 Project Structure

auto-mock/
├── cmd/auto-mock/           # CLI entrypoint
├── internal/
│   ├── cloud/               # Cloud provider abstraction
│   │   ├── aws/             # AWS implementation (S3, ECS, IAM)
│   │   ├── factory.go       # Provider detection & initialization
│   │   └── manager.go       # Orchestration & workflows
│   ├── mcp/                 # AI provider integration (Anthropic, OpenAI)
│   ├── builders/            # Interactive expectation builders
│   ├── collections/         # Collection parsers (Postman, Bruno, Insomnia)
│   ├── expectations/        # Expectation CRUD operations
│   ├── repl/                # Interactive CLI flows
│   ├── terraform/           # Embedded infrastructure modules
│   └── models/              # Data structures
├── go.mod
├── build.sh
├── README.md
└── LICENSE

📊 Roadmap

🛠️ Development

git clone https://github.com/hemantobora/auto-mock.git
cd auto-mock
go mod download
go build -o automock ./cmd/auto-mock

# Run tests
go test ./...

🤝 Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Areas we'd love help with: Azure/GCP provider support, Swagger/OpenAPI import, Bruno .bru format, Web UI for expectation management, Prometheus metrics export.

📄 License

This project is licensed under the MIT License — see the LICENSE file for details.

🙏 Acknowledgments

MockServer — Powerful HTTP mocking server
Anthropic — Claude AI for intelligent mock generation
OpenAI — GPT-4 for intelligent mock generation
AWS — Cloud infrastructure platform
Terraform — Infrastructure as Code

📞 Support

Documentation: GETTING_STARTED.md, automock help
GitHub Issues: Create an issue
Email: hemantobora@gmail.com

Built with ❤️ by Hemanto Bora

GitHub • Issues

Name		Name	Last commit message	Last commit date
Latest commit History 77 Commits
.github/workflows		.github/workflows
cmd/auto-mock		cmd/auto-mock
internal		internal
.gitignore		.gitignore
.goreleaser.yaml		.goreleaser.yaml
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
GETTING_STARTED.md		GETTING_STARTED.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
build.sh		build.sh
docker-compose.yml		docker-compose.yml
go.mod		go.mod
go.sum		go.sum

Folders and files

Latest commit

History

Repository files navigation

AutoMock 🧪⚡

🌟 Highlights

🗺️ Installation

Option A — Homebrew (macOS / Linux)

Option B — Scoop (Windows)

Option C — Download release binary

Option D — Build from source

Upgrading

🚀 Quick Start

📖 Documentation

✨ Key Features

🤖 AI-Powered Generation

📦 Collection Import

🔧 Interactive Builder

☁️ Cloud Deployment

📊 Project Management

🧪 Load Testing — Local

☁️ Managed Locust on AWS

🎯 Use Cases

Frontend Development

Integration Testing

Third-Party API Simulation

Performance Testing

💰 Cost Estimates

Default AWS Infrastructure (10 tasks, 24/7)

AI Generation Costs

🏗️ Infrastructure Details

Auto-Scaling Policies

Monitoring & Alerts

Security

🔧 Advanced Features

Progressive Response Delays

Response Templates

GraphQL Support

📂 Project Structure

📊 Roadmap

🛠️ Development

🤝 Contributing

📄 License

🙏 Acknowledgments

📞 Support

About

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases 12

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages