Remove wait calls

Author: finestructure

Tests/AppTests/AnalyzerTests.swift

@@ -631,20 +631,20 @@ class AnalyzerTests: AppTestCase {
             .mock(description: "rel 2.3.0", publishedAt: 4, tagName: "2.3.0", url: "some url"),
             .mock(description: nil, tagName: "2.4.0")
         ]).save(on: app.db)
-        let versions: [Version] = try [
+        let versions: [Version] = try await [
             (Date(timeIntervalSince1970: 0), Reference.tag(1, 2, 3)),
             (Date(timeIntervalSince1970: 1), Reference.tag(2, 0, 0)),
             (Date(timeIntervalSince1970: 2), Reference.tag(2, 1, 0)),
             (Date(timeIntervalSince1970: 3), Reference.tag(2, 2, 0)),
             (Date(timeIntervalSince1970: 4), Reference.tag(2, 3, 0)),
             (Date(timeIntervalSince1970: 5), Reference.tag(2, 4, 0)),
             (Date(timeIntervalSince1970: 6), Reference.branch("main")),
-        ].map { date, ref in
+        ].mapAsync { date, ref in
             let v = try Version(id: UUID(),
                                 package: pkg,
                                 commitDate: date,
                                 reference: ref)
-            try v.save(on: app.db).wait()
+            try await v.save(on: app.db)
             return v
         }
         let jpr = try await Package.fetchCandidate(app.db, id: .id0)
@@ -895,8 +895,8 @@ class AnalyzerTests: AppTestCase {
             return ""
         }
         let pkgs = try savePackages(on: app.db, ["1", "2"].asGithubUrls.asURLs, processingStage: .ingestion)
-        try pkgs.forEach {
-            try Repository(package: $0, defaultBranch: "main").save(on: app.db).wait()
+        for pkg in pkgs {
+            try await Repository(package: pkg, defaultBranch: "main").save(on: app.db)
         }
 
         // MUT
@@ -907,8 +907,9 @@ class AnalyzerTests: AppTestCase {
         // validation
         // 1 version for the default branch + 2 for the tags each = 6 versions
         // 2 products per version = 12 products
-        XCTAssertEqual(try Version.query(on: app.db).count().wait(), 6)
-        XCTAssertEqual(try Product.query(on: app.db).count().wait(), 12)
+        let db = app.db
+        try await XCTAssertEqualAsync(try await Version.query(on: db).count(), 6)
+        try await XCTAssertEqualAsync(try await Product.query(on: db).count(), 12)
     }
 
     @MainActor

Tests/AppTests/BuildMonitorControllerTests.swift

@@ -19,20 +19,20 @@ import XCTest
 
 class BuildMonitorControllerTests: AppTestCase {
 
-    func test_show_owner() throws {
+    func test_show_owner() async throws {
         do {
             let package = try savePackage(on: app.db, "https://github.com/daveverwer/LeftPad")
             let version = try Version(package: package)
-            try version.save(on: app.db).wait()
-            try Build(version: version,
-                      platform: .macosXcodebuild,
-                      status: .ok,
-                      swiftVersion: .init(5, 6, 0)).save(on: app.db).wait()
-            try Repository(package: package).save(on: app.db).wait()
+            try await version.save(on: app.db)
+            try await Build(version: version,
+                            platform: .macosXcodebuild,
+                            status: .ok,
+                            swiftVersion: .init(5, 6, 0)).save(on: app.db)
+            try await Repository(package: package).save(on: app.db)
         }
 
         // MUT
-        try app.test(.GET, "/build-monitor", afterResponse: { response in
+        try await app.test(.GET, "/build-monitor", afterResponse: { response async in
             XCTAssertEqual(response.status, .ok)
         })
     }

Tests/AppTests/ReAnalyzeVersionsTests.swift

@@ -149,20 +149,20 @@ class ReAnalyzeVersionsTests: AppTestCase {
         do {
             let p = Package(url: "1")
             try await p.save(on: app.db)
-            try createVersion(app.db, p, updatedAt: .t0)
-            try createVersion(app.db, p, updatedAt: .t1)
+            try await createVersion(app.db, p, updatedAt: .t0)
+            try await createVersion(app.db, p, updatedAt: .t1)
         }
         do {
             let p = Package(url: "2")
             try await p.save(on: app.db)
-            try createVersion(app.db, p, updatedAt: .t1)
-            try createVersion(app.db, p, updatedAt: .t3)
+            try await createVersion(app.db, p, updatedAt: .t1)
+            try await createVersion(app.db, p, updatedAt: .t3)
         }
         do {
             let p = Package(url: "3")
             try await p.save(on: app.db)
-            try createVersion(app.db, p, updatedAt: .t3)
-            try createVersion(app.db, p, updatedAt: .t4)
+            try await createVersion(app.db, p, updatedAt: .t3)
+            try await createVersion(app.db, p, updatedAt: .t4)
         }
 
         // MUT
@@ -211,7 +211,7 @@ class ReAnalyzeVersionsTests: AppTestCase {
         try await Analyze.analyze(client: app.client,
                                   database: app.db,
                                   mode: .limit(10))
-        try setAllVersionsUpdatedAt(app.db, updatedAt: .t0)
+        try await setAllVersionsUpdatedAt(app.db, updatedAt: .t0)
         do {
             let candidates = try await Package
                 .fetchReAnalysisCandidates(app.db, before: cutoff, limit: 10)
@@ -245,31 +245,29 @@ class ReAnalyzeVersionsTests: AppTestCase {
 
 private func createVersion(_ db: Database,
                            _ package: Package,
-                           updatedAt: Date) throws {
+                           updatedAt: Date) async throws {
     let id = UUID()
-    try Version(id: id, package: package).save(on: db).wait()
-    try setUpdatedAt(db, versionId: id, updatedAt: updatedAt)
+    try await Version(id: id, package: package).save(on: db)
+    try await setUpdatedAt(db, versionId: id, updatedAt: updatedAt)
 }
 
 
 private func setUpdatedAt(_ db: Database,
                           versionId: Version.Id,
-                          updatedAt: Date) throws {
+                          updatedAt: Date) async throws {
     let db = db as! SQLDatabase
-    try db.raw("""
+    try await db.raw("""
         update versions set updated_at = to_timestamp(\(bind: updatedAt.timeIntervalSince1970))
         where id = \(bind: versionId)
         """)
         .run()
-        .wait()
 }
 
 
-private func setAllVersionsUpdatedAt(_ db: Database, updatedAt: Date) throws {
+private func setAllVersionsUpdatedAt(_ db: Database, updatedAt: Date) async throws {
     let db = db as! SQLDatabase
-    try db.raw("""
+    try await db.raw("""
         update versions set updated_at = to_timestamp(\(bind: updatedAt.timeIntervalSince1970))
         """)
         .run()
-        .wait()
 }

Tests/AppTests/ScoreTests.swift

@@ -240,9 +240,8 @@ class ScoreTests: AppTestCase {
                           reference: .branch("default"),
                           resolvedDependencies: [],
                           swiftVersions: ["5"].asSwiftVersions).save(on: app.db)
-        try (0..<20).forEach {
-            try Version(package: pkg, reference: .tag(.init($0, 0, 0)))
-                .save(on: app.db).wait()
+        for idx in (0..<20) {
+            try await Version(package: pkg, reference: .tag(.init(idx, 0, 0))).save(on: app.db)
         }
         let jpr = try await Package.fetchCandidate(app.db, id: pkg.id!)
         // update versions
@@ -273,9 +272,8 @@ class ScoreTests: AppTestCase {
                           reference: .branch("default"),
                           resolvedDependencies: nil,
                           swiftVersions: ["5"].asSwiftVersions).save(on: app.db)
-        try (0..<20).forEach {
-            try Version(package: pkg, reference: .tag(.init($0, 0, 0)))
-                .save(on: app.db).wait()
+        for idx in (0..<20) {
+            try await Version(package: pkg, reference: .tag(.init(idx, 0, 0))).save(on: app.db)
         }
         let jpr = try await Package.fetchCandidate(app.db, id: pkg.id!)
         // update versions

Tests/AppTests/ViewUtilsTests.swift

@@ -47,12 +47,12 @@ class ViewUtilsTests: XCTestCase {
 // Test that require DB access
 class ViewUtilsDBTests: AppTestCase {
 
-    func test_makeLink() throws {
+    func test_makeLink() async throws {
         // setup
         let pkg = Package(url: "1")
-        try pkg.save(on: app.db).wait()
+        try await pkg.save(on: app.db)
         let version = try Version(package: pkg)
-        try version.save(on: app.db).wait()
+        try await version.save(on: app.db)
 
         do {  // branch reference
             version.reference = .branch("main")