|
|
@@ -0,0 +1,590 @@
|
|
|
+import Foundation
|
|
|
+import Testing
|
|
|
+
|
|
|
+@testable import Trio
|
|
|
+
|
|
|
+@Suite("Bolus Calculator Tests") struct BolusCalculatorTests: Injectable {
|
|
|
+ @Injected() var calculator: BolusCalculationManager!
|
|
|
+ @Injected() var settingsManager: SettingsManager!
|
|
|
+ @Injected() var fileStorage: FileStorage!
|
|
|
+ @Injected() var apsManager: APSManager!
|
|
|
+ let resolver = TrioApp().resolver
|
|
|
+
|
|
|
+ init() {
|
|
|
+ injectServices(resolver)
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test("Calculator is correctly initialized") func testCalculatorInitialization() {
|
|
|
+ #expect(calculator != nil, "BolusCalculationManager should be injected")
|
|
|
+ #expect(calculator is BaseBolusCalculationManager, "Calculator should be of type BaseBolusCalculationManager")
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test("Calculate insulin for standard meal") func testStandardMealCalculation() async throws {
|
|
|
+ // STEP 1: Setup test scenario
|
|
|
+ // We need to provide a CalculationInput struct
|
|
|
+ let carbs: Decimal = 80
|
|
|
+ let currentBG: Decimal = 180 // 80 points above target, should result in 2U correction
|
|
|
+ let deltaBG: Decimal = 5 // Rising trend, should add small correction
|
|
|
+ let target: Decimal = 100
|
|
|
+ let isf: Decimal = 40
|
|
|
+ let carbRatio: Decimal = 10 // Should result in 8U for carbs
|
|
|
+ let iob: Decimal = 1.0 // Should subtract from final result
|
|
|
+ let cob: Int16 = 20
|
|
|
+ let useFattyMealCorrectionFactor: Bool = false
|
|
|
+ let useSuperBolus: Bool = false
|
|
|
+ let fattyMealFactor: Decimal = 0.8
|
|
|
+ let sweetMealFactor: Decimal = 2
|
|
|
+ let basal: Decimal = 1.5
|
|
|
+ let fraction: Decimal = 0.8
|
|
|
+ let maxBolus: Decimal = 10
|
|
|
+
|
|
|
+ // STEP 2: Create calculation input
|
|
|
+ let input = CalculationInput(
|
|
|
+ carbs: carbs,
|
|
|
+ currentBG: currentBG,
|
|
|
+ deltaBG: deltaBG,
|
|
|
+ target: target,
|
|
|
+ isf: isf,
|
|
|
+ carbRatio: carbRatio,
|
|
|
+ iob: iob,
|
|
|
+ cob: cob,
|
|
|
+ useFattyMealCorrectionFactor: useFattyMealCorrectionFactor,
|
|
|
+ fattyMealFactor: fattyMealFactor,
|
|
|
+ useSuperBolus: useSuperBolus,
|
|
|
+ sweetMealFactor: sweetMealFactor,
|
|
|
+ basal: basal,
|
|
|
+ fraction: fraction,
|
|
|
+ maxBolus: maxBolus
|
|
|
+ )
|
|
|
+
|
|
|
+ // STEP 3: Calculate insulin
|
|
|
+ let result = await calculator.calculateInsulin(input: input)
|
|
|
+
|
|
|
+ // STEP 4: Verify results
|
|
|
+ // Expected calculation breakdown:
|
|
|
+ // wholeCob = 80g + 20g COB = 100g
|
|
|
+ // wholeCobInsulin = 100g ÷ 10 g/U = 10U
|
|
|
+ // targetDifference = currentBG - target = 180 - 100 = 80 mg/dL
|
|
|
+ // targetDifferenceInsulin = 80 mg/dL ÷ 40 mg/dL/U = 2U
|
|
|
+ // fifteenMinutesInsulin = 5 mg/dL ÷ 40 mg/dL/U = 0.125U
|
|
|
+ // correctionInsulin = targetDifferenceInsulin = 2U
|
|
|
+ // iobInsulinReduction = 1U
|
|
|
+ // superBolusInsulin = 0U (disabled)
|
|
|
+ // no adjustment for fatty meals (disabled)
|
|
|
+ // wholeCalc = round(wholeCobInsulin + correctionInsulin + fifteenMinutesInsulin - iobInsulinReduction, 3) = 11.125U
|
|
|
+ // insulinCalculated = round(wholeCalc × fraction, 3) = 8.9U
|
|
|
+
|
|
|
+ // Calculate expected values with proper rounding using roundBolus method from the apsManager
|
|
|
+ let wholeCobInsulin = apsManager.roundBolus(amount: Decimal(100) / Decimal(10)) // 10U
|
|
|
+ let targetDifferenceInsulin = apsManager.roundBolus(amount: Decimal(80) / Decimal(40)) // 2U
|
|
|
+ let fifteenMinutesInsulin = apsManager.roundBolus(amount: Decimal(5) / Decimal(40)) // 0.125U
|
|
|
+ let wholeCalc = wholeCobInsulin + targetDifferenceInsulin + fifteenMinutesInsulin - Decimal(1) // 11.125U
|
|
|
+ let expectedInsulinCalculated = apsManager.roundBolus(amount: wholeCalc * fraction) // 8.9U
|
|
|
+
|
|
|
+ #expect(
|
|
|
+ result.insulinCalculated == expectedInsulinCalculated,
|
|
|
+ """
|
|
|
+ Incorrect insulin calculation
|
|
|
+ Expected: \(expectedInsulinCalculated)U
|
|
|
+ Actual: \(result.insulinCalculated)U
|
|
|
+ Components from CalculationResult:
|
|
|
+ - insulinCalculated: \(result.insulinCalculated)U (expected: \(expectedInsulinCalculated)U)
|
|
|
+ - wholeCalc: \(result.wholeCalc)U (expected: \(wholeCalc)U)
|
|
|
+ - correctionInsulin: \(result.correctionInsulin)U (expected: \(targetDifferenceInsulin)U)
|
|
|
+ - iobInsulinReduction: \(result.iobInsulinReduction)U (expected: 1U)
|
|
|
+ - superBolusInsulin: \(result.superBolusInsulin)U (expected: 0U)
|
|
|
+ - targetDifference: \(result.targetDifference) mg/dL (expected: 80 mg/dL)
|
|
|
+ - targetDifferenceInsulin: \(result.targetDifferenceInsulin)U (expected: \(targetDifferenceInsulin)U)
|
|
|
+ - fifteenMinutesInsulin: \(result.fifteenMinutesInsulin)U (expected: \(fifteenMinutesInsulin)U)
|
|
|
+ - wholeCob: \(result.wholeCob)g (expected: 100g)
|
|
|
+ - wholeCobInsulin: \(result.wholeCobInsulin)U (expected: \(wholeCobInsulin)U)
|
|
|
+ """
|
|
|
+ )
|
|
|
+
|
|
|
+ // Verify each component from CalculationResult struct with rounded values
|
|
|
+ #expect(
|
|
|
+ result.insulinCalculated == expectedInsulinCalculated,
|
|
|
+ "Final calculated insulin amount should be \(expectedInsulinCalculated)U"
|
|
|
+ )
|
|
|
+ #expect(result.wholeCalc == wholeCalc, "Total calculation before fraction should be \(wholeCalc)U")
|
|
|
+ #expect(
|
|
|
+ result.correctionInsulin == targetDifferenceInsulin,
|
|
|
+ "Insulin for BG correction should be \(targetDifferenceInsulin)U"
|
|
|
+ )
|
|
|
+ #expect(result.iobInsulinReduction == -1.0, "Absolute IOB reduction amount should be 1U, hence -1U")
|
|
|
+ #expect(result.superBolusInsulin == 0, "Additional insulin for super bolus should be 0U")
|
|
|
+ #expect(result.targetDifference == 80, "Difference from target BG should be 80 mg/dL")
|
|
|
+ #expect(
|
|
|
+ result.targetDifferenceInsulin == targetDifferenceInsulin,
|
|
|
+ "Insulin needed for target difference should be \(targetDifferenceInsulin)U"
|
|
|
+ )
|
|
|
+ #expect(
|
|
|
+ result.fifteenMinutesInsulin == fifteenMinutesInsulin,
|
|
|
+ "Trend-based insulin adjustment should be \(fifteenMinutesInsulin)U"
|
|
|
+ )
|
|
|
+ #expect(result.wholeCob == 100, "Total carbs (COB + new carbs) should be 100g")
|
|
|
+ #expect(result.wholeCobInsulin == wholeCobInsulin, "Insulin for total carbs should be \(wholeCobInsulin)U")
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test("Calculate insulin for fatty meal") func testFattyMealCalculation() async throws {
|
|
|
+ // STEP 1: Setup test scenario
|
|
|
+ // We need to provide a CalculationInput struct
|
|
|
+ let carbs: Decimal = 80
|
|
|
+ let currentBG: Decimal = 180 // 80 points above target, should result in 2U correction
|
|
|
+ let deltaBG: Decimal = 5 // Rising trend, should add small correction
|
|
|
+ let target: Decimal = 100
|
|
|
+ let isf: Decimal = 40
|
|
|
+ let carbRatio: Decimal = 10 // Should result in 8U for carbs
|
|
|
+ let iob: Decimal = 1.0 // Should subtract from final result
|
|
|
+ let cob: Int16 = 20
|
|
|
+ let useFattyMealCorrectionFactor: Bool = true // now set to true
|
|
|
+ let useSuperBolus: Bool = false
|
|
|
+ let fattyMealFactor: Decimal = 0.8
|
|
|
+ let sweetMealFactor: Decimal = 2
|
|
|
+ let basal: Decimal = 1.5
|
|
|
+ let fraction: Decimal = 0.8
|
|
|
+ let maxBolus: Decimal = 10
|
|
|
+
|
|
|
+ // STEP 2: Create calculation input
|
|
|
+ let input = CalculationInput(
|
|
|
+ carbs: carbs,
|
|
|
+ currentBG: currentBG,
|
|
|
+ deltaBG: deltaBG,
|
|
|
+ target: target,
|
|
|
+ isf: isf,
|
|
|
+ carbRatio: carbRatio,
|
|
|
+ iob: iob,
|
|
|
+ cob: cob,
|
|
|
+ useFattyMealCorrectionFactor: useFattyMealCorrectionFactor,
|
|
|
+ fattyMealFactor: fattyMealFactor,
|
|
|
+ useSuperBolus: useSuperBolus,
|
|
|
+ sweetMealFactor: sweetMealFactor,
|
|
|
+ basal: basal,
|
|
|
+ fraction: fraction,
|
|
|
+ maxBolus: maxBolus
|
|
|
+ )
|
|
|
+
|
|
|
+ // STEP 3: Calculate insulin with fatty meal enabled
|
|
|
+ let fattyMealResult = await calculator.calculateInsulin(input: input)
|
|
|
+
|
|
|
+ // STEP 4: Calculate insulin with fatty meal disabled for comparison
|
|
|
+ let standardInput = CalculationInput(
|
|
|
+ carbs: carbs,
|
|
|
+ currentBG: currentBG,
|
|
|
+ deltaBG: deltaBG,
|
|
|
+ target: target,
|
|
|
+ isf: isf,
|
|
|
+ carbRatio: carbRatio,
|
|
|
+ iob: iob,
|
|
|
+ cob: cob,
|
|
|
+ useFattyMealCorrectionFactor: false, // Disabled for comparison
|
|
|
+ fattyMealFactor: fattyMealFactor,
|
|
|
+ useSuperBolus: useSuperBolus,
|
|
|
+ sweetMealFactor: sweetMealFactor,
|
|
|
+ basal: basal,
|
|
|
+ fraction: fraction,
|
|
|
+ maxBolus: maxBolus
|
|
|
+ )
|
|
|
+ let standardResult = await calculator.calculateInsulin(input: standardInput)
|
|
|
+
|
|
|
+ // STEP 5: Verify results
|
|
|
+ // Fatty meal should reduce the insulin amount by the fatty meal factor (0.8)
|
|
|
+ let expectedReduction = fattyMealFactor
|
|
|
+ let actualReduction = Decimal(
|
|
|
+ (Double(fattyMealResult.insulinCalculated) / Double(standardResult.insulinCalculated) * 10.0).rounded() / 10.0
|
|
|
+ )
|
|
|
+
|
|
|
+ #expect(
|
|
|
+ actualReduction == expectedReduction,
|
|
|
+ """
|
|
|
+ Fatty meal calculation incorrect
|
|
|
+ Expected reduction factor: \(expectedReduction)
|
|
|
+ Actual reduction factor: \(actualReduction)
|
|
|
+ Standard calculation: \(standardResult.insulinCalculated)U
|
|
|
+ Fatty meal calculation: \(fattyMealResult.insulinCalculated)U
|
|
|
+ """
|
|
|
+ )
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test("Calculate insulin with super bolus") func testSuperBolusCalculation() async throws {
|
|
|
+ // STEP 1: Setup test scenario
|
|
|
+ // We need to provide a CalculationInput struct
|
|
|
+ let carbs: Decimal = 80
|
|
|
+ let currentBG: Decimal = 180 // 80 points above target, should result in 2U correction
|
|
|
+ let deltaBG: Decimal = 5 // Rising trend, should add small correction
|
|
|
+ let target: Decimal = 100
|
|
|
+ let isf: Decimal = 40
|
|
|
+ let carbRatio: Decimal = 10 // Should result in 8U for carbs
|
|
|
+ let iob: Decimal = 1.0 // Should subtract from final result
|
|
|
+ let cob: Int16 = 20
|
|
|
+ let useFattyMealCorrectionFactor: Bool = false
|
|
|
+ let useSuperBolus: Bool = true // Super bolus enabled
|
|
|
+ let fattyMealFactor: Decimal = 0.8
|
|
|
+ let sweetMealFactor: Decimal = 2
|
|
|
+ let basal: Decimal = 1.5 // Will be added to insulin calculation when super bolus is enabled
|
|
|
+ let fraction: Decimal = 0.8
|
|
|
+ let maxBolus: Decimal = 10
|
|
|
+
|
|
|
+ // STEP 2: Create calculation input with super bolus enabled
|
|
|
+ let input = CalculationInput(
|
|
|
+ carbs: carbs,
|
|
|
+ currentBG: currentBG,
|
|
|
+ deltaBG: deltaBG,
|
|
|
+ target: target,
|
|
|
+ isf: isf,
|
|
|
+ carbRatio: carbRatio,
|
|
|
+ iob: iob,
|
|
|
+ cob: cob,
|
|
|
+ useFattyMealCorrectionFactor: useFattyMealCorrectionFactor,
|
|
|
+ fattyMealFactor: fattyMealFactor,
|
|
|
+ useSuperBolus: useSuperBolus,
|
|
|
+ sweetMealFactor: sweetMealFactor,
|
|
|
+ basal: basal,
|
|
|
+ fraction: fraction,
|
|
|
+ maxBolus: maxBolus
|
|
|
+ )
|
|
|
+
|
|
|
+ // STEP 3: Calculate insulin with super bolus enabled
|
|
|
+ let superBolusResult = await calculator.calculateInsulin(input: input)
|
|
|
+
|
|
|
+ // STEP 4: Calculate insulin with super bolus disabled for comparison
|
|
|
+ let standardInput = CalculationInput(
|
|
|
+ carbs: carbs,
|
|
|
+ currentBG: currentBG,
|
|
|
+ deltaBG: deltaBG,
|
|
|
+ target: target,
|
|
|
+ isf: isf,
|
|
|
+ carbRatio: carbRatio,
|
|
|
+ iob: iob,
|
|
|
+ cob: cob,
|
|
|
+ useFattyMealCorrectionFactor: useFattyMealCorrectionFactor,
|
|
|
+ fattyMealFactor: fattyMealFactor,
|
|
|
+ useSuperBolus: false, // Disabled for comparison
|
|
|
+ sweetMealFactor: sweetMealFactor,
|
|
|
+ basal: basal,
|
|
|
+ fraction: fraction,
|
|
|
+ maxBolus: maxBolus
|
|
|
+ )
|
|
|
+ let standardResult = await calculator.calculateInsulin(input: standardInput)
|
|
|
+
|
|
|
+ // STEP 5: Verify results
|
|
|
+ // Super bolus should add basal rate * sweetMealFactor to the insulin calculation
|
|
|
+ let expectedSuperBolusInsulin = basal * sweetMealFactor
|
|
|
+ #expect(
|
|
|
+ superBolusResult.superBolusInsulin == expectedSuperBolusInsulin,
|
|
|
+ """
|
|
|
+ Super bolus insulin incorrect
|
|
|
+ Expected: \(expectedSuperBolusInsulin)U (basal \(basal)U × sweetMealFactor \(sweetMealFactor))
|
|
|
+ Actual: \(superBolusResult.superBolusInsulin)U
|
|
|
+ """
|
|
|
+ )
|
|
|
+
|
|
|
+ #expect(
|
|
|
+ superBolusResult.insulinCalculated > standardResult.insulinCalculated,
|
|
|
+ """
|
|
|
+ Super bolus calculation incorrect
|
|
|
+ Expected super bolus calculation to be higher than standard
|
|
|
+ Super bolus: \(superBolusResult.insulinCalculated)U
|
|
|
+ Standard: \(standardResult.insulinCalculated)U
|
|
|
+ Difference: \(superBolusResult.insulinCalculated - standardResult.insulinCalculated)U
|
|
|
+ """
|
|
|
+ )
|
|
|
+
|
|
|
+ // The difference should be the difference of super bolus (= standard dose + the basal rate * sweetMealFactor) limited by max bolus, and the standard dose.
|
|
|
+ let actualDifference = (superBolusResult.insulinCalculated - standardResult.insulinCalculated)
|
|
|
+ let expectedDifference = min(superBolusResult.insulinCalculated, maxBolus) - standardResult.insulinCalculated
|
|
|
+ #expect(
|
|
|
+ actualDifference == expectedDifference,
|
|
|
+ """
|
|
|
+ Super bolus difference incorrect
|
|
|
+ Expected difference: min(\(expectedSuperBolusInsulin), \(maxBolus)) U (basal \(basal)U × sweetMealFactor \(sweetMealFactor) + standard dose \(standardResult
|
|
|
+ .insulinCalculated)) - standard dose \(standardResult.insulinCalculated)
|
|
|
+ Actual difference: \(actualDifference)U
|
|
|
+ Standard result: \(standardResult)
|
|
|
+ SuperBolus result: \(superBolusResult)
|
|
|
+ """
|
|
|
+ )
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test("Calculate insulin with zero carbs") func testZeroCarbsCalculation() async throws {
|
|
|
+ // Given
|
|
|
+ let carbs: Decimal = 0
|
|
|
+
|
|
|
+ // When
|
|
|
+ let result = await calculator.handleBolusCalculation(
|
|
|
+ carbs: carbs,
|
|
|
+ useFattyMealCorrection: false,
|
|
|
+ useSuperBolus: false
|
|
|
+ )
|
|
|
+
|
|
|
+ // Then
|
|
|
+ #expect(result.wholeCobInsulin == 0, "Zero carbs should require no insulin for carbs")
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test("Verify settings retrieval") func testGetSettings() async throws {
|
|
|
+ // Given - Save original settings to restore later
|
|
|
+ let originalSettings = settingsManager.settings
|
|
|
+
|
|
|
+ // Setup test settings
|
|
|
+ let expectedUnits = GlucoseUnits.mgdL
|
|
|
+ let expectedFraction: Decimal = 0.7
|
|
|
+ let expectedFattyMealFactor: Decimal = 0.8
|
|
|
+ let expectedSweetMealFactor: Decimal = 2
|
|
|
+ let expectedMaxCarbs: Decimal = 150
|
|
|
+
|
|
|
+ // Update settings through settings manager
|
|
|
+ settingsManager.settings.units = expectedUnits
|
|
|
+ settingsManager.settings.overrideFactor = expectedFraction
|
|
|
+ settingsManager.settings.fattyMealFactor = expectedFattyMealFactor
|
|
|
+ settingsManager.settings.sweetMealFactor = expectedSweetMealFactor
|
|
|
+ settingsManager.settings.maxCarbs = expectedMaxCarbs
|
|
|
+
|
|
|
+ // Save settings to storage
|
|
|
+ fileStorage.save(settingsManager.settings, as: OpenAPS.Settings.settings)
|
|
|
+
|
|
|
+ // When
|
|
|
+ let (units, fraction, fattyMealFactor, sweetMealFactor, maxCarbs) = await getSettings()
|
|
|
+
|
|
|
+ // Then
|
|
|
+ #expect(units == expectedUnits, "Units should match settings")
|
|
|
+ #expect(fraction == expectedFraction, "Override factor should match settings")
|
|
|
+ #expect(fattyMealFactor == expectedFattyMealFactor, "Fatty meal factor should match settings")
|
|
|
+ #expect(sweetMealFactor == expectedSweetMealFactor, "Sweet meal factor should match settings")
|
|
|
+ #expect(maxCarbs == expectedMaxCarbs, "Max carbs should match settings")
|
|
|
+
|
|
|
+ // Cleanup - Restore original settings
|
|
|
+ settingsManager.settings = originalSettings
|
|
|
+ fileStorage.save(originalSettings, as: OpenAPS.Settings.settings)
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test("Verify getCurrentSettingValue returns correct values based on time") func testGetCurrentSettingValue() async throws {
|
|
|
+ // STEP 1: Backup current settings
|
|
|
+ let originalBasalProfile = await fileStorage.retrieveAsync(OpenAPS.Settings.basalProfile, as: [BasalProfileEntry].self)
|
|
|
+ let originalCarbRatios = await fileStorage.retrieveAsync(OpenAPS.Settings.carbRatios, as: CarbRatios.self)
|
|
|
+ let originalBGTargets = await fileStorage.retrieveAsync(OpenAPS.Settings.bgTargets, as: BGTargets.self)
|
|
|
+ let originalISFValues = await fileStorage.retrieveAsync(
|
|
|
+ OpenAPS.Settings.insulinSensitivities,
|
|
|
+ as: InsulinSensitivities.self
|
|
|
+ )
|
|
|
+
|
|
|
+ // STEP 2: Setup test data with known values
|
|
|
+ // Note: Entries must be sorted by time for the algorithm to work correctly
|
|
|
+ let basalProfile = [
|
|
|
+ BasalProfileEntry(start: "00:00", minutes: 0, rate: 1.0), // 12:00 AM - 6:00 AM: 1.0
|
|
|
+ BasalProfileEntry(start: "06:00", minutes: 360, rate: 1.2), // 6:00 AM - 12:00 PM: 1.2
|
|
|
+ BasalProfileEntry(start: "12:00", minutes: 720, rate: 1.1), // 12:00 PM - 6:00 PM: 1.1
|
|
|
+ BasalProfileEntry(start: "18:00", minutes: 1080, rate: 0.9) // 6:00 PM - 12:00 AM: 0.9
|
|
|
+ ]
|
|
|
+
|
|
|
+ let carbRatios = CarbRatios(
|
|
|
+ units: .grams,
|
|
|
+ schedule: [
|
|
|
+ CarbRatioEntry(start: "00:00", offset: 0, ratio: 10), // 12:00 AM - 12:00 PM: 10
|
|
|
+ CarbRatioEntry(start: "12:00", offset: 720, ratio: 12) // 12:00 PM - 12:00 AM: 12
|
|
|
+ ]
|
|
|
+ )
|
|
|
+
|
|
|
+ let bgTargets = BGTargets(
|
|
|
+ units: .mgdL,
|
|
|
+ userPreferredUnits: .mgdL,
|
|
|
+ targets: [
|
|
|
+ BGTargetEntry(low: 100, high: 120, start: "00:00", offset: 0), // 12:00 AM - 8:00 AM: 100
|
|
|
+ BGTargetEntry(low: 90, high: 110, start: "08:00", offset: 480) // 8:00 AM - 12:00 AM: 90
|
|
|
+ ]
|
|
|
+ )
|
|
|
+
|
|
|
+ let isfValues = InsulinSensitivities(
|
|
|
+ units: .mgdL,
|
|
|
+ userPreferredUnits: .mgdL,
|
|
|
+ sensitivities: [
|
|
|
+ InsulinSensitivityEntry(sensitivity: 40, offset: 0, start: "00:00"), // 12:00 AM - 2:00 PM: 40
|
|
|
+ InsulinSensitivityEntry(sensitivity: 45, offset: 840, start: "14:00") // 2:00 PM - 12:00 AM: 45
|
|
|
+ ]
|
|
|
+ )
|
|
|
+
|
|
|
+ // STEP 3: Store test data
|
|
|
+ fileStorage.save(basalProfile, as: OpenAPS.Settings.basalProfile)
|
|
|
+ fileStorage.save(carbRatios, as: OpenAPS.Settings.carbRatios)
|
|
|
+ fileStorage.save(bgTargets, as: OpenAPS.Settings.bgTargets)
|
|
|
+ fileStorage.save(isfValues, as: OpenAPS.Settings.insulinSensitivities)
|
|
|
+
|
|
|
+ // STEP 4: Define test cases with specific times and expected values
|
|
|
+ // Format: (hour, minute, [setting type: expected value])
|
|
|
+ let testTimes: [(hour: Int, minute: Int, expected: [SettingType: Decimal])] = [
|
|
|
+ // Test midnight values (00:00)
|
|
|
+ (
|
|
|
+ hour: 0, minute: 0,
|
|
|
+ expected: [
|
|
|
+ .basal: 1.0, // First basal rate
|
|
|
+ .carbRatio: 10, // First carb ratio
|
|
|
+ .bgTarget: 100, // First target
|
|
|
+ .isf: 40 // First ISF
|
|
|
+ ]
|
|
|
+ ),
|
|
|
+ // Test mid-morning values (7:00)
|
|
|
+ (
|
|
|
+ hour: 7, minute: 0,
|
|
|
+ expected: [
|
|
|
+ .basal: 1.2, // Second basal rate (after 6:00)
|
|
|
+ .carbRatio: 10, // Still first carb ratio
|
|
|
+ .bgTarget: 100, // Still first target
|
|
|
+ .isf: 40 // Still first ISF
|
|
|
+ ]
|
|
|
+ ),
|
|
|
+ // Test afternoon values (15:00)
|
|
|
+ (
|
|
|
+ hour: 15, minute: 0,
|
|
|
+ expected: [
|
|
|
+ .basal: 1.1, // Third basal rate (after 12:00)
|
|
|
+ .carbRatio: 12, // Second carb ratio (after 12:00)
|
|
|
+ .bgTarget: 90, // Second target
|
|
|
+ .isf: 45 // Second ISF (after 14:00)
|
|
|
+ ]
|
|
|
+ )
|
|
|
+ ]
|
|
|
+
|
|
|
+ // STEP 5: Test each time point
|
|
|
+ for testTime in testTimes {
|
|
|
+ // Create a date object for the test time
|
|
|
+ let calendar = Calendar.current
|
|
|
+ var components = calendar.dateComponents([.year, .month, .day], from: Date())
|
|
|
+ components.hour = testTime.hour
|
|
|
+ components.minute = testTime.minute
|
|
|
+ components.second = 0
|
|
|
+ guard let testDate = calendar.date(from: components) else {
|
|
|
+ throw TestError("Failed to create test date")
|
|
|
+ }
|
|
|
+
|
|
|
+ // Test each setting type at this time
|
|
|
+ for (type, expectedValue) in testTime.expected {
|
|
|
+ // Get the actual value for this setting at the test time
|
|
|
+ let value = await getCurrentSettingValue(for: type, at: testDate)
|
|
|
+
|
|
|
+ // Compare with expected value
|
|
|
+ #expect(
|
|
|
+ value == expectedValue,
|
|
|
+ """
|
|
|
+ Failed at \(testTime.hour):\(String(format: "%02d", testTime.minute))
|
|
|
+ Setting: \(type)
|
|
|
+ Expected: \(expectedValue)
|
|
|
+ Actual: \(value)
|
|
|
+ """
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // STEP 6: Cleanup - Restore original settings
|
|
|
+ if let originalBasalProfile = originalBasalProfile {
|
|
|
+ fileStorage.save(originalBasalProfile, as: OpenAPS.Settings.basalProfile)
|
|
|
+ }
|
|
|
+ if let originalCarbRatios = originalCarbRatios {
|
|
|
+ fileStorage.save(originalCarbRatios, as: OpenAPS.Settings.carbRatios)
|
|
|
+ }
|
|
|
+ if let originalBGTargets = originalBGTargets {
|
|
|
+ fileStorage.save(originalBGTargets, as: OpenAPS.Settings.bgTargets)
|
|
|
+ }
|
|
|
+ if let originalISFValues = originalISFValues {
|
|
|
+ fileStorage.save(originalISFValues, as: OpenAPS.Settings.insulinSensitivities)
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Copied over from BolusCalculationManager as they are not included in the protocol definition (and I don´t want them to be included)
|
|
|
+
|
|
|
+extension BolusCalculatorTests {
|
|
|
+ private enum SettingType {
|
|
|
+ case basal
|
|
|
+ case carbRatio
|
|
|
+ case bgTarget
|
|
|
+ case isf
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Retrieves current settings from the SettingsManager
|
|
|
+ /// - Returns: Tuple containing units, fraction, fattyMealFactor, sweetMealFactor, and maxCarbs settings
|
|
|
+ private func getSettings() async -> (
|
|
|
+ units: GlucoseUnits,
|
|
|
+ fraction: Decimal,
|
|
|
+ fattyMealFactor: Decimal,
|
|
|
+ sweetMealFactor: Decimal,
|
|
|
+ maxCarbs: Decimal
|
|
|
+ ) {
|
|
|
+ return (
|
|
|
+ units: settingsManager.settings.units,
|
|
|
+ fraction: settingsManager.settings.overrideFactor,
|
|
|
+ fattyMealFactor: settingsManager.settings.fattyMealFactor,
|
|
|
+ sweetMealFactor: settingsManager.settings.sweetMealFactor,
|
|
|
+ maxCarbs: settingsManager.settings.maxCarbs
|
|
|
+ )
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Gets the current setting value for a specific setting type based on the time of day
|
|
|
+ /// - Parameter type: The type of setting to retrieve (basal, carbRatio, bgTarget, or isf)
|
|
|
+ /// - Returns: The current decimal value for the specified setting type
|
|
|
+ private func getCurrentSettingValue(for type: SettingType, at date: Date) async -> Decimal {
|
|
|
+ let calendar = Calendar.current
|
|
|
+ let midnight = calendar.startOfDay(for: date)
|
|
|
+ let minutesSinceMidnight = calendar.dateComponents([.minute], from: midnight, to: date).minute ?? 0
|
|
|
+
|
|
|
+ switch type {
|
|
|
+ case .basal:
|
|
|
+ let profile = await getBasalProfile()
|
|
|
+ return profile.last { $0.minutes <= minutesSinceMidnight }?.rate ?? 0
|
|
|
+
|
|
|
+ case .carbRatio:
|
|
|
+ let ratios = await getCarbRatios()
|
|
|
+ return ratios.schedule.last { $0.offset <= minutesSinceMidnight }?.ratio ?? 0
|
|
|
+
|
|
|
+ case .bgTarget:
|
|
|
+ let targets = await getBGTargets()
|
|
|
+ return targets.targets.last { $0.offset <= minutesSinceMidnight }?.low ?? 0
|
|
|
+
|
|
|
+ case .isf:
|
|
|
+ let sensitivities = await getISFValues()
|
|
|
+ return sensitivities.sensitivities.last { $0.offset <= minutesSinceMidnight }?.sensitivity ?? 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Retrieves the pump settings from storage
|
|
|
+ /// - Returns: PumpSettings object containing pump configuration
|
|
|
+ private func getPumpSettings() async -> PumpSettings {
|
|
|
+ await fileStorage.retrieveAsync(OpenAPS.Settings.settings, as: PumpSettings.self)
|
|
|
+ ?? PumpSettings(from: OpenAPS.defaults(for: OpenAPS.Settings.settings))
|
|
|
+ ?? PumpSettings(insulinActionCurve: 10, maxBolus: 10, maxBasal: 2)
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Retrieves the basal profile from storage
|
|
|
+ /// - Returns: Array of BasalProfileEntry objects
|
|
|
+ private func getBasalProfile() async -> [BasalProfileEntry] {
|
|
|
+ await fileStorage.retrieveAsync(OpenAPS.Settings.basalProfile, as: [BasalProfileEntry].self)
|
|
|
+ ?? [BasalProfileEntry](from: OpenAPS.defaults(for: OpenAPS.Settings.basalProfile))
|
|
|
+ ?? []
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Retrieves carb ratios from storage
|
|
|
+ /// - Returns: CarbRatios object containing carb ratio schedule
|
|
|
+ private func getCarbRatios() async -> CarbRatios {
|
|
|
+ await fileStorage.retrieveAsync(OpenAPS.Settings.carbRatios, as: CarbRatios.self)
|
|
|
+ ?? CarbRatios(from: OpenAPS.defaults(for: OpenAPS.Settings.carbRatios))
|
|
|
+ ?? CarbRatios(units: .grams, schedule: [])
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Retrieves blood glucose targets from storage
|
|
|
+ /// - Returns: BGTargets object containing target schedule
|
|
|
+ private func getBGTargets() async -> BGTargets {
|
|
|
+ await fileStorage.retrieveAsync(OpenAPS.Settings.bgTargets, as: BGTargets.self)
|
|
|
+ ?? BGTargets(from: OpenAPS.defaults(for: OpenAPS.Settings.bgTargets))
|
|
|
+ ?? BGTargets(units: .mgdL, userPreferredUnits: .mgdL, targets: [])
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Retrieves insulin sensitivity factors from storage
|
|
|
+ /// - Returns: InsulinSensitivities object containing sensitivity schedule
|
|
|
+ private func getISFValues() async -> InsulinSensitivities {
|
|
|
+ await fileStorage.retrieveAsync(OpenAPS.Settings.insulinSensitivities, as: InsulinSensitivities.self)
|
|
|
+ ?? InsulinSensitivities(from: OpenAPS.defaults(for: OpenAPS.Settings.insulinSensitivities))
|
|
|
+ ?? InsulinSensitivities(
|
|
|
+ units: .mgdL,
|
|
|
+ userPreferredUnits: .mgdL,
|
|
|
+ sensitivities: []
|
|
|
+ )
|
|
|
+ }
|
|
|
+}
|
polscm32