Update tests to use non-promise reading + writing

Author: designatednerd

Tests/ApolloCacheDependentTests/ReadWriteFromStoreTests.swift

@@ -9,19 +9,22 @@ class ReadWriteFromStoreTests: XCTestCase {
       "QUERY_ROOT": ["hero": Reference(key: "hero")],
       "hero": ["__typename": "Droid", "name": "R2-D2"]
     ]
-
-    try withCache(initialRecords: initialRecords) { (cache) in
+    let expectation = self.expectation(description: "transaction'd")
+    withCache(initialRecords: initialRecords) { (cache) in
       let store = ApolloStore(cache: cache)
 
       let query = HeroNameQuery()
-
-      try await(store.withinReadTransaction { transaction in
+      
+      store.withinReadTransaction({transaction in
         let data = try transaction.read(query: query)
 
         XCTAssertEqual(data.hero?.__typename, "Droid")
         XCTAssertEqual(data.hero?.name, "R2-D2")
+        expectation.fulfill()
       })
     }
+    
+    self.waitForExpectations(timeout: 1, handler: nil)
   }
 
   func testReadHeroNameQueryWithVariable() throws {
@@ -30,18 +33,22 @@ class ReadWriteFromStoreTests: XCTestCase {
       "hero(episode:JEDI)": ["__typename": "Droid", "name": "R2-D2"]
     ]
 
-    try withCache(initialRecords: initialRecords) { (cache) in
+    let expectation = self.expectation(description: "transaction'd")
+    withCache(initialRecords: initialRecords) { (cache) in
       let store = ApolloStore(cache: cache)
 
       let query = HeroNameQuery(episode: .jedi)
-      
-      try await(store.withinReadTransaction { transaction in
+     
+      store.withinReadTransaction({ transaction in
         let data = try transaction.read(query: query)
 
         XCTAssertEqual(data.hero?.__typename, "Droid")
         XCTAssertEqual(data.hero?.name, "R2-D2")
+        expectation.fulfill()
       })
     }
+    
+    self.waitForExpectations(timeout: 1, handler: nil)
   }
 
   func testReadHeroNameQueryWithMissingName() throws {
@@ -50,21 +57,25 @@ class ReadWriteFromStoreTests: XCTestCase {
       "hero": ["__typename": "Droid"]
     ]
 
-    try withCache(initialRecords: initialRecords) { (cache) in
+    let expectation = self.expectation(description: "transaction'd")
+    withCache(initialRecords: initialRecords) { (cache) in
       let store = ApolloStore(cache: cache)
 
       let query = HeroNameQuery()
 
-      try await(store.withinReadTransaction { transaction in
+      store.withinReadTransaction({ transaction in
         XCTAssertThrowsError(try transaction.read(query: query)) { error in
           if case let error as GraphQLResultError = error {
             XCTAssertEqual(error.path, ["hero", "name"])
             XCTAssertMatch(error.underlying, JSONDecodingError.missingValue)
           } else {
             XCTFail("Unexpected error: \(error)")
           }
+          expectation.fulfill()
         }
       })
+      
+      self.waitForExpectations(timeout: 1, handler: nil)
     }
   }
 
@@ -78,12 +89,16 @@ class ReadWriteFromStoreTests: XCTestCase {
       let store = ApolloStore(cache: cache)
 
       let query = HeroNameQuery()
+      let expectation = self.expectation(description: "transaction'd")
 
-      try await(store.withinReadWriteTransaction { transaction in
+      store.withinReadWriteTransaction({ transaction in
         try transaction.update(query: query) { (data: inout HeroNameQuery.Data) in
           data.hero?.name = "Artoo"
+          expectation.fulfill()
         }
       })
+      
+      self.waitForExpectations(timeout: 1, handler: nil)
 
       let result = try await(store.load(query: query))
 
@@ -93,28 +108,38 @@ class ReadWriteFromStoreTests: XCTestCase {
   }
 
   func testWriteHeroNameQueryWhenWriteErrorIsThrown() throws {
+    let expectation = self.expectation(description: "transaction'd")
     do {
-      try withCache(initialRecords: nil) { (cache) in
+      withCache(initialRecords: nil) { (cache) in
         let store = ApolloStore(cache: cache)
 
-        try store.withinReadWriteTransaction { transaction in
+        store.withinReadWriteTransaction({ transaction in
           let data = HeroNameQuery.Data(unsafeResultMap: [:])
           try transaction.write(data: data, forQuery: HeroNameQuery(episode: nil))
-          }.await()
-        XCTFail("write should fail")
-      }
-    } catch {
-      guard let error = error as? GraphQLResultError,
-        let jsonError = error.underlying as? JSONDecodingError else {
-          XCTFail("unexpected error")
-          return
-      }
-
-      switch jsonError {
-      case .missingValue: break
-      default: XCTFail("unexpected error")
+        }, completion: { result in
+          defer {
+            expectation.fulfill()
+          }
+          switch result {
+          case .success:
+            XCTFail("write should fail")
+          case .failure(let error):
+            guard let error = error as? GraphQLResultError,
+              let jsonError = error.underlying as? JSONDecodingError else {
+                XCTFail("unexpected error")
+                return
+            }
+            
+            switch jsonError {
+            case .missingValue: break
+            default: XCTFail("unexpected error")
+            }
+          }
+        })
       }
     }
+    
+    self.waitForExpectations(timeout: 1, handler: nil)
   }
 
   func testReadHeroAndFriendsNamesQuery() throws {
@@ -134,18 +159,22 @@ class ReadWriteFromStoreTests: XCTestCase {
       "1003": ["__typename": "Human", "name": "Leia Organa"],
     ]
 
-    try withCache(initialRecords: initialRecords) { (cache) in
+    withCache(initialRecords: initialRecords) { (cache) in
       let store = ApolloStore(cache: cache)
 
       let query = HeroAndFriendsNamesQuery()
 
-      try await(store.withinReadTransaction { transaction in
+      let expectation = self.expectation(description: "transaction'd")
+      store.withinReadTransaction({ transaction in
         let data = try transaction.read(query: query)
 
         XCTAssertEqual(data.hero?.name, "R2-D2")
         let friendsNames = data.hero?.friends?.compactMap { $0?.name }
         XCTAssertEqual(friendsNames, ["Luke Skywalker", "Han Solo", "Leia Organa"])
+        expectation.fulfill()
       })
+      
+      self.waitForExpectations(timeout: 1, handler: nil)
     }
   }
 
@@ -171,11 +200,14 @@ class ReadWriteFromStoreTests: XCTestCase {
 
       let query = HeroAndFriendsNamesQuery()
 
-      try await(store.withinReadWriteTransaction { transaction in
+      let expectation = self.expectation(description: "transaction'd")
+      store.withinReadWriteTransaction({ transaction in
         try transaction.update(query: query) { (data: inout HeroAndFriendsNamesQuery.Data) in
           data.hero?.friends?.append(.makeDroid(name: "C-3PO"))
+          expectation.fulfill()
         }
       })
+      self.waitForExpectations(timeout: 1, handler: nil)
 
       let result = try await(store.load(query: query))
       guard let data = result.data else { XCTFail(); return }
@@ -208,11 +240,14 @@ class ReadWriteFromStoreTests: XCTestCase {
 
       let query = HeroAndFriendsNamesQuery(episode: Episode.newhope)
 
-      try await(store.withinReadWriteTransaction { transaction in
+      let expectation = self.expectation(description: "transaction'd")
+      store.withinReadWriteTransaction({ transaction in
         try transaction.update(query: query) { (data: inout HeroAndFriendsNamesQuery.Data) in
           data.hero?.friends?.append(.makeDroid(name: "C-3PO"))
+          expectation.fulfill()
         }
       })
+      self.waitForExpectations(timeout: 1, handler: nil)
 
       let result = try await(store.load(query: query))
       guard let data = result.data else { XCTFail(); return }
@@ -228,15 +263,19 @@ class ReadWriteFromStoreTests: XCTestCase {
       "2001": ["name": "R2-D2", "__typename": "Droid", "primaryFunction": "Protocol"]
     ]
 
-    try withCache(initialRecords: initialRecords) { (cache) in
+    withCache(initialRecords: initialRecords) { (cache) in
       let store = ApolloStore(cache: cache)
 
-      try await(store.withinReadTransaction { transaction in
+      let expectation = self.expectation(description: "transaction'd")
+      store.withinReadTransaction({ transaction in
         let r2d2 = try transaction.readObject(ofType: HeroDetails.self, withKey: "2001")
 
         XCTAssertEqual(r2d2.name, "R2-D2")
         XCTAssertEqual(r2d2.asDroid?.primaryFunction, "Protocol")
+        expectation.fulfill()
       })
+      
+      self.waitForExpectations(timeout: 1, handler: nil)
     }
   }
 
@@ -245,19 +284,23 @@ class ReadWriteFromStoreTests: XCTestCase {
       "2001": ["name": "R2-D2", "__typename": "Droid"]
     ]
 
-    try withCache(initialRecords: initialRecords) { (cache) in
+    withCache(initialRecords: initialRecords) { (cache) in
       let store = ApolloStore(cache: cache)
 
-      try await(store.withinReadTransaction { transaction in
+      let expectation = self.expectation(description: "transaction'd")
+      store.withinReadTransaction({ transaction in
         XCTAssertThrowsError(try transaction.readObject(ofType: HeroDetails.self, withKey: "2001")) { error in
           if case let error as GraphQLResultError = error {
             XCTAssertEqual(error.path, ["primaryFunction"])
             XCTAssertMatch(error.underlying, JSONDecodingError.missingValue)
           } else {
             XCTFail("Unexpected error: \(error)")
           }
+          
+          expectation.fulfill()
         }
       })
+      self.waitForExpectations(timeout: 1, handler: nil)
     }
   }
 
@@ -278,15 +321,19 @@ class ReadWriteFromStoreTests: XCTestCase {
       "1003": ["__typename": "Human", "name": "Leia Organa"],
       ]
 
-    try withCache(initialRecords: initialRecords) { (cache) in
+    withCache(initialRecords: initialRecords) { (cache) in
       let store = ApolloStore(cache: cache)
 
-      try await(store.withinReadTransaction { transaction in
+      let expectation = self.expectation(description: "transaction'd")
+      store.withinReadTransaction({ transaction in
         let friendsNamesFragment = try transaction.readObject(ofType: FriendsNames.self, withKey: "2001")
 
         let friendsNames = friendsNamesFragment.friends?.compactMap { $0?.name }
         XCTAssertEqual(friendsNames, ["Luke Skywalker", "Han Solo", "Leia Organa"])
+        expectation.fulfill()
       })
+      
+      self.waitForExpectations(timeout: 1, handler: nil)
     }
   }
 
@@ -310,11 +357,14 @@ class ReadWriteFromStoreTests: XCTestCase {
     try withCache(initialRecords: initialRecords) { (cache) in
       let store = ApolloStore(cache: cache)
 
-      try await(store.withinReadWriteTransaction { transaction in
+      let expectation = self.expectation(description: "transaction'd")
+      store.withinReadWriteTransaction({ transaction in
         try transaction.updateObject(ofType: FriendsNames.self, withKey: "2001") { (friendsNames: inout FriendsNames) in
           friendsNames.friends?.append(.makeDroid(name: "C-3PO"))
+          expectation.fulfill()
         }
       })
+      self.waitForExpectations(timeout: 1, handler: nil)
 
       let result = try await(store.load(query: HeroAndFriendsNamesQuery()))
       guard let data = result.data else { XCTFail(); return }

Tests/ApolloCacheDependentTests/WatchQueryTests.swift

@@ -312,7 +312,7 @@ class WatchQueryTests: XCTestCase {
             "QUERY_ROOT.hero.friends.1": ["__typename": "Human", "name": "Han Solo"],
             "QUERY_ROOT.hero.friends.2": ["__typename": "Human", "name": "Leia Organa"],
             ]
-    try withCache(initialRecords: initialRecords) { (cache) in
+    withCache(initialRecords: initialRecords) { (cache) in
       let networkTransport = MockNetworkTransport(body: [:])
 
       let store = ApolloStore(cache: cache)
@@ -353,11 +353,14 @@ class WatchQueryTests: XCTestCase {
       waitForExpectations(timeout: 5, handler: nil)
 
       let nameQuery = HeroNameQuery()
-      try await(store.withinReadWriteTransaction { transaction in
+      expectation = self.expectation(description: "transaction'd")
+      store.withinReadWriteTransaction({ transaction in
         try transaction.update(query: nameQuery) { (data: inout HeroNameQuery.Data) in
           data.hero?.name = "Artoo"
         }
+        expectation.fulfill()
       })
+      self.waitForExpectations(timeout: 1, handler: nil)
 
       verifyResult = { result in
         switch result {