feat: handle status codes for retrying in uploader

Sources/Confidence/ConfidenceClient/RemoteConfidenceClient.swift

@@ -38,21 +38,27 @@
             sendTime: timeString,
             sdk: Sdk(id: metadata.name, version: metadata.version)
         )
-
         do {
             let result: HttpClientResult<PublishEventResponse> =
             try await self.httpClient.post(path: ":publish", data: request)
             switch result {
             case .success(let successData):
-                guard successData.response.status == .ok else {
+                guard let status = successData.response.status else {
                     throw successData.response.mapStatusToError(error: successData.decodedError)
                 }
-                let indexedErrorsCount = successData.decodedData?.errors.count ?? 0
-                if indexedErrorsCount > 0 {
-                    Logger(subsystem: "com.confidence.client", category: "network").error(
-                        "Backend reported errors for \(indexedErrorsCount) event(s) in batch")
+                switch status.rawValue {
+                case 200:
+                    //clean up in case of success
+                    return true
+                case 429:
+                    //we shouldn't clean up for rate limiting
+                    return false
+                case 400...499:
+                    //if batch couldn't be processed, we should clean it up
+                    return true
+                default:
+                    return false
                 }
-                return true
             case .failure(let errorData):
                 throw handleError(error: errorData)
             }

Tests/ConfidenceProviderTests/EventSenderEngineTest.swift → Tests/ConfidenceTests/EventSenderEngineTest.swift

@@ -55,4 +55,30 @@ final class EventSenderEngineTest: XCTestCase {
         XCTAssertNil(uploader.calledRequest)
         cancellable.cancel()
     }
+
+    func testRemoveEventsFromStorageOnBadRequest() async throws {
+        MockedClientURLProtocol.mockedOperation = .badRequest
+        let client = RemoteConfidenceClient(
+            options: ConfidenceClientOptions(credentials: ConfidenceClientCredentials.clientSecret(secret: "")),
+            session: MockedClientURLProtocol.mockedSession(),
+            metadata: ConfidenceMetadata(name: "", version: ""))
+
+        let flushPolicies = [MinSizeFlushPolicy()]
+        let storage = EventStorageMock()
+        let eventSenderEngine = EventSenderEngineImpl(
+            clientSecret: "CLIENT_SECRET",
+            uploader: client,
+            storage: storage,
+            flushPolicies: flushPolicies
+        )
+        _ = try await client.upload(events: [
+            NetworkEvent(
+                eventDefinition: "testEvent",
+                payload: NetworkStruct.init(fields: [:]),
+                eventTime: Date.backport.nowISOString
+            )
+        ])
+
+        XCTAssertEqual(try storage.isEmpty(), true)
+    }
 }

Tests/ConfidenceProviderTests/EventUploaderMock.swift → Tests/ConfidenceTests/EventUploaderMock.swift

@@ -43,4 +43,12 @@
     func remove(id: String) throws {
         batches.removeValue(forKey: id)
     }
+
+    internal func isEmpty() throws -> Bool {
+        if self.events.count == 0 {
+            return true
+        } else {
+            return false
+        }
+    }
 }

Tests/ConfidenceTests/RemoteConfidenceClientTests.swift

@@ -56,31 +56,6 @@ class RemoteConfidenceClientTest: XCTestCase {
         XCTAssertTrue(processed)
     }
 
-    func testBadRequestThrows() async throws {
-        MockedClientURLProtocol.mockedOperation = .badRequest
-        let client = RemoteConfidenceClient(
-            options: ConfidenceClientOptions(
-                credentials: ConfidenceClientCredentials.clientSecret(secret: "")),
-            session: MockedClientURLProtocol.mockedSession(),
-            metadata: ConfidenceMetadata(name: "", version: ""))
-
-        var caughtError: ConfidenceError?
-        do {
-            _ = try await client.upload(events: [
-                NetworkEvent(
-                    eventDefinition: "testEvent",
-                    payload: NetworkStruct.init(fields: [:]),
-                    eventTime: Date.backport.nowISOString
-                )
-            ])
-        } catch {
-            // swiftlint:disable:next force_cast 
-            caughtError = error as! ConfidenceError?
-        }
-        let expectedError = ConfidenceError.badRequest(message: "explanation about malformed request")
-        XCTAssertEqual(caughtError, expectedError)
-    }
-
     func testNMalformedResponseThrows() async throws {
         MockedClientURLProtocol.mockedOperation = .malformedResponse
         let client = RemoteConfidenceClient(