Ensure test order: create_empty after teapod_roundtrip

dmitriyrepin · dmitriyrepin · commit d97412515045 · 2025-10-28T17:18:44.000Z
diff --git a/pyproject.toml b/pyproject.toml
@@ -55,7 +55,6 @@ dev = [
     "pre-commit-hooks>=6.0.0",
     "pytest>=8.4.2",
     "pytest-dependency>=0.6.0",
-    "pytest-order>=1.3.0",
     "typeguard>=4.4.4",
     "xdoctest[colors]>=1.3.0",
     "Pygments>=2.19.2"
diff --git a/tests/integration/test_segy_roundtrip_teapot.py b/tests/integration/test_segy_roundtrip_teapot.py
@@ -9,20 +9,17 @@
 import numpy as np
 import numpy.testing as npt
 import pytest
-from segy.schema import HeaderField
-from segy.schema import ScalarType
-from segy.standards import get_segy_standard
+from tests.integration.testing_helpers import UNITS_METER
+from tests.integration.testing_helpers import UNITS_NONE
+from tests.integration.testing_helpers import UNITS_SECOND
 from tests.integration.testing_helpers import get_inline_header_values
+from tests.integration.testing_helpers import get_teapot_segy_spec
 from tests.integration.testing_helpers import get_values
 from tests.integration.testing_helpers import validate_xr_variable
 
 from mdio import __version__
 from mdio import mdio_to_segy
 from mdio.api.io import open_mdio
-from mdio.builder.schemas.v1.units import LengthUnitEnum
-from mdio.builder.schemas.v1.units import LengthUnitModel
-from mdio.builder.schemas.v1.units import TimeUnitEnum
-from mdio.builder.schemas.v1.units import TimeUnitModel
 from mdio.builder.template_registry import TemplateRegistry
 from mdio.converters.segy import segy_to_mdio
 from mdio.segy.file import SegyFileWrapper
@@ -50,17 +47,6 @@ def teapot_segy_spec() -> SegySpec:
     return get_teapot_segy_spec()
 
 
-def get_teapot_segy_spec() -> SegySpec:
-    """Return the customized SEG-Y specification for the teapot dome dataset."""
-    teapot_fields = [
-        HeaderField(name="inline", byte=17, format=ScalarType.INT32),
-        HeaderField(name="crossline", byte=13, format=ScalarType.INT32),
-        HeaderField(name="cdp_x", byte=81, format=ScalarType.INT32),
-        HeaderField(name="cdp_y", byte=85, format=ScalarType.INT32),
-    ]
-    return get_segy_standard(1.0).customize(trace_header_fields=teapot_fields)
-
-
 def text_header_teapot_dome() -> str:
     """Return the teapot dome expected text header."""
     header_rows = [
@@ -157,12 +143,6 @@ def raw_binary_header_teapot_dome() -> str:
     )
 
 
-UNITS_NONE = None
-UNITS_METER = LengthUnitModel(length=LengthUnitEnum.METER)
-UNITS_SECOND = TimeUnitModel(time=TimeUnitEnum.SECOND)
-
-
-@pytest.mark.order(1)
 class TestTeapotRoundtrip:
     """Tests for Teapot Dome data ingestion and export."""
 
diff --git a/tests/integration/test_z_create_empty.py b/tests/integration/test_z_create_empty.py
@@ -1,4 +1,11 @@
-"""Test for create_empty_mdio function."""
+"""Test for create_empty_mdio function.
+
+This set of tests has to run after the segy_roundtrip_teapot tests have run because
+the teapot dataset is used as the input for the create_empty_like test.
+
+NOTE: The only reliable way to ensure the test order (including the case when the 
+test are run in parallel) is to use the alphabetical order of the test names.
+"""
 
 from __future__ import annotations
 
@@ -22,9 +29,11 @@
     from xarray import Dataset as xr_Dataset
 
 
-from tests.integration.test_segy_roundtrip_teapot import get_teapot_segy_spec
-from tests.integration.testing_helpers import get_values
+from tests.integration.testing_helpers import UNITS_NONE, UNITS_SECOND, UNITS_METER, UNITS_FOOT, UNITS_METER_PER_SECOND, UNITS_FEET_PER_SECOND
+from tests.integration.testing_helpers import get_teapot_segy_spec
 from tests.integration.testing_helpers import validate_xr_variable
+from tests.integration.testing_helpers import get_values
+
 
 from mdio import __version__
 from mdio.api.create import create_empty
@@ -37,14 +46,6 @@
 from mdio.converters.mdio import mdio_to_segy
 from mdio.core import Dimension
 
-UNITS_NONE = None
-UNITS_METER = LengthUnitModel(length=LengthUnitEnum.METER)
-UNITS_SECOND = TimeUnitModel(time=TimeUnitEnum.SECOND)
-UNITS_METER_PER_SECOND = SpeedUnitModel(speed=SpeedUnitEnum.METER_PER_SECOND)
-UNITS_FOOT = LengthUnitModel(length=LengthUnitEnum.FOOT)
-UNITS_FEET_PER_SECOND = SpeedUnitModel(speed=SpeedUnitEnum.FEET_PER_SECOND)
-
-
 class PostStack3DVelocityTemplate(Seismic3DPostStackTemplate):
     """Custom template that uses 'velocity' as the default variable name instead of 'amplitude'."""
 
@@ -80,13 +81,72 @@ def _name(self) -> str:
         domain_suffix = self._data_domain.capitalize()
         return f"PostStack3DVelocity{domain_suffix}"
 
-
-@pytest.mark.order(1000)
 class TestCreateEmptyMdio:
     """Tests for create_empty_mdio function."""
 
     @classmethod
-    def _validate_empty_mdio_dataset(cls, ds: xr_Dataset, has_headers: bool, is_velocity: bool) -> None:
+    def _create_empty_mdio(cls, create_headers: bool, output_path: Path, overwrite: bool = True) -> None:
+        """Create a temporary empty MDIO file for testing."""
+        # Create the grid with the specified dimensions
+        dims = [
+            Dimension(name="inline", coords=range(1, 346, 1)),  # 100-300 with step 1
+            Dimension(name="crossline", coords=range(1, 189, 1)),  # 1000-1600 with step 2
+            Dimension(name="time", coords=range(0, 3002, 2)),  # 0-3 seconds 4ms sample rate
+        ]
+
+        # If later on, we want to export to SEG-Y, we need to provide the trace header spec.
+        # The HeaderSpec can be either standard or customized.
+        headers = get_teapot_segy_spec().trace.header if create_headers else None
+        # Create an empty MDIO v1 metric post-stack 3D time velocity dataset
+        create_empty(
+            mdio_template=PostStack3DVelocityTemplate(data_domain="time", is_metric=True),
+            dimensions=dims,
+            output_path=output_path,
+            headers=headers,
+            overwrite=overwrite,
+        )
+
+    @classmethod
+    def validate_teapod_dataset_metadata(cls, ds: xr_Dataset, is_velocity: bool) -> None:
+        """Validate the dataset metadata."""
+        if is_velocity:
+            assert ds.name == "PostStack3DVelocityTime"
+        else:
+            assert ds.name == "PostStack3DTime"
+
+        # Check basic metadata attributes
+        expected_attrs = {
+            "apiVersion": __version__,
+            "name": ds.name,
+        }
+        actual_attrs_json = ds.attrs
+
+        # Compare one by one due to ever changing createdOn
+        for key, value in expected_attrs.items():
+            assert key in actual_attrs_json
+            if key == "createdOn":
+                assert actual_attrs_json[key] is not None
+            else:
+                assert actual_attrs_json[key] == value
+
+        # Check that createdOn exists
+        assert "createdOn" in actual_attrs_json
+        assert actual_attrs_json["createdOn"] is not None
+
+        # Validate template attributes
+        attributes = ds.attrs["attributes"]
+        assert attributes is not None
+        assert len(attributes) == 3
+        # Validate all attributes provided by the abstract template
+        if is_velocity:
+            assert attributes["defaultVariableName"] == "velocity"
+        else:
+            assert attributes["defaultVariableName"] == "amplitude"
+        assert attributes["surveyType"] == "3D"
+        assert attributes["gatherType"] == "stacked"
+
+    @classmethod
+    def validate_teapod_dataset_variables(cls, ds: xr_Dataset, header_dtype: np.dtype | None, is_velocity: bool) -> None:
         """Validate an empty MDIO dataset structure and content."""
         # Check that the dataset has the expected shape
         assert ds.sizes == {"inline": 345, "crossline": 188, "time": 1501}
@@ -102,10 +162,10 @@ def _validate_empty_mdio_dataset(cls, ds: xr_Dataset, has_headers: bool, is_velo
         validate_xr_variable(ds, "cdp_x", {"inline": 345, "crossline": 188}, UNITS_METER, np.float64)
         validate_xr_variable(ds, "cdp_y", {"inline": 345, "crossline": 188}, UNITS_METER, np.float64)
 
-        if has_headers:
+        if header_dtype is not None:
             # Validate the headers (should be empty for empty dataset)
             # Infer the dtype from segy_spec and ignore endianness
-            header_dtype = get_teapot_segy_spec().trace.header.dtype.newbyteorder("native")
+            header_dtype = header_dtype.newbyteorder("native")
             validate_xr_variable(ds, "headers", {"inline": 345, "crossline": 188}, UNITS_NONE, header_dtype)
             validate_xr_variable(ds, "segy_file_header", dims={}, units=UNITS_NONE, data_type=np.dtype("U1"))
         else:
@@ -127,28 +187,6 @@ def _validate_empty_mdio_dataset(cls, ds: xr_Dataset, has_headers: bool, is_velo
                 ds, "amplitude", {"inline": 345, "crossline": 188, "time": 1501}, UNITS_NONE, np.float32
             )
 
-    @classmethod
-    def _create_empty_mdio(cls, create_headers: bool, output_path: Path, overwrite: bool = True) -> None:
-        """Create a temporary empty MDIO file for testing."""
-        # Create the grid with the specified dimensions
-        dims = [
-            Dimension(name="inline", coords=range(1, 346, 1)),  # 100-300 with step 1
-            Dimension(name="crossline", coords=range(1, 189, 1)),  # 1000-1600 with step 2
-            Dimension(name="time", coords=range(0, 3002, 2)),  # 0-3 seconds 4ms sample rate
-        ]
-
-        # If later on, we want to export to SEG-Y, we need to provide the trace header spec.
-        # The HeaderSpec can be either standard or customized.
-        headers = get_teapot_segy_spec().trace.header if create_headers else None
-        # Create an empty MDIO v1 metric post-stack 3D time velocity dataset
-        create_empty(
-            mdio_template=PostStack3DVelocityTemplate(data_domain="time", is_metric=True),
-            dimensions=dims,
-            output_path=output_path,
-            headers=headers,
-            overwrite=overwrite,
-        )
-
     @pytest.fixture(scope="class")
     def mdio_with_headers(self, empty_mdio_dir: Path) -> Path:
         """Create a temporary empty MDIO file for testing.
@@ -171,56 +209,22 @@ def mdio_no_headers(self, empty_mdio_dir: Path) -> Path:
         self._create_empty_mdio(create_headers=False, output_path=empty_mdio)
         return empty_mdio
 
-    def validate_dataset_metadata(self, ds: xr_Dataset, is_velocity: bool) -> None:
-        """Validate the dataset metadata."""
-        if is_velocity:
-            assert ds.name == "PostStack3DVelocityTime"
-        else:
-            assert ds.name == "PostStack3DTime"
-
-        # Check basic metadata attributes
-        expected_attrs = {
-            "apiVersion": __version__,
-            "name": ds.name,
-        }
-        actual_attrs_json = ds.attrs
-
-        # Compare one by one due to ever changing createdOn
-        for key, value in expected_attrs.items():
-            assert key in actual_attrs_json
-            if key == "createdOn":
-                assert actual_attrs_json[key] is not None
-            else:
-                assert actual_attrs_json[key] == value
-
-        # Check that createdOn exists
-        assert "createdOn" in actual_attrs_json
-        assert actual_attrs_json["createdOn"] is not None
-
-        # Validate template attributes
-        attributes = ds.attrs["attributes"]
-        assert attributes is not None
-        assert len(attributes) == 3
-        # Validate all attributes provided by the abstract template
-        if is_velocity:
-            assert attributes["defaultVariableName"] == "velocity"
-        else:
-            assert attributes["defaultVariableName"] == "amplitude"
-        assert attributes["surveyType"] == "3D"
-        assert attributes["gatherType"] == "stacked"
 
     def test_dataset_metadata(self, mdio_with_headers: Path) -> None:
         """Test dataset metadata for empty MDIO file."""
         ds = open_mdio(mdio_with_headers)
-        self.validate_dataset_metadata(ds, is_velocity=True)
+        self.validate_teapod_dataset_metadata(ds, is_velocity=True)
+
 
     def test_variables(self, mdio_with_headers: Path, mdio_no_headers: Path) -> None:
         """Test grid validation for empty MDIO file."""
+        
         ds = open_mdio(mdio_with_headers)
-        self._validate_empty_mdio_dataset(ds, has_headers=True, is_velocity=True)
+        header_dtype = get_teapot_segy_spec().trace.header.dtype
+        self.validate_teapod_dataset_variables(ds, header_dtype=header_dtype, is_velocity=True)
 
         ds = open_mdio(mdio_no_headers)
-        self._validate_empty_mdio_dataset(ds, has_headers=False, is_velocity=True)
+        self.validate_teapod_dataset_variables(ds, header_dtype=None, is_velocity=True)
 
     def test_overwrite_behavior(self, empty_mdio_dir: Path) -> None:
         """Test overwrite parameter behavior in create_empty_mdio."""
@@ -246,7 +250,9 @@ def test_overwrite_behavior(self, empty_mdio_dir: Path) -> None:
 
         # Validate that the MDIO file can be loaded correctly using the helper function
         ds = open_mdio(empty_mdio)
-        self._validate_empty_mdio_dataset(ds, has_headers=True, is_velocity=True)
+        self.validate_teapod_dataset_metadata(ds, is_velocity=True)
+        header_dtype = get_teapot_segy_spec().trace.header.dtype
+        self.validate_teapod_dataset_variables(ds, header_dtype=header_dtype, is_velocity=True)
 
         # Verify the garbage data was overwritten (should not exist)
         assert not garbage_file.exists(), "Garbage file should have been overwritten"
@@ -375,16 +381,21 @@ def test_populate_empty_dataset(self, mdio_with_headers: Path) -> None:
                 output_path=mdio_with_headers.parent / "populated_empty.sgy",
             )
 
-    @pytest.mark.order(1001)
-    @pytest.mark.dependency
-    def test_create_empty_like(self, teapot_mdio_tmp: Path, mdio_with_headers: Path) -> None:
-        """Create an empty MDIO file like the input file."""
-        _ = mdio_with_headers
+
+    def test_create_empty_like(self, teapot_mdio_tmp: Path) -> None:
+        """Create an empty MDIO file like the input MDIO file.
+        
+        This test has to run after the segy_roundtrip_teapot tests have run because
+        its uses 'teapot_mdio_tmp' created by the segy_roundtrip_teapot tests as the input.
+        """
+
         ds = create_empty_like(
             input_path=teapot_mdio_tmp,
+            # TODO: write to a file
             output_path=None,  # We don't want to write to disk for now
             keep_coordinates=True,
             overwrite=True,
         )
-        self.validate_dataset_metadata(ds, is_velocity=False)
-        self._validate_empty_mdio_dataset(ds, has_headers=True, is_velocity=False)
+        self.validate_teapod_dataset_metadata(ds, is_velocity=False)
+        header_dtype = get_teapot_segy_spec().trace.header.dtype
+        self.validate_teapod_dataset_variables(ds, header_dtype=header_dtype, is_velocity=False)
diff --git a/tests/integration/testing_helpers.py b/tests/integration/testing_helpers.py
@@ -4,8 +4,36 @@
 
 import numpy as np
 import xarray as xr
+from segy.schema import HeaderField
+from segy.schema import ScalarType
+from segy.schema.segy import SegySpec
+from segy.standards import get_segy_standard
 
 from mdio.builder.schemas.v1.units import AllUnitModel
+from mdio.builder.schemas.v1.units import LengthUnitEnum
+from mdio.builder.schemas.v1.units import LengthUnitModel
+from mdio.builder.schemas.v1.units import SpeedUnitEnum
+from mdio.builder.schemas.v1.units import SpeedUnitModel
+from mdio.builder.schemas.v1.units import TimeUnitEnum
+from mdio.builder.schemas.v1.units import TimeUnitModel
+
+UNITS_NONE = None
+UNITS_METER = LengthUnitModel(length=LengthUnitEnum.METER)
+UNITS_SECOND = TimeUnitModel(time=TimeUnitEnum.SECOND)
+UNITS_METER_PER_SECOND = SpeedUnitModel(speed=SpeedUnitEnum.METER_PER_SECOND)
+UNITS_FOOT = LengthUnitModel(length=LengthUnitEnum.FOOT)
+UNITS_FEET_PER_SECOND = SpeedUnitModel(speed=SpeedUnitEnum.FEET_PER_SECOND)
+
+
+def get_teapot_segy_spec() -> SegySpec:
+    """Return the customized SEG-Y specification for the teapot dome dataset."""
+    teapot_fields = [
+        HeaderField(name="inline", byte=17, format=ScalarType.INT32),
+        HeaderField(name="crossline", byte=13, format=ScalarType.INT32),
+        HeaderField(name="cdp_x", byte=81, format=ScalarType.INT32),
+        HeaderField(name="cdp_y", byte=85, format=ScalarType.INT32),
+    ]
+    return get_segy_standard(1.0).customize(trace_header_fields=teapot_fields)
 
 
 def get_values(arr: xr.DataArray) -> np.ndarray:
diff --git a/uv.lock b/uv.lock
