MockDatabase done, todo tests

tact · Aug 1, 2024 · 8842428 · 8842428
1 parent c6ec21e
commit 8842428
Show file tree

Hide file tree

Showing 2 changed files with 123 additions and 6 deletions.
diff --git a/Targets/CanopyTestTools/Sources/ReplayingMockDatabase/ReplayingMockDatabase+Types.swift b/Targets/CanopyTestTools/Sources/ReplayingMockDatabase/ReplayingMockDatabase+Types.swift
@@ -31,4 +31,54 @@ public extension ReplayingMockDatabase {
       }
     }
   }
+
+  struct ModifyZonesOperationResult: Codable, Sendable {
+    let result: CodableResult<ModifyZonesResult, CKRecordZoneError>
+    public init(result: Result<ModifyZonesResult, CKRecordZoneError>) {
+      switch result {
+      case .success(let modifyResult): self.result = .success(modifyResult)
+      case .failure(let error): self.result = .failure(error)
+      }
+    }
+  }
+
+  struct FetchZonesOperationResult: Codable, Sendable {
+    let result: CodableResult<CloudKitRecordZoneArchive, CKRecordZoneError>
+    public init(result: Result<[CKRecordZone], CKRecordZoneError>) {
+      switch result {
+      case .success(let zones): self.result = .success(.init(zones: zones))
+      case .failure(let recordZoneError): self.result = .failure(recordZoneError)
+      }
+    }
+  }
+
+  struct ModifySubscriptionsOperationResult: Codable, Sendable {
+    let result: CodableResult<ModifySubscriptionsResult, CKSubscriptionError>
+    public init(result: Result<ModifySubscriptionsResult, CKSubscriptionError>) {
+      switch result {
+      case .success(let modifyResult): self.result = .success(modifyResult)
+      case .failure(let error): self.result = .failure(error)
+      }
+    }
+  }
+
+  struct FetchDatabaseChangesOperationResult: Codable, Sendable {
+    let result: CodableResult<FetchDatabaseChangesResult, CanopyError>
+    public init(result: Result<FetchDatabaseChangesResult, CanopyError>) {
+      switch result {
+      case .success(let fetchResult): self.result = .success(fetchResult)
+      case .failure(let error): self.result = .failure(error)
+      }
+    }
+  }
+
+  struct FetchZoneChangesOperationResult: Codable, Sendable {
+    let result: CodableResult<FetchZoneChangesResult, CanopyError>
+    public init(result: Result<FetchZoneChangesResult, CanopyError>) {
+      switch result {
+      case .success(let fetchResult): self.result = .success(fetchResult)
+      case .failure(let error): self.result = .failure(error)
+      }
+    }
+  }
 }
diff --git a/Targets/CanopyTestTools/Sources/ReplayingMockDatabase/ReplayingMockDatabase.swift b/Targets/CanopyTestTools/Sources/ReplayingMockDatabase/ReplayingMockDatabase.swift
@@ -2,11 +2,18 @@ import CanopyTypes
 import CloudKit
 
 public actor ReplayingMockDatabase: Sendable {
+  #warning("build tests for uncovered cases")
   public enum OperationResult: Codable, Sendable {
     case queryRecords(QueryRecordsOperationResult)
     case modifyRecords(ModifyRecordsOperationResult)
     case deleteRecords(ModifyRecordsOperationResult)
     case fetchRecords(FetchRecordsOperationResult)
+    case modifyZones(ModifyZonesOperationResult)
+    case fetchZones(FetchZonesOperationResult)
+    case fetchAllZones(FetchZonesOperationResult)
+    case modifySubscriptions(ModifySubscriptionsOperationResult)
+    case fetchDatabaseChanges(FetchDatabaseChangesOperationResult)
+    case fetchZoneChanges(FetchZoneChangesOperationResult)
   }
 
   private var operationResults: [OperationResult]
@@ -102,41 +109,101 @@ extension ReplayingMockDatabase: CKDatabaseAPIType {
     deleting recordZoneIDsToDelete: [CKRecordZone.ID]?,
     qos: QualityOfService
   ) async -> Result<ModifyZonesResult, CKRecordZoneError> {
-    fatalError("Not implemented")
+    let operationResult = operationResults.removeFirst()
+    guard case let .modifyZones(result) = operationResult else {
+      fatalError("Asked to modify zones without an available result or invalid result type. Likely a logic error on caller side")
+    }
+    operationsRun += 1
+    switch result.result {
+    case .success(let fetchResult):
+      return .success(fetchResult)
+    case .failure(let e):
+      return .failure(e)
+    }
   }
 
   public func fetchZones(
     with recordZoneIDs: [CKRecordZone.ID],
     qos: QualityOfService
   ) async -> Result<[CKRecordZone], CKRecordZoneError> {
-    fatalError("Not implemented")
+    let operationResult = operationResults.removeFirst()
+    guard case let .fetchZones(result) = operationResult else {
+      fatalError("Asked to fetch zones without an available result or invalid result type. Likely a logic error on caller side")
+    }
+    operationsRun += 1
+    switch result.result {
+    case .success(let zonesArchive):
+      return .success(zonesArchive.zones)
+    case .failure(let e):
+      return .failure(e)
+    }
   }
 
   public func fetchAllZones(
     qos: QualityOfService
   ) async -> Result<[CKRecordZone], CKRecordZoneError> {
-    fatalError("Not implemented")
+    let operationResult = operationResults.removeFirst()
+    guard case let .fetchAllZones(result) = operationResult else {
+      fatalError("Asked to fetch all zones without an available result or invalid result type. Likely a logic error on caller side")
+    }
+    operationsRun += 1
+    switch result.result {
+    case .success(let zonesArchive):
+      return .success(zonesArchive.zones)
+    case .failure(let e):
+      return .failure(e)
+    }
   }
 
   public func modifySubscriptions(
     saving subscriptionsToSave: [CKSubscription]?,
     deleting subscriptionIDsToDelete: [CKSubscription.ID]?,
     qos: QualityOfService
   ) async -> Result<ModifySubscriptionsResult, CKSubscriptionError> {
-    fatalError("Not implemented")
+    let operationResult = operationResults.removeFirst()
+    guard case let .modifySubscriptions(result) = operationResult else {
+      fatalError("Asked to modify subscriptions without an available result or invalid result type. Likely a logic error on caller side")
+    }
+    operationsRun += 1
+    switch result.result {
+    case .success(let fetchResult):
+      return .success(fetchResult)
+    case .failure(let e):
+      return .failure(e)
+    }
   }
 
   public func fetchDatabaseChanges(
     qos: QualityOfService
   ) async -> Result<FetchDatabaseChangesResult, CanopyError> {
-    fatalError("Not implemented")
+    let operationResult = operationResults.removeFirst()
+    guard case let .fetchDatabaseChanges(result) = operationResult else {
+      fatalError("Asked to fetch databse changes without an available result or invalid result type. Likely a logic error on caller side")
+    }
+    operationsRun += 1
+    switch result.result {
+    case .success(let changes):
+      return .success(changes)
+    case .failure(let e):
+      return .failure(e)
+    }
   }
 
   public func fetchZoneChanges(
     recordZoneIDs: [CKRecordZone.ID],
     fetchMethod: FetchZoneChangesMethod,
     qos: QualityOfService
   ) async -> Result<FetchZoneChangesResult, CanopyError> {
-    fatalError("Not implemented")
+    let operationResult = operationResults.removeFirst()
+    guard case let .fetchZoneChanges(result) = operationResult else {
+      fatalError("Asked to fetch zone changes without an available result or invalid result type. Likely a logic error on caller side")
+    }
+    operationsRun += 1
+    switch result.result {
+    case .success(let changes):
+      return .success(changes)
+    case .failure(let e):
+      return .failure(e)
+    }
   }
 }