imap-processing 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

imap_processing/tests/codice/test_codice_l1a.py

@@ -1,7 +1,6 @@
 """Tests the L1a processing for decommutated CoDICE data"""
 
 import logging
-from pathlib import Path
 
 import numpy as np
 import pytest
@@ -10,139 +9,172 @@ import xarray as xr
 from imap_processing.cdf.utils import load_cdf, write_cdf
 from imap_processing.codice.codice_l1a import process_codice_l1a
 
-from .conftest import TEST_PACKETS, VALIDATION_DATA
+from .conftest import TEST_L0_FILE, VALIDATION_DATA
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 
-# TODO: Add test that processes a file with multiple APIDs
-
 EXPECTED_ARRAY_SHAPES = [
-    (99,),  # hskp
-    (1, 1, 6, 1),  # hi-counters-aggregated  # TODO: Double check with Joey
-    (1, 1, 16, 1),  # hi-counters-singles  # TODO: Double check with Joey
-    (1, 15, 4, 1),  # hi-omni  # TODO: Double check with Joey
-    (1, 8, 12, 12),  # hi-sectored
-    (1, 1),  # hi-pha
-    (1, 6, 6, 128),  # lo-counters-aggregated
-    (1, 24, 6, 128),  # lo-counters-singles
-    (1, 5, 12, 128),  # lo-sw-angular
-    (1, 19, 12, 128),  # lo-nsw-angular
-    (1, 1, 12, 128),  # lo-sw-priority
-    (1, 1, 12, 128),  # lo-nsw-priority
-    (1, 1, 1, 128),  # lo-sw-species
-    (1, 1, 1, 128),  # lo-nsw-species
-    (1, 128),  # lo-pha
+    (),  # hi-ialirt  # TODO: Need to implement
+    (),  # lo-ialirt  # TODO: Need to implement
+    (31778,),  # hskp
+    (77, 6, 6, 128),  # lo-counters-aggregated
+    (77, 24, 6, 128),  # lo-counters-singles
+    (77, 1, 12, 128),  # lo-sw-priority
+    (77, 1, 12, 128),  # lo-nsw-priority
+    (77, 1, 1, 128),  # lo-sw-species
+    (77, 1, 1, 128),  # lo-nsw-species
+    (77, 5, 12, 128),  # lo-sw-angular
+    (77, 19, 12, 128),  # lo-nsw-angular
+    (77, 1, 6, 1),  # hi-counters-aggregated
+    (77, 1, 12, 1),  # hi-counters-singles
+    (77, 15, 4, 1),  # hi-omni
+    (77, 8, 12, 12),  # hi-sectored
+    (),  # hi-priority  # TODO: Need to implement
+    (),  # lo-pha  # TODO: Need to implement
+    (),  # hi-pha  # TODO: Need to implement
 ]
-EXPECTED_LOGICAL_SOURCE = [
+
+EXPECTED_LOGICAL_SOURCES = [
+    "imap_codice_l1a_hi-ialirt",
+    "imap_codice_l1a_lo-ialirt",
     "imap_codice_l1a_hskp",
-    "imap_codice_l1a_hi-counters-aggregated",
-    "imap_codice_l1a_hi-counters-singles",
-    "imap_codice_l1a_hi-omni",
-    "imap_codice_l1a_hi-sectored",
-    "imap_codice_l1a_hi-pha",
     "imap_codice_l1a_lo-counters-aggregated",
     "imap_codice_l1a_lo-counters-singles",
-    "imap_codice_l1a_lo-sw-angular",
-    "imap_codice_l1a_lo-nsw-angular",
     "imap_codice_l1a_lo-sw-priority",
     "imap_codice_l1a_lo-nsw-priority",
     "imap_codice_l1a_lo-sw-species",
     "imap_codice_l1a_lo-nsw-species",
+    "imap_codice_l1a_lo-sw-angular",
+    "imap_codice_l1a_lo-nsw-angular",
+    "imap_codice_l1a_hi-counters-aggregated",
+    "imap_codice_l1a_hi-counters-singles",
+    "imap_codice_l1a_hi-omni",
+    "imap_codice_l1a_hi-sectored",
+    "imap_codice_l1a_hi-priority",
     "imap_codice_l1a_lo-pha",
+    "imap_codice_l1a_hi-pha",
 ]
+
 EXPECTED_NUM_VARIABLES = [
-    129,  # hskp
-    1,  # hi-counters-aggregated
-    3,  # hi-counters-singles
-    8,  # hi-omni
-    4,  # hi-sectored
-    0,  # hi-pha
+    0,  # hi-ialirt  # TODO: Need to implement
+    0,  # lo-ialirt  # TODO: Need to implement
+    148,  # hskp
     3,  # lo-counters-aggregated
     3,  # lo-counters-singles
-    6,  # lo-sw-angular
-    3,  # lo-nsw-angular
     7,  # lo-sw-priority
     4,  # lo-nsw-priority
     18,  # lo-sw-species
     10,  # lo-nsw-species
-    0,  # lo-pha
+    6,  # lo-sw-angular
+    3,  # lo-nsw-angular
+    1,  # hi-counters-aggregated
+    3,  # hi-counters-singles
+    8,  # hi-omni
+    4,  # hi-sectored
+    0,  # hi-priority  # TODO: Need to implement
+    0,  # lo-pha  # TODO: Need to implement
+    0,  # hi-pha  # TODO: Need to implement
 ]
 
 
-@pytest.fixture(params=TEST_PACKETS)
-def test_l1a_data(request) -> xr.Dataset:
+@pytest.fixture(scope="session")
+def test_l1a_data() -> xr.Dataset:
     """Return a ``xarray`` dataset containing test data.
 
     Returns
     -------
-    dataset : xarray.Dataset
-        A ``xarray`` dataset containing the test data
+    processed_datasets : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
     """
 
-    dataset = process_codice_l1a(file_path=request.param, data_version="001")
+    processed_datasets = process_codice_l1a(file_path=TEST_L0_FILE, data_version="001")
+
+    return processed_datasets
+
+
+@pytest.mark.parametrize("index", range(len(EXPECTED_ARRAY_SHAPES)))
+def test_l1a_data_array_shape(test_l1a_data, index):
+    """Tests that the data arrays in the generated CDFs have the expected shape.
+
+    Parameters
+    ----------
+    test_l1a_data : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
+    index : int
+        The index of the list to test
+    """
+
+    processed_dataset = test_l1a_data[index]
+    expected_shape = EXPECTED_ARRAY_SHAPES[index]
+
+    # Mark currently broken/unsupported datasets as expected to fail
+    # TODO: Remove these once they are supported
+    if index in [0, 1, 15, 16, 17]:
+        pytest.xfail("Data product is currently unsupported")
 
-    # Write the dataset to a CDF so it can be manually inspected as well
-    file_path = write_cdf(dataset)
-    logger.info(f"CDF file written to {file_path}")
+    for variable in processed_dataset:
+        if variable in ["energy_table", "acquisition_time_per_step"]:
+            assert processed_dataset[variable].data.shape == (128,)
+        else:
+            assert processed_dataset[variable].data.shape == expected_shape
 
-    return dataset
 
+@pytest.mark.parametrize("index", range(len(EXPECTED_LOGICAL_SOURCES)))
+def test_l1a_logical_sources(test_l1a_data, index):
+    """Tests that the Logical source of the dataset is what is expected.
 
-@pytest.mark.xfail(reason="Epoch variable data needs to monotonically increase")
-@pytest.mark.parametrize(
-    "test_l1a_data, expected_logical_source",
-    list(zip(TEST_PACKETS, EXPECTED_LOGICAL_SOURCE)),
-    indirect=["test_l1a_data"],
-)
-def test_l1a_cdf_filenames(test_l1a_data: xr.Dataset, expected_logical_source: str):
-    """Tests that the ``process_codice_l1a`` function generates datasets
-    with the expected logical source.
+    Since the logical source gets set by ``write_cdf``, this also tests that
+    the dataset can be written to a file.
 
     Parameters
     ----------
-    test_l1a_data : xarray.Dataset
-        A ``xarray`` dataset containing the test data
-    expected_logical_source : str
-        The expected CDF filename
+    test_l1a_data : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
+    index : int
+        The index of the list to test
     """
 
-    dataset = test_l1a_data
-    assert dataset.attrs["Logical_source"] == expected_logical_source
+    processed_dataset = test_l1a_data[index]
+    expected_logical_source = EXPECTED_LOGICAL_SOURCES[index]
 
+    # Mark currently broken/unsupported datasets as expected to fail
+    # TODO: Remove these once they are supported
+    if index in [0, 1, 2, 15, 16, 17]:
+        pytest.xfail("Data product is currently unsupported")
 
-@pytest.mark.xfail(reason="Epoch variable data needs to monotonically increase")
-@pytest.mark.parametrize(
-    "test_l1a_data, expected_shape",
-    list(zip(TEST_PACKETS, EXPECTED_ARRAY_SHAPES)),
-    indirect=["test_l1a_data"],
-)
-def test_l1a_data_array_shape(test_l1a_data: xr.Dataset, expected_shape: tuple):
-    """Tests that the data arrays in the generated CDFs have the expected shape.
+    # Write the dataset to a file to set the logical source attribute
+    _ = write_cdf(processed_dataset)
+
+    assert processed_dataset.attrs["Logical_source"] == expected_logical_source
+
+
+@pytest.mark.parametrize("index", range(len(EXPECTED_NUM_VARIABLES)))
+def test_l1a_num_variables(test_l1a_data, index):
+    """Tests that the data arrays in the generated CDFs have the expected number
+    of variables.
 
     Parameters
     ----------
-    test_l1a_data : xarray.Dataset
-        A ``xarray`` dataset containing the test data
-    expected_shape : tuple
-        The expected shape of the data array
+    test_l1a_data : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
+    index : int
+        The index of the list to test
     """
 
-    dataset = test_l1a_data
-    for variable in dataset:
-        if variable in ["energy_table", "acquisition_time_per_step"]:
-            assert dataset[variable].data.shape == (128,)
-        else:
-            assert dataset[variable].data.shape == expected_shape
+    processed_dataset = test_l1a_data[index]
+
+    # Mark currently broken/unsupported datasets as expected to fail
+    # TODO: Remove these once they are supported
+    if index in [0, 1, 15, 16, 17]:
+        pytest.xfail("Data product is currently unsupported")
+
+    assert len(processed_dataset) == EXPECTED_NUM_VARIABLES[index]
 
 
 @pytest.mark.skip("Awaiting validation data")
-@pytest.mark.parametrize(
-    "test_l1a_data, validation_data",
-    list(zip(TEST_PACKETS, VALIDATION_DATA)),
-    indirect=["test_l1a_data"],
-)
-def test_l1a_data_array_values(test_l1a_data: xr.Dataset, validation_data: Path):
+@pytest.mark.parametrize("index", range(len(VALIDATION_DATA)))
+def test_l1a_data_array_values(test_l1a_data: xr.Dataset, index):
     """Tests that the generated L1a CDF contents are valid.
 
     Once proper validation files are acquired, this test function should point
@@ -151,40 +183,28 @@ def test_l1a_data_array_values(test_l1a_data: xr.Dataset, validation_data: Path)
 
     Parameters
     ----------
-    test_l1a_data : xarray.Dataset
-        A ``xarray`` dataset containing the test data
-    validataion_data : pathlib.Path
-        The path to the file containing the validation data
+    test_l1a_data : list[xarray.Dataset]
+        A list of ``xarray`` datasets containing the test data
+    index : int
+        The index of the list to test
     """
 
     generated_dataset = test_l1a_data
-    validation_dataset = load_cdf(validation_data)
+    validation_dataset = load_cdf(VALIDATION_DATA[index])
 
     # Ensure the processed data matches the validation data
     for variable in validation_dataset:
         assert variable in generated_dataset
         if variable != "epoch":
             np.testing.assert_array_equal(
-                validation_data[variable].data, generated_dataset[variable].data[0]
+                validation_dataset[variable].data, generated_dataset[variable].data[0]
             )
 
 
-@pytest.mark.xfail(reason="Epoch variable data needs to monotonically increase")
-@pytest.mark.parametrize(
-    "test_l1a_data, expected_num_variables",
-    list(zip(TEST_PACKETS, EXPECTED_NUM_VARIABLES)),
-    indirect=["test_l1a_data"],
-)
-def test_l1a_num_variables(test_l1a_data: xr.Dataset, expected_num_variables: int):
-    """Tests that the data arrays in the generated CDFs have the expected size.
+def test_l1a_multiple_packets():
+    """Tests that an input L0 file containing multiple APIDs can be processed."""
 
-    Parameters
-    ----------
-    test_l1a_data : xarray.Dataset
-        A ``xarray`` dataset containing the test data
-    expected_num_variables : int
-        The expected number of data variables in the CDF
-    """
+    processed_datasets = process_codice_l1a(file_path=TEST_L0_FILE, data_version="001")
 
-    dataset = test_l1a_data
-    assert len(dataset) == expected_num_variables
+    # TODO: Could add some more checks here?
+    assert len(processed_datasets) == 18

imap_processing/tests/codice/test_codice_l1b.py

@@ -39,6 +39,7 @@ def test_l1b_data(request) -> xr.Dataset:
     return dataset
 
 
+@pytest.mark.skip("Awaiting proper implementation of L1B")
 @pytest.mark.parametrize(
     "test_l1b_data, expected_logical_source",
     list(zip(TEST_L1A_FILES, EXPECTED_LOGICAL_SOURCE)),

imap_processing/tests/codice/test_decompress.py

@@ -10,14 +10,14 @@ from imap_processing.codice.utils import CoDICECompression
 
 # Test the algorithms using input value of 234 (picked randomly)
 lzma_bytes = lzma.compress((234).to_bytes(1, byteorder="big"))
-LZMA_EXAMPLE = "".join(format(byte, "08b") for byte in lzma_bytes)
+# LZMA_EXAMPLE = "".join(format(byte, "08b") for byte in lzma_bytes)
 TEST_DATA = [
-    ("11101010", CoDICECompression.NO_COMPRESSION, [234]),
-    ("11101010", CoDICECompression.LOSSY_A, [221184]),
-    ("11101010", CoDICECompression.LOSSY_B, [1441792]),
-    (LZMA_EXAMPLE, CoDICECompression.LOSSLESS, [234]),
-    (LZMA_EXAMPLE, CoDICECompression.LOSSY_A_LOSSLESS, [221184]),
-    (LZMA_EXAMPLE, CoDICECompression.LOSSY_B_LOSSLESS, [1441792]),
+    (b"\xea", CoDICECompression.NO_COMPRESSION, [234]),
+    (b"\xea", CoDICECompression.LOSSY_A, [221184]),
+    (b"\xea", CoDICECompression.LOSSY_B, [1441792]),
+    (lzma_bytes, CoDICECompression.LOSSLESS, [234]),
+    (lzma_bytes, CoDICECompression.LOSSY_A_LOSSLESS, [221184]),
+    (lzma_bytes, CoDICECompression.LOSSY_B_LOSSLESS, [1441792]),
 ]
 
 

imap_processing/tests/conftest.py

@@ -297,19 +297,55 @@ def _unset_metakernel_path(monkeypatch):
 
 
 @pytest.fixture()
-def _set_spin_data_filepath(monkeypatch, tmpdir, generate_spin_data):
-    """Set the SPIN_DATA_FILEPATH environment variable"""
-    # SWE test data time minus 56120 seconds to get mid-night time
-    start_time = 453051323.0 - 56120
-    spin_df = generate_spin_data(start_time)
-    spin_csv_file_path = tmpdir / "spin_data.spin.csv"
-    spin_df.to_csv(spin_csv_file_path, index=False)
-    monkeypatch.setenv("SPIN_DATA_FILEPATH", str(spin_csv_file_path))
+def use_test_spin_data_csv(monkeypatch):
+    """Sets the SPIN_DATA_FILEPATH environment variable to input path."""
+
+    def wrapped_set_spin_data_filepath(path: Path):
+        monkeypatch.setenv("SPIN_DATA_FILEPATH", str(path))
+
+    return wrapped_set_spin_data_filepath
+
+
+@pytest.fixture()
+def use_fake_spin_data_for_time(
+    request, use_test_spin_data_csv, tmpdir, generate_spin_data
+):
+    """
+    Generate and use fake spin data for testing.
+
+    Returns
+    -------
+    callable
+        Returns a callable function that takes start_met and optionally end_met
+        as inputs, generates fake spin data, writes the data to a csv file,
+        and sets the SPIN_DATA_FILEPATH environment variable to point to the
+        fake spin data file.
+    """
+
+    def wrapped_set_spin_data_filepath(
+        start_met: float, end_met: Optional[int] = None
+    ) -> pd.DataFrame:
+        """
+        Generate and use fake spin data for testing.
+        Parameters
+        ----------
+        start_met : int
+            Provides the start time in Mission Elapsed Time (MET).
+        end_met : int
+            Provides the end time in MET. If not provided, default to one day
+            from start time.
+        """
+        spin_df = generate_spin_data(start_met, end_met=end_met)
+        spin_csv_file_path = tmpdir / "spin_data.spin.csv"
+        spin_df.to_csv(spin_csv_file_path, index=False)
+        use_test_spin_data_csv(spin_csv_file_path)
+
+    return wrapped_set_spin_data_filepath
 
 
 @pytest.fixture()
 def generate_spin_data():
-    def make_data(start_met: int, end_met: Optional[int] = None) -> pd.DataFrame:
+    def make_data(start_met: float, end_met: Optional[float] = None) -> pd.DataFrame:
         """
         Generate a spin table CSV covering one or more days.
         Spin table contains the following fields:
@@ -324,14 +360,14 @@ def generate_spin_data():
             thruster_firing
             )
         This function creates spin data using start MET and end MET time.
-        Each spin start data uses the nominal 15 second spin period. The spins that
+        Each spin start data uses the nominal 15-second spin period. The spins that
         occur from 00:00(Mid-night) to 00:10 UTC are marked with flags for
         thruster firing, invalid spin period, and invalid spin phase.
         Parameters
         ----------
-        start_met : int
+        start_met : float
             Provides the start time in Mission Elapsed Time (MET).
-        end_met : int
+        end_met : float
             Provides the end time in MET. If not provided, default to one day
             from start time.
         Returns
@@ -344,7 +380,8 @@ def generate_spin_data():
             end_met = start_met + 86400
 
         # Create spin start second data of 15 seconds increment
-        spin_start_sec = np.arange(start_met, end_met + 1, 15)
+        spin_start_sec = np.arange(np.floor(start_met), end_met + 1, 15)
+        spin_start_subsec = int((start_met - spin_start_sec[0]) * 1000)
 
         nspins = len(spin_start_sec)
 
@@ -352,7 +389,9 @@ def generate_spin_data():
             {
                 "spin_number": np.arange(nspins, dtype=np.uint32),
                 "spin_start_sec": spin_start_sec,
-                "spin_start_subsec": np.zeros(nspins, dtype=np.uint32),
+                "spin_start_subsec": np.full(
+                    nspins, spin_start_subsec, dtype=np.uint32
+                ),
                 "spin_period_sec": np.full(nspins, 15.0, dtype=np.float32),
                 "spin_period_valid": np.ones(nspins, dtype=np.uint8),
                 "spin_phase_valid": np.ones(nspins, dtype=np.uint8),
@@ -362,7 +401,7 @@ def generate_spin_data():
         )
 
         # Convert spin_start_sec to datetime to set repointing times flags
-        spin_start_dates = met_to_j2000ns(spin_start_sec)
+        spin_start_dates = met_to_j2000ns(spin_start_sec + spin_start_subsec / 1000)
         spin_start_dates = cdflib.cdfepoch.to_datetime(spin_start_dates)
 
         # Convert DatetimeIndex to Series for using .dt accessor

imap_processing/tests/glows/conftest.py

@@ -6,6 +6,7 @@ import pytest
 from imap_processing.glows.l0 import decom_glows
 from imap_processing.glows.l1a.glows_l1a import glows_l1a, process_de_l0
 from imap_processing.glows.l1a.glows_l1a_data import HistogramL1A
+from imap_processing.glows.l1b.glows_l1b import glows_l1b
 
 
 @pytest.fixture()
@@ -40,3 +41,8 @@ def l1a_test_data(decom_test_data):
 @pytest.fixture()
 def l1a_dataset(packet_path):
     return glows_l1a(packet_path, "v001")
+
+
+@pytest.fixture()
+def l1b_hist_dataset(l1a_dataset):
+    return glows_l1b(l1a_dataset[0], "v001")

imap_processing/tests/glows/test_glows_l1b.py

@@ -318,23 +318,23 @@ def test_glows_l1b(de_dataset, hist_dataset):
         "imap_spin_angle_bin_cntr",
         "histogram_flag_array",
         "filter_temperature_average",
-        "filter_temperature_variance",
+        "filter_temperature_std_dev",
         "hv_voltage_average",
-        "hv_voltage_variance",
+        "hv_voltage_std_dev",
         "spin_period_average",
-        "spin_period_variance",
+        "spin_period_std_dev",
         "pulse_length_average",
-        "pulse_length_variance",
+        "pulse_length_std_dev",
         "spin_period_ground_average",
-        "spin_period_ground_variance",
+        "spin_period_ground_std_dev",
         "position_angle_offset_average",
-        "position_angle_offset_variance",
-        "spin_axis_orientation_variance",
+        "position_angle_offset_std_dev",
+        "spin_axis_orientation_std_dev",
         "spin_axis_orientation_average",
         "spacecraft_location_average",
-        "spacecraft_location_variance",
+        "spacecraft_location_std_dev",
         "spacecraft_velocity_average",
-        "spacecraft_velocity_variance",
+        "spacecraft_velocity_std_dev",
         "flags",
     ]
 

imap_processing/tests/glows/test_glows_l1b_data.py

@@ -102,24 +102,24 @@ def test_validation_data_histogram(l1a_dataset):
         # "imap_spin_angle_bin_cntr": "imap_spin_angle_bin_cntr",
         # "histogram_flag_array": "histogram_flag_array",
         "filter_temperature_average": "filter_temperature_average",
-        "filter_temperature_std_dev": "filter_temperature_variance",
+        "filter_temperature_std_dev": "filter_temperature_std_dev",
         "hv_voltage_average": "hv_voltage_average",
-        "hv_voltage_std_dev": "hv_voltage_variance",
+        "hv_voltage_std_dev": "hv_voltage_std_dev",
         "spin_period_average": "spin_period_average",
-        "spin_period_std_dev": "spin_period_variance",
+        "spin_period_std_dev": "spin_period_std_dev",
         "pulse_length_average": "pulse_length_average",
-        "pulse_length_std_dev": "pulse_length_variance",
+        "pulse_length_std_dev": "pulse_length_std_dev",
         # TODO uncomment when spice is complete
         # "spin_period_ground_average": "spin_period_ground_average",
-        # "spin_period_ground_std_dev": "spin_period_ground_variance",
+        # "spin_period_ground_std_dev": "spin_period_ground_std_dev",
         # "position_angle_offset_average": "position_angle_offset_average",
-        # "position_angle_offset_std_dev": "position_angle_offset_variance",
+        # "position_angle_offset_std_dev": "position_angle_offset_std_dev",
         # "spin_axis_orientation_average": "spin_axis_orientation_average",
-        # "spin_axis_orientation_std_dev": "spin_axis_orientation_variance",
+        # "spin_axis_orientation_std_dev": "spin_axis_orientation_std_dev",
         # "spacecraft_location_average": "spacecraft_location_average",
-        # "spacecraft_location_std_dev": "spacecraft_location_variance",
+        # "spacecraft_location_std_dev": "spacecraft_location_std_dev",
         # "spacecraft_velocity_average": "spacecraft_velocity_average",
-        # "spacecraft_velocity_std_dev": "spacecraft_velocity_variance",
+        # "spacecraft_velocity_std_dev": "spacecraft_velocity_std_dev",
     }
 
     for index, validation_output in enumerate(out["output"]):

imap_processing/tests/hi/test_hi_l1b.py

@@ -12,6 +12,8 @@ from imap_processing.hi.l1b.hi_l1b import (
     CoincidenceBitmap,
     compute_coincidence_type_and_time_deltas,
     compute_hae_coordinates,
+    de_esa_energy_step,
+    de_nominal_bin_and_spin_phase,
     hi_l1b,
 )
 from imap_processing.hi.utils import HiConstants
@@ -32,9 +34,13 @@ def test_hi_l1b_hk(hi_l0_test_data_path):
 
 @pytest.mark.external_kernel()
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
-def test_hi_l1b_de(hi_l1a_test_data_path):
+def test_hi_l1b_de(
+    hi_l1a_test_data_path, spice_test_data_path, use_fake_spin_data_for_time
+):
     """Test coverage for imap_processing.hi.hi_l1b.hi_l1b() with
     direct events L1A as input"""
+    # Start MET time of spin for simulated input data is 482372988
+    use_fake_spin_data_for_time(482372988)
     l1a_test_file_path = (
         hi_l1a_test_data_path / "imap_hi_l1a_45sensor-de_20250415_v000.cdf"
     )
@@ -152,6 +158,53 @@ def test_compute_coincidence_type_and_time_deltas(synthetic_trigger_id_and_tof_d
     )
 
 
+@mock.patch("imap_processing.hi.l1b.hi_l1b.parse_sensor_number", return_value=90)
+@mock.patch("imap_processing.hi.l1b.hi_l1b.get_instrument_spin_phase")
+@mock.patch("imap_processing.hi.l1b.hi_l1b.get_spacecraft_spin_phase")
+def test_de_nominal_bin_and_spin_phase(
+    spacecraft_phase_moc, instrument_phase_mock, parse_sensor_number_mock
+):
+    """Test coverage for de_nominal_bin_and_spin_phase."""
+    # set the spacecraft_phase_mock to return an array of values between 0 and 1
+    # that is rolled 30 places for easy testing
+    spacecraft_phase_roll = 30
+    spacecraft_phase_moc.side_effect = lambda x: np.roll(
+        np.arange(0, 1, 1 / len(x)), spacecraft_phase_roll
+    )
+    # set the get_instrument_spin_phase mock to return an array of values between
+    # 0 and 1
+    instrument_phase_mock.side_effect = lambda x, y: np.arange(0, 1, 1 / len(x))
+    # generate a fake dataset with epoch coordinate and event_met variable
+    de_list_length = 720
+    synthetic_ds = xr.Dataset(
+        coords={
+            "epoch": xr.DataArray(
+                np.arange(de_list_length), name="epoch", dims=["epoch"]
+            )
+        },
+        data_vars={
+            "event_met": xr.DataArray(np.arange(de_list_length), dims=["epoch"])
+        },
+        attrs={"Logical_source": "foo_source"},
+    )
+
+    new_vars = de_nominal_bin_and_spin_phase(synthetic_ds)
+    # Check spin_phase
+    assert "spin_phase" in new_vars
+    assert new_vars["spin_phase"].shape == (de_list_length,)
+    np.testing.assert_array_equal(
+        new_vars["spin_phase"].values,
+        np.linspace(0, 1, de_list_length + 1, dtype=np.float32)[:-1],
+    )
+    # Check nominal_bin
+    assert "nominal_bin" in new_vars
+    expected_nominal_bin = np.roll(
+        np.digitize(np.arange(0, 360, 360 / de_list_length), np.arange(90) * 4) - 1,
+        spacecraft_phase_roll,
+    )
+    np.testing.assert_array_equal(new_vars["nominal_bin"].values, expected_nominal_bin)
+
+
 @pytest.mark.parametrize("sensor_number", [45, 90])
 @mock.patch("imap_processing.hi.l1b.hi_l1b.instrument_pointing")
 def test_compute_hae_coordinates(mock_instrument_pointing, sensor_number):
@@ -183,3 +236,20 @@ def test_compute_hae_coordinates(mock_instrument_pointing, sensor_number):
     assert "hae_longitude" in new_vars
     assert new_vars["hae_longitude"].shape == fake_dataset.epoch.shape
     np.testing.assert_allclose(new_vars["hae_longitude"].values, sensor_number)
+
+
+def test_de_esa_energy_step():
+    """Test coverage for de_esa_energy_step function."""
+    n_epoch = 20
+    fake_dataset = xr.Dataset(
+        coords={
+            "epoch": xr.DataArray(np.arange(n_epoch), name="epoch", dims=["epoch"])
+        },
+        data_vars={"esa_step": xr.DataArray(np.arange(n_epoch) % 9, dims=["epoch"])},
+    )
+    esa_energy_step_var = de_esa_energy_step(fake_dataset)
+    # TODO: The below check is for the temporary implementation and should be
+    #    removed when the function is update.
+    np.testing.assert_array_equal(
+        esa_energy_step_var["esa_energy_step"].values, fake_dataset.esa_step.values
+    )