PactSwift

https://github.com/surpher/pactswift
Admin
PactSwift is a Swift DSL for generating and verifying Pact contracts, enabling Consumer-Driven...
Tokens:12,544
Snippets:166
Trust Score:7.8
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install xcbeautify

Source: https://github.com/surpher/pactswift/blob/main/CONTRIBUTING.md

Install xcbeautify, a tool to make Xcode build output more readable, by tapping its repository and then installing.

```sh
brew tap thii/xcbeautify https://github.com/thii/xcbeautify.git
brew install xcbeautify
```

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

### Install SwiftLint using Homebrew

Source: https://github.com/surpher/pactswift/blob/main/CONTRIBUTING.md

Use this command to install SwiftLint, a tool for enforcing Swift style and conventions.

```sh
brew install swiftlint
```

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

### Setting up Rust and Building libpact_ffi.so for Linux

Source: https://github.com/surpher/pactswift/wiki/Upgrading

Instructions for installing Rust and compiling the `libpact_ffi.so` library from the pact-reference repository, required for running PactSwift on Linux.

```shell
# Getting Rust
curl https://sh.rustup.rs -sSf | sh

# Building libpact_ffi.so
git clone https://github.com/pact-foundation/pact-reference
cd pact-reference/rust/pact_ffi
cargo build --release

# Building and Testing your Swift project on Linux
cd /path/to/your/swift/project/ 
export LD_LIBRARY_PATH=/absolute/path/to/pact-reference/rust/target/release/ 
swift build -Xlinker -L/absolute/path/to/pact-reference/rust/target/release/ 
swift test -Xlinker -L/absolute/path/to/pact-reference/rust/target/release/
```

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

### Project File Structure Example

Source: https://github.com/surpher/pactswift/blob/main/Documentation/ADRs/ADR-002-Coding_standard.md

Illustrates the standard file and directory layout for the project, adhering to Swift Package Manager boilerplate.

```text
.
|-- .config.yml
|-- .github
|-- CONTRIBUTING.md
|-- Documentation
|   |-- ADRs
|   |   |-- ADR-001-Language_choice.md
|   |   |-- ...
|-- EmbeddedProject # follows the same file structure
|   |-- Resources
|   |-- Sources
|   |-- Tests
|   |-- ...
|-- Package.swift
|-- README.md
|-- Resources
|   |-- Assets.xcassets
|   |-- ...
|-- Sources
|   |-- Extensions
|   |-- PACTMockService.swift
|   |-- ...
|-- Tests
|   |-- PACTMockService
|   |   |-- TestCaseFile.swift
|   |   |-- ...
|   |-- PACTXCTestCase.swift
|   |-- Resources
|   |   |-- ErrorCapture.swift
|   |   |-- PACTMockServiceStub.swift
|   |   |-- ...
.   .   .
```

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

### Define and Run a Pact Interaction for GET Users

Source: https://github.com/surpher/pactswift/blob/main/README.md

This snippet shows how to define a GET request interaction for fetching users, including setting up provider states, request details, and expected responses with matchers. It then demonstrates running the mock service and verifying the client's response.

```swift
import XCTest
import PactSwift

@testable import ExampleProject

class PassingTestsExample: XCTestCase {

  static var mockService = MockService(consumer: "Example-iOS-app", provider: "some-api-service")

  // MARK: - Tests

  func testGetUsers() {
    // #1 - Declare the interaction's expectations
    PassingTestsExample.mockService

      // #2 - Define the interaction description and provider state for this specific interaction
      .uponReceiving("A request for a list of users")
      .given(ProviderState(description: "users exist", params: ["first_name": "John", "last_name": "Tester"])

      // #3 - Declare what our client's request will look like
      .withRequest(
        method: .GET,
        path: "/api/users",
      )

      // #4 - Declare what the provider should respond with
      .willRespondWith(
        status: 200,
        headers: nil, // `nil` means we don't care what the headers returned from the API are.
        body: [
          "page": Matcher.SomethingLike(1), // We expect an Int, 1 will be used in the unit test
          "per_page": Matcher.SomethingLike(20),
          "total": ExampleGenerator.RandomInt(min: 20, max: 500), // Expecting an Int between 20 and 500
          "total_pages": Matcher.SomethingLike(3),
          "data": Matcher.EachLike( // We expect an array of objects
            [
              "id": ExampleGenerator.RandomUUID(), // We can also use random example generators
              "first_name": Matcher.SomethingLike("John"),
              "last_name": Matcher.SomethingLike("Tester"),
              "renumeration": Matcher.DecimalLike(125_000.00)
            ]
          )
        ]
      )

    // #5 - Fire up our API client
    let apiClient = RestManager()

    // Run a Pact test and assert **our** API client makes the request exactly as we promised above
    PassingTestsExample.mockService.run(timeout: 1) { [unowned self] mockServiceURL, done in

      // #6 - _Redirect_ your API calls to the address MockService runs on - replace base URL, but path should be the same
      apiClient.baseUrl = mockServiceURL

      // #7 - Make the API request.
      apiClient.getUsers() { users in

          // #8 - Test that **our** API client handles the response as expected. (eg: `getUsers() -> [User]`)
          XCTAssertEqual(users.count, 20)
          XCTAssertEqual(users.first?.firstName, "John")
          XCTAssertEqual(users.first?.lastName, "Tester")

        // #9 - Always run the callback. Run it in your successful and failing assertions!
        // Otherwise your test will time out.
        done()
      }
    }
  }

  // Another Pact test example...
  func testCreateUser() {
    PassingTestsExample.mockService
      .uponReceiving("A request to create a user")
      .given(ProviderState(description: "user does not exist", params: ["first_name": "John", "last_name": "Appleseed"])
      .withRequest(
        method: .POST,
        path: Matcher.RegexLike("/api/group/whoopeedeedoodah/users", term: #"^/\w+/group/([a-z])+/users$"#),
        body: [
          // You can use matchers and generators here too, but are an anti-pattern.
          // You should be able to have full control of your requests.
          "first_name": "John",
          "last_name": "Appleseed"
        ]
      )
      .willRespondWith(
        status: 201,
        body: [
          "identifier": Matcher.FromProviderState(parameter: "userId", value: .string("123e4567-e89b-12d3-a456-426614174000")),
          "first_name": "John",
          "last_name": "Appleseed"
        ]
      )

   let apiClient = RestManager()

    PassingTestsExample.mockService.run { mockServiceURL, done in
     // trigger your network request and assert the expectations
     done()
    }
  }
  // etc.
}

```

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

### Install Carthage using Homebrew

Source: https://github.com/surpher/pactswift/blob/main/CONTRIBUTING.md

Install Carthage, a dependency manager for macOS and iOS, to test PactSwift builds distributed via Carthage.

```sh
brew install carthage
```

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

### Initialize Mock Service in Objective-C

Source: https://github.com/surpher/pactswift/blob/main/README.md

Example of initializing a mock service for PactSwift in an Objective-C project. Ensure Pact Foundation (PF) is correctly imported.

```objective-c
_mockService = [[PFMockService alloc] initWithConsumer: @"Consumer-app"
                                              provider: @"Provider-server"
                                      transferProtocol: TransferProtocolStandard];
```

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

### Swift Type Padding Example

Source: https://github.com/surpher/pactswift/blob/main/Documentation/ADRs/ADR-002-Coding_standard.md

Illustrates the convention of single vertical space padding within top-level Swift structures and classes. This applies to the immediate space after an opening brace and before a closing brace.

```swift
struct MyStruct {

    var myInt: Int
    var myString: String

    struct MyNestedStruct {
        var myNestedInt: Int
        var myNestedString: String
    }

}

class MyClass {

    // MARK: - Types

    enum MyEnum {
        case one
        case two
    }

    // MARK: - Properties

    var myVar: SomeType

    // MARK: - Lifecycle

    init(myVar: SomeType) {
        self.myVar = myVar
    }

}
```

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

### Matcher.EqualTo for Exact Values

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use Matcher.EqualTo to define an exact value and type expected from the provider. The provided value is used as an example in consumer unit tests.

```swift
["amount": Matcher.EqualTo(5231)]
```

```objective-c
@{@"amount": [[PFMatcherEqualTo alloc] value:@5231]};
```

```json
{
  "amount": 5231
}
```

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

### Configure Pact Broker for Provider Verification

Source: https://github.com/surpher/pactswift/blob/main/README.md

Instantiate a PactBroker object with URL, authentication token, and provider name to dynamically retrieve pacts from a Pact Broker for verification. This setup is used when the provider needs to fetch pacts from a central location.

```swift
let provider = ProviderVerifier.Provider(port: 8080)

let pactBroker = PactBroker(
  url: URL(string: "https://broker.url/")!,
  auth: auth: .token(PactBroker.APIToken("auth-token")),
  providerName: "Your API Service Name"
)

let options = ProviderVerifier.Options(
  provider: provider,
  pactsSource: .broker(pactBroker)
)

ProviderVerifier().verify(options: options) {
  // do something (eg: shutdown the provider)
}
```

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

### Matcher.DecimalLike for Decimal Values

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use Matcher.DecimalLike to define a Decimal value expected from the provider. The provided value serves as an example for the MockService in consumer unit tests.

```swift
["amount": Matcher.DecimalLike(123.45)]
```

```objective-c
@{@"amount": [[PFMatcherDecimalLike alloc] value:[@123.45 decimalValue]]};
```

```json
{
  "amount": 123.45
}
```

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

### Matcher.IncludesLike for String Inclusion

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use Matcher.IncludesLike to define a matcher expecting a string that includes specific keywords. The 'generate' value is used as an example in consumer unit tests. Supports AND (includesAll) and OR (includesAny) logic.

```swift
["sentence": Matcher.IncludesLike("I'm", "a", "Teapot", combine: .OR, generate: "I'm such a big Teapot")]
```

```objective-c
@{@"sentence": [[PFMatcherIncludesLike alloc] includesAll:@[@"I'm", @"a", @"Teapot", nil] generate:@"I'm such a big Teapot"]}; // for .AND
```

```objective-c
@{@"sentence": [[PFMatcherIncludesLike alloc] includesAny:@[@"I'm", @"a", @"Teapot", nil] generate:@"I'm such a big Teapot"]}; // for .OR
```

```json
{
  "sentence": ["I'm such a big Teapot"]
}
```

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

### Define Integer Type with IntegerLike Matcher

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use IntegerLike to specify that a provider value should be an Int. The provided value serves as an example for consumer unit tests.

```swift
["amount": Matcher.IntegerLike(123)]
```

```objective-c
@{@"amount": [[PFMatcherIntegerLike alloc] value:@123]};
```

```json
{
  "amount": 123
}
```

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

### Define Type with SomethingLike Matcher

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use SomethingLike to specify the type of a provider value, suitable for simple Codable types like String and Int. The provided value is used as an example in consumer unit tests.

```swift
[
  "object": Matcher.SomethingLike("Teapot"),
  "amount": Matcher.SomethingLike(1)
]
```

```objective-c
@{@"object": [[PFMatcherSomethingLike alloc] value:@"Teapot"], @"amount": [[PFMatcherSomethingLike alloc] value:@1]};
```

```json
{
  "object": "Teapot",
  "amount": 1
}
```

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

### Define Specific List of Values with OneOf Matcher

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use OneOf to specify that a value must be one of a predefined list of Strings, Ints, Decimals, or Floats. The first provided value is used as the example in consumer tests.

```swift
[
  "some_string_case": Matcher.OneOf("white", "black", "yellow", "blue", "red"),
  "some_int_case": Matcher.OneOf(5, 1, 2, 3, 4),
]
```

```json
{
  "some_string_case": "white",
  "some_int_case": 5
}
```

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

### Define String Matching Regex with RegexLike Matcher

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use RegexLike to ensure a string value conforms to a specified regex pattern. The provided value must match the pattern and is used as an example in consumer tests. This matcher can also define request paths.

```swift
["object": Matcher.RegexLike(value: "2020:01:31", pattern:#"\d{4}:\d{2}:\d{2}"\)]
```

```objective-c
@{@"object": [[PFMatcherRegexLike alloc] value:@"2020:01:31" pattern:@"\\d{4}:\\d{2}:\\d{2}"]};
```

```json
{
  "object": "2020:01:31"
}
```

```swift
.withRequest(
  method: .GET,
  path: Matcher.RegexLike(value: "/hello/dear/world", pattern: #"^/\\w+/([a-z])+/world$"\)
)
```

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

### Build PactSwift XCFrameworks with Carthage

Source: https://github.com/surpher/pactswift/wiki/Upgrading

Run this command to build the XCFrameworks for PactSwift using Carthage. Ensure you have deleted the old Carthage/Build folder first.

```bash
carthage build --use-xcframeworks
```

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

### Objective-C Mock Service Initialization

Source: https://github.com/surpher/pactswift/wiki/Upgrading

For Objective-C projects, `MockService` has been renamed to `PFMockService` to remove `@objc` annotations and support Linux.

```objective-c
// This no longer works:
_mockService = [[MockService alloc] init];

// Use this:
_mockService = [[PFMockService alloc] init];
```

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

### Basic PactSwift Test Structure

Source: https://github.com/surpher/pactswift/blob/main/README.md

Instantiate a MockService, define provider states, expected requests and responses for an interaction, then run the test by making an API request.

```swift
// Instantiate a MockService object by defining _pacticipants_
// Define the state of the provider for an interaction (one Pact test)
// Define the expected `request` for the interaction
// Define the expected `response` for the interaction
// Run the test by making the API request using your API client and assert what you need asserted
```

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

### Run tests from CLI

Source: https://github.com/surpher/pactswift/blob/main/CONTRIBUTING.md

Execute all tests for the project from the command line using the provided script.

```sh
$PROJECT_DIR/Scripts/run_tests
```

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

### Configure Linux Environment for PactSwift

Source: https://github.com/surpher/pactswift/blob/main/README.md

When using PactSwift on Linux, ensure the `libpact_ffi.so` library is compatible and accessible. Set LD_LIBRARY_PATH or link the library during the build and test phases.

```sh
export LD_LIBRARY_PATH="/absolute/path/to/your/rust/target/release/:$LD_LIBRARY_PATH"
swift build
swift test -Xlinker -L/absolute/path/to/your/rust/target/release/
```

```sh
mv /path/to/target/release/libpact_ffi.so /usr/local/lib/
swift build
swift test -Xlinker -L/usr/local/lib/
```

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

### Organizing Type Members in Swift

Source: https://github.com/surpher/pactswift/blob/main/Documentation/ADRs/ADR-003-Organization_of_type_members.md

Demonstrates the recommended organization of members within a Swift class, including constants, types, stored properties, computed properties, constructors, methods, and overrides. Follows the specified ordering conventions for clarity.

```swift
class MyClass: BaseClass {

	// MARK: - Constants
	
	public static let valueA = 1
	private static let valueB = 2

	// MARK: - Types
	
	public struct SubTypeA {}
	private struct SubTypeB {}

	// MARK: - Stored Properties

	public var propertyA = 1
	private var propertyB = 2

	// MARK: - Computed Properties

	public var propertyC: Int { return propertyA * 3 }
	private var propertyD: Int { return propertyB * 4 }

	// MARK: - Constructors

	public init() {}
	private init(param: Int) {}

	// MARK: - Methods

	public static func k() {}

	public func f() {}
	private func g() {}

	private static func h() {}

	// MARK: - BaseClass overrides

	public override var propertyL: Int { return propertyA * 3 }
	public override func base() {}
	
}

extension MyClass: SomeComformance {

	public var i: Int { return 0 }

	public func j() {}

}
```

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

### Mock Service Initialization in PactSwift

Source: https://github.com/surpher/pactswift/wiki/Upgrading

Previously, `MockService` allowed specifying a port. Now, it automatically assigns an available port using `127.0.0.1:0` for cross-platform compatibility.

```swift
// This no longer works:
mockService = MockService(port: 1234)

// Use this:
mockService = MockService()
```

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

### Clone your PactSwift fork

Source: https://github.com/surpher/pactswift/blob/main/CONTRIBUTING.md

Clone your forked repository of PactSwift to your local machine. Replace <YOUR_GITHUB_USER> with your GitHub username.

```git
git clone git@github.com:<YOUR_GITHUB_USER>/PactSwift.git`
```

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

### Verify Specific Pact Files from URL

Source: https://github.com/surpher/pactswift/blob/main/README.md

Validate pact files by providing their URLs. This enables verification against pacts hosted at a specific network location.

```swift
pactsSource: .urls([URL(string: "https://some.base.url/location/of/pact/consumerName-providerName.json")])
```

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

### Verify Pacts from Local Directories

Source: https://github.com/surpher/pactswift/blob/main/README.md

Use the ProviderVerifier to verify pacts located in a specified local directory. This is useful for testing providers against a set of pact files stored on the local filesystem.

```swift
ProviderVerifier()
  .verify(options: ProviderVerifier.Options( 
    provider: provider,
    pactsSource: .directories(["/absolute/path/to/directory/containing/pact/files/"])
  ),
  completionBlock: {
    // do something
  }
)
```

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

### Preferred Code Formatting - Simple Split

Source: https://github.com/surpher/pactswift/blob/main/Documentation/ADRs/ADR-002-Coding_standard.md

Shows the preferred method for splitting a single statement across multiple lines by increasing indentation by one level after a clean break, typically after a comma.

```swift
func myFunc() {
    someCall(paramOne: argOne, paramTwo: argTwo, paramThree: argThree,
        paramFour: argFour, paramFive: argFive)
}
```

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

### Specify Pact Output Directory in MockService

Source: https://github.com/surpher/pactswift/blob/main/README.md

Configure the directory where generated Pact contracts are written by providing a URL to the MockService initializer. This overrides the default `/tmp/pacts` directory.

```swift
MockService(
    consumer: "consumer",
    provider: "provider",
    writePactTo: URL(fileURLWithPath: "/absolute/path/pacts/folder", isDirectory: true)
)
```

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

### Verify Specific Local Pact Files

Source: https://github.com/surpher/pactswift/blob/main/README.md

Validate specific pact files by providing their paths. This allows for precise control over which pacts are used during provider verification.

```swift
pactsSource: .files(["/absolute/path/to/file/consumerName-providerName.json"])
```

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

### PactSwift SPM Build Phase Removal

Source: https://github.com/surpher/pactswift/wiki/Upgrading

When migrating to Swift Package Manager (SPM) and XCFrameworks, remove the build phase that uses `./Scripts/BuildPhases/build-spm-dependency` to build `libpact_mock_server.a`.

```shell
1. Remove the Build Phase that builds the `libpact_mock_server.a` binary using `./Scripts/BuildPhases/build-spm-dependency` script.
2. Remove `$BUILD_DIR/../../SourcePackages/checkouts/..` entry for `Library Search Paths` in Build Settings.
3. Optional: Remove `cargo` and `rustup` from `PATH`
```

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

### Matcher.FromProviderState for Injected Values

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use Matcher.FromProviderState to define a matcher that uses values injected from the provider state. The 'parameter' is the injected element, and 'value' is used in consumer tests.

```swift
[
  "intId": Matcher.FromProviderState(parameter: "userId", value: .int(666)),
  "stringId": Matcher.FromProviderState(parameter: "/api/v1/${stringId}", value: .string("/api/v1/abc-123"))
]
```

```objective-c
@{
  @"intId": [[PFMatcherFromProviderState alloc] parameter:@"userId" withIntValue:@666],
  @"stringId": [[PFMatcherFromProviderState alloc] parameter:@"/api/v1/${stringId}" withStringValue:@"/api/v1/abc-123"]
};
```

```json
{
  "intId": 666,
  "stringId": "/api/v1/abc-123"
}
```

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

### Submit Verification Results to Pact Broker

Source: https://github.com/surpher/pactswift/blob/main/README.md

Configure the PactBroker to publish verification results, including the provider version and optional tags. This ensures that verification outcomes are recorded in the Pact Broker for tracking and deployment decisions.

```swift
let pactBroker = PactBroker(
  url: URL(string: "https://broker.url/")!,
  auth: .token("auth-token"),
  providerName: "Some API Service",
  publishResults: PactBroker.VerificationResults(
    providerVersion: "v1.0.0+\(ProcessInfo.processInfo.environment["GITHUB_SHA"])",
    providerTags: ["\(ProcessInfo.processInfo.environment["GITHUB_REF"]) "]
  )
)
```

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

### Create a new feature branch

Source: https://github.com/surpher/pactswift/blob/main/CONTRIBUTING.md

Create a new branch for your work using git checkout -b. Branch names should be descriptive, e.g., 'docs/updating-contributing-guide' or 'fix/create-user-crash'.

```git
git checkout -b <YOUR_BRANCH_NAME>
```

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

### Generate Random String by Size (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random string of a specified length. Use this when a fixed-length random string is required.

```swift
{
  "someString": ExampleGenerator.RandomString(size: 16)
}
```

```objective-c
@{@"someString": [[PFGeneratorRandomString alloc] size:@16]};

```

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

### Generate Random String by Regex (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random string that matches a given regular expression. Use raw strings to avoid escaping issues. This is useful for generating strings that conform to specific patterns.

```swift
{
  "someString": ExampleGenerator.RandomString(regex: #"\d{2}[a-z]"#)
}
```

```objective-c
@{@"someString": [[PFGeneratorRandomString alloc] regex:@"\\d{2}[a-z]"]};

```

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

### Preferred Code Formatting - Declarative Style

Source: https://github.com/surpher/pactswift/blob/main/Documentation/ADRs/ADR-002-Coding_standard.md

Presents an alternative preferred style for multi-line statements, especially for function calls, where the structure is clearly delineated by indenting from the opening parenthesis and placing the closing parenthesis on its own line.

```swift
func someCall(
    paramOne: argOne,
    paramTwo: argTwo,
    paramThree: argThree,
    paramFour: argFour,
    paramFive: argFive
) -> Type {...}

func myFunc() {
    let myVar = someCall(
        paramOne: argOne,
        paramTwo: argTwo,
        paramThree: argThree,
        paramFour: argFour,
        paramFive: argFive
    )
}
```

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

### Matcher.EachLike for Array Values

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use Matcher.EachLike to define an array of a specific type expected from the provider. The provided value is a template for the MockService. Configure min, max, and count for array size constraints.

```swift
["object": Matcher.EachLike("Teapot", min: 2)]
```

```swift
["object": Matcher.EachLike("Teapot", min: 1, count: 2)]
```

```swift
["object": Matcher.EachLike("Teapot", max: 5, count: 2)]
```

```objective-c
@{@"object": [[PFMatcherEachLike alloc] value:@"Teapot" min:@2 max:@10 count:@5]};
```

```json
{
  "object": ["Teapot", "Teapot"]
}
```

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

### Add PactSwift Dependency via Swift Package Manager

Source: https://github.com/surpher/pactswift/blob/main/README.md

Add PactSwift to your test target using Swift Package Manager in Xcode or by specifying the dependency in your Package.swift file.

```sh
dependencies: [
    .package(url: "https://github.com/surpher/PactSwift.git", .upToNextMinor(from: "0.11.0"))
]
```

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

### PactSwift MockService.run() Argument Change

Source: https://github.com/surpher/pactswift/wiki/Upgrading

The `waitFor` argument in `MockService.run()` has been renamed to `timeout` for clarity, indicating the duration the test will wait for completion.

```swift
// <0.4.x
mockService.run(waitFor: 1) { [unowned self] testCompleted in ... }
// >=0.5.0
mockService.run(timeout: 1) { [unowned self] testCompleted in ... }
```

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

### RandomTime(format: String?)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a Time value, optionally formatted.

```APIDOC
## RandomTime(format: String?)

### Description
Generates a Time value from the current time either in ISO format or using the provided format string.

### Parameters
#### Path Parameters
- **format** (String?) - Optional - The format string for the time. If nil, ISO format is used.

### Request Example
```swift
ExampleGenerator.RandomTime(format: "HH:mm")
```

### Response Example
```json
{
  "someTime": "14:30"
}
```
```

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

### RandomString(size: Int)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random string value of the specified size.

```APIDOC
## RandomString(size: Int)

### Description
Generates a random string value of the provided size characters.

### Parameters
#### Path Parameters
- **size** (Int) - Required - The desired length of the random string.

### Request Example
```swift
ExampleGenerator.RandomString(size: 16)
```

### Response Example
```json
{
  "someString": "a1b2c3d4e5f67890"
}
```
```

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

### Generate Random DateTime by Format (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random date and time value, either in ISO format or using a custom format string. Ideal for timestamp fields.

```swift
{
  "someDateTime": ExampleGenerator.RandomDateTime(format: "HH:mm - dd/MM")
}
```

```objective-c
@{@"someDateTime": [[PFGeneratorRandomDateTime alloc] format:@"HH:mm - dd/MM"]};

```

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

### Generate Random Time by Format (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random time value, either in ISO format or using a custom format string. Suitable for time-specific fields.

```swift
{
  "someTime": ExampleGenerator.RandomTime(format: "HH:mm")
}
```

```objective-c
@{@"someTime": [[PFGeneratorRandomTime alloc] format:@"HH:mm"]};

```

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

### Generate Random Date by Format (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random date value, either in ISO format or using a custom format string. Useful for date fields in contracts.

```swift
{
  "someDate": ExampleGenerator.RandomDate(format: "dd/MM/yy")
}
```

```objective-c
@{@"someDate": [[PFGeneratorRandomDate alloc] format:@"dd/MM/yy"]};

```

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

### RandomDate(format: String?)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a Date value, optionally formatted.

```APIDOC
## RandomDate(format: String?)

### Description
Generates a Date value from the current date either in ISO format or using the provided format string.

### Parameters
#### Path Parameters
- **format** (String?) - Optional - The format string for the date. If nil, ISO format is used.

### Request Example
```swift
ExampleGenerator.RandomDate(format: "dd/MM/yy")
```

### Response Example
```json
{
  "someDate": "25/12/23"
}
```
```

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

### RandomString(regex: String)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random string value that matches the provided regular expression.

```APIDOC
## RandomString(regex: String)

### Description
Generates a random string value from the provided regular expression. Use a raw `String` (eg: `"\\d{2}/\\d{2,4}"`) to avoid interpreting special characters.

### Parameters
#### Path Parameters
- **regex** (String) - Required - The regular expression to match for generating the string.

### Request Example
```swift
ExampleGenerator.RandomString(regex: #"\\d{2}[a-z]"#)
```

### Response Example
```json
{
  "someString": "12a"
}
```
```

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

### Mock Service URL Access in PactSwift

Source: https://github.com/surpher/pactswift/wiki/Upgrading

In older versions, `baseUrl` was exposed directly on `MockService`. The current approach provides the URL within the `testFunction`'s completion block for independent test execution.

```swift
# This no longer works
let baseURL = MockService.baseUrl

# Use this instead
mockService.run { baseURL, done in
  yourAPIClient(baseURL: baseURL).doThings()
  done()
}
```

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

### Generate Random Integers with RandomInt

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Use RandomInt to generate random integer values within a specified range. This is useful for creating dynamic test data where specific values are not critical, but a range is required.

```swift
{ 
  "someInt": ExampleGenerator.RandomInt(min: 0, max: 100) 
}
```

```objective-c
@{@"someInt": [[PFGeneratorRandomInt alloc] min:@0, max:@100]};

```

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

### Code Formatting to Avoid

Source: https://github.com/surpher/pactswift/blob/main/Documentation/ADRs/ADR-002-Coding_standard.md

Demonstrates an undesirable code formatting style where function call arguments are split across multiple lines with automatic indentation. Xcode's 'Syntax aware indenting' feature can generate this style.

```swift
func myFunc() {
    someCall(paramOne: argOne, paramTwo: argTwo, paramThree: argThree,
             paramFour: argFour, paramFive: argFive)
}
```

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

### Generate Random Decimal by Digits (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random BigDecimal value with a specified number of digits. Useful for numerical fields where precision is important.

```swift
{
  "someDecimal": ExampleGenerator.RandomDecimal(digits: 6)
}
```

```objective-c
@{@"someDecimal": [[PFGeneratorRandomDecimal alloc] digits:@6]};

```

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

### RandomDateTime(format: String?)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a DateTime value, optionally formatted.

```APIDOC
## RandomDateTime(format: String?)

### Description
Generates a Date and Time (timestamp) value from the current date and time either in ISO format or using the provided format string.

### Parameters
#### Path Parameters
- **format** (String?) - Optional - The format string for the date and time. If nil, ISO format is used.

### Request Example
```swift
ExampleGenerator.RandomDateTime(format: "HH:mm - dd/MM")
```

### Response Example
```json
{
  "someDateTime": "14:30 - 25/12"
}
```
```

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

### Generate Random Hexadecimal by Digits (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random hexadecimal string of a specified length. Use this for fields that require hexadecimal representation.

```swift
{
  "someHex": ExampleGenerator.RandomHexadecimal(digits: 12)
}
```

```objective-c
@{@"someHex": [[PFGeneratorRandomHexadecimal alloc] digits:@12]};

```

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

### Define Nullable Value with MatchNull Matcher

Source: https://github.com/surpher/pactswift/wiki/Matchers

Use MatchNull to assert that a provider value is null. This null value is used in consumer unit tests.

```swift
["some_nullable_key": Matcher.MatchNull()]
```

```objective-c
@{@"some_nullable_key": [[PFMatcherNull alloc] init]};
```

```json
{
  "some_nullable_key": null
}
```

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

### Generate Relative Date Times with DateTimeExpression

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Use DateTimeExpression to generate date-time values relative to the current system clock. Specify the desired format for the output. Useful for scenarios where pacts need to accommodate time-sensitive data.

```swift
{ 
  "someDateExpression": ExampleGenerator.DateTimeExpression(expression: "last december + 2 weeks + 4 days", format: "yyyy-MM-dd")
}
```

```objective-c
@{@"someDateExpression": [[PFGeneratorDateTimeExpression alloc] expression:@"last december + 2 weeks + 4 days", format:@"yyyy-MM-dd"]};

```

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

### Generate Random UUID (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random UUID compliant with RFC4122. Note that it generates a lowercased simple format UUID.

```swift
{
  "someUUID": ExampleGenerator.RandomUUID()
}
```

```objective-c
@{@"someUUID": [[PFGeneratorRandomUUID alloc] init]};

```

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

### RandomDecimal(digits: Int)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random decimal value with a specified number of digits.

```APIDOC
## RandomDecimal(digits: Int)

### Description
Generates a random decimal value (BigDecimal) with the provided number of digits.

### Parameters
#### Path Parameters
- **digits** (Int) - Required - The number of digits for the decimal value.

### Request Example
```swift
ExampleGenerator.RandomDecimal(digits: 6)
```

### Response Example
```json
{
  "someDecimal": "123456"
}
```
```

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

### RandomUUID()

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random UUID value compliant with RFC4122.

```APIDOC
## RandomUUID()

### Description
Generates a random UUID value compliant with [RFC4122](https://tools.ietf.org/htmo/rfc4122) specifically [ITU-T Rec. X.667](https://www.itu.int/rec/T-REC-X.667-201210-I/en) (ISO/IEC 9834-8:2005 section 6.5.4).

Note: generates a lowercased simple format UUID such as "385336e1d64744a88b1b3dbf4a073416". See https://github.com/surpher/PactSwift/issues/70.

### Request Example
```swift
ExampleGenerator.RandomUUID()
```

### Response Example
```json
{
  "someUUID": "385336e1-d647-44a8-8b1b-3dbf4a073416"
}
```
```

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

### Generate Random Boolean (Swift/Objective-C)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random boolean value (true or false). This is a simple generator for boolean fields.

```swift
{
  "someBool": ExampleGenerator.RandomBool()
}
```

```objective-c
@{@"someBool": [[PFGeneratorRandomBool alloc] init]};

```

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

### RandomHexadecimal(digits: UInt8)

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random hexadecimal string of a specified length.

```APIDOC
## RandomHexadecimal(digits: UInt8)

### Description
Generates a random hexadecimal value (String) with the provided number of digits.

### Parameters
#### Path Parameters
- **digits** (UInt8) - Required - The number of hexadecimal digits to generate.

### Request Example
```swift
ExampleGenerator.RandomHexadecimal(digits: 12)
```

### Response Example
```json
{
  "someHex": "a1b2c3d4e5f6"
}
```
```

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

### RandomBool()

Source: https://github.com/surpher/pactswift/wiki/Example-generators

Generates a random boolean value (true or false).

```APIDOC
## RandomBool()

### Description
Generates a random boolean value.

### Request Example
```swift
ExampleGenerator.RandomBool()
```

### Response Example
```json
{
  "someBool": true
}
```
```
Tokens:
Raw