MockWails

About

MockWails is a comprehensive desktop application designed for developers, testers, and API designers who need to create and manage mock HTTP servers efficiently. Built with modern technologies including Wails v2, Go, and React, it provides a seamless experience for API mocking and testing.

Why MockWails?

• 🚀 Fast & Lightweight: Native desktop pericnoformance with minimal resource usage
• 🎯 Developer-Friendly: Intuitive interface designed by developers, for developers
• ⚡ Instant Setup: Create and deploy mock servers in seconds
• 🔧 Highly Configurable: Fine-tune every aspect of your mock responses
• 💾 Persistent Storage: All configurations saved locally with SQLite
• 🔄 Auto-Recovery: Servers automatically restart when the application launches
• 🌐 Multi-Platform: Available for Windows, macOS, and Linux

The application allows you to define sophisticated mock servers with specific endpoints, HTTP methods, response statuses, custom headers, and response bodies. All configurations are persisted in a local SQLite database, ensuring your mock setups are preserved across application restarts. Active servers are automatically restarted when the application launches, making it perfect for development workflows.

✨ Features

Core Functionality

• 🏗️ Create and Manage Mock Servers: Intuitive interface for creating, editing, and deleting mock servers with comprehensive configuration options
• 🎨 Customizable Responses: Full control over HTTP responses including:
  • Custom endpoints and HTTP methods (GET, POST, PUT, DELETE, PATCH)
  • Configurable status codes (200, 404, 500, etc.)
  • Custom headers and response bodies (JSON, XML, HTML, plain text)
  • Request validation with expected headers and body matching
  • Simulated response latency for realistic testing
• 💾 Persistent Storage: All mock server configurations are automatically saved to a local SQLite database
• 🔄 Automatic Restart: Active servers intelligently restart when the application launches, maintaining your development workflow
• 🎯 Easy to Use UI: Clean, modern, and intuitive user interface with dark/light theme support

Advanced Features

• 📊 Real-time Status Monitoring: Live status indicators showing which servers are running
• 🔍 Request Inspection: Monitor incoming requests to your mock servers
• ⚡ Quick Actions: Start, stop, edit, and delete servers with single-click actions
• 🔄 Bulk Operations: Manage multiple servers simultaneously
• 📱 Responsive Design: Optimized interface that works perfectly on any screen size
• 🎨 Modern UI Components: Built with Shadcn UI for consistency and accessibility

Developer Experience

• 🚀 Hot Reload: Instant updates during development
• 📝 TypeScript Support: Full type safety across the entire application
• 🧪 Testing Ready: Perfect for API testing, frontend development, and CI/CD pipelines
• 🔧 Extensible: Clean architecture for easy customization and extension

🖼️ Screenshots

🚀 Getting Started

Prerequisites

• Go 1.21+: Download and install Go
• Node.js 18+: Download and install Node.js
• Wails CLI: Install with go install github.com/wailsapp/wails/v2/cmd/wails@latest

Quick Start

1. Clone the repository:

   git clone https://github.com/tacheraSasi/mockwails.git
   cd mockwails
   

2. Install dependencies:

   make deps
   

3. Run in development mode:

   make dev
   

4. Build for production:

   # For your current platform
   wails build
   
   # Or use make commands for specific platforms
   make build-mac      # macOS universal binary
   make build-windows  # Windows 64-bit
   make build-linux    # Linux 64-bit
   

Usage Examples

Creating Your First Mock Server

1. Launch MockWails and click "Create Mock Endpoint"
2. Configure your endpoint:
   • Name: "User API"
   • Endpoint: "/api/users"
   • Method: "GET"
   • Response: {"users": [{"id": 1, "name": "John Doe"}]}
   • Status Code: 200
3. Click "Create" - your mock server starts automatically
4. Test it: Visit http://localhost:8080/api/users in your browser

Advanced Configuration

{
  "endpoint": "/api/users",
  "method": "POST",
  "expectedHeaders": {
    "Content-Type": "application/json",
    "Authorization": "Bearer token"
  },
  "expectedBody": {
    "name": "string",
    "email": "string"
  },
  "response": {
    "status": 201,
    "headers": {
      "Content-Type": "application/json"
    },
    "body": {
      "id": 123,
      "message": "User created successfully"
    }
  },
  "latency": 500
}

🛠️ Tech Stack

Backend

• Go: High-performance backend with excellent concurrency
• Wails v2: Modern desktop app framework bridging Go and web technologies
• SQLite: Embedded database for configuration persistence
• GORM: Elegant ORM for database operations

Frontend

• React 18: Modern UI library with hooks and concurrent features
• TypeScript: Type safety and enhanced developer experience
• Shadcn UI: Beautiful, accessible, and customizable components
• Tailwind CSS: Utility-first CSS framework for rapid styling
• Vite: Lightning-fast build tool and development server

Development Tools

• Biome: Fast formatter and linter for JavaScript/TypeScript
• React Hook Form: Performant forms with easy validation
• Sonner: Beautiful toast notifications

🔧 Development

Live Development

For the best development experience with hot reload:

# Install dependencies (only needed once)
make deps

# Start development server with hot reload
make dev

This starts the app with hot reload for both frontend and backend. For frontend-only development in a browser (with access to Go methods), open http://localhost:34115 in your browser.

Development Workflow

1. Backend Changes: Modify Go files - Wails automatically rebuilds and restarts
2. Frontend Changes: Edit React/TypeScript files - Vite provides instant hot reload
3. Database Changes: Update models in db/ - restart required for schema changes
4. UI Components: Modify components in frontend/src/components/ - see changes instantly

Project Structure

mockwails/
├── app.go              # Main application logic and Wails bindings
├── main.go             # Application entry point
├── wails.json          # Wails configuration
├── config/             # Application configuration
│   └── config.go
├── db/                 # Database models and operations
│   ├── db.go           # Database initialization
│   ├── server.go       # Server model definitions
│   ├── server_ops.go   # Server CRUD operations
│   └── migrate.go      # Database migrations
├── mockserver/         # HTTP server implementation
│   ├── server.go       # Mock server logic
│   └── templates.go    # HTML templates for 404 pages
├── utils/              # Utility functions
│   └── utils.go
├── frontend/           # React frontend
│   ├── src/
│   │   ├── components/ # Reusable UI components
│   │   ├── pages/      # Application pages
│   │   ├── contexts/   # React contexts
│   │   └── lib/        # Utility functions
│   └── wailsjs/        # Generated Wails bindings
└── build/              # Build outputs and assets

📦 Building

Production Builds

To build a redistributable, production-ready package:

# Build for your current platform
wails build

# Or use platform-specific make commands
make build-windows    # Windows 64-bit (.exe)
make build-linux      # Linux 64-bit (AppImage)
make build-mac        # macOS universal binary (.app)

Build Outputs

• Windows: build/bin/MockWails.exe
• macOS: build/bin/MockWails.app
• Linux: build/bin/MockWails (executable)

Distribution

The built applications are self-contained and don't require any additional dependencies. They can be distributed directly to end users.

🛠️ Makefile Commands

The project includes a comprehensive Makefile to simplify common development tasks. Run make help to see all available commands:

Development Commands

• make dev - Run the application in development mode with hot reloading
• make deps - Install frontend dependencies from package.json
• make clean - Clean build artifacts and temporary files

Build Commands

• make build-windows - Build the application for Windows (64-bit)
• make build-linux - Build the application for Linux (64-bit)
• make build-mac - Build the application for macOS (universal binary)

Code Quality Commands

• make lint - Lint the frontend code using Biome
• make format - Format the frontend code using Biome
• make check - Check and apply automatic fixes to the frontend code using Biome

Database Commands

• make db-reset - Reset the database (removes all data)
• make db-migrate - Run database migrations

Example Workflow

# Setup project
make deps

# Start development
make dev

# Before committing
make check
make lint

# Build for production
make build-mac

📋 Use Cases

API Development & Testing

• Frontend Development: Mock backend APIs before they're implemented
• API Design: Prototype and test API responses during design phase
• Integration Testing: Create predictable endpoints for automated testing
• Third-party API Simulation: Mock external services for development

DevOps & CI/CD

• Build Pipelines: Provide consistent mock services for automated tests
• Environment Testing: Simulate different API responses and error conditions
• Load Testing: Create lightweight mock endpoints for performance testing
• Staging Environments: Replace expensive external dependencies

Education & Training

• API Learning: Understand HTTP protocols and REST principles
• Workshop Demos: Quick setup for coding workshops and tutorials
• Student Projects: Provide APIs for learning frontend development
• Interview Preparation: Practice API integration skills

🤝 Contributing

We welcome contributions! Here's how you can help:

Getting Started

1. Fork the repository on GitHub
2. Clone your fork: git clone https://github.com/yourusername/mockwails.git
3. Create a branch: git checkout -b feature/amazing-feature
4. Make your changes and test thoroughly
5. Commit your changes: git commit -m 'Add amazing feature'
6. Push to the branch: git push origin feature/amazing-feature
7. Open a Pull Request

Development Guidelines

• Follow existing code style and patterns
• Write clear commit messages
• Add tests for new features
• Update documentation as needed
• Run make check before submitting

Ways to Contribute

• 🐛 Bug Reports: Found a bug? Open an issue with details
• 💡 Feature Requests: Have an idea? We'd love to hear it
• 📖 Documentation: Help improve our docs
• 🧪 Testing: Add test cases and improve coverage
• 🎨 UI/UX: Enhance the user interface and experience

📄 License

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

🙏 Acknowledgments

• Wails Team - For the amazing desktop app framework
• Shadcn - For the beautiful UI component library
• Go Community - For the robust backend language
• React Team - For the powerful frontend framework

📞 Support & Contact

• GitHub Issues: Report bugs or request features
• Discussions: Join community discussions

---