dkist-processing-cryonirsp 1.4.20__py3-none-any.whl → 1.14.9rc1__py3-none-any.whl

dkist_processing_cryonirsp/tests/test_dark.py

@@ -7,14 +7,13 @@ from dkist_header_validator import spec122_validator
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.tasks.dark import DarkCalibration
-from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
+from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import generate_fits_frame
 from dkist_processing_cryonirsp.tests.header_models import CryonirspHeadersValidDarkFrames
 
@@ -52,7 +51,7 @@ def sp_dark_calibration_task(
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
 
             # Create fake beam border intermediate arrays
@@ -137,7 +136,7 @@ def ci_dark_calibration_task(
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
 
             # Need a beam boundary file
@@ -176,14 +175,14 @@ def ci_dark_calibration_task(
             task._purge()
 
 
-def test_sp_dark_calibration_task(sp_dark_calibration_task, mocker):
+def test_sp_dark_calibration_task(sp_dark_calibration_task, mocker, fake_gql_client):
     """
     Given: A DarkCalibration task with multiple task exposure times
     When: Calling the task instance
     Then: Only one average intermediate dark frame exists for each exposure time and unused times are not made
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # When
     (
@@ -232,14 +231,14 @@ def test_sp_dark_calibration_task(sp_dark_calibration_task, mocker):
             assert data["frames_not_used"] == 3
 
 
-def test_ci_dark_calibration_task(ci_dark_calibration_task, mocker):
+def test_ci_dark_calibration_task(ci_dark_calibration_task, mocker, fake_gql_client):
     """
     Given: A DarkCalibration task with multiple task exposure times
     When: Calling the task instance
     Then: Only one average intermediate dark frame exists for each exposure time and unused times are not made
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # When
     task, exp_conditions, unused_condition = ci_dark_calibration_task

dkist_processing_cryonirsp/tests/test_fits_access.py

@@ -0,0 +1,44 @@
+import pytest
+from dkist_header_validator.translator import translate_spec122_to_spec214_l0
+
+from dkist_processing_cryonirsp.models.fits_access import CryonirspMetadataKey
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspRampFitsAccess
+from dkist_processing_cryonirsp.parsers.cryonirsp_l1_fits_access import CryonirspL1FitsAccess
+from dkist_processing_cryonirsp.tests.header_models import Cryonirsp122ObserveFrames
+
+
+@pytest.fixture(scope="session")
+def complete_header():
+    dataset = Cryonirsp122ObserveFrames(array_shape=(1, 2, 2))
+    header = [translate_spec122_to_spec214_l0(d.header()) for d in dataset]
+    return header
+
+
+def test_metadata_keys_in_access_bases(complete_header):
+    """
+    Given: the set of metadata key names in CryonirspMetadataKey
+    When: the Cryo FITS access classes define a set of new attributes
+    Then: the sets are the same and the attributes have the correct values
+    """
+    cryo_metadata_key_names = {cmk.name for cmk in CryonirspMetadataKey}
+    all_cryo_fits_access_attrs = set()
+    for access_class in [CryonirspRampFitsAccess, CryonirspL0FitsAccess, CryonirspL1FitsAccess]:
+        fits_obj = access_class.from_header(complete_header[0])
+        cryo_instance_attrs = set(vars(fits_obj).keys())
+        parent_class = access_class.mro()[1]
+        parent_fits_obj = parent_class.from_header(complete_header[0])
+        parent_instance_attrs = set(vars(parent_fits_obj).keys())
+        cryo_fits_access_attrs = cryo_instance_attrs - parent_instance_attrs
+        # exposure_conditions is created from multiple header keys, so it is not in CryonirspMetadataKey:
+        cryo_fits_access_attrs -= {"exposure_conditions"}
+        for attr in cryo_fits_access_attrs:
+            match attr:
+                case "cn1_scan_step":
+                    assert getattr(fits_obj, attr) == int(
+                        fits_obj.header[CryonirspMetadataKey[attr]]
+                    )
+                case _:
+                    assert getattr(fits_obj, attr) == fits_obj.header[CryonirspMetadataKey[attr]]
+        all_cryo_fits_access_attrs |= cryo_fits_access_attrs
+    assert cryo_metadata_key_names == all_cryo_fits_access_attrs

dkist_processing_cryonirsp/tests/test_gain.py

@@ -8,15 +8,14 @@ from dkist_header_validator import spec122_validator
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.tasks.gain import CISolarGainCalibration
 from dkist_processing_cryonirsp.tasks.gain import LampGainCalibration
-from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
+from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import generate_fits_frame
 from dkist_processing_cryonirsp.tests.header_models import CryonirspHeadersValidLampGainFrames
 
@@ -43,7 +42,7 @@ def ci_solar_gain_calibration_task(
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
             # Need a beam boundary file
             task.write(
@@ -126,7 +125,7 @@ def lamp_calibration_task(
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
             # Need a beam boundary file
             task.write(
@@ -201,14 +200,14 @@ def lamp_calibration_task(
             task._purge()
 
 
-def test_ci_solar_gain_calibration_task(ci_solar_gain_calibration_task, mocker):
+def test_ci_solar_gain_calibration_task(ci_solar_gain_calibration_task, mocker, fake_gql_client):
     """
     Given: A CISolarGainCalibration task
     When: Calling the task instance
     Then: The correct number of output solar gain frames exists, are tagged correctly, and are not normalized
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # When
     task, solar_signal = ci_solar_gain_calibration_task
@@ -242,14 +241,14 @@ def test_ci_solar_gain_calibration_task(ci_solar_gain_calibration_task, mocker):
 
 
 @pytest.mark.parametrize("number_of_beams", [pytest.param(1, id="CI"), pytest.param(2, id="SP")])
-def test_lamp_calibration_task(lamp_calibration_task, number_of_beams, mocker):
+def test_lamp_calibration_task(lamp_calibration_task, number_of_beams, mocker, fake_gql_client):
     """
     Given: A LampGainCalibration task
     When: Calling the task instance
     Then: The correct number of output lamp gain frames exists, are tagged correctly, and are normalized
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # When
     task = lamp_calibration_task

dkist_processing_cryonirsp/tests/test_instrument_polarization.py

@@ -10,7 +10,6 @@ from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.models.task_name import TaskName
-from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_pac.fitter.polcal_fitter import PolcalFitter
 from dkist_processing_pac.input_data.dresser import Dresser
 
@@ -23,8 +22,8 @@ from dkist_processing_cryonirsp.tasks.instrument_polarization import (
 from dkist_processing_cryonirsp.tasks.instrument_polarization import (
     SPInstrumentPolarizationCalibration,
 )
-from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
+from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import generate_fits_frame
 from dkist_processing_cryonirsp.tests.header_models import CryonirspHeadersValidPolcalFrames
 
@@ -172,7 +171,7 @@ def ci_instrument_polarization_calibration_task(
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
             mocker.patch(
                 "dkist_processing_cryonirsp.tasks.instrument_polarization.PolcalFitter",
@@ -247,7 +246,10 @@ def ci_instrument_polarization_calibration_task_with_no_data(
         workflow_version="VX.Y",
     ) as task:
         try:  # This try... block is here to make sure the dbs get cleaned up if there's a failure in the fixture
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            task.scratch = WorkflowFileSystem(
+                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+            )
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
             yield task
         finally:
@@ -291,7 +293,7 @@ def sp_instrument_polarization_calibration_task(
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
             mocker.patch(
                 "dkist_processing_cryonirsp.tasks.instrument_polarization.PolcalFitter",
@@ -370,7 +372,10 @@ def sp_instrument_polarization_calibration_task_with_no_data(
         workflow_version="VX.Y",
     ) as task:
         try:  # This try... block is here to make sure the dbs get cleaned up if there's a failure in the fixture
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            task.scratch = WorkflowFileSystem(
+                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+            )
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
             yield task
         finally:
@@ -393,7 +398,9 @@ def multiple_demodulation_matrices() -> np.ndarray:
 
 
 def test_ci_instrument_polarization_calibration_task(
-    ci_instrument_polarization_calibration_task, mocker
+    ci_instrument_polarization_calibration_task,
+    mocker,
+    fake_gql_client,
 ):
     """
     Given: An InstrumentPolarizationCalibration task
@@ -402,7 +409,7 @@ def test_ci_instrument_polarization_calibration_task(
     """
 
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
 
     # When
@@ -432,7 +439,9 @@ def test_ci_instrument_polarization_calibration_task(
 
 
 def test_sp_instrument_polarization_calibration_task(
-    sp_instrument_polarization_calibration_task, mocker
+    sp_instrument_polarization_calibration_task,
+    mocker,
+    fake_gql_client,
 ):
     """
     Given: An InstrumentPolarizationCalibration task
@@ -441,7 +450,7 @@ def test_sp_instrument_polarization_calibration_task(
     """
 
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
 
     # When

dkist_processing_cryonirsp/tests/test_linearity_correction.py

@@ -1,4 +1,5 @@
 """Test the linearity correction task."""
+
 import re
 from dataclasses import dataclass
 from datetime import datetime
@@ -10,15 +11,14 @@ from dkist_header_validator import spec122_validator
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.models.tags import Tag
-from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_service_configuration.logging import logger
 
 from dkist_processing_cryonirsp.models.constants import CryonirspBudName
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.tasks.linearity_correction import LinearityCorrection
-from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
+from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import generate_fits_frame
 from dkist_processing_cryonirsp.tests.header_models import CryonirspHeadersValidNonLinearizedFrames
 
@@ -56,7 +56,7 @@ def linearity_correction(
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_class = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(task, param_class())
             ds = CryonirspHeadersValidNonLinearizedFrames(
                 arm_id=arm_id,
@@ -143,6 +143,7 @@ def linearity_correction(
 def test_linearity_correction(
     linearity_correction,
     mocker,
+    fake_gql_client,
     arm_id,
     frames_in_ramp,
     num_chunks,
@@ -154,7 +155,7 @@ def test_linearity_correction(
     Then: The non-linearized frames are linearized and produce the correct results.
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     if num_chunks == 2:
         mocker.patch(

dkist_processing_cryonirsp/tests/test_make_movie_frames.py

@@ -5,7 +5,6 @@ from astropy.io import fits
 from dkist_header_validator import spec122_validator
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.tasks.make_movie_frames import MakeCryonirspMovieFrames
@@ -90,14 +89,14 @@ def movie_frames_task(tmp_path, recipe_run_id, init_cryonirsp_constants_db, requ
             task._purge()
 
 
-def test_make_movie_frames(movie_frames_task, mocker):
+def test_make_movie_frames(movie_frames_task, mocker, fake_gql_client):
     """
     Given: A MakeCryonirspMovieFrames task
     When: Calling the task instance
     Then: a fits file is made for each scan containing the movie frame for that scan
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     task, map_scans, scan_steps, array_shape, is_polarimetric = movie_frames_task
     expected_shape = array_shape

dkist_processing_cryonirsp/tests/test_parameters.py

@@ -5,11 +5,14 @@ import numpy as np
 import pytest
 from astropy.units import Quantity
 from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.array import array_decoder
+from dkist_processing_common.models.input_dataset import InputDatasetFilePointer
+from hypothesis import HealthCheck
 from hypothesis import example
 from hypothesis import given
-from hypothesis import HealthCheck
 from hypothesis import settings
 from hypothesis import strategies as st
+from pydantic import BaseModel
 
 from dkist_processing_cryonirsp.models.parameters import CryonirspParameters
 from dkist_processing_cryonirsp.models.parameters import CryonirspParsingParameters
@@ -17,10 +20,9 @@ from dkist_processing_cryonirsp.parsers.optical_density_filters import (
     ALLOWABLE_OPTICAL_DENSITY_FILTERS,
 )
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
-from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
-from dkist_processing_cryonirsp.tests.conftest import FileParameter
 from dkist_processing_cryonirsp.tests.conftest import TestingParameters
+from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
 
 # The property names of all parameters on `CryonirspParsingParameters`
 PARSE_PARAMETER_NAMES = [
@@ -42,20 +44,18 @@ def basic_science_task_with_parameter_mixin(
         obs_ip_start_time: str = testing_obs_ip_start_time,
     ):
         class Task(CryonirspTaskBase):
-            def run(self):
-                ...
+            def run(self): ...
 
         init_cryonirsp_constants_db(recipe_run_id, CryonirspConstantsDb())
-        task = Task(
+        with Task(
             recipe_run_id=recipe_run_id,
             workflow_name="parse_cryonirsp_input_data",
             workflow_version="VX.Y",
-        )
-        try:  # This try... block is here to make sure the dbs get cleaned up if there's a failure in the fixture
+        ) as task:
             task.scratch = WorkflowFileSystem(
-                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+                scratch_base_path=tmp_path, recipe_run_id=task.recipe_run_id
             )
-            test_params = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            test_params = cryonirsp_testing_parameters_factory(task)
             param_dict = test_params()
             assign_input_dataset_doc_to_task(
                 task,
@@ -65,7 +65,6 @@ def basic_science_task_with_parameter_mixin(
                 obs_ip_start_time=obs_ip_start_time,
             )
             yield task, param_dict
-        finally:
             task._purge()
 
     return make_task
@@ -94,10 +93,11 @@ def test_filter_parameters(basic_science_task_with_parameter_mixin, wave):
     }
     for param in expected:
         assert getattr(task_params, param) == expected[param]
+    task._purge()
 
 
 def _is_file_param(param_value: Any) -> bool:
-    return isinstance(param_value, dict) and "is_file" in param_value and param_value["is_file"]
+    return isinstance(param_value, InputDatasetFilePointer)
 
 
 def test_file_parameters(basic_science_task_with_parameter_mixin):
@@ -115,18 +115,11 @@ def test_file_parameters(basic_science_task_with_parameter_mixin):
     for pn, pv in asdict(test_params).items():
         # We want to test only file parameters
         if _is_file_param(pv):
-            pn_no_prefix = pn.removeprefix("cryonirsp_")
-            # If the param name is an attribute in task_params, then load it directly
-            if hasattr(task_params, pn_no_prefix):
-                param_name = pn_no_prefix
-                actual = getattr(task_params, param_name)
-            # if the param name is not a task param attribute, then check that we can load the param
-            # using the value defined in the input_dataset_parameters list of the task param object
-            else:
-                param_dict = task_params._find_most_recent_past_value(pn)
-                actual = task_params._load_param_value_from_numpy_save(param_dict)
-            # Now get the expected value using the param value dict from the testing params
-            expected = np.load(pv["param_path"])
+            # Get the parameter value the way the tasks do
+            param_obj = task_params._find_most_recent_past_value(pn)
+            actual = task_params._load_param_value_from_numpy_save(param_obj=param_obj)
+            # Now get the expected value using the tag in the value from the testing params
+            expected = next(task.read(tags=pv.file_pointer.tag, decoder=array_decoder))
             # Compare the actual and expected values
             assert np.array_equal(actual, expected)
 
@@ -178,12 +171,11 @@ def test_arm_parameters(basic_science_task_with_parameter_mixin, arm_id):
         suffix = f"_{arm_id}".casefold()
         if _is_arm_param(pn, task_params, test_params, single_arm_only=arm_id):
             generic_param_name = pn.removeprefix("cryonirsp_").removesuffix(suffix)
-
             actual = getattr(task_params, generic_param_name)
             expected = getattr(test_params, pn)
-            if isinstance(expected, FileParameter) and expected.is_file:
-                expected = task_params._load_param_value_from_numpy_save(asdict(expected))
-                assert np.array_equal(expected, actual)
+            if isinstance(expected, InputDatasetFilePointer):
+                expected_array = task_params._load_param_value_from_numpy_save(param_obj=expected)
+                assert np.array_equal(expected_array, actual)
             elif isinstance(actual, np.ndarray):
                 assert expected == actual.tolist()
             else:
@@ -207,9 +199,12 @@ def test_parameters(basic_science_task_with_parameter_mixin):
             or parameter_name in PARSE_PARAMETER_NAMES
         ):
             continue
+
         accessed_parameter_value = getattr(task_params, parameter_name)
         if isinstance(accessed_parameter_value, Quantity):
             assert pv == accessed_parameter_value.value
+        elif isinstance(accessed_parameter_value, BaseModel):
+            assert accessed_parameter_value.model_dump() == pv
         else:
             assert pv == getattr(task_params, parameter_name)
 

dkist_processing_cryonirsp/tests/test_parse.py

@@ -11,7 +11,6 @@ from astropy.io import fits
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.models.constants import BudName
 from dkist_processing_common.tasks import WorkflowTaskBase
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_cryonirsp.models.constants import CryonirspBudName
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
@@ -88,6 +87,8 @@ def write_solar_gain_frames_to_task(
     array_shape=(2, 2, 1),
     tags: list[str] | None = None,
     num_modstates: int = 1,
+    center_wavelength: float = 1080.0,
+    slit_width: float = 52.0,
 ):
     num_frames = 0
     for modstate in range(1, num_modstates + 1):
@@ -96,6 +97,8 @@ def write_solar_gain_frames_to_task(
             exposure_condition=exposure_condition,
             num_modstates=num_modstates,
             modstate=modstate,
+            center_wavelength=center_wavelength,
+            slit_width=slit_width,
         )
 
         num_frames += _write_frames_to_task(
@@ -125,7 +128,8 @@ def write_polcal_frames_to_task(
                 modstate=mod_state,
                 array_shape=array_shape,
                 exposure_condition=exposure_condition,
-                extra_headers=extra_headers,
+                extra_headers={"PAC__006": "clear" if num_frames % 2 else "Cool retarder"}
+                | extra_headers,
             )
 
             _write_frames_to_task(task=task, frame_generator=frame_generator, extra_tags=tags)
@@ -145,6 +149,8 @@ def write_observe_frames_to_task(
     exposure_condition: ExposureConditions,
     change_translated_headers: Callable[[fits.Header | None], fits.Header] = lambda x: x,
     array_shape=(2, 2, 1),
+    center_wavelength: float = 1080.0,
+    slit_width: float = 52.0,
     tags: list[str] | None = None,
 ):
     num_frames = 0
@@ -173,6 +179,8 @@ def write_observe_frames_to_task(
                             num_meas=num_measurements,
                             meas_num=measurement,
                             arm_id=arm_id,
+                            center_wavelength=center_wavelength,
+                            slit_width=slit_width,
                         )
                         start_time += frame_delta_time
 
@@ -249,8 +257,12 @@ def make_linearized_test_frames(
     num_map_scans: int = 1,
     num_sub_repeats: int = 1,
     num_measurements: int = 1,
+    center_wavelength: float = 1080.0,
+    slit_width: float = 52.0,
     extra_headers: dict | None = None,
 ):
+    if extra_headers is None:
+        extra_headers = dict()
     num_dark = 0
     num_polcal = 0
     num_obs = 0
@@ -268,13 +280,15 @@ def make_linearized_test_frames(
         task,
         tags=lin_tag,
         exposure_condition=lamp_exposure_condition,
-        num_modstates=num_modstates or 1,  # We *always* need dark frames
+        num_modstates=num_modstates or 1,  # We *always* need lamp frames
     )
     num_solar = write_solar_gain_frames_to_task(
         task,
         tags=lin_tag,
         exposure_condition=solar_exposure_condition,
-        num_modstates=num_modstates or 1,  # We *always* need dark frames
+        num_modstates=num_modstates or 1,  # We *always* need solar frames
+        center_wavelength=center_wavelength,
+        slit_width=slit_width,
     )
 
     num_polcal += write_polcal_frames_to_task(
@@ -296,6 +310,8 @@ def make_linearized_test_frames(
         num_measurements=num_measurements,
         tags=lin_tag,
         change_translated_headers=change_translated_headers,
+        center_wavelength=center_wavelength,
+        slit_width=slit_width,
     )
 
     return num_dark, num_lamp, num_solar, num_polcal, num_obs
@@ -328,10 +344,10 @@ def make_non_linearized_test_frames(
 
 @pytest.fixture
 def parse_linearized_task(
-    tmp_path, recipe_run_id, assign_input_dataset_doc_to_task, mocker, arm_id
+    tmp_path, recipe_run_id, assign_input_dataset_doc_to_task, mocker, fake_gql_client, arm_id
 ):
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     if arm_id == "CI":
         parsing_class = ParseL0CryonirspCILinearizedData
@@ -346,7 +362,7 @@ def parse_linearized_task(
             task.scratch = WorkflowFileSystem(
                 scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
             )
-            param_dataclass = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_dataclass = cryonirsp_testing_parameters_factory(task)
             assign_input_dataset_doc_to_task(
                 task,
                 param_dataclass(),
@@ -359,9 +375,9 @@ def parse_linearized_task(
 
 
 @pytest.fixture
-def parse_non_linearized_task(tmp_path, recipe_run_id, mocker):
+def parse_non_linearized_task(tmp_path, recipe_run_id, mocker, fake_gql_client):
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     with ParseL0CryonirspRampData(
         recipe_run_id=recipe_run_id,
@@ -964,6 +980,7 @@ def test_parse_cryonirsp_linearized_incomplete_raster_scan(
 
     assert task.constants._db_dict[CryonirspBudName.num_scan_steps.value] == num_scan_steps - 1
     assert task.constants._db_dict[CryonirspBudName.num_map_scans.value] == num_map_scans
+    assert task.constants._db_dict[CryonirspBudName.num_meas.value] == 2
 
 
 @pytest.mark.parametrize("arm_id", ["CI", "SP"])
@@ -1197,6 +1214,8 @@ def test_parse_cryonirsp_linearized_data_constants(
     num_scan_steps = 3
     num_map_scans = 2
     num_sub_repeats = 2
+    center_wavelength = 1234.0
+    slit_width = 6.28
 
     make_linearized_test_frames(
         task,
@@ -1210,6 +1229,8 @@ def test_parse_cryonirsp_linearized_data_constants(
         solar_exposure_condition=solar_exp_cond,
         polcal_exposure_condition=polcal_exp_cond,
         observe_exposure_condition=obs_exp_cond,
+        center_wavelength=center_wavelength,
+        slit_width=slit_width,
     )
 
     task()
@@ -1244,6 +1265,21 @@ def test_parse_cryonirsp_linearized_data_constants(
     assert task.constants._db_dict["MAXIMUM_CADENCE"] == 10
     assert task.constants._db_dict["MINIMUM_CADENCE"] == 10
     assert task.constants._db_dict["VARIANCE_CADENCE"] == 0
+    assert task.constants._db_dict[BudName.retarder_name] == "Cool retarder"
+    if arm_id == "SP":
+        assert (
+            task.constants._db_dict[CryonirspBudName.center_wavelength.value] == center_wavelength
+        )
+        assert task.constants._db_dict[CryonirspBudName.slit_width.value] == slit_width
+        assert (
+            task.constants._db_dict[CryonirspBudName.grating_constant.value] == 770970.3576216539
+        )  # From `SimpleModulatedHeaders`
+
+    assert task.constants._db_dict["CAMERA_NAME"] == "camera_name"
+    assert task.constants._db_dict["DARK_GOS_LEVEL3_STATUS"] == "lamp"
+    assert task.constants._db_dict["SOLAR_GAIN_GOS_LEVEL3_STATUS"] == "clear"
+    assert task.constants._db_dict["SOLAR_GAIN_NUM_RAW_FRAMES_PER_FPA"] == 10
+    assert task.constants._db_dict["POLCAL_NUM_RAW_FRAMES_PER_FPA"] == 10
 
 
 @pytest.mark.parametrize("arm_id", ["SP"])
@@ -1277,9 +1313,9 @@ def test_parse_cryonirsp_linearized_data_internal_scan_loops_as_map_scan_and_sca
     num_alt_scan_steps = 3
 
     def make_dual_scan_loop_headers(translated_header):
-        translated_header[
-            "CNP2DSS"
-        ] = 0.0  # This triggers the parsing of the dual internal scan loops
+        translated_header["CNP2DSS"] = (
+            0.0  # This triggers the parsing of the dual internal scan loops
+        )
         translated_header["CNP1DNSP"] = num_alt_scan_steps  # inner loop -- becomes num scan steps
         translated_header["CNP2DNSP"] = num_alt_maps  # outer loop -- becomes num map scans
         translated_header["CNP1DCUR"] = (translated_header["CNCURSCN"] - 1) % num_alt_scan_steps + 1