Fosmvvm Serverrequest Test Generator

FOSMVVM ServerRequest Test Generator

Read shared/functional-discipline.md before proceeding. Every rule below derives from it.

Generate test files for ServerRequest types using VaporTesting infrastructure.

Conceptual Foundation

For full architecture context, see FOSMVVMArchitecture.md | OpenClaw reference

API catalog: check ../shared/api-catalog/FOSTesting.md § FOSTestingVapor before hand-writing helpers.

ServerRequest testing uses VaporTesting infrastructure to send typed requests through the full server stack:

┌─────────────────────────────────────────────────────────────────────┐
│                    ServerRequest Test Flow                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  Test Code:                                                          │
│    let request = MyRequest(query: .init(...))                        │
│    app.testing().test(request, locale: en) { response in }           │
│                                                                      │
│  Infrastructure handles:                                             │
│    • Path derivation from type name (MyRequest → /my)                │
│    • HTTP method from action (ShowRequest → GET)                     │
│    • Query/body encoding                                             │
│    • Header injection (locale, version)                              │
│    • Response decoding to ResponseBody type                          │
│                                                                      │
│  You verify:                                                         │
│    • response.status (HTTPStatus)                                    │
│    • response.body (R.ResponseBody? - typed!)                        │
│    • response.error (R.ResponseError? - typed!)                      │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

STOP AND READ THIS

Testing ServerRequests uses VaporTesting infrastructure. No manual URL construction. Ever.

┌──────────────────────────────────────────────────────────────────────┐
│          SERVERREQUEST TESTING USES TestingApplicationTester          │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│  1. Configure Vapor Application with routes                           │
│  2. Use app.testing().test(request, locale:) { response in }          │
│  3. Verify response.status, response.body, response.error             │
│                                                                       │
│  TestingServerRequestResponse<R> provides TYPED access to:            │
│    • status: HTTPStatus                                               │
│    • headers: HTTPHeaders                                             │
│    • body: R.ResponseBody?     ← Auto-decoded!                        │
│    • error: R.ResponseError?   ← Auto-decoded!                        │
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

What You Must NEVER Do

// ❌ WRONG - manual URL construction
let url = URL(string: "http://localhost:8080/my_request?query=value")!
let response = try await URLSession.shared.data(from: url)

// ❌ WRONG - string path with method
try await app.test(.GET, "/my_request") { response in }

// ❌ WRONG - manual JSON encoding/decoding
let json = try JSONEncoder().encode(requestBody)
let decoded = try JSONDecoder().decode(ResponseBody.self, from: data)

// ❌ WRONG - constructing TestingHTTPRequest manually
let httpRequest = TestingHTTPRequest(method: .GET, url: "/path", headers: headers)
try await app.testing().performTest(request: httpRequest)

What You Must ALWAYS Do

// ✅ RIGHT - Use TestingApplicationTester.test() with ServerRequest
let request = MyShowRequest(query: .init(userId: userId))
try await app.testing().test(request, locale: en) { response in
    #expect(response.status == .ok)
    #expect(response.body?.viewModel.name == "Expected Name")
}

// ✅ RIGHT - Test multiple locales
for locale in [en, es] {
    try await app.testing().test(request, locale: locale) { response in
        #expect(response.status == .ok)
        // Localized values are automatically handled
    }
}

// ✅ RIGHT - Test error responses: assert the TYPED error (the operation's
// thrown vocabulary), not just a status — statuses are transport, not results
let badRequest = MyShowRequest(query: .init(userId: invalidId))
try await app.testing().test(badRequest, locale: en) { response in
    #expect(response.status == .notFound)          // transport contract
    #expect(response.error?.code == .userNotFound) // the semantics
}

The path is derived from the ServerRequest type. HTTP method comes from the action. Headers are automatic. You NEVER write URL strings or decode JSON manually.

When to Use This Skill

• Testing any ServerRequest implementation
• Verifying server responses for CRUD operations
• Testing error handling and edge cases
• Multi-locale response verification
• Integration testing between client request types and server controllers

If you're about to write URLSession, app.test(.GET, "/path"), or manual JSON decoding, STOP and use this skill instead.

What This Skill Generates

Project Structure Configuration

Key Types

TestingServerRequestResponse

Wraps HTTP response with typed access:

TestingApplicationTester Extension

func test<R: ServerRequest>(
    _ request: R,
    locale: Locale = en,
    headers: HTTPHeaders = [:],
    afterResponse: (TestingServerRequestResponse<R>) async throws -> Void
) async throws -> any TestingApplicationTester

Convenience Locales

Available on TestingApplicationTester:

• en - English
• enUS - English (US)
• enGB - English (UK)
• es - Spanish

Test Structure

Testing discipline: assert the contract, not the wire representation. Verify behavior through the typed response — status, and the decoded response.body?.viewModel (its properties, localized values, round-trip). Never assert the raw response JSON's shape/keys/byte layout; there is no contract that a request encodes a particular way, only that it round-trips. Build requests via their public initializers, not by reaching internal state. @testable import here is for seeing internal types + test infra — not a license to bypass a type's construction contract or read its privates (that's coverage-only). See Architecture Patterns → Encapsulation Is the Precondition.

Basic Test Suite

import FOSFoundation
@testable import FOSMVVM
import FOSTesting
import FOSTestingVapor
import Foundation
import Testing
import Vapor
import VaporTesting

@Suite("MyFeature Request Tests")
struct MyFeatureRequestTests {
    @Test func showRequest_success() async throws {
        try await withTestApp { app in
            let request = MyShowRequest(query: .init(id: validId))

            try await app.testing().test(request, locale: en) { response in
                #expect(response.status == .ok)
                #expect(response.body?.viewModel != nil)
            }
        }
    }

    @Test func showRequest_notFound() async throws {
        try await withTestApp { app in
            let request = MyShowRequest(query: .init(id: invalidId))

            try await app.testing().test(request, locale: en) { response in
                #expect(response.status == .notFound)
            }
        }
    }
}

private func withTestApp(_ test: (Application) async throws -> Void) async throws {
    try await withApp { app in
        // Configure routes
        try app.routes.register(collection: MyController())
        try await test(app)
    }
}

Prefer the shipped harnesses over hand-rolling withTestApp (FOSUtilities 0.5.0+): withFluentTestApp scopes an in-memory SQLite + Vapor application, and withServedFluentTestApp (0.6.0+) additionally serves it on a port for real-client E2E. Both handle the boot path correctly — a hand-rolled harness on Vapor's app.test() runs only the synchronous boot, so async lifecycle handlers (middleware registered in async startup) silently never run under it.

Assert rejections typed, never by status (FOSUtilities 0.7.0+): a credential rejection surfaces as TestingServerRequestResponse.credentialRejection and a request's own failure as the typed .error — #expect(response.status == .unauthorized) is status-sniffing the typed fields exist to eliminate, and it cannot tell a middleware rejection from any other failure wearing the same number.

Testing Different Request Types

How to Use This Skill

Invocation: /fosmvvm-serverrequest-test-generator

Prerequisites:

• ServerRequest type understood from conversation context
• Test scenarios identified (success paths, error paths, validation)
• Controller implementation exists or is being created
• VaporTesting infrastructure understood

Workflow integration: This skill is used when testing ServerRequest implementations. The skill references conversation context automatically—no file paths or Q&A needed. Typically follows fosmvvm-serverrequest-generator.

Pattern Implementation

This skill references conversation context to determine test structure:

Request Analysis

From conversation context, the skill identifies:

• ServerRequest type (from prior discussion or server implementation)
• Request protocol (ShowRequest, CreateRequest, UpdateRequest, etc.)
• ResponseBody type (ViewModel or simple structure)
• ResponseError type (custom errors or EmptyError)

Test Scenario Planning

Based on operation semantics:

• Success paths (valid input, expected output)
• Error paths (not found, validation failure, business logic errors)
• Localization (if ResponseBody has localized fields)
• Multi-locale (testing across supported locales)

Infrastructure Detection

From project state:

• Existing test patterns (similar test files in codebase)
• Localization setup (YAML fixtures needed)
• Database requirements (seed data for tests)

Test File Generation

1. Test suite conforming to VaporTesting patterns
2. One @Test function per scenario
3. withTestApp helper for application setup
4. Route registration
5. Request invocations using app.testing().test()

Context Sources

Skill references information from:

• Prior conversation: Test requirements, scenarios discussed
• ServerRequest: If Claude has read ServerRequest code into context
• Controller: From server implementation
• Existing tests: From codebase analysis of similar test files

Common Scenarios

Testing ViewModelRequest with Localization

@Test func viewModelRequest_multiLocale() async throws {
    try await withTestApp { app in
        let request = DashboardViewModelRequest()

        // Test English
        try await app.testing().test(request, locale: en) { response in
            #expect(response.status == .ok)
            let vm = try #require(response.body)
            #expect(try vm.pageTitle.localizedString == "Dashboard")
        }

        // Test Spanish
        try await app.testing().test(request, locale: es) { response in
            #expect(response.status == .ok)
            let vm = try #require(response.body)
            #expect(try vm.pageTitle.localizedString == "Tablero")
        }
    }
}

Testing CreateRequest with Validation

@Test func createRequest_validInput() async throws {
    try await withTestApp { app in
        let request = CreateIdeaRequest(requestBody: .init(
            content: "Valid idea content"
        ))

        try await app.testing().test(request, locale: en) { response in
            #expect(response.status == .ok)
            #expect(response.body?.id != nil)
        }
    }
}

@Test func createRequest_invalidInput() async throws {
    try await withTestApp { app in
        let request = CreateIdeaRequest(requestBody: .init(
            content: ""  // Empty content should fail validation
        ))

        try await app.testing().test(request, locale: en) { response in
            #expect(response.status == .badRequest)
            #expect(response.error != nil)
        }
    }
}

Testing UpdateRequest

@Test func updateRequest_success() async throws {
    try await withTestApp { app in
        // First create an entity
        let createRequest = CreateIdeaRequest(requestBody: .init(content: "Original"))
        var createdId: ModelIdType?
        try await app.testing().test(createRequest, locale: en) { response in
            createdId = response.body?.id
        }

        // Then update it
        let updateRequest = UpdateIdeaRequest(requestBody: .init(
            ideaId: try #require(createdId),
            content: "Updated content"
        ))

        try await app.testing().test(updateRequest, locale: en) { response in
            #expect(response.status == .ok)
            #expect(response.body?.viewModel.content == "Updated content")
        }
    }
}

Testing DeleteRequest

@Test func deleteRequest_success() async throws {
    try await withTestApp { app in
        // Create, then delete
        let deleteRequest = DeleteIdeaRequest(requestBody: .init(ideaId: existingId))

        try await app.testing().test(deleteRequest, locale: en) { response in
            #expect(response.status == .ok)
        }

        // Verify deleted (should return not found)
        let showRequest = ShowIdeaRequest(query: .init(ideaId: existingId))
        try await app.testing().test(showRequest, locale: en) { response in
            #expect(response.status == .notFound)
        }
    }
}

Testing ShowRequest with Query Parameters

@Test func showRequest_withQuery() async throws {
    try await withTestApp { app in
        let request = UserShowRequest(query: .init(
            userId: userId,
            includeDetails: true
        ))

        try await app.testing().test(request, locale: en) { response in
            #expect(response.status == .ok)
            #expect(response.body?.user.details != nil)
        }
    }
}

Testing ServerRequestError Localizations

Why Error Localization Testing is Different

Unlike ViewModels, ServerRequestError types:

• Are often enums, not structs
• Do not conform to Stubbable or RetrievablePropertyNames
• Cannot use expectTranslations(ErrorType.self) like ViewModels

This means you must manually test each error case individually.

The Pattern

Use LocalizableTestCase.expectTranslations(_ localizable:) on each error's Localizable property:

@Suite("MyError Localization Tests")
struct MyErrorLocalizationTests: LocalizableTestCase {
    let locStore: LocalizationStore

    init() throws {
        self.locStore = try Self.loadLocalizationStore(
            bundle: Bundle.module,
            resourceDirectoryName: "TestYAML"
        )
    }

    @Test func errorMessages_simpleErrors() throws {
        // Test each error case individually
        let serverFailed = MyError(code: .serverFailed)
        try expectTranslations(serverFailed.message)

        let appFailed = MyError(code: .applicationFailed)
        try expectTranslations(appFailed.message)
    }

    @Test func errorMessages_withSubstitutions() throws {
        // For errors with associated values, test with representative values
        let quotaError = QuotaError(code: .quotaExceeded(requested: 100, maximum: 50))
        try expectTranslations(quotaError.message)
    }
}

Testing Error Messages in Integration Tests

When testing the full request/response cycle, verify error messages resolve:

@Test func createRequest_validationError_hasLocalizedMessage() async throws {
    try await withTestApp { app in
        let request = CreateIdeaRequest(requestBody: .init(content: ""))

        try await app.testing().test(request, locale: en) { response in
            #expect(response.status == .badRequest)
            let error = try #require(response.error)

            // Verify the message resolved (not empty or pending)
            #expect(!error.message.isEmpty)

            // Optionally verify specific text for English locale
            #expect(try error.message.localizedString.contains("required"))
        }
    }
}

Why Not Stubbable?

Stubbable works well for ViewModels because:

• ViewModels are structs with many properties
• A single stub() provides a complete test instance

ServerRequestError types are often enums where:

• Each case may have different associated values
• Each case may have a different localized message
• A single stub() can't cover all cases

You must enumerate and test each error case explicitly.

Checklist for Error Localization Tests

• Test each enum case for simple errors
• Test representative associated values for parameterized errors
• Verify messages resolve (not empty) for all configured locales
• Verify substitution placeholders are replaced in LocalizableSubstitutions

Troubleshooting

"Route not found" Error

Cause: Controller not registered in test app.

Fix: Register the controller before testing:

try app.routes.register(collection: MyController())

Response body is nil but status is .ok

Cause: JSON decoding failed silently.

Fix: Check that ResponseBody type matches server response exactly. Use response.headers to verify Content-Type.

Localization not applied

Cause: Locale not passed to encoder.

Fix: The test(_:locale:) method handles this automatically. Ensure you're passing the locale parameter.

"Missing Translation" in Response

Cause: YAML localization not loaded.

Fix: Initialize localization store in test app setup:

try app.initYamlLocalization(
    bundle: Bundle.module,
    resourceDirectoryName: "TestYAML"
)

Parallelism and Shared State

Swift Testing runs suites — and the tests inside a suite — in parallel by default. A suite whose tests touch shared mutable state (a singleton, a static var, the process environment, a fixed-path fixture) carries .serialized; the classic race symptom is a recorded value asserting 0 because another test cleared the state in between. .serialized protects within the suite only — state spanning multiple suites needs a test-owned gate around the racing window, or dependency injection so the state stops being shared at all.

Naming Conventions

File Templates

See reference.md for complete file templates.

See Also

• FOSMVVMArchitecture.md - Full architecture
• Architecture Patterns → Encapsulation Is the Precondition — test the contract, not the representation. Assert behavior the contract guarantees (round-trip identity preservation, "old data still decodes", equality/determinism), never an incidental encoded byte/key layout, and never expose a type's internals to make an assertion easier — that's the encapsulation break from the test side. Repo CLAUDE.md → Encapsulation Is the Precondition SOLID Assumes.
• fosmvvm-serverrequest-generator - Creating ServerRequest types
• fosmvvm-viewmodel-test-generator - Testing ViewModels (localization only)
• reference.md - Complete file templates

Version History