OverrideStorage Unit Tests

Trio/Sources/APS/Storage/OverrideStorage.swift

@@ -201,10 +201,36 @@ final class BaseOverrideStorage: @preconcurrency OverrideStorage, Injectable {
         return newOverride.objectID
     }
 
-    /// marked as MainActor to be able to publish changes from the background
     /// - Parameter: NSManagedObjectID to be able to transfer the object safely from one thread to another thread
-    @MainActor func deleteOverridePreset(_ objectID: NSManagedObjectID) async {
-        await CoreDataStack.shared.deleteObject(identifiedBy: objectID)
+    func deleteOverridePreset(_ objectID: NSManagedObjectID) async {
+        // Use injected context if available, otherwise create new task context
+        let taskContext = context != CoreDataStack.shared.newTaskContext()
+            ? context
+            : CoreDataStack.shared.newTaskContext()
+
+        taskContext.name = "deleteContext"
+        taskContext.transactionAuthor = "deleteOverride"
+
+        await taskContext.perform {
+            do {
+                let result = try taskContext.existingObject(with: objectID) as? OverrideStored
+                guard let override = result else {
+                    debugPrint("Override for batch delete not found. \(DebuggingIdentifiers.failed)")
+                    return
+                }
+
+                taskContext.delete(override)
+
+                guard taskContext.hasChanges else { return }
+                try taskContext.save()
+
+                debugPrint(
+                    "OverrideStorage: \(#function) \(DebuggingIdentifiers.succeeded) deleted override from core data"
+                )
+            } catch {
+                debugPrint("\(DebuggingIdentifiers.failed) Error deleting override: \(error.localizedDescription)")
+            }
+        }
     }
 
     func getOverridesNotYetUploadedToNightscout() async throws -> [NightscoutExercise] {

TrioTests/CoreDataTests/OverrideStorageTests.swift

@@ -38,4 +38,187 @@ import Testing
         // Verify it's the correct type
         #expect(storage is BaseOverrideStorage, "Storage should be of type BaseOverrideStorage")
     }
+
+    @Test("Store and retrieve override") func testStoreAndRetrieveOverride() async throws {
+        // Given
+        let testOverride = Override(
+            name: "Test Override",
+            enabled: false,
+            date: Date(),
+            duration: 120,
+            indefinite: false,
+            percentage: 130,
+            smbIsOff: true,
+            isPreset: false,
+            id: UUID().uuidString,
+            overrideTarget: true,
+            target: 110,
+            advancedSettings: false,
+            isfAndCr: false,
+            isf: false,
+            cr: false,
+            smbIsScheduledOff: false,
+            start: 1,
+            end: 2,
+            smbMinutes: 100,
+            uamMinutes: 120
+        )
+
+        // When
+        try await storage.storeOverride(override: testOverride)
+
+        // Then verify stored entries
+        let storedEntries = try await CoreDataStack.shared.fetchEntitiesAsync(
+            ofType: OverrideStored.self,
+            onContext: testContext,
+            predicate: NSPredicate(format: "name == %@", "Test Override"),
+            key: "date",
+            ascending: false
+        ) as? [OverrideStored]
+
+        #expect(storedEntries?.isEmpty == false, "Should have stored entries")
+        #expect(storedEntries?.count == 1, "Should have exactly one entry")
+        let storedOverride = storedEntries?.first
+        #expect(storedOverride?.name == "Test Override", "Name should match")
+        #expect(storedOverride?.percentage == 130, "Percentage should match")
+        #expect(storedOverride?.target?.decimalValue == 110, "Target should match")
+        #expect(storedOverride?.isPreset == false, "isPreset should match")
+    }
+
+    @Test("Store and retrieve override preset") func testStoreAndRetrieveOverridePreset() async throws {
+        // Given
+        let testPreset = Override(
+            name: "Test Preset",
+            enabled: false,
+            date: Date(),
+            duration: 0,
+            indefinite: true,
+            percentage: 120,
+            smbIsOff: true,
+            isPreset: true,
+            id: UUID().uuidString,
+            overrideTarget: true,
+            target: 110,
+            advancedSettings: false,
+            isfAndCr: false,
+            isf: false,
+            cr: false,
+            smbIsScheduledOff: false,
+            start: 1,
+            end: 2,
+            smbMinutes: 100,
+            uamMinutes: 120
+        )
+
+        // When
+        try await storage.storeOverride(override: testPreset)
+        let presetIDs = try await storage.fetchForOverridePresets()
+
+        // Then
+        #expect(!presetIDs.isEmpty, "Should have stored preset")
+
+        let storedPresets = try await testContext.perform {
+            try presetIDs.map { try testContext.existingObject(with: $0) as! OverrideStored }
+        }
+
+        #expect(storedPresets.count >= 1, "Should have at least one preset")
+        let storedPreset = storedPresets.first { $0.name == "Test Preset" }
+        #expect(storedPreset != nil, "Should find the test preset")
+        #expect(storedPreset?.isPreset == true, "Should be marked as preset")
+        #expect(storedPreset?.indefinite == true, "Should be indefinite")
+        #expect(storedPreset?.percentage == 120, "Percentage should match")
+    }
+
+    @Test("Delete override preset") func testDeleteOverridePreset() async throws {
+        // Given
+        let testPreset = Override(
+            name: "Delete Test",
+            enabled: false,
+            date: Date(),
+            duration: 0,
+            indefinite: true,
+            percentage: 120,
+            smbIsOff: true,
+            isPreset: true,
+            id: UUID().uuidString,
+            overrideTarget: true,
+            target: 110,
+            advancedSettings: false,
+            isfAndCr: false,
+            isf: false,
+            cr: false,
+            smbIsScheduledOff: false,
+            start: 1,
+            end: 2,
+            smbMinutes: 100,
+            uamMinutes: 120
+        )
+
+        // Store the preset
+        try await storage.storeOverride(override: testPreset)
+
+        // Get the stored preset's ObjectID
+        let storedEntries = try await CoreDataStack.shared.fetchEntitiesAsync(
+            ofType: OverrideStored.self,
+            onContext: testContext,
+            predicate: NSPredicate(format: "name == %@", "Delete Test"),
+            key: "date",
+            ascending: false
+        ) as? [OverrideStored]
+
+        guard let objectID = storedEntries?.first?.objectID else {
+            throw TestError("Failed to get stored preset's ObjectID")
+        }
+
+        // When
+        await storage.deleteOverridePreset(objectID)
+
+        // Then verify deletion
+        let remainingEntries = try await CoreDataStack.shared.fetchEntitiesAsync(
+            ofType: OverrideStored.self,
+            onContext: testContext,
+            predicate: NSPredicate(format: "name == %@", "Delete Test"),
+            key: "date",
+            ascending: false
+        ) as? [OverrideStored]
+
+        #expect(remainingEntries?.isEmpty == true, "Should have no entries after deletion")
+    }
+
+    @Test("Get overrides not yet uploaded to Nightscout") func testGetOverridesNotYetUploadedToNightscout() async throws {
+        // Given
+        let testOverride = Override(
+            name: "NS Test",
+            enabled: true, // getOverridesNotYetUploadedToNightscout() fetches only active overrides
+            date: Date(),
+            duration: 90,
+            indefinite: false,
+            percentage: 120,
+            smbIsOff: true,
+            isPreset: true,
+            id: UUID().uuidString,
+            overrideTarget: true,
+            target: 110,
+            advancedSettings: false,
+            isfAndCr: false,
+            isf: false,
+            cr: false,
+            smbIsScheduledOff: false,
+            start: 1,
+            end: 2,
+            smbMinutes: 100,
+            uamMinutes: 120
+        )
+
+        // When
+        try await storage.storeOverride(override: testOverride)
+
+        let notUploadedOverrides = try await storage.getOverridesNotYetUploadedToNightscout()
+
+        // Then
+        #expect(!notUploadedOverrides.isEmpty == true, "Should have overrides not uploaded to NS")
+        #expect(notUploadedOverrides[0].notes == "NS Test", "Override name should match")
+        #expect(notUploadedOverrides[0].duration == 90, "Duration should match")
+        #expect(notUploadedOverrides[0].eventType == .nsExercise, "Event type should be exercise")
+    }
 }