Fix PlausibleTests

Author: finestructure

Sources/App/Core/Dependencies/HTTPClient.swift

@@ -20,9 +20,10 @@ import Vapor
 
 @DependencyClient
 struct HTTPClient {
+    typealias Request = Vapor.HTTPClient.Request
     typealias Response = Vapor.HTTPClient.Response
 
-    var client: @Sendable () -> Vapor.HTTPClient = { XCTFail("client"); return .shared }
+    var post: @Sendable (_ url: String, _ headers: HTTPHeaders, _ body: Data) async throws -> Response
     var fetchDocumentation: @Sendable (_ url: URI) async throws -> Response
     var fetchHTTPStatusCode: @Sendable (_ url: String) async throws -> HTTPStatus
     var postPlausibleEvent: @Sendable (_ kind: Plausible.Event.Kind, _ path: Plausible.Path, _ user: User?) async throws -> Void
@@ -31,7 +32,10 @@ struct HTTPClient {
 extension HTTPClient: DependencyKey {
     static var liveValue: HTTPClient {
         .init(
-            client: { .shared },
+            post: { url, headers, body in
+                let req = try Request(url: url, method: .POST, headers: headers, body: .data(body))
+                return try await Vapor.HTTPClient.shared.execute(request: req).get()
+            },
             fetchDocumentation: { url in
                 try await Vapor.HTTPClient.shared.get(url: url.string).get()
             },

Sources/App/Core/Plausible.swift

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 import Vapor
+import Dependencies
 
 
 enum Plausible {
@@ -46,19 +47,15 @@ enum Plausible {
     static let postEventURL = "https://plausible.io/api/event"
 
     static func postEvent(kind: Event.Kind, path: Path, user: User?) async throws {
-#warning("FIXME: need to inject a http client here to so we can test this in PlausibleTests")
         guard let siteID = Current.plausibleBackendReportingSiteID() else {
             throw Error(message: "PLAUSIBLE_BACKEND_REPORTING_SITE_ID not set")
         }
-        let data = try JSONEncoder().encode(Event(name: .pageview,
+        let body = try JSONEncoder().encode(Event(name: .pageview,
                                                   url: "https://\(siteID)\(path.rawValue)",
                                                   domain: siteID,
                                                   props: user.props))
-        let req = try Vapor.HTTPClient.Request(url: postEventURL,
-                                               method: .POST,
-                                               headers: .applicationJSON,
-                                               body: .data(data))
-        let res = try await Vapor.HTTPClient.shared.execute(request: req).get()
+        @Dependency(\.httpClient) var httpClient
+        let res = try await httpClient.post(url: postEventURL, headers: .applicationJSON, body: body)
         guard res.status.succeeded else {
             throw Error(message: "Request failed with status code: \(res.status)")
         }

Tests/AppTests/PlausibleTests.swift

@@ -16,6 +16,8 @@ import XCTest
 
 @testable import App
 
+import Dependencies
+
 
 final class PlausibleTests: XCTestCase {
 
@@ -29,43 +31,49 @@ final class PlausibleTests: XCTestCase {
     }
 
     func test_postEvent_anonymous() async throws {
-        Current.plausibleBackendReportingSiteID = { "foo.bar" }
-
-        var called = false
-        let client = MockClient { req, _ in
-            called = true
-            // validate
-            XCTAssertEqual(try? req.content.decode(Plausible.Event.self),
-                           .init(name: .pageview,
-                                 url: "https://foo.bar/api/search",
-                                 domain: "foo.bar",
-                                 props: ["user": "none"]))
-        }
+        let called = ActorIsolated(false)
+        try await withDependencies {
+            $0.httpClient.post = { @Sendable _, _, body in
+                await called.withValue { $0 = true }
+                // validate
+                XCTAssertEqual(try? JSONDecoder().decode(Plausible.Event.self, from: body),
+                               .init(name: .pageview,
+                                     url: "https://foo.bar/api/search",
+                                     domain: "foo.bar",
+                                     props: ["user": "none"]))
+                return .ok
+            }
+        } operation: {
+            Current.plausibleBackendReportingSiteID = { "foo.bar" }
 
-        // MUT
-        _ = try await Plausible.postEvent(kind: .pageview, path: .search, user: nil)
+            // MUT
+            _ = try await Plausible.postEvent(kind: .pageview, path: .search, user: nil)
 
-        XCTAssertTrue(called)
+            await called.withValue { XCTAssertTrue($0) }
+        }
     }
 
     func test_postEvent_package() async throws {
-        Current.plausibleBackendReportingSiteID = { "foo.bar" }
+        let called = ActorIsolated(false)
+        try await withDependencies {
+            $0.httpClient.post = { @Sendable _, _, body in
+                await called.withValue { $0 = true }
+                // validate
+                XCTAssertEqual(try? JSONDecoder().decode(Plausible.Event.self, from: body),
+                               .init(name: .pageview,
+                                     url: "https://foo.bar/api/packages/{owner}/{repository}",
+                                     domain: "foo.bar",
+                                     props: ["user": "3c469e9d"]))
+                return .ok
+            }
+        } operation: {
+            Current.plausibleBackendReportingSiteID = { "foo.bar" }
+            let user = User(name: "api", identifier: "3c469e9d")
 
-        let user = User(name: "api", identifier: "3c469e9d")
-        var called = false
-        let client = MockClient { req, _ in
-            called = true
-            // validate
-            XCTAssertEqual(try? req.content.decode(Plausible.Event.self),
-                           .init(name: .pageview,
-                                 url: "https://foo.bar/api/packages/{owner}/{repository}",
-                                 domain: "foo.bar",
-                                 props: ["user": user.identifier]))
-        }
-
-        // MUT
-        _ = try await Plausible.postEvent(kind: .pageview, path: .package, user: user)
+            // MUT
+            _ = try await Plausible.postEvent(kind: .pageview, path: .package, user: user)
 
-        XCTAssertTrue(called)
+            await called.withValue { XCTAssertTrue($0) }
+        }
     }
 }