TempTargetStorage Unit Tests

Trio/Sources/APS/Storage/TempTargetsStorage.swift

@@ -225,8 +225,27 @@ final class BaseTempTargetsStorage: TempTargetsStorage, Injectable {
         return newTempTarget.objectID
     }
 
-    @MainActor func deleteTempTargetPreset(_ objectID: NSManagedObjectID) async {
-        await CoreDataStack.shared.deleteObject(identifiedBy: objectID)
+    func deleteTempTargetPreset(_ objectID: NSManagedObjectID) async {
+        let taskContext = context != CoreDataStack.shared.newTaskContext()
+            ? context
+            : CoreDataStack.shared.newTaskContext()
+
+        await taskContext.perform {
+            do {
+                let result = try taskContext.existingObject(with: objectID) as? TempTargetStored
+                guard let tempTarget = result else {
+                    debug(.default, "\(DebuggingIdentifiers.failed) Temp Target for batch delete not found.")
+                    return
+                }
+
+                taskContext.delete(tempTarget)
+
+                guard taskContext.hasChanges else { return }
+                try taskContext.save()
+            } catch {
+                debug(.default, "\(DebuggingIdentifiers.failed) Failed to delete Temp Target: \(error)")
+            }
+        }
     }
 
     func syncDate() -> Date {

TrioTests/CoreDataTests/TempTargetStorageTests.swift

@@ -39,4 +39,110 @@ import Testing
             storage is BaseTempTargetsStorage, "Storage should be of type BaseTempTargetsStorage"
         )
     }
+
+    @Test("Store and retrieve temp target") func testStoreAndRetrieveTempTarget() async throws {
+        // Given
+        let testTarget = TempTarget(
+            name: "Test Target",
+            createdAt: Date(),
+            targetTop: 120,
+            targetBottom: 120,
+            duration: 60,
+            enteredBy: "Test",
+            reason: "Testing",
+            isPreset: false,
+            halfBasalTarget: 160
+        )
+
+        // When
+        try await storage.storeTempTarget(tempTarget: testTarget)
+
+        // Then verify stored entries
+        let storedEntries = try await CoreDataStack.shared.fetchEntitiesAsync(
+            ofType: TempTargetStored.self,
+            onContext: testContext,
+            predicate: NSPredicate(format: "name == %@", "Test Target"),
+            key: "date",
+            ascending: false
+        ) as? [TempTargetStored]
+
+        #expect(storedEntries?.isEmpty == false, "Should have stored entries")
+        #expect(storedEntries?.count == 1, "Should have exactly one entry")
+        let storedTarget = storedEntries?.first
+        #expect(storedTarget?.name == "Test Target", "Name should match")
+        #expect(storedTarget?.target == 120, "Target should match")
+        #expect(storedTarget?.duration == 60, "Duration should match")
+    }
+
+    @Test("Delete temp target Preset") func testDeleteTempTarget() async throws {
+        // Given
+        let testTarget = TempTarget(
+            name: "Delete Test",
+            createdAt: Date(),
+            targetTop: 120,
+            targetBottom: 120,
+            duration: 60,
+            enteredBy: "Test",
+            reason: "Testing deletion of a preset",
+            isPreset: true,
+            halfBasalTarget: 160
+        )
+        // Store the target
+        try await storage.storeTempTarget(tempTarget: testTarget)
+
+        // Get the stored target's ObjectID
+        let storedEntries = try await CoreDataStack.shared.fetchEntitiesAsync(
+            ofType: TempTargetStored.self,
+            onContext: testContext,
+            predicate: NSPredicate(format: "name == %@", "Delete Test"),
+            key: "date",
+            ascending: false
+        ) as? [TempTargetStored]
+
+        guard let objectID = storedEntries?.first?.objectID else {
+            throw TestError("Failed to get stored target's ObjectID")
+        }
+
+        // When
+        await storage.deleteTempTargetPreset(objectID)
+
+        // Then verify deletion
+        let remainingEntries = try await CoreDataStack.shared.fetchEntitiesAsync(
+            ofType: TempTargetStored.self,
+            onContext: testContext,
+            predicate: NSPredicate(format: "name == %@", "Delete Test"),
+            key: "date",
+            ascending: false
+        ) as? [TempTargetStored]
+
+        #expect(remainingEntries?.isEmpty == true, "Should have no entries after deletion")
+    }
+
+    @Test("Get temp targets not yet uploaded to Nightscout") func testGetTempTargetsNotYetUploadedToNightscout() async throws {
+        // Given
+        let testTarget = TempTarget(
+            name: "NS Test",
+            createdAt: Date(),
+            targetTop: 120,
+            targetBottom: 120,
+            duration: 45,
+            enteredBy: "Test",
+            reason: "Testing NS Upload",
+            isPreset: true,
+            enabled: true,
+            halfBasalTarget: 160
+        )
+
+        // When
+        try await storage.storeTempTarget(tempTarget: testTarget)
+        let notUploadedTargets = try await storage.getTempTargetsNotYetUploadedToNightscout()
+
+        // Then
+        #expect(!notUploadedTargets.isEmpty, "Should have targets not uploaded to NS")
+        let target = notUploadedTargets[0]
+        #expect(target.eventType == .nsTempTarget, "Event type should be NS temp target")
+        #expect(target.duration == 45, "Duration should match")
+        #expect(target.targetTop == 120, "Target top should match target")
+        #expect(target.targetBottom == 120, "Target bottom should match target")
+    }
 }