dkist-processing-common 10.5.4__py3-none-any.whl → 12.1.0rc1__py3-none-any.whl

dkist_processing_common/tests/mock_metadata_store.py

@@ -0,0 +1,271 @@
+"""
+Support functions and constants for customized FakeGQLClient
+"""
+
+import json
+from abc import ABC
+from abc import abstractmethod
+from datetime import datetime
+from datetime import timedelta
+from pathlib import Path
+from uuid import uuid4
+
+import pytest
+from pydantic import BaseModel
+
+from dkist_processing_common.models.graphql import InputDatasetInputDatasetPartResponse
+from dkist_processing_common.models.graphql import InputDatasetPartResponse
+from dkist_processing_common.models.graphql import InputDatasetPartTypeResponse
+from dkist_processing_common.models.graphql import InputDatasetRecipeInstanceResponse
+from dkist_processing_common.models.graphql import InputDatasetRecipeRunResponse
+from dkist_processing_common.models.graphql import InputDatasetResponse
+from dkist_processing_common.models.graphql import RecipeInstanceResponse
+from dkist_processing_common.models.graphql import RecipeRunProvenanceResponse
+from dkist_processing_common.models.graphql import RecipeRunResponse
+from dkist_processing_common.models.graphql import RecipeRunStatusResponse
+
+TILE_SIZE = 64
+
+default_observe_frames_doc = [
+    {
+        "bucket": uuid4().hex[:6],
+        "object_keys": [Path(uuid4().hex[:6]).as_posix() for _ in range(3)],
+    }
+]
+
+default_calibration_frames_doc = [
+    {
+        "bucket": uuid4().hex[:6],
+        "object_keys": [Path(uuid4().hex[:6]).as_posix() for _ in range(3)],
+    },
+    {
+        "bucket": uuid4().hex[:6],
+        "object_keys": [Path(uuid4().hex[:6]).as_posix() for _ in range(3)],
+    },
+]
+
+default_parameters_doc = [
+    {
+        "parameterName": "param_name_1",
+        "parameterValues": [
+            {
+                "parameterValueId": 1,
+                "parameterValue": json.dumps([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
+                "parameterValueStartDate": datetime(2000, 1, 1).isoformat(),
+            }
+        ],
+    },
+    {
+        "parameterName": "param_name_2",
+        "parameterValues": [
+            {
+                "parameterValueId": 2,
+                "parameterValue": json.dumps(
+                    {
+                        "__file__": {
+                            "bucket": "data",
+                            "objectKey": f"parameters/param_name/{uuid4().hex}.dat",
+                        }
+                    }
+                ),
+                "parameterValueStartDate": datetime(2000, 1, 1).isoformat(),
+            },
+            {
+                "parameterValueId": 3,
+                "parameterValue": json.dumps(
+                    {
+                        "__file__": {
+                            "bucket": "data",
+                            "objectKey": f"parameters/param_name/{uuid4().hex}.dat",
+                        }
+                    }
+                ),
+                "parameterValueStartDate": datetime(2000, 1, 2).isoformat(),
+            },
+        ],
+    },
+    {
+        "parameterName": "param_name_4",
+        "parameterValues": [
+            {
+                "parameterValueId": 4,
+                "parameterValue": json.dumps({"a": 1, "b": 3.14159, "c": "foo", "d": [1, 2, 3]}),
+                "parameterValueStartDate": datetime(2000, 1, 1).isoformat(),
+            }
+        ],
+    },
+]
+
+default_recipe_run_configuration = {"tile_size": TILE_SIZE}
+
+
+class Unset:
+    pass
+
+
+class ResponseMapping(BaseModel, ABC):
+    response: BaseModel
+
+    @abstractmethod
+    def match_query(self, query_base: str, query_response_cls: type):
+        pass
+
+
+class RecipeRunStatusResponseMapping(ResponseMapping):
+    def match_query(self, query_base: str, query_response_cls: type):
+        if query_base == "recipeRunStatuses":
+            if query_response_cls == RecipeRunStatusResponse:
+                return self.response
+        return Unset
+
+
+class RecipeRunResponseMapping(ResponseMapping):
+    def match_query(self, query_base: str, query_response_cls: type):
+        if query_base == "recipeRuns":
+            if query_response_cls == RecipeRunResponse:
+                return self.response
+        return Unset
+
+
+class InputDatasetRecipeRunResponseMapping(ResponseMapping):
+    def match_query(self, query_base: str, query_response_cls: type):
+        if query_base == "recipeRuns":
+            if query_response_cls == InputDatasetRecipeRunResponse:
+                return self.response
+        return Unset
+
+
+def make_default_recipe_run_status_response() -> RecipeRunStatusResponse:
+    return RecipeRunStatusResponse(recipeRunStatusId=1)
+
+
+def make_default_recipe_run_response() -> RecipeRunResponse:
+    return RecipeRunResponse(
+        recipeInstanceId=1,
+        recipeInstance=RecipeInstanceResponse(
+            recipeId=1,
+            inputDatasetId=1,
+        ),
+        configuration=json.dumps(default_recipe_run_configuration),
+        recipeRunProvenances=[
+            RecipeRunProvenanceResponse(recipeRunProvenanceId=1, isTaskManual=False),
+        ],
+    )
+
+
+def make_default_input_dataset_recipe_run_response() -> InputDatasetRecipeRunResponse:
+    return InputDatasetRecipeRunResponse(
+        recipeInstance=InputDatasetRecipeInstanceResponse(
+            inputDataset=InputDatasetResponse(
+                inputDatasetId=1,
+                isActive=True,
+                inputDatasetInputDatasetParts=[
+                    InputDatasetInputDatasetPartResponse(
+                        inputDatasetPart=InputDatasetPartResponse(
+                            inputDatasetPartId=1,
+                            inputDatasetPartDocument=json.dumps(default_parameters_doc),
+                            inputDatasetPartType=InputDatasetPartTypeResponse(
+                                inputDatasetPartTypeName="parameters"
+                            ),
+                        )
+                    ),
+                    InputDatasetInputDatasetPartResponse(
+                        inputDatasetPart=InputDatasetPartResponse(
+                            inputDatasetPartId=2,
+                            inputDatasetPartDocument=json.dumps(default_observe_frames_doc),
+                            inputDatasetPartType=InputDatasetPartTypeResponse(
+                                inputDatasetPartTypeName="observe_frames"
+                            ),
+                        )
+                    ),
+                    InputDatasetInputDatasetPartResponse(
+                        inputDatasetPart=InputDatasetPartResponse(
+                            inputDatasetPartId=3,
+                            inputDatasetPartDocument=json.dumps(default_calibration_frames_doc),
+                            inputDatasetPartType=InputDatasetPartTypeResponse(
+                                inputDatasetPartTypeName="calibration_frames"
+                            ),
+                        )
+                    ),
+                ],
+            ),
+        ),
+    )
+
+
+default_response_mappings = (
+    RecipeRunStatusResponseMapping(response=make_default_recipe_run_status_response()),
+    RecipeRunResponseMapping(response=make_default_recipe_run_response()),
+    InputDatasetRecipeRunResponseMapping(response=make_default_input_dataset_recipe_run_response()),
+)
+
+
+def fake_gql_client_factory(response_mapping_override: ResponseMapping | None = None):
+
+    if response_mapping_override:
+        response_mappings = (response_mapping_override,) + default_response_mappings
+    else:
+        response_mappings = default_response_mappings
+
+    class FakeGQLClientClass:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def execute_gql_query(self, query_base: str, query_response_cls: type, *args, **kwargs):
+            # Overrides are prepended; first match is returned.
+            for rm in response_mappings:
+                response = rm.match_query(query_base, query_response_cls)
+                if response is not Unset:
+                    return [response]
+            raise ValueError(f"Mocked response not found for {query_base=}, {query_response_cls=}")
+
+        @staticmethod
+        def execute_gql_mutation(**kwargs): ...
+
+    return FakeGQLClientClass
+
+
+@pytest.fixture()
+def fake_gql_client():
+    """
+    Convenience fixture for default mock GQL client. To customize, use fake_gql_client_factory.
+    """
+    return fake_gql_client_factory()
+
+
+def input_dataset_parameters_part_factory(
+    parameter_count: int = 1,
+    parameter_value_count: int = 1,
+    has_date: bool = False,
+    has_file: bool = False,
+) -> list[dict]:
+    """Create a mock InputDatasetPartDocumentList with parameters."""
+    result = [
+        {
+            "parameterName": uuid4().hex[:6],
+            "parameterValues": [
+                {"parameterValueId": i, "parameterValue": json.dumps(uuid4().hex)}
+                for i in range(parameter_value_count)
+            ],
+        }
+        for _ in range(parameter_count)
+    ]
+    if has_date:
+        base = datetime(2018, 9, 14, 0, 0, 0)  # This date is before any possible start dates
+        for parameter_index, data in enumerate(result):
+            for item in data["parameterValues"]:
+                dt = base + timedelta(days=parameter_index)
+                item["parameterValueStartDate"] = dt.isoformat()
+    if has_file:
+        for data in result:
+            param_list = data["parameterValues"]
+            for item in param_list:
+                item["parameterValue"] = json.dumps(
+                    {
+                        "__file__": {
+                            "bucket": "data",
+                            "objectKey": f"parameters/{data['parameterName']}/{uuid4().hex}.dat",
+                        }
+                    }
+                )
+    return result

dkist_processing_common/tests/test_assemble_movie.py

@@ -10,7 +10,6 @@ from dkist_processing_common.models.constants import BudName
 from dkist_processing_common.models.fits_access import FitsAccessBase
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks.assemble_movie import AssembleMovie
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 
 @pytest.fixture
@@ -61,7 +60,6 @@ def assemble_task_with_tagged_movie_frames(
         task.constants._update(
             {
                 BudName.num_dsps_repeats.value: num_dsps_repeats,
-                BudName.recipe_run_id.value: recipe_run_id,
             }
         )
         for d in range(num_dsps_repeats):
@@ -85,14 +83,16 @@ def assemble_task_with_tagged_movie_frames(
     "movie_dimensions",
     [pytest.param((2048, 1536), id="Even_dims"), pytest.param((2047, 1535), id="Odd_dims")],
 )
-def test_assemble_movie(assemble_task_with_tagged_movie_frames, mocker, movie_dimensions):
+def test_assemble_movie(
+    assemble_task_with_tagged_movie_frames, mocker, movie_dimensions, fake_gql_client
+):
     """
     Given: An AssembleMovie subclass with movie frames in scratch
     When: Calling the task
     Then: The movie is written and has an even number of pixels in both dimensions
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     assemble_task_with_tagged_movie_frames()
     expected_dimensions = tuple([size + 1 if size % 2 else size for size in movie_dimensions])

dkist_processing_common/tests/test_assemble_quality.py

@@ -220,6 +220,17 @@ def quality_metrics(dataframe_json) -> list[Metric]:
             {"name": "hist 3", "value": 9.35, "warnings": "warning for historical metric 3"},
             ["QUALITY_HISTORICAL"],
         ),
+        Metric(
+            {
+                "input_wavelength_nm": [1001.0, 1002.0, 1003.0, 1004.0],
+                "input_spectrum": [1.0, 1.0, 0.5, 1.0],
+                "best_fit_wavelength_nm": [1001.5, 1002.6, 1003.7, 1004.8],
+                "best_fit_atlas": [1.0, 1.0, 0.4, 1.0],
+                "normalized_residuals": [0.0, 0.0, 0.1, 0.0],
+                "weights": None,
+            },
+            ["QUALITY_WAVECAL_FIT"],
+        ),
     ]
     return metrics
 
@@ -247,6 +258,20 @@ def plot_data_expected() -> Callable[[str], bool]:
     return expected
 
 
+@pytest.fixture()
+def multi_plot_data_expected() -> Callable[[str], bool]:
+    """
+    Tightly coupled with quality_metrics fixture and resultant report metric name
+    """
+    # names where multi_plot_data is expected to be populated
+    names = {"Wavelength Calibration Results"}
+
+    def expected(name: str) -> bool:
+        return name in names
+
+    return expected
+
+
 @pytest.fixture()
 def table_data_expected() -> Callable[[str], bool]:
     """
@@ -426,6 +451,7 @@ def test_assemble_quality_data(
     assemble_quality_data_task,
     recipe_run_id,
     plot_data_expected,
+    multi_plot_data_expected,
     table_data_expected,
     modmat_data_expected,
     histogram_data_expected,
@@ -447,14 +473,16 @@ def test_assemble_quality_data(
     quality_data = list(
         chain.from_iterable(task.read(tags=Tag.quality_data(), decoder=json_decoder))
     )
-    # With polcal, this would be 19, but the polcal metrics are not included with this task
-    assert len(quality_data) == 15
+    # With polcal, this would be 20, but the polcal metrics are not included with this task
+    assert len(quality_data) == 16
     for metric_data in quality_data:
         rm: ReportMetric = ReportMetric.from_dict(metric_data)
         assert isinstance(rm.name, str)
         assert isinstance(rm.description, str)
         if plot_data_expected(rm.name):
             assert rm.plot_data
+        if multi_plot_data_expected(rm.name):
+            assert rm.multi_plot_data
         if table_data_expected(rm.name):
             assert rm.table_data
         if modmat_data_expected(rm.name):
@@ -496,8 +524,8 @@ def test_assemble_quality_data_for_polcal(
     quality_data = list(
         chain.from_iterable(task.read(tags=Tag.quality_data(), decoder=json_decoder))
     )
-    # this is 19 with polcal
-    assert len(quality_data) == 19
+    # this is 20 with polcal
+    assert len(quality_data) == 20
     for metric_data in quality_data:
         rm: ReportMetric = ReportMetric.from_dict(metric_data)
         assert isinstance(rm.name, str)

dkist_processing_common/tests/test_base.py

@@ -7,7 +7,6 @@ from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.models.tags import StemName
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import WorkflowTaskBase
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 
 class Task(WorkflowTaskBase):
@@ -33,7 +32,7 @@ def base_task(tmp_path, recipe_run_id):
 
 @pytest.fixture
 def tags_and_expected_generic_name() -> (list[str], str):
-    random_seed = f"ZZZ{uuid4().hex[:6]}"
+    random_seed = f"ZZ:Z{uuid4().hex[:6]}"
     tags = [
         Tag.input(),
         Tag.output(),
@@ -62,25 +61,11 @@ def tags_and_expected_generic_name() -> (list[str], str):
         f"{StemName.cs_step.value.replace('_', '-')}-4_"
         f"{StemName.modstate.value}-5_"
         f"{StemName.movie.value}_"
-        f"{random_seed}"
+        f"{random_seed.replace(':', '-')}"
     )
     return tags, expected_base_name
 
 
-def test_apm_spans(base_task):
-    """
-    Given: A WorkflowTaskBase task
-    When: Calling the task-specific apm_steps with weird inputs
-    Then: Errors happen when they're supposed to and not when they're not supposed to
-    """
-    with pytest.raises(RuntimeError):
-        with base_task.apm_processing_step("foo", span_type="bar"):
-            pass
-
-    with base_task.apm_task_step("foo", labels={"foo": "bar"}):
-        pass
-
-
 def test_tags(base_task):
     """
     Given: A WorkflowTaskBase task
@@ -123,6 +108,7 @@ def test_build_generic_tag_filename(base_task, tags_and_expected_generic_name):
     [
         pytest.param("A", id="single"),
         pytest.param(["A", "B"], id="list"),
+        pytest.param(["A", ["B", "C"]], id="nested list"),
     ],
 )
 def test_write_workflow_task_tag(base_task, other_tags: str | list[str]):
@@ -143,10 +129,10 @@ def test_write_workflow_task_tag(base_task, other_tags: str | list[str]):
 
 
 @pytest.fixture
-def rollback_task_setup(tmp_path, recipe_run_id, base_task, mocker) -> dict:
+def rollback_task_setup(tmp_path, recipe_run_id, base_task, mocker, fake_gql_client) -> dict:
     """Return setup data for a task that has data in scratch/constants written by 2 task names (The one from base_task and the RollbackTask)."""
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # add data that should remain
     keep_tag = "test_keep_tag"

dkist_processing_common/tests/test_codecs.py

@@ -19,9 +19,15 @@ from astropy.io.fits import CompImageHDU
 from astropy.io.fits import HDUList
 from astropy.io.fits import Header
 from astropy.io.fits import PrimaryHDU
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import create_model
 
 from dkist_processing_common.codecs.asdf import asdf_decoder
 from dkist_processing_common.codecs.asdf import asdf_encoder
+from dkist_processing_common.codecs.asdf import asdf_fileobj_encoder
+from dkist_processing_common.codecs.basemodel import basemodel_decoder
+from dkist_processing_common.codecs.basemodel import basemodel_encoder
 from dkist_processing_common.codecs.bytes import bytes_decoder
 from dkist_processing_common.codecs.bytes import bytes_encoder
 from dkist_processing_common.codecs.fits import fits_access_decoder
@@ -33,10 +39,10 @@ from dkist_processing_common.codecs.iobase import iobase_decoder
 from dkist_processing_common.codecs.iobase import iobase_encoder
 from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.codecs.json import json_encoder
+from dkist_processing_common.codecs.quality import QualityDataEncoder
 from dkist_processing_common.codecs.quality import quality_data_decoder
 from dkist_processing_common.codecs.quality import quality_data_encoder
 from dkist_processing_common.codecs.quality import quality_data_hook
-from dkist_processing_common.codecs.quality import QualityDataEncoder
 from dkist_processing_common.codecs.str import str_decoder
 from dkist_processing_common.codecs.str import str_encoder
 from dkist_processing_common.models.fits_access import FitsAccessBase
@@ -99,6 +105,14 @@ def path_to_json(dictionary, tmp_file) -> Path:
     return tmp_file
 
 
+@pytest.fixture
+def pydantic_basemodel() -> BaseModel:
+    class Foo(BaseModel):
+        bar: int
+
+    return Foo(bar=123)
+
+
 @pytest.fixture
 def string() -> str:
     return "string"
@@ -129,6 +143,11 @@ def asdf_tree() -> dict:
     return {"metadata_value": "something", "data": np.empty((100, 100))}
 
 
+@pytest.fixture
+def asdf_obj(asdf_tree) -> dict:
+    return asdf.AsdfFile(asdf_tree)
+
+
 @pytest.fixture
 def path_to_asdf_file(asdf_tree, tmp_file) -> Path:
     asdf_obj = asdf.AsdfFile(asdf_tree)
@@ -164,7 +183,7 @@ def primary_hdu_list(ndarray_object, fits_header) -> HDUList:
 
 @pytest.fixture
 def path_to_primary_fits_file(primary_hdu_list, tmp_file) -> Path:
-    primary_hdu_list.writeto(tmp_file)
+    primary_hdu_list.writeto(tmp_file, checksum=True)
     return tmp_file
 
 
@@ -191,7 +210,7 @@ def compressed_hdu_list(ndarray_object, fits_header) -> HDUList:
 
 @pytest.fixture
 def path_to_compressed_fits_file(compressed_hdu_list, tmp_file) -> Path:
-    compressed_hdu_list.writeto(tmp_file)
+    compressed_hdu_list.writeto(tmp_file, checksum=True)
     return tmp_file
 
 
@@ -350,8 +369,10 @@ class DummyFitsAccess(FitsAccessBase):
         pytest.param("primary_hdu_list", fits_hdulist_encoder, id="fits uncompressed HDUList"),
         pytest.param("compressed_hdu_list", fits_hdulist_encoder, id="fits compressed HDUList"),
         pytest.param("dictionary", json_encoder, id="json"),
+        pytest.param("pydantic_basemodel", basemodel_encoder, id="pydantic basemodel"),
         pytest.param("string", str_encoder, id="str"),
         pytest.param("asdf_tree", asdf_encoder, id="asdf"),
+        pytest.param("asdf_obj", asdf_fileobj_encoder, id="asdf_obj"),
     ],
 )
 def test_encoder(data_fixture_name, encoder_function: Callable, request):
@@ -451,16 +472,27 @@ def test_bytesio_decoder(bytesIO_object, path_to_bytesIO):
         pytest.param("path_to_compressed_fits_file", id="compressed"),
     ],
 )
-def test_fits_hdu_decoder(path_fixture_name, ndarray_object, fits_header, request):
+@pytest.mark.parametrize(
+    "checksum", [pytest.param(True, id="checksum"), pytest.param(False, id="no_checksum")]
+)
+@pytest.mark.parametrize(
+    "decompress", [pytest.param(True, id="decompress"), pytest.param(False, id="no_decompress")]
+)
+def test_fits_hdu_decoder(
+    path_fixture_name, ndarray_object, fits_header, request, checksum, decompress
+):
     """
     Given: Path to a FITS file
     When: Decoding the path with the fits_hdu_decoder
     Then: The correct data are returned
     """
     file_path = request.getfixturevalue(path_fixture_name)
-    hdu = fits_hdu_decoder(file_path)
+    hdu = fits_hdu_decoder(file_path, checksum=checksum, disable_image_compression=not decompress)
 
-    assert np.array_equal(hdu.data, ndarray_object)
+    if "compressed" in path_fixture_name and not decompress:
+        assert not np.array_equal(hdu.data, ndarray_object)
+    else:
+        assert np.array_equal(hdu.data, ndarray_object)
     assert hdu.header["foo"] == fits_header["foo"]
 
 
@@ -471,7 +503,15 @@ def test_fits_hdu_decoder(path_fixture_name, ndarray_object, fits_header, reques
         pytest.param("path_to_compressed_fits_file", id="compressed"),
     ],
 )
-def test_fits_access_decoder(path_fixture_name, ndarray_object, fits_header, request):
+@pytest.mark.parametrize(
+    "checksum", [pytest.param(True, id="checksum"), pytest.param(False, id="no_checksum")]
+)
+@pytest.mark.parametrize(
+    "decompress", [pytest.param(True, id="decompress"), pytest.param(False, id="no_decompress")]
+)
+def test_fits_access_decoder(
+    path_fixture_name, ndarray_object, fits_header, request, checksum, decompress
+):
     """
     Given: Path to a FITS file
     When: Decoding the path with the fits_access_decoder
@@ -479,20 +519,47 @@ def test_fits_access_decoder(path_fixture_name, ndarray_object, fits_header, req
     """
     file_path = request.getfixturevalue(path_fixture_name)
 
-    fits_obj = fits_access_decoder(file_path, fits_access_class=DummyFitsAccess)
+    fits_obj = fits_access_decoder(
+        file_path,
+        fits_access_class=DummyFitsAccess,
+        checksum=checksum,
+        disable_image_compression=not decompress,
+    )
     assert fits_obj.name == str(file_path)
-    assert np.array_equal(fits_obj.data, ndarray_object)
     assert fits_obj.foo == fits_header["foo"]
+    if "compressed" in path_fixture_name and not decompress:
+        assert not np.array_equal(fits_obj.data, ndarray_object)
+    else:
+        assert np.array_equal(fits_obj.data, ndarray_object)
 
 
-def test_fits_array_decoder(path_to_primary_fits_file, ndarray_object):
+@pytest.mark.parametrize(
+    "path_fixture_name",
+    [
+        pytest.param("path_to_primary_fits_file", id="uncompressed"),
+        pytest.param("path_to_compressed_fits_file", id="compressed"),
+    ],
+)
+@pytest.mark.parametrize(
+    "checksum", [pytest.param(True, id="checksum"), pytest.param(False, id="no_checksum")]
+)
+@pytest.mark.parametrize(
+    "decompress", [pytest.param(True, id="decompress"), pytest.param(False, id="no_decompress")]
+)
+def test_fits_array_decoder(path_fixture_name, ndarray_object, request, checksum, decompress):
     """
     Given: Path to a FITS file
     When: Decoding the path the fits_array_decoder
     Then: The correct data are returned
     """
-    array = fits_array_decoder(path_to_primary_fits_file)
-    assert np.array_equal(ndarray_object, array)
+    file_path = request.getfixturevalue(path_fixture_name)
+    array = fits_array_decoder(
+        file_path, checksum=checksum, disable_image_compression=not decompress
+    )
+    if "compressed" in path_fixture_name and not decompress:
+        assert not np.array_equal(array, ndarray_object)
+    else:
+        assert np.array_equal(ndarray_object, array)
 
 
 def test_fits_array_decoder_autosqueeze(
@@ -593,6 +660,30 @@ def test_json_encoder_invalid(python_object: Any, expected_exception_type: type[
         json_encoder(python_object)
 
 
+def test_basemodel_decoder(valid_json_codec, path_to_text_file):
+    """
+    Given: a python object that can be validated to a Pydantic BaseModel object is written to file as json
+    When: basemodel decoding is applied to the json file
+    Then: the string gets decoded to the correct Pydantic BaseModel object
+    """
+    # write python object to file as json string
+    python_object = valid_json_codec["python_object"]
+    path = path_to_text_file(json.dumps({"foo": python_object}))
+
+    # create basemodel on the fly
+    DynamicBaseModel = create_model(
+        "DynamicBaseModel", foo=(Any, Field(default_factory=type(python_object)))
+    )
+
+    # get the same object via the basemodel decoder
+    decoded_obj = basemodel_decoder(path, model=DynamicBaseModel)
+    if python_object is nan:
+        # By definition, nan != nan
+        assert isnan(decoded_obj.foo)
+    else:
+        assert decoded_obj.foo == python_object
+
+
 def test_quality_data_encoder_valid(valid_quality_codec):
     """
     Given: a python object that can be encoded as a json string

dkist_processing_common/tests/test_constants.py

@@ -40,6 +40,21 @@ class ConstantsFinal(ConstantsBase):
         return self._db_dict["KEY 1"] ** 2  # Just to show that you can do whatever you want
 
 
+def test_bud_names_in_constant_base():
+    """
+    Given: a set of constants in the BudNames sting enumeration
+    When: ConstantBase class defines a set of properties
+    Then: the sets are the same (except for constants that are not in the redis database)
+    """
+    all_bud_names = {b.name for b in BudName}
+    all_properties_in_constants_base = {
+        k for k, v in ConstantsBase.__dict__.items() if isinstance(v, property)
+    }
+    constants_not_in_redis = {"dataset_id", "stokes_params"}
+    all_buds_defined_in_constant_base = all_properties_in_constants_base - constants_not_in_redis
+    assert all_bud_names == all_buds_defined_in_constant_base
+
+
 def test_constants_db_as_dict(test_constants_db, test_dict):
     """
     Given: a ConstantsDb object and a python dictionary