dkist-processing-common 11.0.0rc1__py3-none-any.whl → 11.1.0rc1__py3-none-any.whl

dkist_processing_common/tests/mock_metadata_store.py

@@ -0,0 +1,237 @@
+"""
+Support functions and constants for customized FakeGQLClient
+"""
+import json
+from abc import ABC
+from abc import abstractmethod
+from datetime import datetime
+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
+
+
+class QualityResponseMapping(ResponseMapping):
+    pass  # TODO
+
+
+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()

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
@@ -85,14 +84,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

@@ -482,8 +482,7 @@ def test_assemble_quality_data(
         if plot_data_expected(rm.name):
             assert rm.plot_data
         if vertical_multi_pane_plot_data_expected(rm.name):
-            # TODO: Update this once `dkist-quality` knows about vertical multi-pane metrics
-            assert True
+            assert rm.vertical_multi_pane_plot_data
         if table_data_expected(rm.name):
             assert rm.table_data
         if modmat_data_expected(rm.name):

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):
@@ -144,10 +143,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_interservice_bus_mixin.py

@@ -15,7 +15,6 @@ from dkist_processing_common.config import common_configurations
 from dkist_processing_common.models.message_queue_binding import common_message_queue_bindings
 from dkist_processing_common.tasks import WorkflowTaskBase
 from dkist_processing_common.tasks.mixin.interservice_bus import InterserviceBusMixin
-from dkist_processing_common.tests.conftest import recipe_run_id
 
 logger = logging.getLogger(__name__)
 

dkist_processing_common/tests/test_output_data_base.py

@@ -7,7 +7,6 @@ from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks.output_data_base import OutputDataBase
 from dkist_processing_common.tasks.output_data_base import TransferDataBase
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 
 class OutputDataBaseTask(OutputDataBase):
@@ -16,9 +15,9 @@ class OutputDataBaseTask(OutputDataBase):
 
 
 @pytest.fixture
-def output_data_base_task(recipe_run_id, mocker):
+def output_data_base_task(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
     )
     proposal_id = "test_proposal_id"
     with OutputDataBaseTask(
@@ -37,9 +36,9 @@ class TransferDataTask(TransferDataBase):
 
 
 @pytest.fixture
-def transfer_data_task(recipe_run_id, tmp_path, mocker):
+def transfer_data_task(recipe_run_id, tmp_path, 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 TransferDataTask(
         recipe_run_id=recipe_run_id,

dkist_processing_common/tests/test_publish_catalog_messages.py

@@ -4,13 +4,12 @@ import pytest
 
 from dkist_processing_common.models.message import CreateQualityReportMessage
 from dkist_processing_common.tasks.l1_output_data import PublishCatalogAndQualityMessages
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 
 @pytest.fixture
-def publish_catalog_and_quality_messages_task(recipe_run_id, mocker):
+def publish_catalog_and_quality_messages_task(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 PublishCatalogAndQualityMessages(
         recipe_run_id=recipe_run_id,

dkist_processing_common/tests/test_quality_mixin.py

@@ -1300,7 +1300,7 @@ def test_build_wavecal_results(quality_task, wavecal_data_json):
     assert metric["description"] == (
         "These plots show the wavelength solution computed based on fits to a Solar FTS atlas. "
         "The top plot shows the input and best-fit spectra along with the best-fit atlas, which is "
-        "a combination of Solar and Telluric spectra. The bottom plot shows the fir residuals."
+        "a combination of Solar and Telluric spectra. The bottom plot shows the fit residuals."
     )
     assert metric["metric_code"] == MetricCode.wavecal_fit.value
     assert metric["facet"] is None

dkist_processing_common/tests/test_submit_dataset_metadata.py

@@ -7,7 +7,6 @@ from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import SubmitDatasetMetadata
 from dkist_processing_common.tasks.mixin import metadata_store
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 
 @pytest.fixture()
@@ -86,6 +85,7 @@ def submit_dataset_metadata_task(
 def test_submit_dataset_metadata(
     submit_dataset_metadata_task,
     mocker,
+    fake_gql_client,
 ):
     """
     :Given: An instance of SubmitDatasetMetadata with tagged processed data
@@ -93,7 +93,7 @@ def test_submit_dataset_metadata(
     :Then: Metadata files for the dataset are saved to the remote database
     """
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     # intercept these two GraphQLClient calls so they can be confirmed
     mocked_metadata_store_add_dataset_receipt_account = mocker.patch.object(

dkist_processing_common/tests/test_teardown.py

@@ -5,10 +5,11 @@ import pytest
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.str import str_encoder
-from dkist_processing_common.models.graphql import RecipeRunResponse
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks.teardown import Teardown
-from dkist_processing_common.tests.conftest import FakeGQLClient
+from dkist_processing_common.tests.mock_metadata_store import fake_gql_client_factory
+from dkist_processing_common.tests.mock_metadata_store import make_default_recipe_run_response
+from dkist_processing_common.tests.mock_metadata_store import RecipeRunResponseMapping
 
 
 class TeardownTest(Teardown):
@@ -19,15 +20,17 @@ class TeardownTest(Teardown):
 @pytest.fixture()
 def make_mock_GQL_with_configuration():
     def class_generator(teardown_option: bool | None):
-        class TeardownFakeGQLClient(FakeGQLClient):
-            def execute_gql_query(self, **kwargs):
-                response = super().execute_gql_query(**kwargs)
-                if isinstance(response, list):
-                    if isinstance(response[0], RecipeRunResponse):
-                        if isinstance(teardown_option, bool):
-                            response[0].configuration.teardown_enabled = teardown_option
-                return response
-
+        recipe_run_response = make_default_recipe_run_response()
+        config = recipe_run_response.configuration
+        if isinstance(teardown_option, bool):
+            config.teardown_enabled = teardown_option
+        else:
+            config_dict = config.model_dump(exclude="teardown_enabled")
+            config = json.dumps(config_dict)
+        response_mapping_override = RecipeRunResponseMapping(response=recipe_run_response)
+        TeardownFakeGQLClient = fake_gql_client_factory(
+            response_mapping_override=response_mapping_override
+        )
         return TeardownFakeGQLClient
 
     return class_generator

dkist_processing_common/tests/test_transfer_input_data.py

@@ -6,13 +6,57 @@ import pytest
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.basemodel import basemodel_decoder
-from dkist_processing_common.models.graphql import InputDatasetRecipeRunResponse
 from dkist_processing_common.models.input_dataset import InputDatasetPartDocumentList
 from dkist_processing_common.models.tags import Tag
+from dkist_processing_common.tasks import WorkflowTaskBase
 from dkist_processing_common.tasks.transfer_input_data import TransferL0Data
-from dkist_processing_common.tests.conftest import create_input_frames
-from dkist_processing_common.tests.conftest import create_parameter_files
-from dkist_processing_common.tests.conftest import FakeGQLClient
+from dkist_processing_common.tests.mock_metadata_store import default_calibration_frames_doc
+from dkist_processing_common.tests.mock_metadata_store import default_observe_frames_doc
+from dkist_processing_common.tests.mock_metadata_store import default_parameters_doc
+from dkist_processing_common.tests.mock_metadata_store import fake_gql_client_factory
+from dkist_processing_common.tests.mock_metadata_store import InputDatasetRecipeRunResponseMapping
+from dkist_processing_common.tests.mock_metadata_store import (
+    make_default_input_dataset_recipe_run_response,
+)
+
+
+def create_parameter_files(
+    task: WorkflowTaskBase, parameters_doc: list[dict] = default_parameters_doc
+):
+    """
+    Create the parameter files specified in the parameters document returned by the metadata store.
+
+    This fixture assumes that the JSON parameters document has already been loaded into a python
+    structure (a list of dicts), but the parameter values themselves are still JSON.
+    """
+    for parameter in parameters_doc:
+        for value in parameter["parameterValues"]:
+            if "__file__" not in value["parameterValue"]:
+                continue
+            parameter_value = json.loads(value["parameterValue"])
+            param_path = parameter_value["__file__"]["objectKey"]
+            file_path = task.scratch.workflow_base_path / Path(param_path)
+            if not file_path.parent.exists():
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+            file_path.write_text(data="")
+            task.tag(path=file_path, tags=Tag.parameter(param_path))
+
+
+def create_input_frames(
+    task: WorkflowTaskBase,
+    input_frame_docs: list[dict] = default_observe_frames_doc + default_calibration_frames_doc,
+):
+    """
+    Create the observe and calibration frame files specified in the input dataset documents
+    returned by the metadata store.
+    """
+    for frame in input_frame_docs:
+        for object_key in frame["object_keys"]:
+            file_path = task.scratch.workflow_base_path / Path(object_key)
+            if not file_path.parent.exists():
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+            file_path.write_text(data="")
+            task.tag(path=file_path, tags=[Tag.frame(), Tag.input()])
 
 
 class TransferL0DataTask(TransferL0Data):
@@ -20,15 +64,26 @@ class TransferL0DataTask(TransferL0Data):
         ...
 
 
-class FakeGQLClientMissingInputDatasetCalibrationPart(FakeGQLClient):
-    """Same metadata mocker with calibration input dataset part missing."""
+@pytest.fixture
+def fake_gql_client_class_missing_calibration_part():
+    input_dataset_recipe_run_response = make_default_input_dataset_recipe_run_response()
+    dataset_parts = (
+        input_dataset_recipe_run_response.recipeInstance.inputDataset.inputDatasetInputDatasetParts
+    )
+    for index, part in enumerate(dataset_parts):
+        if (
+            part.inputDatasetPart.inputDatasetPartType.inputDatasetPartTypeName
+            == "calibration_frames"
+        ):
+            del dataset_parts[index]
+    new_response_mapping = InputDatasetRecipeRunResponseMapping(
+        response=input_dataset_recipe_run_response
+    )
+    FakeGQLClientMissingInputDatasetCalibrationPart = fake_gql_client_factory(
+        response_mapping_override=new_response_mapping
+    )
 
-    def execute_gql_query(self, **kwargs):
-        original_response = super().execute_gql_query(**kwargs)
-        # Remove calibration frames part if getting InputDatasetRecipeRunResponse:
-        if kwargs.get("query_response_cls") == InputDatasetRecipeRunResponse:
-            del original_response[0].recipeInstance.inputDataset.inputDatasetInputDatasetParts[2]
-        return original_response
+    return FakeGQLClientMissingInputDatasetCalibrationPart
 
 
 def _transfer_l0_data_task_with_client(recipe_run_id, tmp_path, mocker, client_cls):
@@ -50,14 +105,16 @@ def _transfer_l0_data_task_with_client(recipe_run_id, tmp_path, mocker, client_c
 
 
 @pytest.fixture
-def transfer_l0_data_task(recipe_run_id, tmp_path, mocker):
-    yield from _transfer_l0_data_task_with_client(recipe_run_id, tmp_path, mocker, FakeGQLClient)
+def transfer_l0_data_task(recipe_run_id, tmp_path, mocker, fake_gql_client):
+    yield from _transfer_l0_data_task_with_client(recipe_run_id, tmp_path, mocker, fake_gql_client)
 
 
 @pytest.fixture
-def transfer_l0_data_task_missing_calibration_part(recipe_run_id, tmp_path, mocker):
+def transfer_l0_data_task_missing_calibration_part(
+    recipe_run_id, tmp_path, mocker, fake_gql_client_class_missing_calibration_part
+):
     yield from _transfer_l0_data_task_with_client(
-        recipe_run_id, tmp_path, mocker, FakeGQLClientMissingInputDatasetCalibrationPart
+        recipe_run_id, tmp_path, mocker, fake_gql_client_class_missing_calibration_part
     )
 
 
@@ -65,17 +122,17 @@ def transfer_l0_data_task_missing_calibration_part(recipe_run_id, tmp_path, mock
     "expected_doc, tag",
     [
         pytest.param(
-            FakeGQLClient.observe_frames_doc_object,
+            default_observe_frames_doc,
             Tag.input_dataset_observe_frames(),
             id="observe_frames",
         ),
         pytest.param(
-            FakeGQLClient.calibration_frames_doc_object,
+            default_calibration_frames_doc,
             Tag.input_dataset_calibration_frames(),
             id="calibration_frames",
         ),
         pytest.param(
-            FakeGQLClient.parameters_doc_object,
+            default_parameters_doc,
             Tag.input_dataset_parameters(),
             id="parameters",
         ),
@@ -175,9 +232,9 @@ def test_build_frame_transfer_list_formatted(request, task_name):
     # Then
     source_filenames = []
     destination_filenames = []
-    expected_frames = list(FakeGQLClient.observe_frames_doc_object)
+    expected_frames = list(default_observe_frames_doc)
     if "missing_calibration_part" not in task_name:
-        expected_frames += FakeGQLClient.calibration_frames_doc_object
+        expected_frames += default_calibration_frames_doc
     for frame_set in expected_frames:
         for key in frame_set["object_keys"]:
             source_filenames.append(os.path.join("/", frame_set["bucket"], key))
@@ -204,7 +261,7 @@ def test_build_parameter_file_transfer_items(transfer_l0_data_task):
     # Then
     source_filenames = []
     destination_filenames = []
-    parameters = FakeGQLClient.parameters_doc_object
+    parameters = default_parameters_doc
     for param in parameters:
         for value in param["parameterValues"]:
             if "__file__" in value["parameterValue"]:

dkist_processing_common/tests/test_transfer_l1_output_data.py

@@ -5,7 +5,6 @@ import pytest
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import TransferL1Data
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 
 def fake_list_objects(self, bucket, prefix=None):
@@ -37,7 +36,7 @@ def transfer_l1_data_task(recipe_run_id, tmp_path, fake_constants_db):
         task._purge()
 
 
-def test_transfer_l1_data(transfer_l1_data_task, mocker):
+def test_transfer_l1_data(transfer_l1_data_task, mocker, fake_gql_client):
     """
     Given: A task with frames and movies tagged as output
     When: Transfering the L1 data
@@ -45,7 +44,7 @@ def test_transfer_l1_data(transfer_l1_data_task, mocker):
     """
     # Yeah, we mock a whole bunch of stuff here, but this test at least confirms that the setup to these calls is correct
     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_common.tasks.mixin.globus.GlobusMixin.globus_transfer_scratch_to_object_store"

dkist_processing_common/tests/test_trial_catalog.py

@@ -19,7 +19,6 @@ from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks import CreateTrialAsdf
 from dkist_processing_common.tasks import CreateTrialDatasetInventory
 from dkist_processing_common.tasks import CreateTrialQualityReport
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 
 @pytest.fixture()
@@ -46,12 +45,17 @@ def scratch_with_l1_frames(recipe_run_id, tmp_path) -> WorkflowFileSystem:
 
 @pytest.fixture()
 def create_trial_dataset_inventory_task(
-    recipe_run_id, tmp_path, scratch_with_l1_frames, fake_constants_db, mocker
+    recipe_run_id,
+    tmp_path,
+    scratch_with_l1_frames,
+    fake_constants_db,
+    mocker,
+    fake_gql_client,
 ) -> CreateTrialDatasetInventory:
     """An instance of CreateTrialDatasetInventory with L1 frames tagged in scratch."""
     mocker.patch(
         "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient",
-        new=FakeGQLClient,
+        new=fake_gql_client,
     )
     task = CreateTrialDatasetInventory(
         recipe_run_id=recipe_run_id,