feat: add lox-test-utils crate and refine EOP parser interface

helgee · helgee · commit 9d2c6df939cc · 2025-10-15T15:11:51.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -20,6 +20,7 @@ lox-io = { path = "crates/lox-io", version = "0.1.0-alpha.8" }
 lox-math = { path = "crates/lox-math", version = "0.1.0-alpha.8" }
 lox-orbits = { path = "crates/lox-orbits", version = "0.1.0-alpha.20" }
 lox-space = { path = "crates/lox-space", version = "0.1.0-alpha.27" }
+lox-test-utils = { path = "crates/lox-test-utils", version = "0.1.0-alpha.0"}
 lox-time = { path = "crates/lox-time", version = "0.1.0-alpha.10" }
 lox-units = { path = "crates/lox-units", version = "0.1.0-alpha.0" }
 
diff --git a/crates/lox-earth/Cargo.toml b/crates/lox-earth/Cargo.toml
@@ -23,5 +23,6 @@ serde.workspace = true
 thiserror.workspace = true
 
 [dev-dependencies]
+lox-test-utils.workspace = true
 float_eq.workspace = true
 rstest.workspace = true
diff --git a/crates/lox-earth/src/iers.rs b/crates/lox-earth/src/iers.rs
@@ -76,8 +76,7 @@ impl From<csv::Error> for EopParserError {
 
 #[derive(Default)]
 pub struct EopParser {
-    iau1980: Option<PathBuf>,
-    iau2000: Option<PathBuf>,
+    paths: (Option<PathBuf>, Option<PathBuf>),
     lsp: Option<Box<dyn LeapSecondsProvider>>,
 }
 
@@ -86,28 +85,28 @@ impl EopParser {
         Self::default()
     }
 
-    pub fn with_iau1980(&mut self, path: impl AsRef<Path>) -> &mut Self {
-        self.iau1980 = Some(path.as_ref().to_owned());
+    pub fn from_path(&mut self, path: impl AsRef<Path>) -> &mut Self {
+        self.paths = (Some(path.as_ref().to_owned()), None);
         self
     }
 
-    pub fn with_iau2000(&mut self, path: impl AsRef<Path>) -> &mut Self {
-        self.iau2000 = Some(path.as_ref().to_owned());
+    pub fn from_paths(&mut self, path1: impl AsRef<Path>, path2: impl AsRef<Path>) -> &mut Self {
+        self.paths = (
+            Some(path1.as_ref().to_owned()),
+            Some(path2.as_ref().to_owned()),
+        );
         self
     }
 
-    pub fn with_leap_seconds_provider(&mut self, lsp: Box<dyn LeapSecondsProvider>) -> &mut Self {
+    pub fn leap_seconds_provider(&mut self, lsp: Box<dyn LeapSecondsProvider>) -> &mut Self {
         self.lsp = Some(lsp);
         self
     }
 
     pub fn parse(&self) -> Result<EopProvider, EopParserError> {
-        let n = if let Some(iau1980) = self.iau1980.as_ref() {
+        let n = if let Some(iau1980) = self.paths.0.as_ref() {
             let mut reader = ReaderBuilder::new().delimiter(b';').from_path(iau1980)?;
             reader.records().count()
-        } else if let Some(iau2000) = self.iau2000.as_ref() {
-            let mut reader = ReaderBuilder::new().delimiter(b';').from_path(iau2000)?;
-            reader.records().count()
         } else {
             return Err(EopParserError::NoFiles);
         };
@@ -123,10 +122,10 @@ impl EopParser {
 
         let mut rdr1 = ReaderBuilder::new()
             .delimiter(b';')
-            .from_path(self.iau1980.as_ref().or(self.iau2000.as_ref()).unwrap())?;
+            .from_path(self.paths.0.as_ref().unwrap())?;
         let mut rdr2 = ReaderBuilder::new()
             .delimiter(b';')
-            .from_path(self.iau2000.as_ref().or(self.iau1980.as_ref()).unwrap())?;
+            .from_path(self.paths.1.as_ref().or(self.paths.0.as_ref()).unwrap())?;
         let mut raw1 = ByteRecord::new();
         let mut raw2 = ByteRecord::new();
         let headers = rdr1.byte_headers()?.clone();
@@ -315,3 +314,39 @@ impl EopProvider {
         Ok(-TimeDelta::try_from_decimal_seconds(val).unwrap())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use lox_test_utils::data_dir;
+    use lox_time::{Time, time_scales::Tai};
+
+    use super::*;
+
+    #[test]
+    #[should_panic(expected = "NoFiles")]
+    fn test_eop_parser_no_files() {
+        EopParser::new().parse().unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "MissingIau2000")]
+    fn test_eop_provider_missing_iau2000() {
+        let t: Time<Tai> = Time::default();
+        let eop = EopParser::new()
+            .from_path(data_dir().join("finals.all.csv"))
+            .parse()
+            .unwrap();
+        eop.nutation_precession_iau2000(t).unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "MissingIau1980")]
+    fn test_eop_provider_missing_iau1980() {
+        let t: Time<Tai> = Time::default();
+        let eop = EopParser::new()
+            .from_path(data_dir().join("finals2000A.all.csv"))
+            .parse()
+            .unwrap();
+        eop.nutation_precession_iau1980(t).unwrap();
+    }
+}
diff --git a/crates/lox-earth/src/ut1.rs b/crates/lox-earth/src/ut1.rs
@@ -182,11 +182,13 @@ mod tests {
     use float_eq::assert_float_eq;
     use lox_math::assert_close;
     use lox_math::is_close::IsClose;
+    use lox_test_utils::data_dir;
     use lox_time::Time;
     use lox_time::deltas::ToDelta;
     use lox_time::subsecond::Subsecond;
     use lox_time::time;
     use lox_time::time_scales::Ut1;
+    use lox_time::utc::leap_seconds::BuiltinLeapSeconds;
     use lox_time::utc::transformations::ToUtc;
     use lox_time::{DynTime, calendar_dates::Date, time_of_day::TimeOfDay};
     use rstest::{fixture, rstest};
@@ -389,14 +391,11 @@ mod tests {
         static PROVIDER: OnceLock<EopProvider> = OnceLock::new();
         PROVIDER.get_or_init(|| {
             EopParser::new()
-                .with_iau1980(format!(
-                    "{}/../../data/finals.all.csv",
-                    env!("CARGO_MANIFEST_DIR")
-                ))
-                .with_iau2000(format!(
-                    "{}/../../data/finals2000A.all.csv",
-                    env!("CARGO_MANIFEST_DIR")
-                ))
+                .from_paths(
+                    data_dir().join("finals.all.csv"),
+                    data_dir().join("finals2000A.all.csv"),
+                )
+                .leap_seconds_provider(Box::new(BuiltinLeapSeconds))
                 .parse()
                 .unwrap()
         })
diff --git a/crates/lox-orbits/Cargo.toml b/crates/lox-orbits/Cargo.toml
@@ -28,4 +28,5 @@ sgp4.workspace = true
 thiserror.workspace = true
 
 [dev-dependencies]
+lox-test-utils.workspace = true
 rstest.workspace = true
diff --git a/crates/lox-orbits/src/analysis.rs b/crates/lox-orbits/src/analysis.rs
@@ -483,11 +483,11 @@ mod tests {
     use lox_ephem::spk::parser::{Spk, parse_daf_spk};
     use lox_math::assert_close;
     use lox_math::is_close::IsClose;
+    use lox_test_utils::data_dir;
     use lox_time::Time;
     use lox_time::time_scales::Tai;
     use lox_time::utc::Utc;
     use std::iter::zip;
-    use std::path::PathBuf;
     use std::sync::OnceLock;
 
     use super::*;
@@ -703,8 +703,4 @@ mod tests {
         static EPHEMERIS: OnceLock<Spk> = OnceLock::new();
         EPHEMERIS.get_or_init(|| parse_daf_spk(&contents).unwrap())
     }
-
-    pub fn data_dir() -> PathBuf {
-        PathBuf::from(format!("{}/../../data", env!("CARGO_MANIFEST_DIR")))
-    }
 }
diff --git a/crates/lox-orbits/src/states.rs b/crates/lox-orbits/src/states.rs
@@ -403,14 +403,15 @@ impl DynState {
 
 #[cfg(test)]
 mod tests {
-    use std::{path::PathBuf, sync::OnceLock};
+    use std::sync::OnceLock;
 
     use float_eq::assert_float_eq;
 
     use lox_bodies::{Earth, Jupiter, Venus};
     use lox_ephem::spk::parser::{Spk, parse_daf_spk};
     use lox_math::assert_close;
     use lox_math::is_close::IsClose;
+    use lox_test_utils::data_dir;
     use lox_time::{Time, offsets::DefaultOffsetProvider, time, time_scales::Tdb, utc::Utc};
 
     use super::*;
@@ -489,10 +490,6 @@ mod tests {
         assert_float_eq!(ground.altitude(), alt_exp, rel <= 1e-4);
     }
 
-    pub fn data_dir() -> PathBuf {
-        PathBuf::from(format!("{}/../../data", env!("CARGO_MANIFEST_DIR")))
-    }
-
     #[test]
     fn test_state_to_origin() {
         let r_venus = DVec3::new(
diff --git a/crates/lox-space/Cargo.toml b/crates/lox-space/Cargo.toml
@@ -30,6 +30,7 @@ rayon = { workspace = true, optional = true }
 sgp4 = { workspace = true, optional = true }
 
 [dev-dependencies]
+lox-test-utils.workspace = true
 float_eq.workspace = true
 pyo3 = { workspace = true, features = ["auto-initialize"] }
 rstest.workspace = true
diff --git a/crates/lox-space/lox_space.pyi b/crates/lox-space/lox_space.pyi
@@ -343,7 +343,7 @@ class UTC:
     ) -> Time: ...
 
 class EOPProvider:
-    def __new__(cls, iau1980: os.PathLike | None = None, iau2000: os.PathLike | None = None): ...
+    def __new__(cls, *args: os.PathLike): ...
 
 class Series:
     def __new__(
diff --git a/crates/lox-space/src/earth/python/ut1.rs b/crates/lox-space/src/earth/python/ut1.rs
@@ -10,7 +10,8 @@ use std::path::PathBuf;
 
 use lox_earth::iers::{EopParser, EopProvider};
 use pyo3::exceptions::PyException;
-use pyo3::{PyErr, PyResult, create_exception, pyclass, pymethods};
+use pyo3::types::{PyAnyMethods, PyTuple};
+use pyo3::{Bound, PyErr, PyResult, create_exception, pyclass, pymethods};
 
 create_exception!(lox_space, EopParserError, PyException);
 
@@ -38,15 +39,14 @@ pub struct PyEopProvider(pub EopProvider);
 
 #[pymethods]
 impl PyEopProvider {
-    #[pyo3(signature = (iau1980=None, iau2000=None))]
+    #[pyo3(signature = (*args))]
     #[new]
-    pub fn new(iau1980: Option<PathBuf>, iau2000: Option<PathBuf>) -> PyResult<PyEopProvider> {
+    pub fn new(args: &Bound<'_, PyTuple>) -> PyResult<PyEopProvider> {
         let mut parser = EopParser::new();
-        if let Some(iau1980) = iau1980 {
-            parser.with_iau1980(iau1980);
-        }
-        if let Some(iau2000) = iau2000 {
-            parser.with_iau2000(iau2000);
+        if let Ok((path1, path2)) = args.extract::<(PathBuf, PathBuf)>() {
+            parser.from_paths(path1, path2);
+        } else if let Ok((path,)) = args.extract::<(PathBuf,)>() {
+            parser.from_path(path);
         }
         Ok(PyEopProvider(parser.parse().map_err(PyEopParserError)?))
     }
@@ -56,26 +56,27 @@ impl PyEopProvider {
 mod tests {
     use super::*;
 
-    use crate::test_helpers::data_dir;
     use crate::time::python::time::PyTime;
-
-    use pyo3::{Bound, IntoPyObjectExt, Python};
+    use lox_test_utils::data_dir;
+    use pyo3::{Bound, IntoPyObject, IntoPyObjectExt, Python};
 
     #[test]
     #[should_panic(expected = "No such file")]
     fn test_ut1_provider_invalid_path() {
-        let _provider = PyEopProvider::new(Some("invalid_path".into()), None).unwrap();
+        Python::attach(|py| {
+            let path = (data_dir().join("invalid"),).into_pyobject(py).unwrap();
+            let _provider = PyEopProvider::new(&path).unwrap();
+        })
     }
 
     #[test]
     #[should_panic(expected = "extrapolated")]
     fn test_ut1_provider_extrapolated() {
         Python::attach(|py| {
-            let provider = Bound::new(
-                py,
-                PyEopProvider::new(None, Some(data_dir().join("finals2000A.all.csv"))).unwrap(),
-            )
-            .unwrap();
+            let path = (data_dir().join("finals2000A.all.csv"),)
+                .into_pyobject(py)
+                .unwrap();
+            let provider = Bound::new(py, PyEopProvider::new(&path).unwrap()).unwrap();
             let tai =
                 PyTime::new(&"TAI".into_bound_py_any(py).unwrap(), 2100, 1, 1, 0, 0, 0.0).unwrap();
             let _ut1 = tai
diff --git a/crates/lox-space/src/lib.rs b/crates/lox-space/src/lib.rs
@@ -35,6 +35,3 @@ pub mod units;
 
 #[cfg(feature = "python")]
 pub(crate) mod python;
-
-#[cfg(test)]
-mod test_helpers;
diff --git a/crates/lox-space/src/time/python/time.rs b/crates/lox-space/src/time/python/time.rs
@@ -434,10 +434,9 @@ mod tests {
     use super::*;
 
     use crate::math::assert_close;
-    use crate::test_helpers::data_dir;
-
     use float_eq::assert_float_eq;
-    use pyo3::{IntoPyObjectExt, Python, types::PyDict};
+    use lox_test_utils::data_dir;
+    use pyo3::{IntoPyObject, IntoPyObjectExt, Python, types::PyDict};
     use rstest::rstest;
 
     #[test]
@@ -733,11 +732,10 @@ mod tests {
     #[case("UT1", "UT1")]
     fn test_pytime_to_scale(#[case] scale1: &str, #[case] scale2: &str) {
         Python::attach(|py| {
-            let provider = Bound::new(
-                py,
-                PyEopProvider::new(None, Some(data_dir().join("finals2000A.all.csv"))).unwrap(),
-            )
-            .unwrap();
+            let path = (data_dir().join("finals2000A.all.csv"),)
+                .into_pyobject(py)
+                .unwrap();
+            let provider = Bound::new(py, PyEopProvider::new(&path).unwrap()).unwrap();
             let scale1 = scale_to_any(py, scale1);
             let scale2 = scale_to_any(py, scale2);
             let exp = PyTime::new(&scale1, 2000, 1, 1, 0, 0, 0.0).unwrap();
diff --git a/crates/lox-space/src/time/python/utc.rs b/crates/lox-space/src/time/python/utc.rs
@@ -146,9 +146,9 @@ impl PyUtc {
 mod tests {
     use super::*;
 
-    use crate::test_helpers::data_dir;
+    use lox_test_utils::data_dir;
 
-    use pyo3::{Bound, IntoPyObjectExt, Python};
+    use pyo3::{Bound, IntoPyObject, IntoPyObjectExt, Python};
     use rstest::rstest;
 
     #[test]
@@ -208,11 +208,10 @@ mod tests {
     #[case("UT1")]
     fn test_pyutc_transformations(#[case] scale: &str) {
         Python::attach(|py| {
-            let provider = Bound::new(
-                py,
-                PyEopProvider::new(None, Some(data_dir().join("finals2000A.all.csv"))).unwrap(),
-            )
-            .unwrap();
+            let path = (data_dir().join("finals2000A.all.csv"),)
+                .into_pyobject(py)
+                .unwrap();
+            let provider = Bound::new(py, PyEopProvider::new(&path).unwrap()).unwrap();
             let scale = scale.into_bound_py_any(py).unwrap();
             let exp = PyUtc::new(2000, 1, 1, 0, 0, 0.0).unwrap();
             let act = exp
diff --git a/crates/lox-space/tests/conftest.py b/crates/lox-space/tests/conftest.py
@@ -17,7 +17,7 @@
 
 @pytest.fixture(scope="session")
 def provider():
-    return lox.EOPProvider(iau2000=DATA_DIR.joinpath("finals2000A.all.csv"))
+    return lox.EOPProvider(DATA_DIR.joinpath("finals2000A.all.csv"))
 
 
 @pytest.fixture(scope="session")
diff --git a/crates/lox-test-utils/Cargo.toml b/crates/lox-test-utils/Cargo.toml
diff --git a/crates/lox-test-utils/src/lib.rs b/crates/lox-test-utils/src/lib.rs
diff --git a/crates/lox-time/src/test_helpers.rs b/crates/lox-time/src/test_helpers.rs
