LOOP-3802: Adds trend to GlucoseStore (#434)

* LOOP-1328: Initialize GlucoseStore with whatever CGMManager reports as its healthKitStorageDelay

* LOOP-1328: Adds `device` to CachedGlucoseObject

* unit tests and WatchHistoricalGlucose

* ckpt

* pr feedback: remove unneeded change to `GlucoseStoreProtocol`

* Revert unintended change

Author: Rick Pasetto

Common/Models/WatchContext.swift

@@ -147,7 +147,12 @@ extension WatchContext {
 extension WatchContext {
     var newGlucoseSample: NewGlucoseSample? {
         if let quantity = glucose, let date = glucoseDate, let syncIdentifier = glucoseSyncIdentifier {
-            return NewGlucoseSample(date: date, quantity: quantity, isDisplayOnly: glucoseIsDisplayOnly ?? false, wasUserEntered: glucoseWasUserEntered ?? false, syncIdentifier: syncIdentifier, syncVersion: 0)
+            return NewGlucoseSample(date: date,
+                                    quantity: quantity,
+                                    trend: glucoseTrendRawValue.flatMap { GlucoseTrend(rawValue: $0) },
+                                    isDisplayOnly: glucoseIsDisplayOnly ?? false,
+                                    wasUserEntered: glucoseWasUserEntered ?? false,
+                                    syncIdentifier: syncIdentifier, syncVersion: 0)
         }
         return nil
     }

Common/Models/WatchHistoricalGlucose.swift

@@ -41,6 +41,7 @@ extension WatchHistoricalGlucose: RawRepresentable {
         let syncVersions: [Int?]
         let startDates: [Date]
         let quantities: [Double]
+        let trends: [GlucoseTrend?]
         let isDisplayOnlys: [Bool]
         let wasUserEntereds: [Bool]
         let devices: [Data?]
@@ -52,6 +53,7 @@ extension WatchHistoricalGlucose: RawRepresentable {
             self.syncVersions = samples.map { $0.syncVersion }
             self.startDates = samples.map { $0.startDate }
             self.quantities = samples.map { $0.quantity.doubleValue(for: .milligramsPerDeciliter) }
+            self.trends = samples.map { $0.trend }
             self.isDisplayOnlys = samples.map { $0.isDisplayOnly }
             self.wasUserEntereds = samples.map { $0.wasUserEntered }
             self.devices = samples.map { try? WatchHistoricalGlucose.encoder.encode($0.device) }
@@ -65,6 +67,7 @@ extension WatchHistoricalGlucose: RawRepresentable {
                                     syncVersion: syncVersions[$0],
                                     startDate: startDates[$0],
                                     quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: quantities[$0]),
+                                    trend: trends[$0],
                                     isDisplayOnly: isDisplayOnlys[$0],
                                     wasUserEntered: wasUserEntereds[$0],
                                     device: devices[$0].flatMap { try? HKDevice(from: $0) })

Loop/Extensions/GlucoseStore+SimulatedCoreData.swift

@@ -28,7 +28,29 @@ extension GlucoseStore {
         var simulated = [NewGlucoseSample]()
 
         while startDate < endDate {
-            simulated.append(NewGlucoseSample.simulated(date: startDate, value: simulatedValueBase + simulatedValueAmplitude * sin(value)))
+            let prev = simulatedValueBase + simulatedValueAmplitude * sin(value - simulatedValueIncrement)
+            let new = simulatedValueBase + simulatedValueAmplitude * sin(value)
+            let trend: GlucoseTrend? = {
+                switch new - prev {
+                case -0.01...0.01:
+                    return .flat
+                case -2 ..< -0.01:
+                    return .down
+                case -5 ..< -2:
+                    return .downDown
+                case -Double.greatestFiniteMagnitude ..< -5:
+                    return .downDownDown
+                case 0.01...2:
+                    return .up
+                case 2...5:
+                    return .upUp
+                case 5...Double.greatestFiniteMagnitude:
+                    return .upUpUp
+                default:
+                    return nil
+                }
+            }()
+            simulated.append(NewGlucoseSample.simulated(date: startDate, value: new, trend: trend))
 
             if simulated.count >= simulatedLimit {
                 if let error = addSimulatedHistoricalGlucoseObjects(samples: simulated) {
@@ -62,9 +84,10 @@ extension GlucoseStore {
 }
 
 fileprivate extension NewGlucoseSample {
-    static func simulated(date: Date, value: Double, unit: HKUnit = HKUnit.milligramsPerDeciliter) -> NewGlucoseSample {
+    static func simulated(date: Date, value: Double, trend: GlucoseTrend?, unit: HKUnit = HKUnit.milligramsPerDeciliter) -> NewGlucoseSample {
         return NewGlucoseSample(date: date,
                                 quantity: HKQuantity(unit: unit, doubleValue: value),
+                                trend: trend,
                                 isDisplayOnly: false,
                                 wasUserEntered: false,
                                 syncIdentifier: UUID().uuidString)

Loop/View Models/BolusEntryViewModel.swift

@@ -453,6 +453,7 @@ final class BolusEntryViewModel: ObservableObject {
             NewGlucoseSample(
                 date: entryDate,
                 quantity: quantity,
+                trend: nil, // All manual glucose entries are assumed to have no trend.
                 isDisplayOnly: false,
                 wasUserEntered: true,
                 syncIdentifier: uuidProvider()

Loop/View Models/SimpleBolusViewModel.swift

@@ -257,7 +257,12 @@ class SimpleBolusViewModel: ObservableObject {
 
         func saveManualGlucose(_ completion: @escaping (Bool) -> Void) {
             if let glucose = glucose {
-                let manualGlucoseSample = NewGlucoseSample(date: saveDate, quantity: glucose, isDisplayOnly: false, wasUserEntered: true, syncIdentifier: UUID().uuidString)
+                let manualGlucoseSample = NewGlucoseSample(date: saveDate,
+                                                           quantity: glucose,
+                                                           trend: nil, // All manual glucose entries are assumed to have no trend.
+                                                           isDisplayOnly: false,
+                                                           wasUserEntered: true,
+                                                           syncIdentifier: UUID().uuidString)
                 delegate.addGlucose([manualGlucoseSample]) { error in
                     DispatchQueue.main.async {
                         if let error = error {

LoopTests/Managers/CGMStalenessMonitorTests.swift

@@ -18,11 +18,11 @@ class CGMStalenessMonitorTests: XCTestCase {
     private var fetchExpectation: XCTestExpectation?
 
     private var storedGlucoseSample: StoredGlucoseSample {
-        return StoredGlucoseSample(uuid: UUID(), provenanceIdentifier: UUID().uuidString, syncIdentifier: "syncIdentifier", syncVersion: 1, startDate: Date().addingTimeInterval(-.minutes(5)), quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 120), isDisplayOnly: false, wasUserEntered: false, device: nil)
+        return StoredGlucoseSample(uuid: UUID(), provenanceIdentifier: UUID().uuidString, syncIdentifier: "syncIdentifier", syncVersion: 1, startDate: Date().addingTimeInterval(-.minutes(5)), quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 120), trend: .flat, isDisplayOnly: false, wasUserEntered: false, device: nil)
     }
 
     private var newGlucoseSample: NewGlucoseSample {
-        return NewGlucoseSample(date: Date().addingTimeInterval(-.minutes(1)), quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 120), isDisplayOnly: false, wasUserEntered: false, syncIdentifier: "syncIdentifier")
+        return NewGlucoseSample(date: Date().addingTimeInterval(-.minutes(1)), quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 120), trend: .flat, isDisplayOnly: false, wasUserEntered: false, syncIdentifier: "syncIdentifier")
     }
 
     func testInitialValue() {

LoopTests/Models/WatchHistoricalGlucoseTest.swift

@@ -21,6 +21,7 @@ class WatchHistoricalGlucoseTests: XCTestCase {
                                     syncVersion: 4,
                                     startDate: Date(timeIntervalSinceReferenceDate: .hours(100)),
                                     quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 123.45),
+                                    trend: nil,
                                     isDisplayOnly: false,
                                     wasUserEntered: true,
                                     device: device),
@@ -30,6 +31,7 @@ class WatchHistoricalGlucoseTests: XCTestCase {
                                     syncVersion: 2,
                                     startDate: Date(timeIntervalSinceReferenceDate: .hours(99)),
                                     quantity: HKQuantity(unit: .millimolesPerLiter, doubleValue: 7.2),
+                                    trend: .up,
                                     isDisplayOnly: true,
                                     wasUserEntered: false,
                                     device: device),
@@ -39,6 +41,7 @@ class WatchHistoricalGlucoseTests: XCTestCase {
                                     syncVersion: nil,
                                     startDate: Date(timeIntervalSinceReferenceDate: .hours(98)),
                                     quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 187.65),
+                                    trend: .downDownDown,
                                     isDisplayOnly: false,
                                     wasUserEntered: false,
                                     device: nil),

LoopTests/ViewModels/BolusEntryViewModelTests.swift

@@ -477,7 +477,7 @@ class BolusEntryViewModelTests: XCTestCase {
 
         try saveAndDeliver(BolusEntryViewModelTests.noBolus)
 
-        let expectedGlucoseSample = NewGlucoseSample(date: now, quantity: Self.exampleManualGlucoseQuantity, isDisplayOnly: false, wasUserEntered: true, syncIdentifier: mockUUID)
+        let expectedGlucoseSample = NewGlucoseSample(date: now, quantity: Self.exampleManualGlucoseQuantity, trend: nil, isDisplayOnly: false, wasUserEntered: true, syncIdentifier: mockUUID)
         XCTAssertEqual([expectedGlucoseSample], delegate.glucoseSamplesAdded)
 
         delegate.addGlucoseCompletion?(.success([Self.exampleManualStoredGlucoseSample]))
@@ -532,7 +532,7 @@ class BolusEntryViewModelTests: XCTestCase {
 
         try saveAndDeliver(BolusEntryViewModelTests.exampleBolusQuantity)
 
-        let expectedGlucoseSample = NewGlucoseSample(date: now, quantity: Self.exampleManualGlucoseQuantity, isDisplayOnly: false, wasUserEntered: true, syncIdentifier: mockUUID)
+        let expectedGlucoseSample = NewGlucoseSample(date: now, quantity: Self.exampleManualGlucoseQuantity, trend: nil, isDisplayOnly: false, wasUserEntered: true, syncIdentifier: mockUUID)
         XCTAssertEqual([expectedGlucoseSample], delegate.glucoseSamplesAdded)
 
         delegate.addGlucoseCompletion?(.success([Self.exampleManualStoredGlucoseSample]))
@@ -622,7 +622,7 @@ class BolusEntryViewModelTests: XCTestCase {
 
         try saveAndDeliver(BolusEntryViewModelTests.exampleBolusQuantity)
 
-        let expectedGlucoseSample = NewGlucoseSample(date: now, quantity: Self.exampleManualGlucoseQuantity, isDisplayOnly: false, wasUserEntered: true, syncIdentifier: mockUUID)
+        let expectedGlucoseSample = NewGlucoseSample(date: now, quantity: Self.exampleManualGlucoseQuantity, trend: nil, isDisplayOnly: false, wasUserEntered: true, syncIdentifier: mockUUID)
         XCTAssertEqual([expectedGlucoseSample], delegate.glucoseSamplesAdded)
 
         delegate.addGlucoseCompletion?(.success([Self.exampleManualStoredGlucoseSample]))