dkist-processing-visp 2.20.14__py3-none-any.whl → 5.1.1__py3-none-any.whl

dkist_processing_visp/tests/test_parameters.py

@@ -1,13 +1,15 @@
 from dataclasses import asdict
 from dataclasses import dataclass
 
+import astropy.units as u
 import numpy as np
 import pytest
+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_visp.models.parameters import VispParameters
 from dkist_processing_visp.models.parameters import VispParsingParameters
@@ -15,10 +17,27 @@ from dkist_processing_visp.tasks.visp_base import VispTaskBase
 from dkist_processing_visp.tests.conftest import VispConstantsDb
 from dkist_processing_visp.tests.conftest import VispInputDatasetParameterValues
 
-# The property names of all parameters on `VispParsingParameters`
-PARSE_PARAMETER_NAMES = [
-    k for k, v in vars(VispParsingParameters).items() if isinstance(v, property)
-]
+
+@pytest.fixture(scope="session")
+def parse_parameter_names() -> list[str]:
+    # The property names of all parameters on `VispParsingParameters`
+    return [k for k, v in vars(VispParsingParameters).items() if isinstance(v, property)]
+
+
+@pytest.fixture(scope="session")
+def arm_parameter_names() -> list[str]:
+    return [
+        "wavecal_camera_lens_parameters",
+    ]
+
+
+@pytest.fixture(scope="session")
+def unit_parameter_names_and_units() -> dict[str, u.Unit | list[u.Unit]]:
+    return {
+        "solar_vignette_crval_bounds_px": u.pix,
+        "wavecal_camera_lens_parameters": [u.m, u.m / u.nm, u.m / u.nm**2],
+        "wavecal_pixel_pitch_micron_per_pix": u.um / u.pix,
+    }
 
 
 @pytest.fixture(scope="function")
@@ -27,6 +46,7 @@ def basic_science_task_with_parameter_mixin(
     assign_input_dataset_doc_to_task,
     init_visp_constants_db,
     testing_obs_ip_start_time,
+    arm_id,
 ):
     def make_task(
         parameters_part: dataclass,
@@ -34,8 +54,7 @@ def basic_science_task_with_parameter_mixin(
         obs_ip_start_time=testing_obs_ip_start_time,
     ):
         class Task(VispTaskBase):
-            def run(self):
-                ...
+            def run(self): ...
 
         init_visp_constants_db(recipe_run_id, VispConstantsDb())
         task = Task(
@@ -49,8 +68,9 @@ def basic_science_task_with_parameter_mixin(
                 parameters_part,
                 parameter_class=parameter_class,
                 obs_ip_start_time=obs_ip_start_time,
+                arm_id=arm_id,
             )
-            yield task, parameters_part
+            yield task, asdict(parameters_part)
         except:
             raise
         finally:
@@ -59,7 +79,14 @@ def basic_science_task_with_parameter_mixin(
     return make_task
 
 
-def test_non_wave_parameters(basic_science_task_with_parameter_mixin):
+@pytest.mark.parametrize("arm_id", [pytest.param("1"), pytest.param("2"), pytest.param("3")])
+def test_non_wave_parameters(
+    basic_science_task_with_parameter_mixin,
+    parse_parameter_names,
+    arm_parameter_names,
+    unit_parameter_names_and_units,
+    arm_id,
+):
     """
     Given: A Science task with the parameter mixin
     When: Accessing properties for parameters that do not depend on wavelength
@@ -69,15 +96,41 @@ def test_non_wave_parameters(basic_science_task_with_parameter_mixin):
         basic_science_task_with_parameter_mixin(VispInputDatasetParameterValues())
     )
     task_param_attr = task.parameters
-    for pn, pv in asdict(expected).items():
-        property_name = pn.removeprefix("visp_")
+    parameter_properties = [k for k, v in vars(VispParameters).items() if isinstance(v, property)]
+    for parameter_name in parameter_properties:
+        pn = f"visp_{parameter_name}"
+        if parameter_name in arm_parameter_names:
+            pn = f"{pn}_{arm_id}"
+        pv = expected[pn]
+        is_wavelength_param = isinstance(pv, dict) and "wavelength" in pv
         if (
-            type(pv) is not dict and property_name not in PARSE_PARAMETER_NAMES
-        ):  # Don't test wavelength dependent parameters
-            assert getattr(task_param_attr, property_name) == pv
+            parameter_name not in parse_parameter_names
+            and not is_wavelength_param
+            and parameter_name != "solar_vignette_wavecal_fit_kwargs"
+        ):
+            param_obj_value = getattr(task_param_attr, parameter_name)
+            if isinstance(pv, tuple):
+                pv = list(pv)
 
+            if parameter_name in unit_parameter_names_and_units:
+                expected_units = unit_parameter_names_and_units[parameter_name]
+                if not isinstance(param_obj_value, list):
+                    param_obj_value = [param_obj_value]
+                    pv = [pv]
+                    expected_units = [expected_units]
 
-def test_parse_parameters(basic_science_task_with_parameter_mixin):
+                assert all([param_obj_value[i].value == pv[i] for i in range(len(pv))])
+                assert all(
+                    [param_obj_value[i].unit == expected_units[i] for i in range(len(pv))]
+                ), f"Units {[v.unit for v in param_obj_value]} does not match expected {expected_units}"
+            elif isinstance(param_obj_value, BaseModel):
+                assert param_obj_value.model_dump() == pv
+            else:
+                assert getattr(task_param_attr, parameter_name) == pv
+
+
+@pytest.mark.parametrize("arm_id", ["1"])
+def test_parse_parameters(basic_science_task_with_parameter_mixin, parse_parameter_names):
     """
     Given: A Science task with Parsing parameters
     When: Accessing properties for Parse parameters
@@ -91,16 +144,19 @@ def test_parse_parameters(basic_science_task_with_parameter_mixin):
         )
     )
     task_param_attr = task.parameters
-    for pn, pv in asdict(expected).items():
+    for pn, pv in expected.items():
         property_name = pn.removeprefix("visp_")
-        if property_name in PARSE_PARAMETER_NAMES and type(pv) is not dict:
+        if property_name in parse_parameter_names and type(pv) is not dict:
             assert getattr(task_param_attr, property_name) == pv
 
 
 @given(wave=st.floats(min_value=500.0, max_value=2000.0))
 @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
 @example(wave=492.5)
-def test_wave_parameters(basic_science_task_with_parameter_mixin, wave):
+@pytest.mark.parametrize("arm_id", ["1"])
+def test_wave_parameters(
+    basic_science_task_with_parameter_mixin, parse_parameter_names, arm_parameter_names, wave
+):
     """
     Given: A Science task with the paramter mixin
     When: Accessing properties for parameters that depend on wavelength
@@ -111,10 +167,55 @@ def test_wave_parameters(basic_science_task_with_parameter_mixin, wave):
     )
     task_param_attr = task.parameters
     task_param_attr._wavelength = wave
-    pwaves = np.array(expected.visp_solar_zone_normalization_percentile.wavelength)
+    pwaves = np.array(expected["visp_geo_zone_normalization_percentile"]["wavelength"])
     midpoints = 0.5 * (pwaves[1:] + pwaves[:-1])
     idx = np.sum(midpoints < wave)
-    for pn, pv in asdict(expected).items():
+    for pn, pv in expected.items():
         property_name = pn.removeprefix("visp_")
-        if type(pv) is dict and property_name not in PARSE_PARAMETER_NAMES:
+        is_wavelength_param = isinstance(pv, dict) and "wavelength" in pv
+        if is_wavelength_param and property_name not in parse_parameter_names + arm_parameter_names:
             assert getattr(task_param_attr, property_name) == pv["values"][idx]
+
+
+class AnyInt:
+    pass
+
+
+@pytest.mark.parametrize("arm_id", [pytest.param("1")])
+@pytest.mark.parametrize(
+    "db_value, expected",
+    [
+        pytest.param({"method": "nelder"}, {"method": "nelder"}, id="non_rng_method"),
+        pytest.param(
+            {"method": "basinhopping"}, {"method": "basinhopping", "rng": AnyInt}, id="random_rng"
+        ),
+        pytest.param(
+            {"method": "differential_evolution", "rng": 6.28},
+            {"method": "differential_evolution", "rng": 6.28},
+            id="override_rng",
+        ),
+        pytest.param(dict(), dict(), id="no_kwargs"),
+    ],
+)
+def test_fit_kwarg_parameters(
+    basic_science_task_with_parameter_mixin,
+    db_value,
+    expected,
+):
+    """
+    Given: A Science task with the parameter mixin
+    When: Accessing properties for parameters that do not depend on wavelength
+    Then: The correct value is returned
+    """
+    task, _ = next(
+        basic_science_task_with_parameter_mixin(
+            VispInputDatasetParameterValues(visp_solar_vignette_wavecal_fit_kwargs=db_value)
+        )
+    )
+    kwarg_dict = task.parameters.solar_vignette_wavecal_fit_kwargs
+    assert kwarg_dict.keys() == expected.keys()
+    for k in expected.keys():
+        if expected[k] is AnyInt:
+            assert type(kwarg_dict[k]) is int
+        else:
+            assert expected[k] == kwarg_dict[k]

dkist_processing_visp/tests/test_parse.py

@@ -2,7 +2,6 @@ import pytest
 from dkist_data_simulator.dataset import key_function
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.models.tags import Tag
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_visp.models.parameters import VispParsingParameters
 from dkist_processing_visp.models.tags import VispTag
@@ -11,7 +10,9 @@ from dkist_processing_visp.tests.conftest import VispInputDatasetParameterValues
 from dkist_processing_visp.tests.conftest import write_frames_to_task
 from dkist_processing_visp.tests.header_models import VispHeadersInputDarkFrames
 from dkist_processing_visp.tests.header_models import VispHeadersInputLampGainFrames
+from dkist_processing_visp.tests.header_models import VispHeadersInputPolcalDarkFrames
 from dkist_processing_visp.tests.header_models import VispHeadersInputPolcalFrames
+from dkist_processing_visp.tests.header_models import VispHeadersInputPolcalGainFrames
 from dkist_processing_visp.tests.header_models import VispHeadersInputSolarGainFrames
 from dkist_processing_visp.tests.header_models import VispHeadersValidObserveFrames
 
@@ -40,13 +41,11 @@ def observe_readout_exp_times() -> list[float]:
 def required_dark_readout_exp_times(
     lamp_readout_exp_time,
     solar_readout_exp_time,
-    polcal_readout_exp_time,
     observe_readout_exp_times,
 ) -> list[float]:
     return [
         lamp_readout_exp_time,
         solar_readout_exp_time,
-        polcal_readout_exp_time,
     ] + observe_readout_exp_times
 
 
@@ -87,6 +86,7 @@ def write_input_dark_frames_to_task(
     time_delta: float = 10.0,
     num_modstates: int = 2,
     data_shape: tuple[int, int] = (2, 2),
+    **kwargs,
 ):
     array_shape = (1, *data_shape)
     dataset = VispHeadersInputDarkFrames(
@@ -95,6 +95,7 @@ def write_input_dark_frames_to_task(
         exp_time=exp_time,
         readout_exp_time=readout_exp_time,
         num_modstates=num_modstates,
+        **kwargs,
     )
 
     num_written_frames = write_frames_to_task(
@@ -110,6 +111,7 @@ def write_input_lamp_frames_to_task(
     time_delta: float = 10.0,
     num_modstates: int = 2,
     data_shape: tuple[int, int] = (2, 2),
+    **kwargs,
 ):
     array_shape = (1, *data_shape)
     dataset = VispHeadersInputLampGainFrames(
@@ -118,6 +120,7 @@ def write_input_lamp_frames_to_task(
         exp_time=exp_time,
         readout_exp_time=readout_exp_time,
         num_modstates=num_modstates,
+        **kwargs,
     )
 
     num_written_frames = write_frames_to_task(
@@ -133,6 +136,7 @@ def write_input_solar_frames_to_task(
     time_delta: float = 10.0,
     num_modstates: int = 2,
     data_shape: tuple[int, int] = (2, 2),
+    **kwargs,
 ):
     array_shape = (1, *data_shape)
     dataset = VispHeadersInputSolarGainFrames(
@@ -141,6 +145,7 @@ def write_input_solar_frames_to_task(
         exp_time=exp_time,
         readout_exp_time=readout_exp_time,
         num_modstates=num_modstates,
+        **kwargs,
     )
 
     num_written_frames = write_frames_to_task(
@@ -156,6 +161,7 @@ def write_input_polcal_frames_to_task(
     time_delta: float = 30.0,
     num_modstates: int = 2,
     data_shape: tuple[int, int] = (2, 2),
+    **kwargs,
 ):
     array_shape = (1, *data_shape)
     dataset = VispHeadersInputPolcalFrames(
@@ -164,6 +170,57 @@ def write_input_polcal_frames_to_task(
         exp_time=exp_time,
         readout_exp_time=readout_exp_time,
         num_modstates=num_modstates,
+        **kwargs,
+    )
+
+    num_written_frames = write_frames_to_task(
+        task=task, frame_generator=dataset, extra_tags=[VispTag.input()]
+    )
+    return num_written_frames
+
+
+def write_input_polcal_dark_frames_to_task(
+    task,
+    readout_exp_time: float,
+    exp_time: float,
+    time_delta: float = 30.0,
+    num_modstates: int = 2,
+    data_shape: tuple[int, int] = (2, 2),
+    **kwargs,
+):
+    array_shape = (1, *data_shape)
+    dataset = VispHeadersInputPolcalDarkFrames(
+        array_shape=array_shape,
+        time_delta=time_delta,
+        exp_time=exp_time,
+        readout_exp_time=readout_exp_time,
+        num_modstates=num_modstates,
+        **kwargs,
+    )
+
+    num_written_frames = write_frames_to_task(
+        task=task, frame_generator=dataset, extra_tags=[VispTag.input()]
+    )
+    return num_written_frames
+
+
+def write_input_polcal_gain_frames_to_task(
+    task,
+    readout_exp_time: float,
+    exp_time: float,
+    time_delta: float = 30.0,
+    num_modstates: int = 2,
+    data_shape: tuple[int, int] = (2, 2),
+    **kwargs,
+):
+    array_shape = (1, *data_shape)
+    dataset = VispHeadersInputPolcalGainFrames(
+        array_shape=array_shape,
+        time_delta=time_delta,
+        exp_time=exp_time,
+        readout_exp_time=readout_exp_time,
+        num_modstates=num_modstates,
+        **kwargs,
     )
 
     num_written_frames = write_frames_to_task(
@@ -182,6 +239,7 @@ def write_input_observe_frames_to_task(
     time_delta: float = 10.0,
     data_shape: tuple[int, int] = (2, 2),
     obs_dataset_class=VispHeadersValidObserveFrames,
+    **kwargs,
 ):
     array_shape = (1, *data_shape)
     dataset = obs_dataset_class(
@@ -192,6 +250,7 @@ def write_input_observe_frames_to_task(
         num_modstates=num_modstates,
         exp_time=exp_time,
         readout_exp_time=readout_exp_time,
+        **kwargs,
     )
     num_written_frames = write_frames_to_task(
         task=task, frame_generator=dataset, extra_tags=[VispTag.input()]
@@ -227,6 +286,11 @@ def write_input_cal_frames_to_task(
     solar_exp_time,
     polcal_exp_time,
     num_modstates,
+    testing_arm_id,
+    testing_solar_ip_start_time,
+    testing_grating_constant,
+    testing_grating_angle,
+    testing_arm_position,
 ):
     def write_frames_to_task(task):
         for readout_exp_time in required_dark_readout_exp_times:
@@ -235,6 +299,7 @@ def write_input_cal_frames_to_task(
                 readout_exp_time=readout_exp_time,
                 exp_time=dark_exp_time,
                 num_modstates=num_modstates,
+                arm_id=testing_arm_id,
             )
 
         write_input_lamp_frames_to_task(
@@ -242,18 +307,39 @@ def write_input_cal_frames_to_task(
             readout_exp_time=lamp_readout_exp_time,
             exp_time=lamp_exp_time,
             num_modstates=num_modstates,
+            arm_id=testing_arm_id,
         )
         write_input_solar_frames_to_task(
             task=task,
             readout_exp_time=solar_readout_exp_time,
             exp_time=solar_exp_time,
             num_modstates=num_modstates,
+            arm_id=testing_arm_id,
+            ip_start_time=testing_solar_ip_start_time,
+            grating_constant=testing_grating_constant,
+            grating_angle=testing_grating_angle,
+            arm_position=testing_arm_position,
         )
         write_input_polcal_frames_to_task(
             task=task,
             readout_exp_time=polcal_readout_exp_time,
             exp_time=polcal_exp_time,
             num_modstates=num_modstates,
+            arm_id=testing_arm_id,
+        )
+        write_input_polcal_dark_frames_to_task(
+            task=task,
+            readout_exp_time=polcal_readout_exp_time,
+            exp_time=polcal_exp_time,
+            num_modstates=num_modstates,
+            arm_id=testing_arm_id,
+        )
+        write_input_polcal_gain_frames_to_task(
+            task,
+            readout_exp_time=polcal_readout_exp_time,
+            exp_time=polcal_exp_time,
+            num_modstates=num_modstates,
+            arm_id=testing_arm_id,
         )
 
     return write_frames_to_task
@@ -292,6 +378,11 @@ def test_parse_visp_input_data(
     observe_exp_times,
     num_modstates,
     mocker,
+    fake_gql_client,
+    testing_arm_id,
+    testing_grating_constant,
+    testing_grating_angle,
+    testing_arm_position,
 ):
     """
     Given: A ParseVispInputData task
@@ -299,7 +390,7 @@ def test_parse_visp_input_data(
     Then: All tagged files exist and individual task tags are applied
     """
     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 = parse_task_with_no_data
     write_input_cal_frames_to_task(task)
@@ -311,6 +402,10 @@ def test_parse_visp_input_data(
             num_steps=3,
             readout_exp_time=obs_readout_exp_time,
             exp_time=obs_exp_time,
+            arm_id=testing_arm_id,
+            grating_constant=testing_grating_constant,
+            grating_angle=testing_grating_angle,
+            arm_position=testing_arm_position,
         )
 
     # When
@@ -323,14 +418,19 @@ def test_parse_visp_input_data(
     assert list(task.read(tags=[Tag.input(), Tag.task_dark()]))
     assert list(task.read(tags=[Tag.input(), Tag.task_lamp_gain()]))
     assert list(task.read(tags=[Tag.input(), Tag.task_solar_gain()]))
-    assert list(task.read(tags=[Tag.input(), Tag.task_polcal()]))
+    assert (
+        len(list(task.read(tags=[Tag.input(), Tag.task_polcal()]))) == 6
+    )  # 2 polcal observes, 2 darks, 2 gains
     assert list(task.read(tags=[Tag.input(), Tag.task_observe()]))
+    assert len(list(task.read(tags=[Tag.input(), Tag.task_polcal_dark()]))) == 2  # 2 polcal darks
+    assert len(list(task.read(tags=[Tag.input(), Tag.task_polcal_gain()]))) == 2  # 2 polcal gains
 
 
 def test_parse_visp_input_data_constants(
     parse_task_with_no_data,
     write_input_cal_frames_to_task,
     mocker,
+    fake_gql_client,
     lamp_readout_exp_time,
     solar_readout_exp_time,
     polcal_readout_exp_time,
@@ -341,6 +441,12 @@ def test_parse_visp_input_data_constants(
     polcal_exp_time,
     observe_exp_times,
     num_modstates,
+    testing_arm_id,
+    testing_obs_ip_start_time,
+    testing_solar_ip_start_time,
+    testing_grating_constant,
+    testing_grating_angle,
+    testing_arm_position,
 ):
     """
     Given: A ParseVispInputData task
@@ -348,7 +454,7 @@ def test_parse_visp_input_data_constants(
     Then: Constants are in the constants object as expected
     """
     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 = parse_task_with_no_data
     write_input_cal_frames_to_task(task)
@@ -363,17 +469,29 @@ def test_parse_visp_input_data_constants(
             num_steps=num_steps,
             readout_exp_time=obs_readout_exp_time,
             exp_time=obs_exp_time,
+            arm_id=testing_arm_id,
+            ip_start_time=testing_obs_ip_start_time,
+            grating_constant=testing_grating_constant,
+            grating_angle=testing_grating_angle,
+            arm_position=testing_arm_position,
         )
 
     # When
     task()
     # Then
+    assert task.constants._db_dict["ARM_ID"] == testing_arm_id
     expected_dark_readout_exp_times = [
         lamp_readout_exp_time,
         solar_readout_exp_time,
-        polcal_readout_exp_time,
     ] + observe_readout_exp_times
-    assert task.constants._db_dict["OBS_IP_START_TIME"] == "2022-11-28T13:55:00"
+    assert task.constants._db_dict["OBS_IP_START_TIME"] == testing_obs_ip_start_time
+    assert task.constants._db_dict["INCIDENT_LIGHT_ANGLE_DEG"] == -1 * testing_grating_angle
+    assert (
+        task.constants._db_dict["REFLECTED_LIGHT_ANGLE_DEG"]
+        == -1 * testing_grating_angle + testing_arm_position
+    )
+    assert task.constants._db_dict["GRATING_CONSTANT_INVERSE_MM"] == testing_grating_constant
+    assert task.constants._db_dict["SOLAR_GAIN_IP_START_TIME"] == testing_solar_ip_start_time
     assert task.constants._db_dict["NUM_MODSTATES"] == num_modstates
     assert task.constants._db_dict["NUM_MAP_SCANS"] == num_maps_per_readout_exp_time * len(
         observe_readout_exp_times
@@ -392,6 +510,11 @@ def test_parse_visp_input_data_constants(
     assert sorted(task.constants._db_dict["OBSERVE_READOUT_EXP_TIMES"]) == sorted(
         observe_readout_exp_times
     )
+    assert task.constants._db_dict["RETARDER_NAME"] == "SiO2 OC"
+    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
 
 
 def test_parse_visp_values(
@@ -400,6 +523,11 @@ def test_parse_visp_values(
     observe_readout_exp_times,
     num_modstates,
     mocker,
+    fake_gql_client,
+    testing_arm_id,
+    testing_grating_constant,
+    testing_grating_angle,
+    testing_arm_position,
 ):
     """
     :Given: A valid parse input task
@@ -407,7 +535,7 @@ def test_parse_visp_values(
     :Then: Values are correctly loaded into the constants mutable mapping
     """
     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 = parse_task_with_no_data
     write_input_cal_frames_to_task(task)
@@ -418,6 +546,10 @@ def test_parse_visp_values(
         num_maps=1,
         num_steps=1,
         num_modstates=num_modstates,
+        arm_id=testing_arm_id,
+        grating_constant=testing_grating_constant,
+        grating_angle=testing_grating_angle,
+        arm_position=testing_arm_position,
     )
 
     task()
@@ -426,16 +558,19 @@ def test_parse_visp_values(
     assert task.constants.maximum_cadence == 10
     assert task.constants.minimum_cadence == 10
     assert task.constants.variance_cadence == 0
+    assert task.constants.camera_name == "camera_name"
 
 
-def test_multiple_num_raster_steps_raises_error(parse_task_with_no_data, num_modstates, mocker):
+def test_multiple_num_raster_steps_raises_error(
+    parse_task_with_no_data, num_modstates, mocker, fake_gql_client
+):
     """
     :Given: A prase task with data that have inconsistent VSPNSTP values
     :When: Calling the parse task
     :Then: The correct error is raised
     """
     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 = parse_task_with_no_data
     write_input_dark_frames_to_task(task, readout_exp_time=0.1, exp_time=0.2)
@@ -453,14 +588,14 @@ def test_multiple_num_raster_steps_raises_error(parse_task_with_no_data, num_mod
         task()
 
 
-def test_incomplete_single_map(parse_task_with_no_data, num_modstates, mocker):
+def test_incomplete_single_map(parse_task_with_no_data, num_modstates, mocker, fake_gql_client):
     """
     :Given: A parse task with data that has an incomplete raster scan
     :When: Calling the parse task
     :Then: The correct number of raster steps are found
     """
     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 = parse_task_with_no_data
     num_steps = 4
@@ -480,14 +615,14 @@ def test_incomplete_single_map(parse_task_with_no_data, num_modstates, mocker):
     assert task.constants._db_dict["NUM_MAP_SCANS"] == num_map_scans
 
 
-def test_incomplete_final_map(parse_task_with_no_data, num_modstates, mocker):
+def test_incomplete_final_map(parse_task_with_no_data, num_modstates, mocker, fake_gql_client):
     """
     :Given: A parse task with data that has complete raster scans along with an incomplete raster scan
     :When: Calling the parse task
     :Then: The correct number of raster steps and maps are found
     """
     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 = parse_task_with_no_data
     num_steps = 4
@@ -513,6 +648,11 @@ def test_intensity_observes_and_polarimetric_cals(
     observe_readout_exp_times,
     observe_exp_times,
     mocker,
+    fake_gql_client,
+    testing_arm_id,
+    testing_grating_constant,
+    testing_grating_angle,
+    testing_arm_position,
 ):
     """
     :Given: Data where the observe frames are in intensity mode and the calibration frames are in polarimetric mode
@@ -520,7 +660,7 @@ def test_intensity_observes_and_polarimetric_cals(
     :Then: All modulator state keys generated for all frames are in the first modulator state
     """
     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 = parse_task_with_no_data
     write_input_cal_frames_to_task(task)
@@ -532,6 +672,10 @@ def test_intensity_observes_and_polarimetric_cals(
         readout_exp_time=observe_readout_exp_times[0],
         exp_time=observe_exp_times[0],
         obs_dataset_class=VispHeadersIntensityObserveFrames,
+        arm_id=testing_arm_id,
+        grating_constant=testing_grating_constant,
+        grating_angle=testing_grating_angle,
+        arm_position=testing_arm_position,
     )
     task()
     assert task.constants._db_dict["NUM_MODSTATES"] == 1
@@ -541,14 +685,16 @@ def test_intensity_observes_and_polarimetric_cals(
         assert "MODSTATE_1" in task.scratch.tags(file)
 
 
-def test_dark_readout_exp_time_picky_bud(parse_task_with_no_data, mocker, lamp_readout_exp_time):
+def test_dark_readout_exp_time_picky_bud(
+    parse_task_with_no_data, mocker, fake_gql_client, lamp_readout_exp_time
+):
     """
     :Given: Dataset where non-dark readout exp time values are missing from the set of dark IP frames.
     :When: Parsing
     :Then: The `DarkReadoutExpTimePickyBud` raises an error
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     bad_readout_exp_time = lamp_readout_exp_time + 0.02
     dummy_exp_time = 99.0