### Install Unimock Go Client

Source: https://github.com/bmcszk/unimock/blob/master/docs/client.md

Use 'go get' to install the Unimock Go client library. This command fetches and installs the specified package.

```bash
go get github.com/bmcszk/unimock/pkg/client
```

--------------------------------

### Run Unimock Example

Source: https://github.com/bmcszk/unimock/blob/master/examples/library/README.md

Execute the example using the Go run command. This starts a mock server on port 8081.

```bash
go run .
```

--------------------------------

### Test Environment Configuration Example

Source: https://github.com/bmcszk/unimock/blob/master/docs/testing-guidelines.md

Shows how to define test-specific environment variables in a .env.test file and load them during test setup.

```dotenv
# .env.test
TEST_DB_URL=postgres://test:test@localhost:5433/testdb
TEST_SQS_QUEUE_URL=http://localhost:4566/000000000000/test-queue
TEST_SERVICE_ADDRESS=http://localhost:18082
```

```go
// Test setup with environment loading
func newParts(t *testing.T) (*parts, *parts, *parts) {
    t.Helper()
    var envs config.Environment
    
    // Load test-specific environment
    err := godotenv.Load(".env.test")
    assert.NoError(t, err, "load test config")

    err = env.Parse(&envs)
    assert.NoError(t, err, "parse test config")
    
    // Continue with test setup...
}
```

--------------------------------

### Start Tilt Development Environment

Source: https://github.com/bmcszk/unimock/blob/master/docs/deployment.md

Run this command to start the local development environment with Tilt. It automates cluster creation, image building, deployment, and live reload setup.

```bash
make tilt-run
```

--------------------------------

### Install and Run Unimock Binary from Source

Source: https://github.com/bmcszk/unimock/blob/master/docs/deployment.md

Instructions for installing the Unimock binary by cloning the repository and building it locally. This method is useful for development or when direct Go installation is not preferred.

```bash
# Install from source
git clone https://github.com/bmcszk/unimock.git
cd unimock
make build
./unimock
```

--------------------------------

### Unimock Installation Methods

Source: https://github.com/bmcszk/unimock/blob/master/README.md

Overview of different methods to install and run Unimock, including Docker, Helm, local build, and as a Go library.

```markdown
| Method | Command | Use Case |
|--------|---------|----------|
| **Docker** | `docker run -p 8080:8080 ghcr.io/bmcszk/unimock` | Quick testing |
| **Helm (Registry)** | `helm install unimock oci://ghcr.io/bmcszk/charts/unimock` | Production |
| **Local Build** | `make build && ./unimock` | Development |
| **Go Library** | `import "github.com/bmcszk/unimock/pkg"` | Embed in apps |
```

--------------------------------

### Quick Start: Unimock Go Client Usage

Source: https://github.com/bmcszk/unimock/blob/master/docs/client.md

Demonstrates creating a client, performing a POST request to store data, and a GET request to retrieve it. Assumes the Unimock server is running on localhost:8080.

```go
package main

import (
    "context"
    "fmt"
    "log"
    
    "github.com/bmcszk/unimock/pkg/client"
)

func main() {
    // Create client (uses localhost:8080 if URL is empty)
    c, err := client.NewClient("http://localhost:8080")
    if err != nil {
        log.Fatal(err)
    }
    
    ctx := context.Background()
    
    // Store data via POST
    headers := map[string]string{"Content-Type": "application/json"}
    data := `{"id": "123", "name": "John Doe", "email": "john@example.com"}`
    
    resp, err := c.Post(ctx, "/api/users", headers, []byte(data))
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Created: %d\n", resp.StatusCode)
    
    // Retrieve data via GET
    resp, err = c.Get(ctx, "/api/users/123", nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Retrieved: %s\n", string(resp.Body))
}
```

--------------------------------

### Install Unimock Go Package

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Use 'go get' to install the Unimock package for use in your Go projects.

```bash
go get github.com/bmcszk/unimock/pkg
```

--------------------------------

### Install Unimock Binary with Go

Source: https://github.com/bmcszk/unimock/blob/master/docs/deployment.md

Install the Unimock standalone binary using the Go toolchain. This is a convenient way to get the latest version for direct command-line usage.

```bash
# Install with Go
go install github.com/bmcszk/unimock@latest
unimock
```

--------------------------------

### Environment Configuration Example

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Shows example environment variables for database, SQS, and service addresses, along with Go code to load and parse these configurations using godotenv.

```text
// .env.test
TEST_DB_URL=postgres://test:test@localhost:5433/testdb
TEST_SQS_QUEUE_URL=http://localhost:4566/000000000000/test-queue
TEST_SERVICE_ADDRESS=http://localhost:18082
```

```go
// Test setup with environment loading
func newParts(t *testing.T) (*parts, *parts, *parts) {
    t.Helper()
    var envs config.Environment

    // Load test-specific environment
    err := godotenv.Load(".env.test")
    assert.NoError(t, err, "load test config")

    err = env.Parse(&envs)
    assert.NoError(t, err, "parse test config")

    // Continue with test setup...
}
```

--------------------------------

### Unimock Quick Reference - GET Test

Source: https://github.com/bmcszk/unimock/blob/master/README.md

Example of how to test a GET request to the Unimock server using curl.

```bash
curl :8080/api/users/1
```

--------------------------------

### Unimock Configuration for Practical Example

Source: https://github.com/bmcszk/unimock/blob/master/prds/strict_path_matching/strict_path_matching_prd.md

This YAML configuration is used for a practical example comparing strict and flexible path matching behaviors.

```yaml
sections:
  regular_users:
    path_pattern: "/users/*"
    strict_path: false
    body_id_paths: ["/id"]
  
  admin_users:
    path_pattern: "/admin/users/*"
    strict_path: true
    body_id_paths: ["/id"]
```

--------------------------------

### Start Embedded Unimock Server in Go

Source: https://github.com/bmcszk/unimock/blob/master/docs/deployment.md

This Go code snippet demonstrates how to initialize and start an embedded Unimock server. Ensure you have the necessary imports and mock configuration defined.

```go
import "github.com/bmcszk/unimock/pkg"

// Start embedded server
server, err := pkg.NewServer(
    pkg.WithPort(8080),
    pkg.WithMockConfig(mockConfig),
)
if err != nil {
    log.Fatal(err)
}

go server.ListenAndServe()
```

--------------------------------

### Implement Clean Test Setup Separation in Go

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Shows the correct pattern for separating test setup from test logic using a fluent interface. This improves readability and maintainability.

```go
// GOOD: Clean setup separation
func TestVideoProcessing(t *testing.T) {
    given, when, then := newParts(t)

    given.
        setupVideoProcessingEnvironment().and().
        uploadTestVideo()

    when.
        startVideoProcessing()

    then.
        videoProcessedSuccessfully().and().
        assetsCreated()
}

func (p *parts) setupVideoProcessingEnvironment() *parts {
    // All complex setup encapsulated in helper method
    p.db = setupDatabase(p.T, "test-config.sql")
    p.sqsClient = setupSQS(p.T)
    p.s3Client = setupS3(p.T)
    p.videoProcessor = NewVideoProcessor(p.db, p.sqsClient, p.s3Client)
    return p
}
```

--------------------------------

### Install Unimock from Local Chart

Source: https://github.com/bmcszk/unimock/blob/master/docs/deployment.md

Install Unimock from a local chart directory after cloning the repository. Supports default installation or installation with custom values.

```bash
# Clone repository
git clone https://github.com/bmcszk/unimock.git
cd unimock

# Install with defaults
helm install my-unimock ./helm/unimock

# Install with custom values
helm install my-unimock ./helm/unimock -f my-values.yaml
```

--------------------------------

### Install Unimock Helm Chart from Source

Source: https://github.com/bmcszk/unimock/blob/master/helm/unimock/README.md

Clone the Unimock repository and install the Helm chart directly from the local source files. This is an alternative to installing from a published repository.

```bash
git clone https://github.com/bmcszk/unimock.git
cd unimock/helm
helm install my-unimock ./unimock
```

--------------------------------

### Valid Fixture File Syntax Examples

Source: https://github.com/bmcszk/unimock/blob/master/CLAUDE.md

Illustrates valid syntax for loading fixture files, including space after '<' and immediate '@' after '<'.

```text
"< file" - VALID (space after <)
"<@ file" - VALID (@ immediately after <, space after @)
```

--------------------------------

### Troubleshoot Unimock Pod Startup

Source: https://github.com/bmcszk/unimock/blob/master/helm/unimock/README.md

If a Unimock pod fails to start, check resource limits and pull secrets. Use `kubectl describe pod` to get detailed information about the pod's status and events.

```bash
kubectl describe pod -l app.kubernetes.io/name=unimock
```

--------------------------------

### Start Unimock with Unified Config

Source: https://github.com/bmcszk/unimock/blob/master/docs/scenarios.md

Commands to start the Unimock service using a unified configuration file, either directly or via Docker.

```bash
# Using unified config file
unimock

# Using Docker with unified config
docker run -p 8080:8080 \
  -v $(pwd)/config.yaml:/etc/unimock/config.yaml \
  ghcr.io/bmcszk/unimock:latest
```

--------------------------------

### Simplified Unified Configuration Scenario

Source: https://github.com/bmcszk/unimock/blob/master/docs/scenarios.md

A minimal example of a scenario defined in a unified configuration file, focusing on a GET request for a specific user.

```yaml
sections:
  users:
    path_pattern: "/api/users/*"
    body_id_paths: ["/id"]

scenarios:
  - uuid: "example-user-001"
    method: "GET"
    path: "/api/users/123"
    status_code: 200
    content_type: "application/json"
    data: |
      {
        "id": "123",
        "name": "John Doe",
        "email": "john.doe@example.com"
      }
```

--------------------------------

### Anti-Pattern: Complex Test Setup

Source: https://github.com/bmcszk/unimock/blob/master/docs/testing-guidelines.md

Demonstrates a test where setup logic is intertwined with test execution and assertions, making it hard to read and maintain.

```go
// Bad: Test setup mixed with test logic
func TestBadExample(t *testing.T) {
    // Complex setup mixed in
    db, err := sqlx.Connect("postgres", "postgres://test:test@localhost:5433/testdb")
    if err != nil {
        t.Fatal(err)
    }
    
    httpClient := &http.Client{}
    sqsClient := setupSQSClient()
    
    // Test logic buried in setup
    resp, err := httpClient.Post("http://localhost:8080/videos", "application/json", bytes.NewReader(data))
    if err != nil {
        t.Fatal(err)
    }
    
    // Assertions mixed with setup
    if resp.StatusCode != 201 {
        t.Errorf("expected 201, got %d", resp.StatusCode)
    }
}
```

--------------------------------

### Install Unimock from Registry

Source: https://github.com/bmcszk/unimock/blob/master/docs/deployment.md

Install the latest or a specific version of Unimock from the GitHub Container Registry using Helm. Custom values can be applied using a YAML file.

```bash
# Install latest version from GitHub Container Registry
helm install unimock oci://ghcr.io/bmcszk/charts/unimock

# Install specific version
helm install unimock oci://ghcr.io/bmcszk/charts/unimock --version 1.2.0

# Install with custom values
helm install unimock oci://ghcr.io/bmcszk/charts/unimock -f my-values.yaml
```

--------------------------------

### Run Unimock with Docker and Test

Source: https://github.com/bmcszk/unimock/blob/master/README.md

Quickly start Unimock using Docker and test its functionality with sample curl commands.

```bash
# 1. Run with Docker
docker run -p 8080:8080 ghcr.io/bmcszk/unimock:latest

# 2. Test it
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"id": "123", "name": "John Doe"}'

curl http://localhost:8080/api/users/123
```

--------------------------------

### Correct: Single Given Chain

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Demonstrates the correct fluent chaining pattern where all setup steps are chained within a single 'given' statement. This ensures proper test state management and atomic setup.

```go
// ✅ CORRECT: Single given chain
func TestComplexSetup(t *testing.T) {
    given, when, then := newParts(t)

    given.
        setupDatabase().and().
        createTestData().and().
        configureServices()

    when.
        executeAction()

    then.
        verifyResult()
}
```

--------------------------------

### E2E Test Workflow Example

Source: https://github.com/bmcszk/unimock/blob/master/docs/testing-guidelines.md

Demonstrates a complete user journey test in an E2E scenario. Assumes Docker Compose services are running and connects to them via localhost.

```go
package e2e_test

import (
    "testing"
    "net/http"
)

func TestWorkflow_CompleteUserJourney(t *testing.T) {
    // given - assumes docker-compose.test.yml services are running
    client := &http.Client{}
    userData := buildUserData()
    
    // when - connect to containerized services
    response := makeRequest(client, "POST", "http://localhost:18081/api/register", userData)
    
    // then
    assert.Equal(t, http.StatusCreated, response.StatusCode)
    
    // Continue workflow testing with external service connections...
}
```

--------------------------------

### Test File Structure Example

Source: https://github.com/bmcszk/unimock/blob/master/docs/testing-guidelines.md

Illustrates a recommended directory structure for organizing end-to-end tests, separating test data, templates, configuration, and test logic.

```directory
test/
├── e2e/
│   ├── assets/               # Test data files
│   │   └── test-video.mp4
│   ├── templates/            # Template files for test data
│   │   ├── asset_event.json
│   │   └── encode_task_event.json
│   ├── .env.test           # Test environment configuration
│   ├── docker-compose.test.yml
│   ├── e2e_test.go         # Main test scenarios (readable workflows)
│   ├── e2e_parts_test.go   # Test helpers and fluent interface
│   └── e2e_checks_test.go  # Asynchronous check implementation
```

--------------------------------

### Given/When/Then Structure for Complex Workflow Test

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Demonstrates the use of all three Given/When/Then parts for tests requiring setup and configuration.

```go
func TestComplexWorkflow(t *testing.T) {
    given, when, then := newParts(t)

    given.
        setupTestData().and().
        configureServices()

    when.
        executeWorkflow()

    then.
        verifyExpectedResult().and().
        noError()
}
```

--------------------------------

### JSON with Arrays for Order Items

Source: https://github.com/bmcszk/unimock/blob/master/docs/examples.md

This example demonstrates creating an order resource that includes an array of items, each with its own details like product, price, and quantity.

```bash
curl -X POST http://localhost:8080/api/orders \
  -H "Content-Type: application/json" \
  -d '{
    "id": "order789",
    "customer": "John Doe",
    "items": [
      {"id": "item1", "product": "Laptop", "price": 1200, "quantity": 1},
      {"id": "item2", "product": "Mouse", "price": 25, "quantity": 2}
    ],
    "total": 1250
  }'
```

--------------------------------

### Unimock Quick Reference - POST Test

Source: https://github.com/bmcszk/unimock/blob/master/README.md

Example of how to test a POST request to the Unimock server using curl.

```bash
curl -X POST :8080/api/users -d '{"id":"1"}'
```

--------------------------------

### Standard Integration Test Example

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

This Go code demonstrates a typical structure for a standard integration test before migration. It focuses on direct function calls and assertions.

```go
// BEFORE: Standard integration test
func TestUserService_CreateUser(t *testing.T) {
    db := setupTestDatabase(t)
    defer db.Close()

    service := NewUserService(db)
    user := &User{Name: "Test User", Email: "test@example.com"}

    created, err := service.CreateUser(user)
    assert.NoError(t, err)
    assert.Equal(t, user.Name, created.Name)
    assert.NotZero(t, created.ID)
}
```

--------------------------------

### Correct: Single Given Method (No Chaining)

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Illustrates a correct scenario for a single 'given' statement when no further chaining is required. This is suitable for simpler setup configurations.

```go
// ✅ CORRECT: Single given method (when no chaining needed)
func TestSimpleSetup(t *testing.T) {
    given, when, then := newParts(t)

    given.
        unifiedConfigFile()

    when.
        a_get_request_is_made_to("/api/resource")

    then.
        the_response_is_successful()
}
```

--------------------------------

### Setup Test Data Helper

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

A helper function to set up test data. It marks itself as a test helper using `t.Helper()`.

```go
func setupTestData(t *testing.T) TestData {
    t.Helper()

    data := TestData{
        Field1: "value1",
        Field2: "value2",
    }

    return data
}
```

--------------------------------

### Invalid Fixture File Syntax Examples

Source: https://github.com/bmcszk/unimock/blob/master/CLAUDE.md

Shows invalid syntax for fixture file loading that will result in fallback to literal string data.

```text
"<file" - INVALID (gracefully falls back to literal string)
"< @file" - INVALID (space between < and @, falls back)
```

--------------------------------

### Send Request with Query Parameters

Source: https://github.com/bmcszk/unimock/blob/master/docs/examples.md

Demonstrates passing query parameters in the URL for POST and GET requests, showing they are preserved and passed through.

```bash
# Query parameters are preserved and passed to stored data
curl -X POST "http://localhost:8080/api/users?source=registration&campaign=summer2024" \
  -H "Content-Type: application/json" \
  -d '{"id": "user789", "name": "Campaign User"}'

# Retrieve with same parameters
curl "http://localhost:8080/api/users/user789?source=registration&campaign=summer2024"
```

--------------------------------

### Server Creation with Transformations

Source: https://github.com/bmcszk/unimock/blob/master/prds/request_response_transformation/request_response_transformation_prd.md

Demonstrates how to load configuration, add custom transformation functions (request and response), and then create a new server instance with these transformations applied.

```go
serverConfig := config.FromEnv()
mockConfig, err := config.LoadFromYAML("config.yaml")

// Add transformation functions
mockConfig.Sections["users"].Transformations = &config.TransformationConfig{
    RequestTransforms: []config.RequestTransformFunc{
        func(ctx context.Context, req *http.Request, section string) (*http.Request, error) {
            // Add custom header
            req.Header.Set("X-Test-Mode", "true")
            return req, nil
        },
    },
    ResponseTransforms: []config.ResponseTransformFunc{
        func(ctx context.Context, req *http.Request, resp *http.Response, section string) (*http.Response, error) {
            // Add response header
            resp.Header.Set("X-Transformed", "true")
            return resp, nil
        },
    },
}

srv, err := pkg.NewServer(serverConfig, mockConfig)
```

--------------------------------

### Basic Unimock Server Setup in Go

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Demonstrates creating a Unimock server with basic configuration for port, log level, and mock sections. Ensure necessary imports are included.

```go
import (
    "log"
    "net/http"
    
    "github.com/bmcszk/unimock/pkg"
    "github.com/bmcszk/unimock/pkg/config"
)

func main() {
    // Create server configuration
    serverConfig := &config.ServerConfig{
        Port:       "8080",
        LogLevel:   "info",
        ConfigPath: "config.yaml",
    }

    // Create mock configuration
    uniConfig := &config.UniConfig{
        Sections: map[string]config.Section{
            "users": {
                PathPattern:   "/api/users/*",
                BodyIDPaths:   []string{"/id"},  // XPath-like syntax for JSON/XML
                HeaderIDNames: []string{"X-User-ID"},
                ReturnBody:    true,
            },
        },
    }

    // Create server
    server, err := pkg.NewServer(serverConfig, uniConfig)
    if err != nil {
        log.Fatal(err)
    }

    // Start server
    log.Printf("Starting server on port %s", serverConfig.Port)
    if err := server.ListenAndServe(); err != nil {
        log.Fatal(err)
    }
}
```

--------------------------------

### Example Scenarios YAML Structure

Source: https://github.com/bmcszk/unimock/blob/master/prds/separate_scenarios_yaml/separate_scenarios_yaml_prd.md

Defines the structure for scenarios in a YAML file, including request method, path, status code, headers, and data. Supports GET and POST requests.

```yaml
# scenarios.yaml
scenarios:
  - uuid: "test-scenario-001"
    method: "GET"
    path: "/users/123"
    status_code: 200
    headers:
      Content-Type: "application/json"
    data: |
      {
        "id": "123",
        "name": "Test User",
        "email": "test@example.com"
      }
  
  - uuid: "test-scenario-002"
    method: "POST"
    path: "/users"
    status_code: 201
    headers:
      Content-Type: "application/json"
      Location: "/users/456"
    data: |
      {
        "id": "456",
        "name": "Created User",
        "email": "created@example.com"
      }
```

--------------------------------

### Create Server Configuration with Defaults

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Instantiate server configuration using default values or load settings from environment variables.

```go
// Create with defaults
serverConfig := config.NewDefaultServerConfig()
// Defaults: Port="8080", LogLevel="info", ConfigPath="config.yaml"

// Load from environment variables
serverConfig := config.FromEnv()
// Reads: UNIMOCK_PORT, UNIMOCK_LOG_LEVEL, UNIMOCK_CONFIG
```

--------------------------------

### Interact with Mock Server using cURL

Source: https://github.com/bmcszk/unimock/blob/master/examples/library/README.md

Examples of making various HTTP requests (POST, GET, PUT, DELETE) to the running Unimock server on port 8081 to test user-related API endpoints.

```bash
# Create a user
curl -X POST -H "Content-Type: application/json" -d '{"id":"123","name":"Test User"}' http://localhost:8081/users

# Get the user
curl http://localhost:8081/users/123

# Update the user
curl -X PUT -H "Content-Type: application/json" -d '{"id":"123","name":"Updated User"}' http://localhost:8081/users/123

# Delete the user
curl -X DELETE http://localhost:8081/users/123
```

--------------------------------

### Correct Config Creation via Fluent Method

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Demonstrates the correct method for creating test configurations using fluent methods in the 'given' section, which internally handles storage and access.

```go
// ✅ CORRECT: Config creation via fluent method
func TestPerformanceTest(t *testing.T) {
    given, when, then := newParts(t)

    given.
        performanceTestConfig()  // Creates config, stores in parts.configFile

    when.
        a_load_test_is_executed()  // Accesses parts.configFile internally

    then.
        the_response_time_is_acceptable()
}
```

--------------------------------

### Correct Use of Fluent Method for Config Creation

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Illustrates the correct approach for creating a configuration file using a fluent method within the 'given' section, ensuring adherence to the fluent pattern.

```go
// ✅ CORRECT: Use fluent method in given section
func TestScenarioFileLoading(t *testing.T) {
    given, when, then := newParts(t)

    given.
        unifiedConfigFile()  // Fluent method that creates config and stores in parts.configFile

    when.
        a_get_request_is_made_to("/api/resource")

    then.
        the_response_is_successful()
}
```

--------------------------------

### Asynchronous Check Pattern Usage Example

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Demonstrates how to use the Asynchronous Check Pattern within test methods to verify a video's status. It makes an HTTP GET request and parses the JSON response.

```go
// Usage in test methods
func (p *parts) videoHasStatus(expectedStatus string) *parts {
    p.checks.add(func() error {
        resp, err := p.httpClient.Get("http://" + p.envs.ServiceAddress + "/videos/" + p.videoID)
        if err != nil {
            return fmt.Errorf("get video by ID request: %w", err)
        }
        defer resp.Body.Close()

        // Parse and validate status
        var videoResp struct { Status string `json:"status"` }
        if err := json.NewDecoder(resp.Body).Decode(&videoResp); err != nil {
            return fmt.Errorf("parse video response: %w", err)
        }

        if videoResp.Status != expectedStatus {
            return fmt.Errorf("expected status %s, got %s", expectedStatus, videoResp.Status)
        }

        return nil
    })
    return p
}
```

--------------------------------

### Configure Server and Mock Settings

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Define server port, log level, configuration path, and mock URL patterns, ID paths, and transformations.

```go
// Server configuration
serverConfig := &config.ServerConfig{
    Port:       "8080",        // Server port
    LogLevel:   "info",        // Log level: debug, info, warn, error
    ConfigPath: "config.yaml", // Path to mock config file
}

// Mock configuration  
uniConfig := &config.UniConfig{
    Sections: map[string]config.Section{
        "section_name": {
            PathPattern:     "/api/path/*",           // URL pattern
            BodyIDPaths:     []string{"/id"},         // JSON/XML ID paths
            HeaderIDNames:   []string{"X-Resource-ID"}, // Header ID names
            ReturnBody:      true,                   // Return request body on GET
            StrictPath:      false,                  // Strict path matching
            Transformations: transformationConfig,    // Library-only transformations
        },
    },
}
```

--------------------------------

### Advanced Unimock Server Configuration in Go

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Shows how to configure a Unimock server using environment variables for server settings and a more detailed mock configuration, including transformations. Ensure necessary imports are included.

```go
import (
    "github.com/bmcszk/unimock/pkg"
    "github.com/bmcszk/unimock/pkg/config"
)

func main() {
    // Load server config from environment variables
    // UNIMOCK_PORT, UNIMOCK_LOG_LEVEL, UNIMOCK_CONFIG
    serverConfig := config.FromEnv()

    // Create comprehensive mock configuration
    uniConfig := &config.UniConfig{
        Sections: map[string]config.Section{
            "users": {
                PathPattern:     "/api/users/*",
                BodyIDPaths:     []string{"/id", "/user/id"},
                HeaderIDNames:   []string{"X-User-ID"}, 
                ReturnBody:      true,
                Transformations: createUserTransformations(), // Library-only
            },
            "orders": {
                PathPattern:   "/api/orders/*",
                BodyIDPaths:   []string{"/order_id"},
                HeaderIDNames: []string{"X-Order-ID"},
                ReturnBody:    false,
            },
        },
    }

    // Create server with configuration
    server, err := pkg.NewServer(serverConfig, uniConfig)
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Server starting on port %s", serverConfig.Port)
    if err := server.ListenAndServe(); err != nil {
        log.Fatal(err)
    }
}
```

--------------------------------

### Simple JSON Resource Creation

Source: https://github.com/bmcszk/unimock/blob/master/docs/examples.md

This example demonstrates creating a user resource with basic fields like ID, name, email, and role using a simple JSON object.

```bash
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "id": "user123",
    "name": "John Doe",
    "email": "john@example.com",
    "role": "admin"
  }'
```

--------------------------------

### Gherkin: Chart Installation from GHCR

Source: https://github.com/bmcszk/unimock/blob/master/prds/helm_chart_publishing/helm_chart_publishing_prd_task_tracking.md

Describes the successful installation of a Helm chart from the GHCR registry.

```gherkin
Given a chart is published to GHCR
When a user runs helm install from the registry
Then the chart should be downloaded and installed successfully
```

--------------------------------

### Get Application URL for Ingress

Source: https://github.com/bmcszk/unimock/blob/master/helm/unimock/templates/NOTES.txt

Use this command to get the application URL when Ingress is enabled.

```shell
{{- if .Values.ingress.enabled }}
{{- range $host := .Values.ingress.hosts }}
  {{- range .paths }}
  http{{ if $.Values.ingress.tls }}s{{ end }}://{{ $host.host }}{{ .path }}
  {{- end }}
{{- end }}
{{- end }}
```

--------------------------------

### Configure Unimock Binary with Environment Variables

Source: https://github.com/bmcszk/unimock/blob/master/docs/deployment.md

Demonstrates how to configure the standalone Unimock binary using environment variables for the configuration file path, port, and log level.

```bash
# Configuration via environment variables
UNIMOCK_CONFIG=/path/to/config.yaml unimock
UNIMOCK_PORT=9090 unimock
UNIMOCK_LOG_LEVEL=debug unimock
```

--------------------------------

### Start Docker Compose Services

Source: https://github.com/bmcszk/unimock/blob/master/docs/deployment.md

Use this command to start the services defined in your docker-compose.yml file in detached mode.

```bash
docker-compose up -d
```

--------------------------------

### GET Request ID Extraction from Path

Source: https://github.com/bmcszk/unimock/blob/master/docs/id_extraction.md

Demonstrates how Unimock extracts an ID from the last segment of a URL path for GET requests.

```text
GET /users/123
```

--------------------------------

### List All Scenarios in Go

Source: https://github.com/bmcszk/unimock/blob/master/docs/client.md

Fetches a list of all currently configured mock scenarios.

```go
scenarios, err := client.ListScenarios(ctx)
if err != nil {
    log.Fatal(err)
}

for _, scenario := range scenarios {
    fmt.Printf("- %s: %s %s\n", scenario.UUID, scenario.Method, scenario.Path)
}
```

--------------------------------

### Install Unimock Helm Chart with Custom Values

Source: https://github.com/bmcszk/unimock/blob/master/helm/unimock/README.md

Install the Unimock Helm chart using a custom values file. This allows for detailed configuration of the deployment.

```bash
helm install my-unimock ./unimock -f values.yaml
```

--------------------------------

### Create Nested Resources (User and Order)

Source: https://github.com/bmcszk/unimock/blob/master/docs/examples.md

Demonstrates creating a user first, then creating an order associated with that user using sequential POST requests.

```bash
# Create user first
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"id": "user123", "name": "John Doe"}'

# Create order for that user
curl -X POST http://localhost:8080/api/users/user123/orders \
  -H "Content-Type: application/json" \
  -d '{
    "id": "order456",
    "product": "Laptop",
    "price": 1200
  }'
```

--------------------------------

### Unit Testing with Embedded Unimock Server

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Demonstrates setting up and testing with an embedded Unimock server for unit tests. It includes configuration, server startup, graceful shutdown, and making HTTP requests.

```go
import (
    "context"
    "fmt"
    "net/http"
    "testing"
    "time"
    
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
    
    "github.com/bmcszk/unimock/pkg"
    "github.com/bmcszk/unimock/pkg/config"
)

func TestWithEmbeddedUnimock(t *testing.T) {
    // Create test configuration
    serverConfig := &config.ServerConfig{
        Port:       "0", // Use random available port
        LogLevel:   "error", // Reduce noise in tests
        ConfigPath: "config.yaml",
    }
    
    uniConfig := &config.UniConfig{
        Sections: map[string]config.Section{
            "users": {
                PathPattern:   "/api/users/*",
                BodyIDPaths:   []string{"/id"},
                HeaderIDNames: []string{"X-User-ID"},
                ReturnBody:    true,
            },
        },
    }
    
    // Start embedded server
    server, err := pkg.NewServer(serverConfig, uniConfig)
    require.NoError(t, err)
    
    // Start server in background
    go func() {
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            t.Errorf("Server error: %v", err)
        }
    }()
    
    // Cleanup
    defer func() {
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()
        server.Shutdown(ctx)
    }()
    
    // Wait for server to start
    time.Sleep(100 * time.Millisecond)
    
    // Get server address from actual listener
    baseURL := fmt.Sprintf("http://%s", server.Addr)
    
    // Test operations using standard HTTP client
    client := &http.Client{Timeout: 5 * time.Second}
    
    // Create user
    resp, err := client.Post(baseURL+"/api/users", "application/json", 
        strings.NewReader(`{"id": "test123", "name": "Test User"}`))
    require.NoError(t, err)
    defer resp.Body.Close()
    assert.Equal(t, 201, resp.StatusCode)
    
    // Get user
    resp, err = client.Get(baseURL + "/api/users/test123")
    require.NoError(t, err)
    defer resp.Body.Close()
    assert.Equal(t, 200, resp.StatusCode)
}
```

--------------------------------

### Build and Run Locally

Source: https://github.com/bmcszk/unimock/blob/master/CLAUDE.md

Builds the unimock binary and then runs it. Useful for local development and testing.

```bash
make run
```

--------------------------------

### Apply Unimock Scenario for GET Request

Source: https://github.com/bmcszk/unimock/blob/master/docs/test_scenarios.md

Create a Unimock scenario to override the default behavior of a GET request for a specific product. This scenario intercepts the request and returns a custom teapot response.

```Go
POST /_unimock/scenarios HTTP/1.1
Host: localhost:8080
Content-Type: application/json

{
    "request_path": "GET /products/{productID1}",
    "status_code": 418,
    "response_body": "{\"message\": \"I am a teapot - scenario active!\"}",
    "content_type": "application/json"
}
```

--------------------------------

### Create Unimock Go Client Instance

Source: https://github.com/bmcszk/unimock/blob/master/docs/client.md

Shows how to create a new Unimock client, connecting to the default address (localhost:8080) or a custom URL. The client includes a default 10-second timeout.

```go
// Connect to localhost:8080 (default)
client, err := client.NewClient("")

// Connect to custom URL
client, err := client.NewClient("http://localhost:9090")
client, err := client.NewClient("https://unimock.example.com")

// The client includes a 10-second timeout HTTP client by default
```

--------------------------------

### Test Usage Example: Video Upload and Retrieval

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Demonstrates a clean test structure using the fluent builder for video upload and retrieval scenarios. Follows the When/Then pattern for clarity.

```go
func TestVideoUploadAndRetrieval(t *testing.T) {
    videoFilePath := "./assets/test-video.mp4"
    given, when, then := newParts(t)

    when.
        uploadVideoFile(videoFilePath, "E2E Test Video")

    then.
        videoUploadedSuccessfully().and().
        getVideoByID(then.videoID).and().
        videoFoundSuccessfully()
}
```

--------------------------------

### Install Unimock Helm Chart with Inline Values

Source: https://github.com/bmcszk/unimock/blob/master/helm/unimock/README.md

Install the Unimock Helm chart and override specific values directly on the command line using the --set flag. This is useful for quick adjustments or CI/CD pipelines.

```bash
helm install my-unimock ./unimock \
  --set image.tag=v1.2.0 \
  --set scenarios.enabled=true
```

--------------------------------

### Lint and Test Helm Chart

Source: https://github.com/bmcszk/unimock/blob/master/helm/unimock/README.md

Use these commands to lint your Helm chart for syntax errors and test template rendering with default or custom values. The dry-run install option verifies the installation process without actually deploying.

```bash
# Lint the chart
helm lint ./helm/unimock
```

```bash
# Test template rendering
helm template my-unimock ./helm/unimock
```

```bash
# Test with different values
helm template my-unimock ./helm/unimock -f test-values.yaml
```

```bash
# Dry run install
helm install my-unimock ./helm/unimock --dry-run --debug
```

--------------------------------

### Run Tilt with Unimock

Source: https://github.com/bmcszk/unimock/blob/master/tilt/README.md

Navigate to the tilt directory and run 'tilt up' to build the Docker image, deploy Unimock to Kubernetes, set up port forwarding, and enable live reload.

```bash
cd tilt
tilt up
```

--------------------------------

### Get Scenario

Source: https://github.com/bmcszk/unimock/blob/master/docs/client.md

Retrieves a specific scenario by its UUID.

```APIDOC
## Get Scenario

### Description
Retrieves a specific scenario by its UUID.

### Method
`client.GetScenario`

### Parameters
#### Path Parameters
- **uuid** (string) - Required - The UUID of the scenario to retrieve.
#### Request Body
- **ctx** (context.Context) - Required - The context for the request.

### Response
#### Success Response (200)
- **scenario** (model.Scenario) - The retrieved scenario object.

### Request Example
```go
// Get specific scenario by UUID
scenario, err := client.GetScenario(ctx, "user-not-found")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Scenario: %s %s -> %d\n", scenario.Method, scenario.Path, scenario.StatusCode)
```
```

--------------------------------

### Get a Scenario

Source: https://github.com/bmcszk/unimock/blob/master/docs/technical_endpoints.md

Retrieves a specific test scenario by its UUID.

```APIDOC
## GET /_uni/scenarios/{uuid}

### Description
Retrieves a specific test scenario using its unique identifier (UUID).

### Method
GET

### Endpoint
/_uni/scenarios/{uuid}

### Parameters
#### Path Parameters
- **uuid** (string) - Required - The unique identifier of the scenario to retrieve.

### Response
#### Success Response (200)
- **uuid** (string) - Unique identifier for the scenario.
- **method** (string) - HTTP method.
- **path** (string) - API path.
- **status_code** (integer) - HTTP status code.
- **content_type** (string) - Content type of the response.
- **location** (string) - Location header returned (if provided).
- **headers** (object) - Additional response headers returned (if provided).
- **data** (string) - Response body data returned (if provided).

### Response Example
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000",
  "method": "GET",
  "path": "/api/users/123",
  "status_code": 200,
  "content_type": "application/json",
  "data": "{\"id\":\"123\",\"name\":\"John Doe\"}"
}
```

--------------------------------

### Get Specific Scenario

Source: https://github.com/bmcszk/unimock/blob/master/docs/scenarios.md

Retrieve the details of a particular scenario by its unique identifier.

```bash
curl http://localhost:8080/_uni/scenarios/user-not-found
```

--------------------------------

### Get comments from a specific review

Source: https://github.com/bmcszk/unimock/blob/master/docs/pr-guidelines.md

Fetches comments associated with a particular review on a pull request.

```bash
gh api repos/:owner/:repo/pulls/:pr_number/reviews/:review_id/comments
```

--------------------------------

### Create a Mock Scenario in Go

Source: https://github.com/bmcszk/unimock/blob/master/docs/client.md

Shows how to define and create a new scenario for mocking API responses. Ensure the `model` package is imported.

```go
import "github.com/bmcszk/unimock/pkg/model"

scenario := model.Scenario{
    UUID:        "user-not-found", // Optional, auto-generated if empty
    Method:      "GET",
    Path:        "/api/users/999",
    StatusCode:  404,
    ContentType: "application/json",
    Data:        `{"error": "User not found", "code": "USER_NOT_FOUND"}`,
}

err := client.CreateScenario(ctx, scenario)
if err != nil {
    log.Fatal(err)
}
```

--------------------------------

### Get Server Health Status

Source: https://github.com/bmcszk/unimock/blob/master/docs/technical_endpoints.md

Use this endpoint to check the current status and uptime of the Unimock server.

```bash
curl -X GET http://localhost:8080/_uni/health
```

--------------------------------

### Get all reviews for a PR

Source: https://github.com/bmcszk/unimock/blob/master/docs/pr-guidelines.md

Retrieves all reviews submitted for a specific pull request using the GitHub API.

```bash
gh api repos/:owner/:repo/pulls/:pr_number/reviews
```

--------------------------------

### Configure Server via Environment Variables

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Use environment variables for production-ready Unimock server configuration. This allows for flexible deployment-time settings.

```go
// Production-ready configuration
serverConfig := config.FromEnv()

// Allows deployment-time configuration via:
// UNIMOCK_PORT=8080
// UNIMOCK_LOG_LEVEL=info
// UNIMOCK_CONFIG=/etc/unimock/config.yaml
```

--------------------------------

### Get a Specific Scenario by UUID in Go

Source: https://github.com/bmcszk/unimock/blob/master/docs/client.md

Retrieves a single mock scenario using its unique identifier (UUID).

```go
// Get specific scenario by UUID
scenario, err := client.GetScenario(ctx, "user-not-found")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Scenario: %s %s -> %d\n", scenario.Method, scenario.Path, scenario.StatusCode)
```

--------------------------------

### Integration Testing with File-based Configuration

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Shows how to perform integration tests using Unimock with configurations loaded from temporary YAML files. It includes creating a temporary file, configuring the server, and loading the configuration.

```go
func TestWithConfigFiles(t *testing.T) {
    // Create temporary config file
    configFile := createTempConfig(t, `
sections:
  users:
    path_pattern: "/api/users/*"
    body_id_paths:
      - "/id"
    return_body: true
`)
    defer os.Remove(configFile)
    
    // Create server config pointing to file
    serverConfig := &config.ServerConfig{
        Port:       "0",
        LogLevel:   "error",
        ConfigPath: configFile,
    }
    
    // Load mock config from file
    uniConfig, err := config.LoadFromYAML(serverConfig.ConfigPath)
    require.NoError(t, err)
    
    // Create and test server
    server, err := pkg.NewServer(serverConfig, uniConfig)
    require.NoError(t, err)
    
    // ... test operations
}

func createTempConfig(t *testing.T, content string) string {
    file, err := os.CreateTemp("", "unimock-test-*.yaml")
    require.NoError(t, err)
    
    _, err = file.WriteString(content)
    require.NoError(t, err)
    
    err = file.Close()
    require.NoError(t, err)
    
    return file.Name()
}
```

--------------------------------

### Get general PR comments

Source: https://github.com/bmcszk/unimock/blob/master/docs/pr-guidelines.md

Retrieves all general comments made on a pull request, excluding those within specific reviews.

```bash
gh api repos/:owner/:repo/pulls/:pr_number/comments
```

--------------------------------

### Implement Graceful Server Shutdown

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Start the Unimock server and handle interrupt signals for a graceful shutdown with a configurable timeout.

```go
import (
    "context"
    "log"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    server, err := pkg.NewServer(serverConfig, uniConfig)
    if err != nil {
        log.Fatal(err)
    }
    
    // Start server in background
    go func() {
        log.Printf("Starting server on %s", server.Addr)
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatal("Server error:", err)
        }
    }()
    
    // Wait for interrupt signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    log.Println("Shutting down server...")
    
    // Graceful shutdown with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    if err := server.Shutdown(ctx); err != nil {
        log.Fatal("Server forced to shutdown:", err)
    }
    
    log.Println("Server exited")
}
```

--------------------------------

### Setting up Test Environment with GoDotEnv

Source: https://github.com/bmcszk/unimock/blob/master/docs/fluent-testing.md

Loads test-specific environment variables from a .env.test file and initializes a TestEnvironment struct with necessary configuration values.

```go
// Separate test configs with environment-specific behavior
func setupTestEnvironment(t *testing.T) *TestEnvironment {
    t.Helper()

    // Load test-specific config
    err := godotenv.Load(".env.test")
    require.NoError(t, err, "load test environment")

    env := &TestEnvironment{
        DBURL:     os.Getenv("TEST_DB_URL"),
        SQSQueue:  os.Getenv("TEST_SQS_QUEUE_URL"),
        ServiceAddr: os.Getenv("TEST_SERVICE_ADDRESS"),
    }

    return env
}
```

--------------------------------

### Load Configuration from YAML

Source: https://github.com/bmcszk/unimock/blob/master/docs/library.md

Loads mock configuration from a specified YAML file. Use this for standard configuration loading.

```go
import (
    "github.com/bmcszk/unimock/pkg/config"
)

func loadFromYAML() (*config.UniConfig, error) {
    // Load mock configuration from YAML file
    return config.LoadFromYAML("config.yaml")
}
```

```go
import (
    "github.com/bmcszk/unimock/pkg/config"
)

func loadUnifiedFromYAML() (*config.UnifiedConfig, error) {
    // Load unified configuration (sections + scenarios) from YAML file  
    return config.LoadUnifiedFromYAML("config.yaml")
}
```