LoadShedderIntegrationTests: verify requests are actually handled by load shedder

Sources/Logging/Strings/NetworkStrings.swift

@@ -34,6 +34,7 @@ enum NetworkStrings {
     case blocked_network(url: URL, newHost: String?)
     case api_request_redirect(from: URL, to: URL)
     case operation_state(NetworkOperation.Type, state: String)
+    case request_handled_by_load_shedder(HTTPRequest.Path)
 
     #if DEBUG
     case api_request_forcing_server_error(HTTPRequest)
@@ -103,6 +104,9 @@ extension NetworkStrings: LogMessage {
         case let .operation_state(operation, state):
             return "\(operation): \(state)"
 
+        case let .request_handled_by_load_shedder(path):
+            return "Request was handled by load shedder: \(path.description)"
+
         #if DEBUG
         case let .api_request_forcing_server_error(request):
             return "Returning fake HTTP 500 error for '\(request.description)'"

Sources/Networking/HTTPClient/ETagManager.swift

@@ -84,6 +84,8 @@ class ETagManager {
             .compactMapValues { $0 }
     }
 
+    /// - Returns: `response` if a cached response couldn't be fetched,
+    /// or the cached `HTTPResponse`, always including the headers in `response`.
     func httpResultFromCacheOrBackend(with response: HTTPResponse<Data?>,
                                       request: URLRequest,
                                       retried: Bool) -> HTTPResponse<Data>? {
@@ -99,7 +101,8 @@ class ETagManager {
                 let newResponse = storedResponse.withUpdatedValidationTime()
 
                 self.storeIfPossible(newResponse, for: request)
-                return newResponse.asResponse(withRequestDate: response.requestDate)
+                return newResponse.asResponse(withRequestDate: response.requestDate,
+                                              headers: response.responseHeaders)
             }
             if retried {
                 Logger.warn(
@@ -148,10 +151,6 @@ private extension ETagManager {
         }
     }
 
-    func storedHTTPResponse(for request: URLRequest, withRequestDate requestDate: Date?) -> HTTPResponse<Data>? {
-        return self.storedETagAndResponse(for: request)?.asResponse(withRequestDate: requestDate)
-    }
-
     func storeStatusCodeAndResponseIfNoError(for request: URLRequest,
                                              response: HTTPResponse<Data?>,
                                              eTag: String) {
@@ -246,10 +245,13 @@ extension ETagManager.Response {
         return try? JSONEncoder.default.encode(self)
     }
 
-    fileprivate func asResponse(withRequestDate requestDate: Date?) -> HTTPResponse<Data> {
+    fileprivate func asResponse(
+        withRequestDate requestDate: Date?,
+        headers: HTTPClient.ResponseHeaders
+    ) -> HTTPResponse<Data> {
         return HTTPResponse(
             statusCode: self.statusCode,
-            responseHeaders: [:],
+            responseHeaders: headers,
             body: self.data,
             requestDate: requestDate,
             verificationResult: self.verificationResult

Sources/Networking/HTTPClient/HTTPClient.swift

@@ -112,6 +112,7 @@ extension HTTPClient {
         case signature = "X-Signature"
         case requestDate = "X-RevenueCat-Request-Time"
         case contentType = "Content-Type"
+        case isLoadShedder = "X-RevenueCat-Fortress"
 
     }
 
@@ -319,6 +320,11 @@ private extension HTTPClient {
                     // If that can't be extracted, get status code from the parsed response.
                     httpCode: urlResponse?.httpStatusCode ?? response.statusCode
                 ))
+
+                if response.isLoadShedder {
+                    Logger.debug(Strings.network.request_handled_by_load_shedder(request.httpRequest.path))
+                }
+
             case let .failure(error):
                 Logger.debug(Strings.network.api_request_failed(request.httpRequest,
                                                                 httpCode: urlResponse?.httpStatusCode,
@@ -530,6 +536,10 @@ private extension HTTPResponse {
         }
     }
 
+    var isLoadShedder: Bool {
+        return self.value(forHeaderField: HTTPClient.ResponseHeader.isLoadShedder.rawValue) == "true"
+    }
+
 }
 
 private extension HTTPResponse where Body == Data {

Tests/BackendIntegrationTests/LoadShedderIntegrationTests.swift

@@ -37,15 +37,45 @@ class LoadShedderStoreKit1IntegrationTests: BaseStoreKitIntegrationTests {
         return Signing.enforcedVerificationMode()
     }
 
+    // MARK: -
+
+    private var logger: TestLogHandler!
+
+    override func setUp() async throws {
+        self.logger = TestLogHandler(capacity: 500)
+
+        try await super.setUp()
+    }
+
+    override func tearDown() async throws {
+        self.logger = nil
+
+        try await super.tearDown()
+    }
+
     func testCanGetOfferings() async throws {
         let receivedOfferings = try await Purchases.shared.offerings()
 
         expect(receivedOfferings.all).toNot(beEmpty())
         assertSnapshot(matching: receivedOfferings.response, as: .formattedJson)
     }
 
+    func testOfferingsComeFromLoadShedder() async throws {
+        self.logger.verifyMessageWasLogged(
+            Strings.network.request_handled_by_load_shedder(
+                .getOfferings(appUserID: try Purchases.shared.appUserID.escapedOrError())
+            ),
+            level: .debug
+        )
+    }
+
     func testCanPurchasePackage() async throws {
         try await self.purchaseMonthlyOffering()
+
+        self.logger.verifyMessageWasLogged(
+            Strings.network.request_handled_by_load_shedder(.postReceiptData),
+            level: .debug
+        )
     }
 
     @available(iOS 15.0, tvOS 15.0, watchOS 8.0, macOS 12.0, *)
@@ -57,4 +87,16 @@ class LoadShedderStoreKit1IntegrationTests: BaseStoreKitIntegrationTests {
         expect(result.entitlementsByProduct["com.revenuecat.loadShedder.monthly"]) == ["premium"]
     }
 
+    @available(iOS 15.0, tvOS 15.0, watchOS 8.0, macOS 12.0, *)
+    func testProductEntitlementMappingComesFromLoadShedder() async throws {
+        try AvailabilityChecks.iOS15APIAvailableOrSkipTest()
+
+        try await self.logger.verifyMessageIsEventuallyLogged(
+            Strings.network.request_handled_by_load_shedder(.getProductEntitlementMapping).description,
+            level: .debug,
+            timeout: .seconds(5),
+            pollInterval: .milliseconds(100)
+        )
+    }
+
 }

Tests/BackendIntegrationTests/OtherIntegrationTests.swift

@@ -32,6 +32,14 @@ class OtherIntegrationTests: BaseBackendIntegrationTests {
         try await Purchases.shared.healthRequest(signatureVerification: true)
     }
 
+    func testHandledByProductionServer() async throws {
+        let logger = TestLogHandler()
+
+        try await Purchases.shared.healthRequest(signatureVerification: false)
+
+        logger.verifyMessageWasNotLogged(Strings.network.request_handled_by_load_shedder(.health))
+    }
+
     @available(iOS 15.0, tvOS 15.0, watchOS 8.0, macOS 12.0, *)
     func testProductEntitlementMapping() async throws {
         try AvailabilityChecks.iOS15APIAvailableOrSkipTest()

Tests/UnitTests/Networking/ETagManagerTests.swift

@@ -45,17 +45,22 @@ class ETagManagerTests: TestCase {
         let request = URLRequest(url: Self.testURL)
         let cachedResponse = self.mockStoredETagResponse(for: Self.testURL, statusCode: .success, eTag: eTag)
 
-        let response = self.eTagManager.httpResultFromCacheOrBackend(
-            with: self.responseForTest(url: Self.testURL,
-                                       body: nil,
-                                       eTag: eTag,
-                                       statusCode: .notModified),
-            request: request,
-            retried: false
+        let response = try XCTUnwrap(
+            self.eTagManager.httpResultFromCacheOrBackend(
+                with: self.responseForTest(url: Self.testURL,
+                                           body: nil,
+                                           eTag: eTag,
+                                           statusCode: .notModified),
+                request: request,
+                retried: false
+            )
         )
-        expect(response).toNot(beNil())
-        expect(response?.statusCode) == .success
-        expect(response?.body) == cachedResponse
+
+        expect(response.statusCode) == .success
+        expect(response.body) == cachedResponse
+        expect(response.responseHeaders).toNot(beEmpty())
+        expect(Set(response.responseHeaders.keys.compactMap { $0 as? String }))
+        == Set(self.getHeaders(eTag: eTag).keys)
     }
 
     func testValidationTimeIsUpdatedWhenUsingStoredResponse() throws {

Tests/UnitTests/Networking/HTTPClientTests.swift

@@ -1069,11 +1069,16 @@ final class HTTPClientTests: BaseHTTPClientTests {
         let eTag = "tag"
         let requestDate = Date().addingTimeInterval(-1000000)
 
+        let headers: [String: String] = [
+            HTTPClient.ResponseHeader.contentType.rawValue: "application/json",
+            HTTPClient.ResponseHeader.signature.rawValue: UUID().uuidString
+        ]
+
         self.eTagManager.stubResponseEtag(eTag)
         self.eTagManager.shouldReturnResultFromBackend = false
         self.eTagManager.stubbedHTTPResultFromCacheOrBackendResult = .init(
             statusCode: .success,
-            responseHeaders: [:],
+            responseHeaders: headers,
             body: mockedCachedResponse,
             requestDate: requestDate,
             verificationResult: .notRequested
@@ -1084,7 +1089,7 @@ final class HTTPClientTests: BaseHTTPClientTests {
 
             return .init(data: Data(),
                          statusCode: .notModified,
-                         headers: nil)
+                         headers: headers)
         }
 
         let response: HTTPResponse<Data>.Result? = waitUntilValue { completion in
@@ -1098,6 +1103,7 @@ final class HTTPClientTests: BaseHTTPClientTests {
         expect(response?.value?.body) == mockedCachedResponse
         expect(response?.value?.requestDate) == requestDate
         expect(response?.value?.verificationResult) == .notRequested
+        expect(response?.value?.responseHeaders).to(haveCount(headers.count))
 
         expect(self.eTagManager.invokedETagHeaderParametersList).to(haveCount(1))
         expect(self.eTagManager.invokedETagHeaderParameters?.withSignatureVerification) == false
@@ -1415,6 +1421,53 @@ final class HTTPClientTests: BaseHTTPClientTests {
         )
     }
 
+    func testNormalResponsesAreNotDetectedAsLoadSheddder() throws {
+        let path: HTTPRequest.Path = .logIn
+
+        stub(condition: isPath(path)) { _ in
+            return HTTPStubsResponse(
+                data: .init(),
+                statusCode: .success,
+                headers: [:]
+            )
+        }
+
+        let logger = TestLogHandler()
+
+        let response: HTTPResponse<Data>.Result? = waitUntilValue { completion in
+            self.client.perform(.init(method: .get, path: path), completionHandler: completion)
+        }
+        expect(response).to(beSuccess())
+
+        logger.verifyMessageWasNotLogged(Strings.network.request_handled_by_load_shedder(path))
+    }
+
+    func testLoadShedderResponsesAreLogged() throws {
+        let path: HTTPRequest.Path = .logIn
+
+        stub(condition: isPath(path)) { _ in
+            return HTTPStubsResponse(
+                data: .init(),
+                statusCode: .success,
+                headers: [
+                    HTTPClient.ResponseHeader.isLoadShedder.rawValue: "true"
+                ]
+            )
+        }
+
+        let logger = TestLogHandler()
+
+        let response: HTTPResponse<Data>.Result? = waitUntilValue { completion in
+            self.client.perform(.init(method: .get, path: path), completionHandler: completion)
+        }
+        expect(response).to(beSuccess())
+
+        logger.verifyMessageWasLogged(
+            Strings.network.request_handled_by_load_shedder(path),
+            level: .debug
+        )
+    }
+
 }
 
 func isPath(_ path: HTTPRequest.Path) -> HTTPStubsTestBlock {