imap-processing 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

imap_processing/tests/ultra/unit/test_ultra_l1a.py

@@ -1,9 +1,10 @@
+"""Test ULTRA L1a CDFs."""
+
 import numpy as np
-import pytest
+import xarray as xr
 
-from imap_processing import decom
-from imap_processing.cdf.utils import load_cdf, write_cdf
-from imap_processing.ultra.l0.decom_ultra import process_ultra_apids
+from imap_processing.cdf.utils import write_cdf
+from imap_processing.ultra.l0.decom_ultra import get_event_id
 from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_AUX,
     ULTRA_EVENTS,
@@ -11,344 +12,120 @@ from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_TOF,
 )
 from imap_processing.ultra.l1a.ultra_l1a import (
-    create_dataset,
-    get_event_id,
     ultra_l1a,
 )
-from imap_processing.utils import group_by_apid
-
 
-@pytest.fixture()
-def decom_ultra_aux(ccsds_path_theta_0, xtce_path):
-    """Data for decom_ultra_aux"""
-    packets = decom.decom_packets(ccsds_path_theta_0, xtce_path)
-    grouped_data = group_by_apid(packets)
 
-    data_packet_list = process_ultra_apids(
-        grouped_data[ULTRA_AUX.apid[0]], ULTRA_AUX.apid[0]
-    )
-    return data_packet_list
-
-
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_AUX.apid[0],
-                "filename": "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50"
-                "_theta-0.00_20240207T102740.CCSDS",
-            }
-        )
-    ],
-    indirect=True,
-)
-@pytest.mark.xfail(reason="Fix CDF attrs")
-def test_xarray_aux(decom_test_data):
+def test_xarray_aux(ccsds_path_theta_0):
     """This function checks that a xarray was
     successfully created from the decom_ultra_aux data."""
-    pass
-    # decom_ultra_aux, _ = decom_test_data
-    # dataset = create_dataset({ULTRA_AUX.apid[0]: decom_ultra_aux})
-
-    # # Spot check string data and attributes
-    # spin_period_valid_list = dataset.variables["SPINPERIODVALID"].values.tolist()
-    # spin_period_valid_attr = dataset.variables["SPINPERIODVALID"].attrs
-    # expected_spin_period_valid_attr = ultra_cdf_attrs.StringAttrs(
-    #     depend_0="epoch", catdesc="spinperiodvalid", fieldname="spinperiodvalid"
-    # )
-
-    # assert spin_period_valid_list == decom_ultra_aux["SPINPERIODVALID"]
-    # assert spin_period_valid_attr == expected_spin_period_valid_attr.output()
-
-    # # Spot check support data and attributes
-    # version_list = dataset.variables["VERSION"].values.tolist()
-    # version_attr = dataset.variables["VERSION"].attrs
-    # expected_version_attr = dataclasses.replace(
-    #     ultra_cdf_attrs.ultra_support_attrs,
-    #     catdesc="version",
-    #     fieldname="version",
-    #     label_axis="version",
-    # ).output()
-
-    # assert version_list == decom_ultra_aux["VERSION"]
-    # assert version_attr == expected_version_attr
-
-    # # Spot check metadata data and attributes
-    # shcoarse_list = dataset.variables["SHCOARSE"].values.tolist()
-    # shcoarse_attr = dataset.variables["SHCOARSE"].attrs
-
-    # expected_shcoarse_attr = dataclasses.replace(
-    #     ultra_cdf_attrs.ultra_support_attrs,
-    #     catdesc="shcoarse",
-    #     fieldname="shcoarse",
-    #     label_axis="shcoarse",
-    # ).output()
-
-    # assert shcoarse_list == decom_ultra_aux["SHCOARSE"]
-    # assert shcoarse_attr == expected_shcoarse_attr
-
-
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_RATES.apid[0],
-                "filename": "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50"
-                "_theta-0.00_20240207T102740.CCSDS",
-            }
-        )
-    ],
-    indirect=True,
-)
-@pytest.mark.xfail(reason="Fix CDF attrs")
-def test_xarray_rates(decom_test_data):
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_AUX.apid[0])
+
+    # Spot check metadata data and attributes
+    specific_epoch_data = test_data[0].sel(epoch=test_data[0].epoch[0])[
+        "spinperiodvalid"
+    ]
+
+    assert (specific_epoch_data == test_data[0]["spinperiodvalid"][0]).all()
+
+
+def test_xarray_rates(ccsds_path_theta_0):
     """This function checks that a xarray was
     successfully created from the decom_ultra_rates data."""
-    pass
-    # decom_ultra_rates, _ = decom_test_data
-    # dataset = create_dataset({ULTRA_RATES.apid[0]: decom_ultra_rates})
-
-    # # Spot check metadata data and attributes
-    # j2000_time = (
-    #     np.datetime64("2024-02-07T15:28:37.184000", "ns") - TTJ2000_EPOCH
-    # ).astype(np.int64)
-    # specific_epoch_data = dataset.sel(epoch=j2000_time)["START_RF"]
-    # startrf_list = specific_epoch_data.values.tolist()
-    # startrf_attr = dataset.variables["START_RF"].attrs
-
-    # expected_startrf_attr = dataclasses.replace(
-    #     ultra_cdf_attrs.ultra_support_attrs,
-    #     catdesc="start_rf",
-    #     fieldname="start_rf",
-    #     label_axis="start_rf",
-    # ).output()
-
-    # assert startrf_list == decom_ultra_rates["START_RF"][0]
-    # assert startrf_attr == expected_startrf_attr
-
-
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_TOF.apid[0],
-                "filename": "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50"
-                "_theta-0.00_20240207T102740.CCSDS",
-            }
-        )
-    ],
-    indirect=True,
-)
-@pytest.mark.xfail(reason="Fix CDF attrs")
-def test_xarray_tof(decom_test_data):
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_RATES.apid[0])
+    # Spot check metadata data and attributes
+    specific_epoch_data = test_data[0].sel(epoch=test_data[0].epoch[0])["start_rf"]
+    assert (specific_epoch_data == test_data[0]["start_rf"][0]).all()
+
+
+def test_xarray_tof(ccsds_path_theta_0):
     """This function checks that a xarray was
     successfully created from the decom_ultra_tof data."""
-    pass
-    # decom_ultra_tof, _ = decom_test_data
-    # dataset = create_dataset({ULTRA_TOF.apid[0]: decom_ultra_tof})
-
-    # # Spot check metadata data and attributes
-    # j2000_time = (
-    #     np.datetime64("2024-02-07T15:28:36.184000", "ns") - TTJ2000_EPOCH
-    # ).astype(np.int64)
-    # specific_epoch_data = dataset.sel(epoch=j2000_time, sid=0)["PACKETDATA"]
-    # packetdata_attr = dataset.variables["PACKETDATA"].attrs
-
-    # expected_packetdata_attr = dataclasses.replace(
-    #     ultra_cdf_attrs.ultra_support_attrs,
-    #     catdesc="packetdata",
-    #     fieldname="packetdata",
-    #     label_axis="packetdata",
-    #     depend_1="sid",
-    #     depend_2="row",
-    #     depend_3="column",
-    #     units="pixels",
-    #     variable_purpose="primary_var",
-    # ).output()
-
-    # assert (specific_epoch_data == decom_ultra_tof["PACKETDATA"][0][0]).all()
-    # assert packetdata_attr == expected_packetdata_attr
-
-
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_EVENTS.apid[0],
-                "filename": "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50"
-                "_theta-0.00_20240207T102740.CCSDS",
-            },
-        )
-    ],
-    indirect=True,
-)
-@pytest.mark.xfail(reason="Fix CDF attrs")
-def test_xarray_events(decom_test_data, decom_ultra_aux, events_test_path):
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_TOF.apid[0])
+
+    # Spot check metadata data and attributes
+    specific_epoch_data = test_data[0].sel(epoch=test_data[0].epoch[0], sid=0)[
+        "packetdata"
+    ]
+    assert (specific_epoch_data == test_data[0]["packetdata"][0][0]).all()
+
+
+def test_xarray_events(ccsds_path_theta_0):
     """This function checks that a xarray was
     successfully created from the decom_ultra_events data."""
-    pass
-    # decom_ultra_events, _ = decom_test_data
-    # dataset = create_dataset(
-    #     {
-    #         ULTRA_EVENTS.apid[0]: decom_ultra_events,
-    #         ULTRA_AUX.apid[0]: decom_ultra_aux,
-    #     }
-    # )
-
-    # # Spot check metadata data and attributes
-    # j2000_time = (
-    #     np.datetime64("2024-02-07T15:28:37.184000", "ns") - TTJ2000_EPOCH
-    # ).astype(np.int64)
-    # specific_epoch_data = dataset.sel(epoch=j2000_time)["COIN_TYPE"]
-    # cointype_list = specific_epoch_data.values.tolist()
-    # cointype_attr = dataset.variables["COIN_TYPE"].attrs
-
-    # expected_cointype_attr = dataclasses.replace(
-    #     ultra_cdf_attrs.ultra_support_attrs,
-    #     catdesc="coin_type",
-    #     fieldname="coin_type",
-    #     label_axis="coin_type",
-    # ).output()
-
-    # assert cointype_list == decom_ultra_events["COIN_TYPE"][0]
-    # assert cointype_attr == expected_cointype_attr
-
-
-def test_cdf_aux(
-    ccsds_path_theta_0,
-    decom_ultra_aux,
-):
-    """Tests that CDF file is created and contains same attributes as xarray."""
-
-    test_data = ultra_l1a(
-        ccsds_path_theta_0, data_version="001", apid=ULTRA_AUX.apid[0]
-    )
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_EVENTS.apid[0])
+    specific_epoch_data = test_data[0].sel(epoch=test_data[0].epoch[0])["coin_type"]
+    assert (specific_epoch_data == test_data[0]["coin_type"][0]).all()
+
+
+def test_xarray_hk(ccsds_path_theta_0):
+    """This function checks that a xarray was
+    successfully created from the decom_ultra_hk data."""
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=869)
+
+    assert isinstance(test_data[0], xr.Dataset)
+
+
+def test_cdf_aux(ccsds_path_theta_0):
+    """Tests that CDF file can be created."""
+
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_AUX.apid[0])
     test_data_path = write_cdf(test_data[0])
 
     assert test_data_path.exists()
-    assert test_data_path.name == "imap_ultra_l1a_45sensor-aux_20240207_v001.cdf"
-
-    dataset_aux = create_dataset({ULTRA_AUX.apid[0]: decom_ultra_aux})
-    input_xarray_aux = load_cdf(test_data_path)
-
-    # write_cdf() injects some attributes that are not in the xarray
-    assert set(dataset_aux.attrs.keys()).issubset(set(input_xarray_aux.attrs.keys()))
-
-
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_RATES.apid[0],
-                "filename": "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50"
-                "_theta-0.00_20240207T102740.CCSDS",
-            },
-        )
-    ],
-    indirect=True,
-)
-def test_cdf_rates(ccsds_path_theta_0, decom_test_data):
-    """Tests that CDF file is created and contains same attributes as xarray."""
-    decom_ultra_rates, _ = decom_test_data
-    test_data = ultra_l1a(
-        ccsds_path_theta_0, data_version="001", apid=ULTRA_RATES.apid[0]
-    )
-    test_data_path = write_cdf(test_data[0], istp=False)
+    assert test_data_path.name == "imap_ultra_l1a_45sensor-aux_20240207_v999.cdf"
 
-    assert test_data_path.exists()
-    assert test_data_path.name == "imap_ultra_l1a_45sensor-rates_20240207_v001.cdf"
 
-    dataset_rates = create_dataset({ULTRA_RATES.apid[0]: decom_ultra_rates})
-    input_xarray_rates = load_cdf(test_data_path)
+def test_cdf_rates(ccsds_path_theta_0):
+    """Tests that CDF file can be created."""
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_RATES.apid[0])
+    test_data_path = write_cdf(test_data[0], istp=False)
 
-    # write_cdf() injects some attributes that are not in the xarray
-    assert set(dataset_rates.attrs.keys()).issubset(
-        set(input_xarray_rates.attrs.keys())
-    )
+    assert test_data_path.exists()
+    assert test_data_path.name == "imap_ultra_l1a_45sensor-rates_20240207_v999.cdf"
 
 
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_TOF.apid[0],
-                "filename": "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50"
-                "_theta-0.00_20240207T102740.CCSDS",
-            },
-        )
-    ],
-    indirect=True,
-)
-def test_cdf_tof(ccsds_path_theta_0, decom_test_data):
-    """Tests that CDF file is created and contains same attributes as xarray."""
-    decom_ultra_tof, _ = decom_test_data
-    test_data = ultra_l1a(
-        ccsds_path_theta_0, data_version="001", apid=ULTRA_TOF.apid[0]
-    )
+def test_cdf_tof(ccsds_path_theta_0):
+    """Tests that CDF file can be created."""
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_TOF.apid[0])
     test_data_path = write_cdf(test_data[0])
-
     assert test_data_path.exists()
-    assert test_data_path.name == "imap_ultra_l1a_45sensor-histogram_20240207_v001.cdf"
-
-    dataset_tof = create_dataset({ULTRA_TOF.apid[0]: decom_ultra_tof})
-    input_xarray_tof = load_cdf(test_data_path)
-    # write_cdf() injects some attributes that are not in the xarray
-    assert set(dataset_tof.attrs.keys()).issubset(set(input_xarray_tof.attrs.keys()))
-
-
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_EVENTS.apid[0],
-                "filename": "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50"
-                "_theta-0.00_20240207T102740.CCSDS",
-            },
-        )
-    ],
-    indirect=True,
-)
-def test_cdf_events(ccsds_path_theta_0, decom_ultra_aux, decom_test_data):
-    """Tests that CDF file is created and contains same attributes as xarray."""
-    decom_ultra_events, _ = decom_test_data
-    test_data = ultra_l1a(
-        ccsds_path_theta_0, data_version="001", apid=ULTRA_EVENTS.apid[0]
+    assert (
+        test_data_path.name
+        == "imap_ultra_l1a_45sensor-histogram-ena-phxtof-hi-ang_20240207_v999.cdf"
     )
+
+
+def test_cdf_events(ccsds_path_theta_0):
+    """Tests that CDF file can be created."""
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_EVENTS.apid[0])
     test_data_path = write_cdf(test_data[0], istp=False)
 
     assert test_data_path.exists()
-    assert test_data_path.name == "imap_ultra_l1a_45sensor-de_20240207_v001.cdf"
+    assert test_data_path.name == "imap_ultra_l1a_45sensor-de_20240207_v999.cdf"
 
-    dataset_events = create_dataset({ULTRA_EVENTS.apid[0]: decom_ultra_events})
-    input_xarray_events = load_cdf(test_data_path)
 
-    # write_cdf() injects some attributes that are not in the xarray
-    assert set(dataset_events.attrs.keys()).issubset(
-        set(input_xarray_events.attrs.keys())
-    )
+def test_cdf_hk(ccsds_path_theta_0):
+    """Tests that CDF file can be created."""
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=869)
+    data = test_data[0]
+    data.attrs["Data_version"] = "v999"
+    test_data_path = write_cdf(data, istp=True)
+
+    assert test_data_path.exists()
+    assert test_data_path.name == "imap_ultra_l1a_45sensor-status_20240207_v999.cdf"
 
 
 def test_get_event_id():
     """Test get_event_id"""
-    decom_ultra_dict = {
-        ULTRA_EVENTS.apid[0]: {"SHCOARSE": [445015662, 445015663, 445015664, 445015664]}
-    }
-    decom_events = get_event_id(decom_ultra_dict)
+    data = np.array([445015662, 445015663, 445015664, 445015664])
+    decom_events = get_event_id(data)
     counters_for_met = []
-    for i in range(len(decom_events["EVENTID"])):
-        event_id = decom_events["EVENTID"][i]
+    for i in range(len(decom_events)):
+        event_id = decom_events[i]
         met_extracted = event_id >> np.int64(31)
 
-        assert met_extracted == np.int64(
-            decom_ultra_dict[ULTRA_EVENTS.apid[0]]["SHCOARSE"][i]
-        )
+        assert met_extracted == np.int64(data[i])
         counters_for_met.append(event_id & np.int64(0x7FFFFFFF))
 
     assert counters_for_met == [0, 0, 0, 1]

imap_processing/tests/ultra/unit/test_ultra_l1b.py

@@ -7,7 +7,7 @@ from imap_processing.ultra.l1b.ultra_l1b import ultra_l1b
 from imap_processing.ultra.utils.ultra_l1_utils import create_dataset
 
 
-@pytest.fixture()
+@pytest.fixture
 def mock_data_l1a_rates_dict():
     # Create sample data for the xarray Dataset
     epoch = np.arange(
@@ -30,7 +30,7 @@ def mock_data_l1a_rates_dict():
     return data_dict
 
 
-@pytest.fixture()
+@pytest.fixture
 def mock_data_l1b_de_dict():
     epoch = np.array(
         [760591786368000000, 760591787368000000, 760591788368000000],
@@ -40,8 +40,12 @@ def mock_data_l1b_de_dict():
     return data_dict
 
 
-@pytest.fixture()
+@pytest.fixture
 def mock_data_l1b_extendedspin_dict():
+    epoch = np.array(
+        [760591786368000000, 760591787368000000, 760591788368000000],
+        dtype="datetime64[ns]",
+    )
     spin = np.array(
         [0, 1, 2],
         dtype="uint32",
@@ -53,6 +57,7 @@ def mock_data_l1b_extendedspin_dict():
     spin_start_time = np.array([0, 1, 2], dtype="uint64")
     quality = np.zeros((2, 3), dtype="uint16")
     data_dict = {
+        "epoch": epoch,
         "spin_number": spin,
         "energy_bin_geometric_mean": energy,
         "spin_start_time": spin_start_time,
@@ -67,7 +72,6 @@ def test_create_extendedspin_dataset(mock_data_l1b_extendedspin_dict):
         mock_data_l1b_extendedspin_dict,
         "imap_ultra_l1b_45sensor-extendedspin",
         "l1b",
-        "001",
     )
 
     assert "spin_number" in dataset.coords
@@ -82,9 +86,7 @@ def test_create_extendedspin_dataset(mock_data_l1b_extendedspin_dict):
 
 def test_create_de_dataset(mock_data_l1b_de_dict):
     """Tests that dataset is created as expected."""
-    dataset = create_dataset(
-        mock_data_l1b_de_dict, "imap_ultra_l1b_45sensor-de", "l1b", "001"
-    )
+    dataset = create_dataset(mock_data_l1b_de_dict, "imap_ultra_l1b_45sensor-de", "l1b")
 
     assert "epoch" in dataset.coords
     assert dataset.coords["epoch"].dtype == "datetime64[ns]"
@@ -106,9 +108,9 @@ def test_ultra_l1b(l1b_de_dataset):
 
 def test_cdf_de(l1b_de_dataset):
     """Tests that CDF file is created and contains same attributes as xarray."""
-    test_data_path = write_cdf(l1b_de_dataset[0], istp=False)
+    test_data_path = write_cdf(l1b_de_dataset[0], istp=True)
     assert test_data_path.exists()
-    assert test_data_path.name == "imap_ultra_l1b_45sensor-de_20240207_v001.cdf"
+    assert test_data_path.name == "imap_ultra_l1b_45sensor-de_20240207_v999.cdf"
 
 
 def test_ultra_l1b_extendedspin(l1b_extendedspin_dataset):
@@ -130,13 +132,29 @@ def test_ultra_l1b_extendedspin(l1b_extendedspin_dataset):
 
 def test_cdf_extendedspin(l1b_extendedspin_dataset):
     """Tests that CDF file is created and contains same attributes as xarray."""
-    test_data_path = write_cdf(l1b_extendedspin_dataset[0], istp=False)
+    test_data_path = write_cdf(l1b_extendedspin_dataset[0], istp=True)
+    assert test_data_path.exists()
+    assert (
+        test_data_path.name == "imap_ultra_l1b_45sensor-extendedspin_20240207_v999.cdf"
+    )
+
+
+def test_cdf_cullingmask(l1b_extendedspin_dataset):
+    """Tests that CDF file is created and contains same attributes as xarray."""
+    test_data_path = write_cdf(l1b_extendedspin_dataset[1], istp=True)
     assert test_data_path.exists()
     assert (
-        test_data_path.name == "imap_ultra_l1b_45sensor-extendedspin_20000101_v001.cdf"
+        test_data_path.name == "imap_ultra_l1b_45sensor-cullingmask_20240207_v999.cdf"
     )
 
 
+def test_cdf_badtimes(l1b_extendedspin_dataset):
+    """Tests that CDF file is created and contains same attributes as xarray."""
+    test_data_path = write_cdf(l1b_extendedspin_dataset[2], istp=True)
+    assert test_data_path.exists()
+    assert test_data_path.name == "imap_ultra_l1b_45sensor-badtimes_20240207_v999.cdf"
+
+
 def test_ultra_l1b_error(mock_data_l1a_rates_dict):
     """Tests that L1a data throws an error."""
     mock_data_l1a_rates_dict["bad_key"] = mock_data_l1a_rates_dict.pop(
@@ -145,4 +163,4 @@ def test_ultra_l1b_error(mock_data_l1a_rates_dict):
     with pytest.raises(
         ValueError, match="Data dictionary does not contain the expected keys."
     ):
-        ultra_l1b(mock_data_l1a_rates_dict, data_version="001")
+        ultra_l1b(mock_data_l1a_rates_dict)

imap_processing/tests/ultra/unit/test_ultra_l1b_annotated.py

@@ -10,7 +10,7 @@ from imap_processing.ultra.l1b.ultra_l1b_annotated import (
 )
 
 
-@pytest.fixture()
+@pytest.fixture
 def kernels(spice_test_data_path):
     """List SPICE kernels."""
     required_kernels = [
@@ -28,7 +28,7 @@ def kernels(spice_test_data_path):
     return kernels
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 def test_get_particle_velocity(spice_test_data_path, kernels):
     """Tests get_particle_velocity function."""
     spiceypy.furnsh(kernels)

imap_processing/tests/ultra/unit/test_ultra_l1b_culling.py

@@ -3,6 +3,7 @@
 import numpy as np
 import pytest
 
+from imap_processing import imap_module_directory
 from imap_processing.quality_flags import ImapAttitudeUltraFlags, ImapRatesUltraFlags
 from imap_processing.ultra.constants import UltraConstants
 from imap_processing.ultra.l1b.ultra_l1b_culling import (
@@ -14,8 +15,10 @@ from imap_processing.ultra.l1b.ultra_l1b_culling import (
     get_spin_data,
 )
 
+TEST_PATH = imap_module_directory / "tests" / "ultra" / "data" / "l1"
 
-@pytest.fixture()
+
+@pytest.fixture
 def test_data(use_fake_spin_data_for_time):
     """Fixture to compute and return test data."""