Update tests

Author: finestructure

Tests/AppTests/AnalyzerTests.swift

@@ -317,14 +317,14 @@ class AnalyzerTests: AppTestCase {
             $0.git.hasBranch = { @Sendable _, _ in false }  // simulate analysis error via branch mismatch
             $0.git.lastCommitDate = { @Sendable _ in .t1 }
             $0.git.shortlog = { @Sendable _ in "" }
+            $0.shell.run = { @Sendable _, _ in "" }
         } operation: {
             // setup
             do {
                 let pkg = try await savePackage(on: app.db, "https://github.com/foo/1", processingStage: .ingestion)
                 try await Repository(package: pkg, defaultBranch: "main").save(on: app.db)
             }
 
-
             // Ensure candidate selection is as expected
             let app = self.app!
             try await XCTAssertEqualAsync(try await Package.fetchCandidates(app.db, for: .ingestion, limit: 10).count, 0)

Tests/AppTests/GitLiveTests.swift

@@ -16,6 +16,7 @@ import XCTest
 
 @testable import App
 
+import Dependencies
 import ShellOut
 
 
@@ -47,6 +48,14 @@ class GitLiveTests: XCTestCase {
     override func setUp() {
         Current.setLogger(.init(label: "test", factory: { _ in logger }))
     }
+
+    override func invokeTest() {
+        withDependencies {
+            $0.shell = .liveValue
+        } operation: {
+            super.invokeTest()
+        }
+    }
 }
 
 

Tests/AppTests/ReAnalyzeVersionsTests.swift

@@ -88,6 +88,7 @@ class ReAnalyzeVersionsTests: AppTestCase {
                     XCTAssertEqual(versions.map { $0.targets.map(\.name) } , [[], []])
                     XCTAssertEqual(versions.map(\.releaseNotes) , [nil, nil])
                 }
+                
                 try await withDependencies {
                     // Update state that would normally not be affecting existing versions, effectively simulating the situation where we only started parsing it after versions had already been created
                     $0.shell.run = { @Sendable cmd, path in
@@ -105,42 +106,42 @@ class ReAnalyzeVersionsTests: AppTestCase {
                         }
                         return ""
                     }
-                } operation: {
                     // also, update release notes to ensure mergeReleaseInfo is being called
                     let r = try await Repository.find(repoId, on: app.db).unwrap()
                     r.releases = [
                         .mock(description: "rel 1.2.3", tagName: "1.2.3")
                     ]
                     try await r.save(on: app.db)
-                }
-                do {  // assert running analysis again does not update existing versions
-                    try await Analyze.analyze(client: app.client,
-                                              database: app.db,
-                                              mode: .limit(10))
+                } operation: {
+                    do {  // assert running analysis again does not update existing versions
+                        try await Analyze.analyze(client: app.client,
+                                                  database: app.db,
+                                                  mode: .limit(10))
+                        let versions = try await Version.query(on: app.db)
+                            .with(\.$targets)
+                            .all()
+                        XCTAssertEqual(versions.map(\.toolsVersion), [nil, nil])
+                        XCTAssertEqual(versions.map { $0.targets.map(\.name) } , [[], []])
+                        XCTAssertEqual(versions.map(\.releaseNotes) , [nil, nil])
+                        XCTAssertEqual(versions.map(\.docArchives), [nil, nil])
+                    }
+
+                    // MUT
+                    try await ReAnalyzeVersions.reAnalyzeVersions(client: app.client,
+                                                                  database: app.db,
+                                                                  before: Date.now,
+                                                                  refreshCheckouts: false,
+                                                                  limit: 10)
+
+                    // validate that re-analysis has now updated existing versions
                     let versions = try await Version.query(on: app.db)
                         .with(\.$targets)
+                        .sort(\.$createdAt)
                         .all()
-                    XCTAssertEqual(versions.map(\.toolsVersion), [nil, nil])
-                    XCTAssertEqual(versions.map { $0.targets.map(\.name) } , [[], []])
-                    XCTAssertEqual(versions.map(\.releaseNotes) , [nil, nil])
-                    XCTAssertEqual(versions.map(\.docArchives), [nil, nil])
+                    XCTAssertEqual(versions.map(\.toolsVersion), ["5.3", "5.3"])
+                    XCTAssertEqual(versions.map { $0.targets.map(\.name) } , [["t1"], ["t1"]])
+                    XCTAssertEqual(versions.compactMap(\.releaseNotes) , ["rel 1.2.3"])
                 }
-
-                // MUT
-                try await ReAnalyzeVersions.reAnalyzeVersions(client: app.client,
-                                                              database: app.db,
-                                                              before: Date.now,
-                                                              refreshCheckouts: false,
-                                                              limit: 10)
-
-                // validate that re-analysis has now updated existing versions
-                let versions = try await Version.query(on: app.db)
-                    .with(\.$targets)
-                    .sort(\.$createdAt)
-                    .all()
-                XCTAssertEqual(versions.map(\.toolsVersion), ["5.3", "5.3"])
-                XCTAssertEqual(versions.map { $0.targets.map(\.name) } , [["t1"], ["t1"]])
-                XCTAssertEqual(versions.compactMap(\.releaseNotes) , ["rel 1.2.3"])
             }
         }
     }