fix: Fixes crashes when estimating pressures with a filter pressure drop.

Sources/EstimatedPressureDependency/Key.swift

@@ -144,45 +144,47 @@ extension EstimatedPressureDependency {
     }
   }
   
+  private func setFilterPressureDrop(
+    _ filterDrop: Positive<Double>,
+    measurement: inout EquipmentMeasurement
+  ) {
+    switch measurement {
+    case var .airHandler(airHandler):
+      airHandler.postFilterPressure = airHandler.returnPlenumPressure +
+      filterDrop.positiveValue
+      measurement = .airHandler(airHandler)
+    case var .furnaceAndCoil(furnace):
+      furnace.postFilterPressure = furnace.returnPlenumPressure + filterDrop.positiveValue
+      measurement = .furnaceAndCoil(furnace)
+    }
+  }
+
   public func estimatedPressure(
     equipmentMeasurement: EquipmentMeasurement,
     airflow updatedAirflow: Positive<Double>,
-    filterPressureDrop: Positive<Double>
+    filterPressureDrop: Positive<Double>?
   ) async throws -> EquipmentMeasurement {
-    let estimate = try await estimatedPressure(
+    var estimate = try await estimatedPressure(
       equipmentMeasurement: equipmentMeasurement,
       airflow: updatedAirflow.positiveValue
     )
-
+    guard let filterPressureDrop else { return estimate }
-    switch estimate {
+    setFilterPressureDrop(filterPressureDrop, measurement: &estimate)
-
+    return estimate
-    case var .airHandler(airHandler):
-      airHandler.postFilterPressure = airHandler.returnPlenumPressure + filterPressureDrop.positiveValue
-      return .airHandler(airHandler)
-
-    case var .furnaceAndCoil(furnaceAndCoil):
-      furnaceAndCoil.postFilterPressure = furnaceAndCoil.returnPlenumPressure + filterPressureDrop.positiveValue
-      return .furnaceAndCoil(furnaceAndCoil)
-    }
   }
   
   public func estimatedPressure(
     equipmentMeasurement: EquipmentMeasurement,
     airflow updatedAirflow: Double,
-    filterPressureDrop: Positive<Double>?
+    filterPressureDrop: Double?
   ) async throws -> EquipmentMeasurement {
-    guard let filterPressureDrop else {
+    try await estimatedPressure(
-      return try await estimatedPressure(
-        equipmentMeasurement: equipmentMeasurement,
-        airflow: updatedAirflow
-      )
-    }
-    return try await estimatedPressure(
       equipmentMeasurement: equipmentMeasurement,
-      airflow: updatedAirflow,
+      airflow: Positive(updatedAirflow),
-      filterPressureDrop: Positive(filterPressureDrop.positiveValue)
+      filterPressureDrop: filterPressureDrop != nil ? Positive(filterPressureDrop!) : nil
     )
   }
+
 }
 
 extension EstimatedPressureDependency: DependencyKey {

Sources/PressureEstimationsFeature/FlaggedMeasurementsList.swift

@@ -298,7 +298,7 @@ public struct FlaggedMeasurementsList: Sendable {
 
     let measurement = try await estimatedPressuresClient.estimatedPressure(
       equipmentMeasurement: equipmentMeasurement,
-      airflow: airflow,
+      airflow: Positive(airflow),
       filterPressureDrop: filterPressureDrop
     )
 

Tests/PressureEstimationsFeatureTests/FlaggedMeasurementListTests.swift

@@ -23,46 +23,84 @@ struct FlaggedMeasurementListStateTests {
     #expect(result != nil)
   }
   
+   @Test(
+    "Pressure Estimation",
+    .tags(.flaggedMeasurementList),
+    arguments: [
+      (EquipmentMeasurement.EquipmentType.airHandler, Optional<Double>.none),
+      (.furnaceAndCoil, nil),
+      (.airHandler, 0.1),
+      (.furnaceAndCoil, 0.1),
+    ]
+  )
+  func pressureEstimation(
+    equipmentType: EquipmentMeasurement.EquipmentType,
+    filterPressureDrop: Double?
+  ) async throws {
+    try await withDependencies {
+      $0.estimatedPressuresClient = .liveValue
+    } operation: {
+      @Dependency(\.estimatedPressuresClient) var client
+      let equipmentMeasurement = EquipmentMeasurement.mock(type: equipmentType)
+      
+      let measurement = try await client.estimatedPressure(
+        equipmentMeasurement: equipmentMeasurement,
+        airflow: 1050,
+        filterPressureDrop: filterPressureDrop
+      )
+      
+      print(measurement)
+      #expect(measurement.equipmentType == equipmentType)
+      #expect(measurement.manufacturersIncludedFilterPressureDrop == equipmentMeasurement.manufacturersIncludedFilterPressureDrop)
+    }
+  }
+  
   @Test(
     "Handle Estimation Form",
-    .tags(.flaggedMeasurementList)
+    .tags(.flaggedMeasurementList),
+    arguments: [nil, 0.1]
   )
-  func handleEstimationForm() async throws {
+  func handleEstimationForm(filterPressureDrop: Double?) async throws {
     try await withDependencies {
       $0.estimatedPressuresClient = .liveValue
       $0.uuid = .incrementing
     } operation: {
       @Dependency(\.estimatedPressuresClient) var client
       
+      let equipmentMeasurement = EquipmentMeasurement.mock(type: .airHandler)
+      let budgets = BudgetedPercentEnvelope(equipmentType: .airHandler, fanType: .constantSpeed)
+      let flaggedMeasurement = EquipmentMeasurement.FlaggedMeasurement(
+        budgets: budgets,
+        measurement: equipmentMeasurement,
+        ratedPressures: .init(),
+        tons: .three
+      )
+      
       let reducer = FlaggedMeasurementsList()
       let result = try await reducer._handleEstimationForm(
         form: .init(
-          existingMeasurement: SharedReader(Shared(.mock(type: .airHandler))),
+          existingMeasurement: SharedReader(Shared(equipmentMeasurement)),
           cfmTextField: 350,
+          filterPressureDrop: filterPressureDrop,
           name: "Test"
         ),
         state: .init(sharedSettings: Shared(.init(
-          budgets: .init(equipmentType: .airHandler, fanType: .constantSpeed),
+          budgets: budgets,
-          equipmentMeasurement: .mock(type: .airHandler),
+          equipmentMeasurement: equipmentMeasurement,
-          flaggedEquipmentMeasurement: .init(
+          flaggedEquipmentMeasurement: flaggedMeasurement
-            budgets: .init(equipmentType: .airHandler, fanType: .constantSpeed),
-            measurement: .mock(type: .airHandler),
-            ratedPressures: .init(),
-            tons: .three
-          )
         )))
       )
       
       let measurement = try await client.estimatedPressure(
-        equipmentMeasurement: .mock(type: .airHandler),
+        equipmentMeasurement: equipmentMeasurement,
         airflow: 1050,
-        filterPressureDrop: 0.1
+        filterPressureDrop: filterPressureDrop
       )
       
       #expect(result != nil)
       #expect(result?.estimationState == .init(
         cfm: .cfmPerTon(350, .three),
-        filterPressureDrop: 0.1,
+        filterPressureDrop: filterPressureDrop,
         name: "Test"
       ))
       
@@ -206,6 +244,57 @@ final class FlaggedMeasurementListReducerTests: XCTestCase {
 //      }
 //  
 //    }
+  
+  
+  @MainActor
+  func testPressureEstimation() async throws {
+    _ = try await pressureEstimation(
+      equipmentType: .airHandler,
+      filterPressureDrop: 0.1
+    )
+//    XCTFail()
+  }
+  
+  
+  private func pressureEstimation(
+    equipmentType: EquipmentMeasurement.EquipmentType,
+    filterPressureDrop: Double?
+  ) async throws -> EquipmentMeasurement {
+    try await withDependencies {
+      $0.estimatedPressuresClient = .liveValue
+    } operation: {
+      @Dependency(\.estimatedPressuresClient) var client
+      let equipmentMeasurement = EquipmentMeasurement.mock(type: equipmentType)
+      
+      var estimate = try await client.estimatedPressure(
+        equipmentMeasurement: equipmentMeasurement,
+        airflow: 1050
+      )
+      
+      guard let filterPressureDrop else { return estimate }
+      setFilterPressureDrop(Positive(filterPressureDrop), measurement: &estimate)
+      return estimate
+      
+    }
+  }
+  
+  private func setFilterPressureDrop(
+    _ filterDrop: Positive<Double>,
+    measurement: inout EquipmentMeasurement
+  ) {
+    switch measurement {
+    case var .airHandler(airHandler):
+//      let newPressure = airHandler.$returnPlenumPressure + filterDrop
+//      print("newPressure: \(newPressure)")
+      airHandler.postFilterPressure = airHandler.returnPlenumPressure +
+      filterDrop.positiveValue
+      measurement = .airHandler(airHandler)
+    case var .furnaceAndCoil(furnace):
+      furnace.postFilterPressure = furnace.returnPlenumPressure + filterDrop.positiveValue
+      measurement = .furnaceAndCoil(furnace)
+    }
+  }
+  
 }
 
 extension Tag {