Testing · Apollo iOS · apollographql/skills · Skills Docs

Testing · Apollo iOS · apollographql/skills · Skills Docs

// Package.swift
.testTarget(
  name: "MyAppTests",
  dependencies: [
    "MyApp",
    .product(name: "ApolloTestSupport", package: "apollo-ios"),
    // If you used `testMocks.swiftPackage`, add the generated mocks package too:
    .product(name: "MyAPITestMocks", package: "MyAPI"),
  ]
),

import ApolloTestSupport
import MyAPITestMocks
import Testing

@Test
func viewModelDisplaysUser() async throws {
  // 1. Leaf entity mock.
  let mockUser = Mock<User>(
    id: "user-1",
    name: "Ada Lovelace",
    email: "ada@example.com"
  )

  // 2. Root `Query` mock with the leaf mock attached to the `user` field.
  let mockQuery = Mock<Query>(user: mockUser)

  // 3. Coerce into a real `GetUserQuery.Data`. `.from(_:)` is async.
  let data = await GetUserQuery.Data.from(mockQuery)

  #expect(data.user?.name == "Ada Lovelace")
}

// In the app target:
protocol GraphQLService: Sendable {
  func getUser(id: String) async throws -> GetUserQuery.Data.User?
}

final class ApolloGraphQLService: GraphQLService {
  private let client: ApolloClient
  init(client: ApolloClient) { self.client = client }

  func getUser(id: String) async throws -> GetUserQuery.Data.User? {
    let response = try await client.fetch(query: GetUserQuery(id: id))
    if let firstError = response.errors?.first { throw firstError }
    return response.data?.user
  }
}

import ApolloTestSupport
import MyAPITestMocks

// `GraphQLService: Sendable`, so `FakeGraphQLService` must also be Sendable.
// Under Swift 6 strict concurrency that means stored properties must be `let` —
// inject the canned response at init time rather than mutating it after
// construction.
final class FakeGraphQLService: GraphQLService {
  let userToReturn: GetUserQuery.Data.User?
  init(userToReturn: GetUserQuery.Data.User?) { self.userToReturn = userToReturn }
  func getUser(id: String) async throws -> GetUserQuery.Data.User? { userToReturn }
}

@Test
func viewModelLoadsUser() async throws {
  // Build the fixture root-first (Mock<Query> with the User attached),
  // convert to the operation's Data, then hand the nested user field
  // back to the fake service.
  let mockUser = Mock<User>(id: "1", name: "Grace Hopper")
  let data = await GetUserQuery.Data.from(Mock<Query>(user: mockUser))

  let service = FakeGraphQLService(userToReturn: data.user)

  let viewModel = UserViewModel(service: service)
  await viewModel.load(userID: "1")

  #expect(viewModel.userName == "Grace Hopper")
}

import Apollo
import ApolloAPI

final class CannedNetworkTransport: NetworkTransport, Sendable {
  let queryResponses: [String: String]  // operationName → JSON response body

  init(queryResponses: [String: String]) { self.queryResponses = queryResponses }

  func send<Query: GraphQLQuery>(
    query: Query,
    fetchBehavior: FetchBehavior,
    requestConfiguration: RequestConfiguration
  ) throws -> AsyncThrowingStream<GraphQLResponse<Query>, any Error> {
    return AsyncThrowingStream { continuation in
      guard let json = queryResponses[Query.operationName],
            let data = json.data(using: .utf8) else {
        continuation.finish(throwing: TestError.notConfigured)
        return
      }
      // Parse `data` into a GraphQLResponse<Query> using ApolloAPI decoders,
      // then yield and finish. The exact conversion helpers live in ApolloAPI.
      // For most tests, prefer the protocol-based FakeGraphQLService above —
      // this level of detail is only needed when testing Apollo itself.
      _ = data
      continuation.finish(throwing: TestError.notImplemented)
    }
  }

  func send<Mutation: GraphQLMutation>(
    mutation: Mutation,
    requestConfiguration: RequestConfiguration
  ) throws -> AsyncThrowingStream<GraphQLResponse<Mutation>, any Error> {
    throw TestError.notImplemented
  }

  enum TestError: Error { case notConfigured, notImplemented }
}

@Test
@MainActor
func watcherReactsToCacheUpdate() async throws {
  let store = ApolloStore()
  // ... build an ApolloClient with a transport that never actually hits the network ...

  var received: [String] = []
  let watcher = await client.watch(query: GetUserQuery(id: "1")) { result in
    if case let .success(response) = result, let name = response.data?.user?.name {
      Task { @MainActor in received.append(name) }
    }
  }

  let beforeData = await GetUserQuery.Data.from(
    Mock<Query>(user: Mock<User>(id: "1", name: "Before"))
  )
  try await store.withinReadWriteTransaction { tx in
    try tx.write(data: beforeData, for: GetUserQuery(id: "1"))
  }
  try await Task.sleep(for: .milliseconds(50))

  let afterData = await GetUserQuery.Data.from(
    Mock<Query>(user: Mock<User>(id: "1", name: "After"))
  )
  try await store.withinReadWriteTransaction { tx in
    try tx.write(data: afterData, for: GetUserQuery(id: "1"))
  }
  try await Task.sleep(for: .milliseconds(50))

  #expect(received == ["Before", "After"])
  watcher.cancel()
}