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

dkist_processing_visp/tests/test_background_light.py

@@ -12,7 +12,6 @@ from dkist_header_validator.translator import translate_spec122_to_spec214_l0
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.task_name import TaskName
-from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_pac.fitter.fitter_parameters import PolcalDresserParameters
 from dkist_processing_pac.input_data.drawer import Drawer
 from dkist_processing_pac.input_data.dresser import Dresser
@@ -351,7 +350,7 @@ def constants_bad_exp_times() -> VispConstantsDb:
 
 
 @pytest.fixture(scope="session")
-def constatns_nor_polarimetric() -> VispConstantsDb:
+def constants_nor_polarimetric() -> VispConstantsDb:
     return VispConstantsDb(
         SOLAR_EXPOSURE_TIMES=(10.0,),
         OBSERVE_EXPOSURE_TIMES=(10.0,),
@@ -361,42 +360,47 @@ def constatns_nor_polarimetric() -> VispConstantsDb:
 
 
 @pytest.fixture(scope="function")
-def background_light_calibration_task(
+def background_light_calibration_task_factory(
     tmp_path,
-    assign_input_dataset_doc_to_task,
     init_visp_constants_db,
+    default_constants,
     recipe_run_id,
+    assign_input_dataset_doc_to_task,
     background_testing_parameter_values,
 ):
-    constants_db = VispConstantsDb()
-    init_visp_constants_db(recipe_run_id, constants_db)
-    with BackgroundLightCalibration(
-        recipe_run_id=recipe_run_id,
-        workflow_name="background_light_calibration",
-        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
-            task.scratch = WorkflowFileSystem(
-                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
-            )
-            assign_input_dataset_doc_to_task(task, background_testing_parameter_values())
+    def make_task(background_on: bool = True, constants: VispConstantsDb = default_constants):
+        constants_db = VispConstantsDb()
+        init_visp_constants_db(recipe_run_id, constants_db)
+        with BackgroundLightCalibration(
+            recipe_run_id=recipe_run_id,
+            workflow_name="background_light_calibration",
+            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
+                task.scratch = WorkflowFileSystem(
+                    scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+                )
+                init_visp_constants_db(task.recipe_run_id, constants)
+                assign_input_dataset_doc_to_task(
+                    task, background_testing_parameter_values(background_on=background_on)
+                )
+                yield task
+            except:
+                raise
+            finally:
+                task._purge()
 
-            yield task
-        except:
-            raise
-        finally:
-            task._purge()
+    return make_task
 
 
 def test_background_light_calibration_task(
-    background_light_calibration_task,
+    background_light_calibration_task_factory,
     write_background_input_files_to_task,
-    default_constants,
-    init_visp_constants_db,
     total_polcal_files,
     num_polcal_dark_files,
     background_light,
     mocker,
+    fake_gql_client,
 ):
     """
     Give: a BackgroundLightCalibrationTask with a valid set of polcal data
@@ -404,10 +408,10 @@ def test_background_light_calibration_task(
     Then: BACKGROUND intermediate frames are generated for each beam
     """
     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 = background_light_calibration_task
-    init_visp_constants_db(task.recipe_run_id, default_constants)
+    task_generator = background_light_calibration_task_factory()
+    task = next(task_generator)
     write_background_input_files_to_task(task)
     task()
 
@@ -435,7 +439,10 @@ def test_background_light_calibration_task(
 
 
 def test_background_light_bad_exposure_times(
-    background_light_calibration_task, constants_bad_exp_times, init_visp_constants_db, mocker
+    background_light_calibration_task_factory,
+    constants_bad_exp_times,
+    mocker,
+    fake_gql_client,
 ):
     """
     Given: A set of data where the polcal exposure times don't match those of solar gain and observe
@@ -443,16 +450,19 @@ def test_background_light_bad_exposure_times(
     Then: An 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 = background_light_calibration_task
-    init_visp_constants_db(task.recipe_run_id, constants_bad_exp_times)
+    task_generator = background_light_calibration_task_factory(constants=constants_bad_exp_times)
+    task = next(task_generator)
     with pytest.raises(ValueError, match="do not all have the same FPA exposure time"):
         task()
 
 
 def test_background_light_non_polarimetric_dataset(
-    background_light_calibration_task, constatns_nor_polarimetric, init_visp_constants_db, mocker
+    background_light_calibration_task_factory,
+    constants_nor_polarimetric,
+    mocker,
+    fake_gql_client,
 ):
     """
     Given: A dataset that is non-polarimetric (i.e., Stokes-I only)
@@ -460,10 +470,11 @@ def test_background_light_non_polarimetric_dataset(
     Then: Nothing is done and no files are written
     """
     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 = background_light_calibration_task
-    init_visp_constants_db(task.recipe_run_id, constatns_nor_polarimetric)
+
+    task_generator = background_light_calibration_task_factory(constants=constants_nor_polarimetric)
+    task = next(task_generator)
     task()
 
     # Test that no BACKGROUND files were created
@@ -474,12 +485,9 @@ def test_background_light_non_polarimetric_dataset(
 
 
 def test_background_light_switch_off(
-    background_light_calibration_task,
-    default_constants,
-    init_visp_constants_db,
-    assign_input_dataset_doc_to_task,
-    background_testing_parameter_values,
+    background_light_calibration_task_factory,
     mocker,
+    fake_gql_client,
 ):
     """
     Given: A task with the background light switch turned off
@@ -487,11 +495,10 @@ def test_background_light_switch_off(
     Then: Nothing is done and no files are written
     """
     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 = background_light_calibration_task
-    init_visp_constants_db(task.recipe_run_id, default_constants)
-    assign_input_dataset_doc_to_task(task, background_testing_parameter_values(background_on=False))
+    task_generator = background_light_calibration_task_factory(background_on=False)
+    task = next(task_generator)
     task()
 
     # Test that no BACKGROUND files were created

dkist_processing_visp/tests/test_dark.py

@@ -6,7 +6,6 @@ import pytest
 from astropy.io import fits
 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.tags import VispTag
 from dkist_processing_visp.tasks.dark import DarkCalibration
@@ -90,14 +89,16 @@ def dark_calibration_task(tmp_path, init_visp_constants_db, recipe_run_id):
             task._purge()
 
 
-def test_dark_calibration_task(dark_calibration_task, assign_input_dataset_doc_to_task, mocker):
+def test_dark_calibration_task(
+    dark_calibration_task, assign_input_dataset_doc_to_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
     )
     # Given
     task, readout_exp_times = dark_calibration_task

dkist_processing_visp/tests/test_downsample.py

@@ -26,6 +26,7 @@ def task_with_downsample_mixin(
     assign_input_dataset_doc_to_task(task, VispInputDatasetParameterValues())
 
     yield task
+    task._purge()
 
 
 @pytest.fixture(scope="session")

dkist_processing_visp/tests/test_fits_access.py

@@ -0,0 +1,43 @@
+import pytest
+from dkist_header_validator.translator import translate_spec122_to_spec214_l0
+
+from dkist_processing_visp.models.fits_access import VispMetadataKey
+from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
+from dkist_processing_visp.parsers.visp_l1_fits_access import VispL1FitsAccess
+from dkist_processing_visp.tests.header_models import VispHeadersValidObserveFrames
+
+
+@pytest.fixture(scope="session")
+def complete_header():
+    dataset = VispHeadersValidObserveFrames(
+        array_shape=(1, 1, 1),
+        time_delta=10,
+        num_maps=1,
+        num_raster_steps=1,
+        num_modstates=1,
+    )
+    header = translate_spec122_to_spec214_l0(dataset.header())
+    return header
+
+
+def test_metadata_keys_in_access_bases(complete_header):
+    """
+    Given: the set of metadata key names in VispMetadataKey
+    When: the ViSP FITS access classes define a set of new attributes
+    Then: the sets are the same and the attributes have the correct values
+    """
+    # Given
+    visp_metadata_key_names = {vmk.name for vmk in VispMetadataKey}
+    # When
+    all_visp_fits_access_attrs = set()
+    for access_class in [VispL0FitsAccess, VispL1FitsAccess]:
+        fits_obj = access_class.from_header(complete_header)
+        visp_instance_attrs = set(vars(fits_obj).keys())
+        parent_class = access_class.mro()[1]
+        parent_fits_obj = parent_class.from_header(complete_header)
+        parent_instance_attrs = set(vars(parent_fits_obj).keys())
+        visp_fits_access_attrs = visp_instance_attrs - parent_instance_attrs
+        for attr in visp_fits_access_attrs:
+            assert getattr(fits_obj, attr) == fits_obj.header[VispMetadataKey[attr]]
+        all_visp_fits_access_attrs |= visp_fits_access_attrs
+    assert visp_metadata_key_names == all_visp_fits_access_attrs

dkist_processing_visp/tests/test_geometric.py

@@ -7,14 +7,13 @@ import pytest
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.models.tags import Tag
-from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_math import transform
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.geometric import GeometricCalibration
-from dkist_processing_visp.tests.conftest import tag_on_modstate
 from dkist_processing_visp.tests.conftest import VispConstantsDb
 from dkist_processing_visp.tests.conftest import VispInputDatasetParameterValues
+from dkist_processing_visp.tests.conftest import tag_on_modstate
 from dkist_processing_visp.tests.conftest import write_frames_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_darks_to_task
 from dkist_processing_visp.tests.header_models import VispHeadersInputLampGainFrames
@@ -189,7 +188,9 @@ def geometric_calibration_task(tmp_path, recipe_run_id, init_visp_constants_db):
             task._purge()
 
 
-def test_geometric_task(geometric_calibration_task, assign_input_dataset_doc_to_task, mocker):
+def test_geometric_task(
+    geometric_calibration_task, assign_input_dataset_doc_to_task, mocker, fake_gql_client
+):
     """
     Given: A set of raw solar gain images and necessary intermediate calibrations
     When: Running the geometric task
@@ -201,7 +202,7 @@ def test_geometric_task(geometric_calibration_task, assign_input_dataset_doc_to_
     # tests for that. In other words, this fixture just tests if the machinery of the task completes and some object
     # (ANY object) is written correctly.
     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, readout_exp_times, num_modstates = geometric_calibration_task
     dark_signal = 3.0
@@ -357,3 +358,43 @@ def test_basic_corrections(geometric_calibration_task, assign_input_dataset_doc_
             lamp_array = task.basic_corrected_lamp_data(beam=beam, modstate=modstate)
             np.testing.assert_equal(expected, solar_array)
             np.testing.assert_equal(expected, lamp_array)
+
+
+def test_line_zones(geometric_calibration_task):
+    """
+    Given: A spectrum with some absorption lines
+    When: Computing zones around the lines
+    Then: Correct results are returned
+    """
+
+    # NOTE that it does not test for removal of overlapping regions
+    def gaussian(x, amp, mu, sig):
+        return amp * np.exp(-np.power(x - mu, 2.0) / (2 * np.power(sig, 2.0)))
+
+    spec = np.ones(1000) * 100
+    x = np.arange(1000.0)
+    expected = []
+    for m, s in zip([100.0, 300.0, 700], [10.0, 20.0, 5.0]):
+        spec -= gaussian(x, 40, m, s)
+        hwhm = s * 2.355 / 2
+        expected.append((np.floor(m - hwhm).astype(int), np.ceil(m + hwhm).astype(int)))
+
+    task = geometric_calibration_task[0]
+
+    zones = task.compute_line_zones(spec[:, None], bg_order=0, rel_height=0.5)
+    assert zones == expected
+
+
+def test_identify_overlapping_zones(geometric_calibration_task):
+    """
+    Given: A list of zone borders that contain overlapping zones
+    When: Identifying zones that overlap
+    Then: The smaller of the overlapping zones are identified for removal
+    """
+    rips = np.array([100, 110, 220, 200])
+    lips = np.array([150, 120, 230, 250])
+
+    task = geometric_calibration_task[0]
+
+    idx_to_remove = task.identify_overlapping_zones(rips, lips)
+    assert idx_to_remove == [1, 2]

dkist_processing_visp/tests/test_instrument_polarization.py

@@ -6,7 +6,6 @@ import pytest
 from astropy.io import fits
 from dkist_data_simulator.spec122 import Spec122Dataset
 from dkist_processing_common._util.scratch import WorkflowFileSystem
-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
 
@@ -19,7 +18,11 @@ from dkist_processing_visp.tests.conftest import write_frames_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_background_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_darks_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_geometric_to_task
+from dkist_processing_visp.tests.conftest import write_intermediate_polcal_darks_to_task
+from dkist_processing_visp.tests.conftest import write_intermediate_polcal_gains_to_task
+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
 
 
 class DummyPolcalFitter(PolcalFitter):
@@ -88,6 +91,58 @@ def write_input_polcals_to_task(
     )
 
 
+def write_input_polcal_darks_to_task(
+    task,
+    readout_exp_time: float,
+    num_modstates: int,
+    data_shape: tuple[int, int],
+):
+    array_shape = (1, *data_shape)
+    dataset = VispHeadersInputPolcalDarkFrames(
+        array_shape=array_shape,
+        time_delta=10,
+        num_modstates=num_modstates,
+        readout_exp_time=readout_exp_time,
+    )
+
+    write_frames_to_task(
+        task=task,
+        frame_generator=dataset,
+        extra_tags=[
+            VispTag.input(),
+            VispTag.task_polcal(),
+            VispTag.task_polcal_dark(),
+            VispTag.readout_exp_time(readout_exp_time),
+        ],
+    )
+
+
+def write_input_polcal_gains_to_task(
+    task,
+    readout_exp_time: float,
+    num_modstates: int,
+    data_shape: tuple[int, int],
+):
+    array_shape = (1, *data_shape)
+    dataset = VispHeadersInputPolcalGainFrames(
+        array_shape=array_shape,
+        time_delta=10,
+        num_modstates=num_modstates,
+        readout_exp_time=readout_exp_time,
+    )
+
+    write_frames_to_task(
+        task=task,
+        frame_generator=dataset,
+        extra_tags=[
+            VispTag.input(),
+            VispTag.task_polcal(),
+            VispTag.task_polcal_gain(),
+            VispTag.readout_exp_time(readout_exp_time),
+        ],
+    )
+
+
 @pytest.fixture(scope="function")
 def instrument_polarization_calibration_task(
     tmp_path,
@@ -157,6 +212,7 @@ def test_instrument_polarization_calibration_task(
     background_on,
     assign_input_dataset_doc_to_task,
     mocker,
+    fake_gql_client,
 ):
     """
     Given: An InstrumentPolarizationCalibration task
@@ -165,7 +221,7 @@ def test_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
     )
     mocker.patch(
         "dkist_processing_visp.tasks.instrument_polarization.PolcalFitter",
@@ -190,12 +246,6 @@ def test_instrument_polarization_calibration_task(
         ),
     )
 
-    write_intermediate_darks_to_task(
-        task=task,
-        dark_signal=0,
-        readout_exp_time=readout_exp_time,
-        data_shape=intermediate_shape,
-    )
     if background_on:
         write_intermediate_background_to_task(
             task=task, background_signal=0.0, data_shape=intermediate_shape
@@ -205,7 +255,8 @@ def test_instrument_polarization_calibration_task(
         task=task, num_modstates=num_modstates, data_shape=intermediate_shape
     )
     write_dummy_intermediate_solar_cals_to_task(
-        task=task, data_shape=intermediate_shape, num_modstates=num_modstates
+        task=task,
+        data_shape=intermediate_shape,
     )
     write_input_polcals_to_task(
         task=task,
@@ -214,6 +265,18 @@ def test_instrument_polarization_calibration_task(
         num_cs_steps=num_cs_steps,
         data_shape=input_shape,
     )
+    write_input_polcal_darks_to_task(
+        task=task,
+        readout_exp_time=readout_exp_time,
+        num_modstates=num_modstates,
+        data_shape=input_shape,
+    )
+    write_input_polcal_gains_to_task(
+        task=task,
+        readout_exp_time=readout_exp_time,
+        num_modstates=num_modstates,
+        data_shape=input_shape,
+    )
 
     task()
 

dkist_processing_visp/tests/test_lamp.py

@@ -6,13 +6,12 @@ import pytest
 from astropy.io import fits
 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.tags import VispTag
 from dkist_processing_visp.tasks.lamp import LampCalibration
-from dkist_processing_visp.tests.conftest import tag_on_modstate
 from dkist_processing_visp.tests.conftest import VispConstantsDb
 from dkist_processing_visp.tests.conftest import VispInputDatasetParameterValues
+from dkist_processing_visp.tests.conftest import tag_on_modstate
 from dkist_processing_visp.tests.conftest import write_frames_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_darks_to_task
 from dkist_processing_visp.tests.header_models import VispHeadersInputLampGainFrames
@@ -24,9 +23,10 @@ def make_lamp_array_data(
     frame: VispHeadersInputLampGainFrames, dark_signal: float, beam_border: int
 ):
     num_raw_frames_per_fpa = frame.header()["CAM__014"]
+    modstate = frame.current_modstate("")  # Weird signature due to @key_function
     data = np.zeros(frame.array_shape)
-    data[0, :beam_border, :] = (1.1 + dark_signal) * num_raw_frames_per_fpa
-    data[0, beam_border:, :] = (1.2 + dark_signal) * num_raw_frames_per_fpa
+    data[0, :beam_border, :] = (1.0 + 0.1 * modstate + dark_signal) * num_raw_frames_per_fpa
+    data[0, beam_border:, :] = (2.0 + 0.1 * modstate + dark_signal) * num_raw_frames_per_fpa
 
     return data
 
@@ -91,14 +91,16 @@ def lamp_calibration_task(
             task._purge()
 
 
-def test_lamp_calibration_task(lamp_calibration_task, assign_input_dataset_doc_to_task, mocker):
+def test_lamp_calibration_task(
+    lamp_calibration_task, assign_input_dataset_doc_to_task, mocker, fake_gql_client
+):
     """
     Given: A LampCalibration task
     When: Calling the task instance
     Then: The correct number of output lamp gain frames exists, and are tagged correctly
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # Given
     task, num_modstates, readout_exp_time = lamp_calibration_task
@@ -131,27 +133,21 @@ def test_lamp_calibration_task(lamp_calibration_task, assign_input_dataset_doc_t
         VispTag.task_lamp_gain(),
         VispTag.intermediate(),
     ]
-    assert len(list(task.read(tags=tags))) == num_modstates * 2  # 2 from beams
-
-    for i in range(num_modstates):
-        for beam in [1, 2]:
-            tags = [
-                VispTag.task_lamp_gain(),
-                VispTag.intermediate(),
-                VispTag.modstate(i + 1),
-                VispTag.beam(beam),
-            ]
-            files = list(task.read(tags=tags))
-            assert len(files) == 1
-            hdu = fits.open(files[0])[0]
-            np.testing.assert_allclose(hdu.data, np.ones((10, 10)) * (1 + (0.1 * beam)))
+    assert len(list(task.read(tags=tags))) == 2  # One per beam
 
-    tags = [
-        VispTag.task_lamp_gain(),
-        VispTag.intermediate(),
-    ]
-    for filepath in task.read(tags=tags):
-        assert filepath.exists()
+    for beam in [1, 2]:
+        tags = [
+            VispTag.task_lamp_gain(),
+            VispTag.intermediate(),
+            VispTag.beam(beam),
+        ]
+        files = list(task.read(tags=tags))
+        assert len(files) == 1
+
+        expected_signal = beam + np.mean(np.arange(1, num_modstates + 1)) * 0.1
+
+        hdu = fits.open(files[0])[0]
+        np.testing.assert_allclose(hdu.data, np.ones(intermediate_shape) * expected_signal)
 
     quality_files = task.read(tags=[Tag.quality("TASK_TYPES")])
     for file in quality_files:

dkist_processing_visp/tests/test_make_movie_frames.py

@@ -1,7 +1,7 @@
 import pytest
 from astropy.io import fits
 from dkist_processing_common._util.scratch import WorkflowFileSystem
-from dkist_processing_common.tests.conftest import FakeGQLClient
+from dkist_processing_common.models.fits_access import MetadataKey
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.make_movie_frames import MakeVispMovieFrames
@@ -30,14 +30,14 @@ def movie_frames_task(tmp_path, recipe_run_id, init_visp_constants_db):
 
 
 @pytest.mark.parametrize("pol_mode", ["observe_polarimetric", "observe_intensity"])
-def test_make_movie_frames(movie_frames_task, pol_mode, mocker):
+def test_make_movie_frames(movie_frames_task, pol_mode, mocker, fake_gql_client):
     """
     Given: A MakeVispMovieFrames task
     When: Calling the task instance
     Then: a fits file is made for each raster 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, num_maps, num_steps = movie_frames_task
     spectral_size = 3
@@ -57,5 +57,5 @@ def test_make_movie_frames(movie_frames_task, pol_mode, mocker):
     for filepath in task.read(tags=[VispTag.movie_frame()]):
         assert filepath.exists()
         hdul = fits.open(filepath)
-        assert hdul[0].header["INSTRUME"] == "VISP"
+        assert hdul[0].header[MetadataKey.instrument] == "VISP"
         assert hdul[0].data.shape == expected_movie_fram_shape

dkist_processing_visp/tests/test_map_repeats.py

@@ -14,6 +14,7 @@ from dkist_processing_common.parsers.single_value_single_key_flower import (
 )
 
 from dkist_processing_visp.models.constants import VispBudName
+from dkist_processing_visp.models.fits_access import VispMetadataKey
 from dkist_processing_visp.models.tags import VispStemName
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.parsers.map_repeats import MapScanFlower
@@ -90,7 +91,8 @@ class ParseTaskJustMapStuff(ParseL0VispInputData):
             MapScanFlower(),
             RasterScanStepFlower(),
             SingleValueSingleKeyFlower(
-                tag_stem_name=VispStemName.modstate.value, metadata_key="modulator_state"
+                tag_stem_name=VispStemName.modstate.value,
+                metadata_key=VispMetadataKey.modulator_state,
             ),
         ]