Remove deprecated client-based fetchMetadata functions

Author: finestructure

Sources/App/Core/Dependencies/HTTPClient.swift

@@ -106,8 +106,9 @@ extension HTTPClient.Response {
         self.init(host: "host", status: status, version: version, headers: headers, body: body)
     }
 
-    static var ok: Self { .init(status: .ok) }
-    static var notFound: Self { .init(status: .notFound) }
     static var badRequest: Self { .init(status: .badRequest) }
+    static var notFound: Self { .init(status: .notFound) }
+    static var tooManyRequests: Self { .init(status: .tooManyRequests) }
+    static var ok: Self { .init(status: .ok) }
 }
 #endif

Sources/App/Core/Github.swift

@@ -289,17 +289,6 @@ extension Github {
         }
     }
 
-    @available(*, deprecated)
-    static func fetchMetadata(client: Client, owner: String, repository: String) async throws(Github.Error) -> Metadata {
-        struct Response<T: Decodable & Equatable>: Decodable, Equatable {
-            var data: T
-        }
-        return try await fetchResource(Response<Metadata>.self,
-                                       client: client,
-                                       query: Metadata.query(owner: owner, repository: repository))
-        .data
-    }
-
     static func fetchMetadata(owner: String, repository: String) async throws(Github.Error) -> Metadata {
         struct Response<T: Decodable & Equatable>: Decodable, Equatable {
             var data: T
@@ -309,11 +298,6 @@ extension Github {
         .data
     }
 
-    static func fetchMetadata(client: Client, packageUrl: String) async throws -> Metadata {
-        let (owner, name) = try parseOwnerName(url: packageUrl)
-        return try await fetchMetadata(client: client, owner: owner, repository: name)
-    }
-
 }
 
 

Tests/AppTests/GithubTests.swift

@@ -199,65 +199,48 @@ class GithubTests: AppTestCase {
         }
     }
 
-    func test_fetchMetadata_badUrl() async throws {
-        let pkg = Package(url: "https://foo/bar")
-        let client = MockClient { _, resp in
-            resp.status = .ok
-        }
-        do {
-            _ = try await Github.fetchMetadata(client: client, packageUrl: pkg.url)
-            XCTFail("expected error to be thrown")
-        } catch {
-            guard case Github.Error.invalidURL = error else {
-                XCTFail("unexpected error: \(error.localizedDescription)")
-                return
-            }
-        }
-    }
-
     func test_fetchMetadata_badData() async throws {
         // setup
         Current.githubToken = { "secr3t" }
-        let pkg = Package(url: "https://github.com/foo/bar")
-        let client = MockClient { _, resp in
-            resp.status = .ok
-            resp.body = makeBody("bad data")
-        }
 
-        // MUT
-        do {
-            _ = try await Github.fetchMetadata(client: client, packageUrl: pkg.url)
-            XCTFail("expected error to be thrown")
-        } catch let Github.Error.decodeContentFailed(uri, error) {
-            // validation
-            XCTAssertEqual(uri, "https://api.github.com/graphql")
-            guard case DecodingError.dataCorrupted = error else {
-                XCTFail("unexpected error: \(error.localizedDescription)")
-                return
+        await withDependencies {
+            $0.httpClient.post = { @Sendable _, _, _ in .ok(body: "bad data") }
+        } operation: {
+            // MUT
+            do {
+                _ = try await Github.fetchMetadata(owner: "foo", repository: "bar")
+                XCTFail("expected error to be thrown")
+            } catch let Github.Error.decodeContentFailed(uri, error) {
+                // validation
+                XCTAssertEqual(uri, "https://api.github.com/graphql")
+                guard case DecodingError.dataCorrupted = error else {
+                    XCTFail("unexpected error: \(error.localizedDescription)")
+                    return
+                }
+            } catch {
+                XCTFail("Unexpected error: \(error)")
             }
-        } catch {
-            XCTFail("Unexpected error: \(error)")
         }
     }
 
     func test_fetchMetadata_rateLimiting_429() async throws {
         // Github doesn't actually send a 429 when you hit the rate limit
         // setup
         Current.githubToken = { "secr3t" }
-        let pkg = Package(url: "https://github.com/foo/bar")
-        let client = MockClient { _, resp in
-            resp.status = .tooManyRequests
-        }
 
-        // MUT
-        do {
-            _ = try await Github.fetchMetadata(client: client, packageUrl: pkg.url)
-            XCTFail("expected error to be thrown")
-        } catch {
-            // validation
-            guard case Github.Error.requestFailed(.tooManyRequests) = error else {
-                XCTFail("unexpected error: \(error.localizedDescription)")
-                return
+        await withDependencies {
+            $0.httpClient.post = { @Sendable _, _, _ in .tooManyRequests }
+        } operation: {
+            // MUT
+            do {
+                _ = try await Github.fetchMetadata(owner: "foo", repository: "bar")
+                XCTFail("expected error to be thrown")
+            } catch {
+                // validation
+                guard case Github.Error.requestFailed(.tooManyRequests) = error else {
+                    XCTFail("unexpected error: \(error.localizedDescription)")
+                    return
+                }
             }
         }
     }
@@ -297,26 +280,27 @@ class GithubTests: AppTestCase {
         // Ensure we record it as a rate limit error and raise a Rollbar item
         // setup
         Current.githubToken = { "secr3t" }
-        let pkg = Package(url: "https://github.com/foo/bar")
-        let client = MockClient { _, resp in
-            resp.status = .forbidden
-            resp.headers.add(name: "X-RateLimit-Remaining", value: "0")
-        }
 
-        // MUT
-        do {
-            _ = try await Github.fetchMetadata(client: client, packageUrl: pkg.url)
-            XCTFail("expected error to be thrown")
-        } catch {
-            // validation
-            logger.logs.withValue { logs in
-                XCTAssertEqual(logs, [
-                    .init(level: .critical, message: "rate limited while fetching resource Response<Metadata>")
-                ])
+        await withDependencies {
+            $0.httpClient.post = { @Sendable _, _, _ in
+                    .init(status: .forbidden, headers: ["X-RateLimit-Remaining": "0"])
             }
-            guard case Github.Error.requestFailed(.tooManyRequests) = error else {
-                XCTFail("unexpected error: \(error.localizedDescription)")
-                return
+        } operation: {
+            // MUT
+            do {
+                _ = try await Github.fetchMetadata(owner: "foo", repository: "bar")
+                XCTFail("expected error to be thrown")
+            } catch {
+                // validation
+                logger.logs.withValue { logs in
+                    XCTAssertEqual(logs, [
+                        .init(level: .critical, message: "rate limited while fetching resource Response<Metadata>")
+                    ])
+                }
+                guard case Github.Error.requestFailed(.tooManyRequests) = error else {
+                    XCTFail("unexpected error: \(error.localizedDescription)")
+                    return
+                }
             }
         }
     }