fix: update deps and use run_compare for test

Author: swwind

src/queries/baseline.rs

@@ -176,172 +176,30 @@ fn subtract_30_months(date: &str) -> Result<String, crate::error::Error> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use browserslist_data::baseline;
-    use std::collections::HashMap;
-    use std::process::Command;
+    use crate::test::run_compare;
+    use crate::opts::Opts;
     use test_case::test_case;
 
-    /// Run a Node.js snippet and return stdout lines.
-    fn node_output(script: &str) -> Vec<String> {
-        let out = Command::new("node")
-            .arg("-e")
-            .arg(script)
-            .output()
-            .expect("node must be available");
-        assert!(
-            out.status.success(),
-            "node failed: {}",
-            String::from_utf8_lossy(&out.stderr)
-        );
-        String::from_utf8(out.stdout)
-            .unwrap()
-            .lines()
-            .filter(|l| !l.is_empty())
-            .map(str::to_owned)
-            .collect()
-    }
-
-    /// Call getCompatibleVersions() and return a map of caniuse_browser -> min_version.
-    fn js_min_versions(js_opts: &str) -> HashMap<String, String> {
-        let opts_str = if js_opts.is_empty() {
-            "suppressWarnings: true".to_owned()
-        } else {
-            format!("{js_opts}, suppressWarnings: true")
-        };
-        let script = format!(
-            r#"
-const {{ getCompatibleVersions }} = require('./node_modules/baseline-browser-mapping');
-const map = {{chrome:'chrome',chrome_android:'and_chr',edge:'edge',firefox:'firefox',firefox_android:'and_ff',safari:'safari',safari_ios:'ios_saf'}};
-const r = getCompatibleVersions({{ {opts_str} }});
-r.filter(e=>map[e.browser]).forEach(e => console.log(map[e.browser] + ' ' + e.version));
-"#
-        );
-        node_output(&script)
-            .into_iter()
-            .map(|line| {
-                let (b, v) = line.split_once(' ').unwrap();
-                (b.to_owned(), v.to_owned())
-            })
-            .collect()
-    }
-
-    /// Verify that the minimum version our data returns for each browser matches
-    /// what getCompatibleVersions() from the JS library reports.
-    fn assert_min_versions_match(
-        label: &str,
-        expected: &HashMap<String, String>,
-        get_min: impl Fn(&str) -> Option<&'static str>,
-    ) {
-        for (browser, js_version) in expected {
-            let rust_version = get_min(browser).unwrap_or_else(|| {
-                panic!("[{label}] {browser}: Rust returned None, JS expected {js_version}")
-            });
-            let js_v: Version = js_version.parse().unwrap_or_default();
-            let rust_v: Version = rust_version.parse().unwrap_or_default();
-            assert_eq!(
-                js_v, rust_v,
-                "[{label}] {browser}: Rust min={rust_version}, JS min={js_version}"
-            );
-        }
-        assert_eq!(
-            expected.len(),
-            7,
-            "[{label}] expected 7 core browsers, got {}",
-            expected.len()
-        );
-    }
-
-    #[test]
-    fn widely_min_versions_match_js() {
-        let expected = js_min_versions("");
-        assert_min_versions_match("widely", &expected, |b| {
-            baseline::get_baseline_widely_min_version(b)
-        });
-    }
-
-    #[test_case(2015; "year_2015")]
-    #[test_case(2016; "year_2016")]
-    #[test_case(2017; "year_2017")]
-    #[test_case(2018; "year_2018")]
-    #[test_case(2019; "year_2019")]
-    #[test_case(2020; "year_2020")]
-    #[test_case(2021; "year_2021")]
-    #[test_case(2022; "year_2022")]
-    #[test_case(2023; "year_2023")]
-    #[test_case(2024; "year_2024")]
-    fn year_min_versions_match_js(year: u16) {
-        let expected = js_min_versions(&format!("targetYear: {year}"));
-        assert_min_versions_match(&format!("year {year}"), &expected, |b| {
-            baseline::get_baseline_year_min_version(year, b)
-        });
-    }
-
-    #[test_case("2023-04-05"; "date_2023_04_05")]
-    #[test_case("2021-01-01"; "date_2021_01_01")]
-    #[test_case("2024-06-15"; "date_2024_06_15")]
-    fn widely_on_date_min_versions_match_js(date: &str) {
-        let expected = js_min_versions(&format!("widelyAvailableOnDate: '{date}'"));
-        let cutoff = subtract_30_months(date).unwrap();
-        assert_min_versions_match(&format!("date {date}"), &expected, |b| {
-            baseline::get_baseline_cutoff_date_min_version(&cutoff, b)
-        });
-    }
-
     #[test_case("baseline widely available"; "widely")]
-    #[test_case("baseline 2020"; "year 2020")]
-    #[test_case("baseline 2022"; "year 2022")]
-    #[test_case("baseline 2015"; "year 2015")]
     #[test_case("BASELINE WIDELY AVAILABLE"; "case insensitive widely")]
-    #[test_case("baseline widely available on 2023-04-05"; "widely on date")]
-    fn valid_queries_return_results(query: &str) {
-        let results = crate::resolve([query], &Opts::default()).unwrap();
-        assert!(
-            !results.is_empty(),
-            "expected non-empty results for {query:?}"
-        );
-    }
-
     #[test_case("baseline newly available"; "newly")]
-    #[test_case("Baseline Newly Available"; "case insensitive newly")]
-    fn valid_queries_no_error(query: &str) {
-        // "newly" min versions may be ahead of the caniuse data, so results can be empty
-        crate::resolve([query], &Opts::default()).expect("query should not error");
-    }
-
-    #[test_case("baseline 2022 with downstream"; "year_downstream")]
-    #[test_case("baseline widely available with downstream"; "widely_downstream")]
-    fn valid_queries_with_downstream(query: &str) {
-        let results = crate::resolve([query], &Opts::default()).unwrap();
-        assert!(
-            !results.is_empty(),
-            "expected non-empty results for {query:?}"
-        );
-        // Should have more results than without downstream
-        let without = crate::resolve(
-            [query.replace(" with downstream", "").as_str()],
-            &Opts::default(),
-        )
-        .unwrap();
-        assert!(
-            results.len() > without.len(),
-            "downstream should add browsers: got {}, without got {}",
-            results.len(),
-            without.len()
-        );
-    }
-
-    #[test_case("baseline 2020 with downstream including kaios"; "year_downstream_kaios")]
-    fn valid_queries_with_kaios(query: &str) {
-        let results = crate::resolve([query], &Opts::default()).unwrap();
-        assert!(
-            !results.is_empty(),
-            "expected non-empty results for {query:?}"
-        );
-        // Should include kaios
-        assert!(
-            results.iter().any(|d| d.name() == "kaios"),
-            "expected kaios in results"
-        );
+    #[test_case("baseline 2015"; "year 2015")]
+    #[test_case("baseline 2016"; "year 2016")]
+    #[test_case("baseline 2017"; "year 2017")]
+    #[test_case("baseline 2018"; "year 2018")]
+    #[test_case("baseline 2019"; "year 2019")]
+    #[test_case("baseline 2020"; "year 2020")]
+    #[test_case("baseline 2021"; "year 2021")]
+    #[test_case("baseline 2022"; "year 2022")]
+    #[test_case("baseline 2023"; "year 2023")]
+    #[test_case("baseline 2024"; "year 2024")]
+    #[test_case("baseline widely available on 2021-01-01"; "widely on date 2021-01-01")]
+    #[test_case("baseline widely available on 2023-04-05"; "widely on date 2023-04-05")]
+    #[test_case("baseline widely available on 2024-06-15"; "widely on date 2024-06-15")]
+    #[test_case("baseline 2022 with downstream"; "year with downstream")]
+    #[test_case("baseline widely available with downstream"; "widely with downstream")]
+    #[test_case("baseline 2020 with downstream including kaios"; "year with downstream and kaios")]
+    fn valid(query: &str) {
+        run_compare(query, &Opts::default(), None);
     }
 }