keychain/TrustedPeersHelperUnitTests/MockCuttlefish.swift

   1 //
   2 //  MockCuttlefish.swift
   3 //  TrustedPeersHelperUnitTests
   4 //
   5 //  Created by Ben Williamson on 5/1/18.
   6 //
   7
   8 import Foundation
   9 import XCTest
  10
  11 enum Handler {
  12     case reset((ResetRequest, @escaping (ResetResponse?, Error?) -> Void) -> Void)
  13     case establish((EstablishRequest, @escaping (EstablishResponse?, Error?) -> Void) -> Void)
  14     case joinWithVoucher((JoinWithVoucherRequest, @escaping (JoinWithVoucherResponse?, Error?) -> Void) -> Void)
  15     case updateTrust((UpdateTrustRequest, @escaping (UpdateTrustResponse?, Error?) -> Void) -> Void)
  16     case setRecoveryKey((SetRecoveryKeyRequest, @escaping (SetRecoveryKeyResponse?, Error?) -> Void) -> Void)
  17     case fetchChanges((FetchChangesRequest, @escaping (FetchChangesResponse?, Error?) -> Void) -> Void)
  18     case fetchViableBottles((FetchViableBottlesRequest, @escaping (FetchViableBottlesResponse?, Error?) -> Void) -> Void)
  19     case fetchPolicyDocuments((FetchPolicyDocumentsRequest,
  20         @escaping (FetchPolicyDocumentsResponse?, Error?) -> Void) -> Void)
  21 }
  22
  23 class MockCuttlefishAPIAsyncClient: CuttlefishAPIAsync {
  24     var handlers: [Handler] = []
  25     var index: Int = 0
  26
  27     func expect(_ handler: Handler) {
  28         self.handlers.append(handler)
  29     }
  30
  31     func next() -> Handler {
  32         if index >= handlers.count {
  33             XCTFail("MockCuttlefish: Not expecting any more calls.")
  34             self.dump()
  35             abort()
  36         }
  37         return handlers[index]
  38     }
  39
  40     func dump() {
  41         print("---")
  42         for i in 0 ..< handlers.count {
  43             print("\(i) \(i == index ? "->" : "  ") \(handlers[i])")
  44         }
  45         print("---")
  46     }
  47
  48     func reset(_ request: ResetRequest, completion: @escaping (ResetResponse?, Error?) -> Void) {
  49         print("MockCuttlefish: reset called")
  50         if case .reset(let f) = next() {
  51             index += 1
  52             f(request, completion)
  53         } else {
  54             XCTFail("Unexpected: reset")
  55             print("Unexpected: reset")
  56             self.dump()
  57             abort()
  58         }
  59     }
  60
  61     func establish(_ request: EstablishRequest, completion: @escaping (EstablishResponse?, Error?) -> Void) {
  62         print("MockCuttlefish: establish called")
  63         if case .establish(let f) = next() {
  64             index += 1
  65             f(request, completion)
  66         } else {
  67             XCTFail("Unexpected: establish")
  68             print("Unexpected: establish")
  69             self.dump()
  70             abort()
  71         }
  72     }
  73
  74     func joinWithVoucher(_ request: JoinWithVoucherRequest,
  75                          completion: @escaping (JoinWithVoucherResponse?, Error?) -> Void) {
  76         print("MockCuttlefish: joinWithVoucher called")
  77         if case .joinWithVoucher(let f) = next() {
  78             index += 1
  79             f(request, completion)
  80         } else {
  81             XCTFail("Unexpected: joinWithVoucher")
  82             print("Unexpected: joinWithVoucher")
  83             self.dump()
  84             abort()
  85         }
  86     }
  87
  88     func updateTrust(_ request: UpdateTrustRequest, completion: @escaping (UpdateTrustResponse?, Error?) -> Void) {
  89         print("MockCuttlefish: updateTrust called")
  90         if case .updateTrust(let f) = next() {
  91             index += 1
  92             f(request, completion)
  93         } else {
  94             XCTFail("Unexpected: updateTrust")
  95             print("Unexpected: updateTrust")
  96             self.dump()
  97             abort()
  98         }
  99     }
 100
 101     func setRecoveryKey(_ request: SetRecoveryKeyRequest,
 102                         completion: @escaping (SetRecoveryKeyResponse?, Error?) -> Void) {
 103         print("MockCuttlefish: setRecoveryKey called")
 104         if case .setRecoveryKey(let f) = next() {
 105             index += 1
 106             f(request, completion)
 107         } else {
 108             XCTFail("Unexpected: setRecoveryKey")
 109             print("Unexpected: setRecoveryKey")
 110             self.dump()
 111             abort()
 112         }
 113     }
 114
 115     func fetchChanges(_ request: FetchChangesRequest, completion: @escaping (FetchChangesResponse?, Error?) -> Void) {
 116         print("MockCuttlefish: fetchChanges called")
 117         if case .fetchChanges(let f) = next() {
 118             index += 1
 119             f(request, completion)
 120         } else {
 121             XCTFail("Unexpected: fetchChanges")
 122             print("Unexpected: fetchChanges")
 123             self.dump()
 124             abort()
 125         }
 126     }
 127
 128     func fetchViableBottles(_ request: FetchViableBottlesRequest, completion: @escaping (FetchViableBottlesResponse?, Error?) -> Void) {
 129         print("MockCuttlefish: fetchViableBottles called")
 130         if case .fetchViableBottles(let f) = next() {
 131             index += 1
 132             f(request, completion)
 133         } else {
 134             XCTFail("Unexpected: fetchViableBottles")
 135             self.dump()
 136             abort()
 137         }
 138     }
 139
 140     func fetchPolicyDocuments(_ request: FetchPolicyDocumentsRequest,
 141                               completion: @escaping (FetchPolicyDocumentsResponse?, Error?) -> Void) {
 142         print("MockCuttlefish: fetchPolicyDocuments called")
 143         if case .fetchPolicyDocuments(let f) = next() {
 144             index += 1
 145             f(request, completion)
 146         } else {
 147             XCTFail("Unexpected: fetchPolicyDocuments")
 148             print("Unexpected: fetchPolicyDocuments")
 149             self.dump()
 150             abort()
 151         }
 152     }
 153
 154     func validatePeers(_: ValidatePeersRequest, completion: @escaping (ValidatePeersResponse?, Error?) -> Void) {
 155         completion(ValidatePeersResponse(), nil)
 156     }
 157     func reportHealth(_: ReportHealthRequest, completion: @escaping (ReportHealthResponse?, Error?) -> Void) {
 158         print("MockCuttlefish: reportHealth called")
 159         completion(ReportHealthResponse(), nil)
 160     }
 161     func pushHealthInquiry(_: PushHealthInquiryRequest, completion: @escaping (PushHealthInquiryResponse?, Error?) -> Void) {
 162         completion(PushHealthInquiryResponse(), nil)
 163     }
 164     func getRepairAction(_: GetRepairActionRequest, completion: @escaping (GetRepairActionResponse?, Error?) -> Void) {
 165         completion(GetRepairActionResponse(), nil)
 166     }
 167     func getSupportAppInfo(_: GetSupportAppInfoRequest, completion: @escaping (GetSupportAppInfoResponse?, Error?) -> Void) {
 168         completion(GetSupportAppInfoResponse(), nil)
 169     }
 170     func getClubCertificates(_: GetClubCertificatesRequest, completion: @escaping (GetClubCertificatesResponse?, Error?) -> Void) {
 171         completion(GetClubCertificatesResponse(), nil)
 172     }
 173     func fetchSosiCloudIdentity(_: FetchSOSiCloudIdentityRequest, completion: @escaping (FetchSOSiCloudIdentityResponse?, Error?) -> Void) {
 174         completion(FetchSOSiCloudIdentityResponse(), nil)
 175     }
 176 }