LOOP-1328: Initialize GlucoseStore with a healthKitStorageDelay (#428)

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

* LOOP-1328: Adds `device` to CachedGlucoseObject

* unit tests and WatchHistoricalGlucose

* pr feedback: remove unneeded change to `GlucoseStoreProtocol`

Author: Rick Pasetto

Common/Models/WatchHistoricalGlucose.swift

@@ -43,6 +43,7 @@ extension WatchHistoricalGlucose: RawRepresentable {
         let quantities: [Double]
         let isDisplayOnlys: [Bool]
         let wasUserEntereds: [Bool]
+        let devices: [Data?]
 
         init(samples: [StoredGlucoseSample]) {
             self.uuids = samples.map { $0.uuid }
@@ -53,27 +54,29 @@ extension WatchHistoricalGlucose: RawRepresentable {
             self.quantities = samples.map { $0.quantity.doubleValue(for: .milligramsPerDeciliter) }
             self.isDisplayOnlys = samples.map { $0.isDisplayOnly }
             self.wasUserEntereds = samples.map { $0.wasUserEntered }
+            self.devices = samples.map { try? WatchHistoricalGlucose.encoder.encode($0.device) }
         }
 
         var samples: [StoredGlucoseSample] {
             return (0..<uuids.count).map {
-                StoredGlucoseSample(uuid: uuids[$0],
+                return StoredGlucoseSample(uuid: uuids[$0],
                                     provenanceIdentifier: provenanceIdentifiers[$0],
                                     syncIdentifier: syncIdentifiers[$0],
                                     syncVersion: syncVersions[$0],
                                     startDate: startDates[$0],
                                     quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: quantities[$0]),
                                     isDisplayOnly: isDisplayOnlys[$0],
-                                    wasUserEntered: wasUserEntereds[$0])
+                                    wasUserEntered: wasUserEntereds[$0],
+                                    device: devices[$0].flatMap { try? HKDevice(from: $0) })
             }
         }
     }
 
-    private static var encoder: PropertyListEncoder {
+    fileprivate static var encoder: PropertyListEncoder {
         let encoder = PropertyListEncoder()
         encoder.outputFormat = .binary
         return encoder
     }
 
-    private static var decoder: PropertyListDecoder = PropertyListDecoder()
+    fileprivate static var decoder: PropertyListDecoder = PropertyListDecoder()
 }

Loop/Managers/DeviceDataManager.swift

@@ -616,6 +616,7 @@ private extension DeviceDataManager {
         cgmManager?.delegateQueue = queue
 
         glucoseStore.managedDataInterval = cgmManager?.managedDataInterval
+        glucoseStore.healthKitStorageDelay = cgmManager.map{ type(of: $0).healthKitStorageDelay } ?? 0
 
         updatePumpManagerBLEHeartbeatPreference()
         if let cgmManager = cgmManager {

Loop/Managers/Store Protocols/GlucoseStoreProtocol.swift

@@ -25,7 +25,7 @@ protocol GlucoseStoreProtocol: AnyObject {
     var authorizationRequired: Bool { get }
 
     var sharingDenied: Bool { get }
-    
+
     func authorize(toShare: Bool, read: Bool, _ completion: @escaping (_ result: HealthKitSampleStoreResult<Bool>) -> Void)
 
     // MARK: Sample Management

LoopTests/Managers/CGMStalenessMonitorTests.swift

@@ -18,7 +18,7 @@ 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)
+        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)
     }
 
     private var newGlucoseSample: NewGlucoseSample {

LoopTests/Mock Stores/MockGlucoseStore.swift

@@ -11,6 +11,7 @@ import LoopKit
 @testable import Loop
 
 class MockGlucoseStore: GlucoseStoreProtocol {
+    
     init(for test: DataManagerTestType = .flatAndStable) {
         self.testType = test // The store returns different effect values based on the test type
     }
@@ -38,6 +39,8 @@ class MockGlucoseStore: GlucoseStoreProtocol {
 
     var managedDataInterval: TimeInterval?
 
+    var healthKitStorageDelay = TimeInterval(0)
+
     var authorizationRequired: Bool = false
 
     var sharingDenied: Bool = false

LoopTests/Models/WatchHistoricalGlucoseTest.swift

@@ -13,6 +13,7 @@ import LoopKit
 @testable import Loop
 
 class WatchHistoricalGlucoseTests: XCTestCase {
+    private lazy var device = HKDevice(name: "NAME", manufacturer: "MANUFACTURER", model: "MODEL", hardwareVersion: "HARDWAREVERSION", firmwareVersion: "FIRMWAREVERSION", softwareVersion: "SOFTWAREVERSION", localIdentifier: "LOCALIDENTIFIER", udiDeviceIdentifier: "UDIDEVICEIDENTIFIER")
     private lazy var samples: [StoredGlucoseSample] = {
         return [StoredGlucoseSample(uuid: UUID(),
                                     provenanceIdentifier: UUID().uuidString,
@@ -21,23 +22,26 @@ class WatchHistoricalGlucoseTests: XCTestCase {
                                     startDate: Date(timeIntervalSinceReferenceDate: .hours(100)),
                                     quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 123.45),
                                     isDisplayOnly: false,
-                                    wasUserEntered: true),
+                                    wasUserEntered: true,
+                                    device: device),
                 StoredGlucoseSample(uuid: UUID(),
                                     provenanceIdentifier: UUID().uuidString,
                                     syncIdentifier: UUID().uuidString,
                                     syncVersion: 2,
                                     startDate: Date(timeIntervalSinceReferenceDate: .hours(99)),
                                     quantity: HKQuantity(unit: .millimolesPerLiter, doubleValue: 7.2),
                                     isDisplayOnly: true,
-                                    wasUserEntered: false),
+                                    wasUserEntered: false,
+                                    device: device),
                 StoredGlucoseSample(uuid: nil,
                                     provenanceIdentifier: UUID().uuidString,
                                     syncIdentifier: nil,
                                     syncVersion: nil,
                                     startDate: Date(timeIntervalSinceReferenceDate: .hours(98)),
                                     quantity: HKQuantity(unit: .milligramsPerDeciliter, doubleValue: 187.65),
                                     isDisplayOnly: false,
-                                    wasUserEntered: false),
+                                    wasUserEntered: false,
+                                    device: nil),
         ]
     }()