fix: matching both devnet4 and devnet5 slot clock fixtures

Author: Sahilgill24

testing/lean-spec-tests/src/slot_clock.rs

@@ -3,10 +3,7 @@ use std::path::Path;
 use anyhow::{anyhow, bail, ensure};
 use tracing::info;
 
-use crate::types::{
-    TestFixture,
-    slot_clock::{CurrentTimeInput, FromSlotInput, FromUnixTimeInput, SlotClockTest},
-};
+use crate::types::{TestFixture, slot_clock::SlotClockTest};
 
 /// Load a slot_clock test fixture from a JSON file
 pub fn load_slot_clock_test(path: impl AsRef<Path>) -> anyhow::Result<TestFixture<SlotClockTest>> {
@@ -17,14 +14,33 @@ pub fn load_slot_clock_test(path: impl AsRef<Path>) -> anyhow::Result<TestFixtur
         .map_err(|err| anyhow!("Failed to parse test file {}: {err}", path.display()))
 }
 
+/// Parse a JSON value as u64, accepting both integer and float representations.
+fn json_u64(v: &serde_json::Value, field: &str) -> anyhow::Result<u64> {
+    v.as_u64()
+        .or_else(|| v.as_f64().map(|f| f as u64))
+        .ok_or_else(|| anyhow!("Missing or non-numeric field: {field}"))
+}
+
 /// Run a single slot_clock test case
 pub fn run_slot_clock_test(test_name: &str, test: &SlotClockTest) -> anyhow::Result<()> {
-    info!(
-        "Running slot_clock test: {test_name} (operation={})",
-        test.operation
-    );
+    // Config lives at top-level in devnet5, inside output in devnet4.
+    let cfg = test
+        .config
+        .as_ref()
+        .or(test.output.config.as_ref())
+        .ok_or_else(|| anyhow!("Missing config"))?;
+
+    // Operation kind: plain string in devnet4, object with `kind` field in devnet5.
+    let kind: &str = if let Some(s) = test.operation.as_str() {
+        s
+    } else {
+        test.operation["kind"]
+            .as_str()
+            .ok_or_else(|| anyhow!("Missing operation.kind"))?
+    };
+
+    info!("Running slot_clock test: {test_name} (operation={kind})");
 
-    let cfg = &test.output.config;
     ensure!(
         cfg.seconds_per_slot * 1000 == cfg.intervals_per_slot * cfg.milliseconds_per_interval,
         "Inconsistent config: secondsPerSlot * 1000 != intervalsPerSlot * msPerInterval",
@@ -33,35 +49,46 @@ pub fn run_slot_clock_test(test_name: &str, test: &SlotClockTest) -> anyhow::Res
     let ms_per_slot = cfg.seconds_per_slot * 1000;
     let ms_per_interval = cfg.milliseconds_per_interval;
 
-    match test.operation.as_str() {
+    // In devnet4 params are in `input`; in devnet5 they are in the `operation` object.
+    let params: &serde_json::Value = if let Some(inp) = test.input.as_ref() {
+        inp
+    } else {
+        &test.operation
+    };
+
+    // Look up a u64 param, falling back to an alternate key name if the first is missing.
+    let param_u64 = |key: &str, alt: Option<&str>| -> anyhow::Result<u64> {
+        let v = params
+            .get(key)
+            .or_else(|| alt.and_then(|k| params.get(k)))
+            .ok_or_else(|| anyhow!("Missing param: {key}"))?;
+        json_u64(v, key)
+    };
+
+    match kind {
         "current_slot" => {
-            let input: CurrentTimeInput = serde_json::from_value(test.input.clone())?;
-            let expected = test
-                .output
-                .slot
-                .ok_or_else(|| anyhow!("Missing output.slot"))?;
-            let genesis_ms = input.genesis_time * 1000;
-            let actual = if input.current_time_ms <= genesis_ms {
+            let genesis_time = param_u64("genesisTime", None)?;
+            // devnet4: currentTimeMs (integer), devnet5: currentTimeMilliseconds (float)
+            let current_time_ms = param_u64("currentTimeMs", Some("currentTimeMilliseconds"))?;
+            let expected = test.output.slot.ok_or_else(|| anyhow!("Missing output.slot"))?;
+            let genesis_ms = genesis_time * 1000;
+            let actual = if current_time_ms <= genesis_ms {
                 0
             } else {
-                (input.current_time_ms - genesis_ms) / ms_per_slot
+                (current_time_ms - genesis_ms) / ms_per_slot
             };
-            ensure!(
-                actual == expected,
-                "current_slot mismatch: expected {expected}, got {actual}"
-            );
+            ensure!(actual == expected, "current_slot mismatch: expected {expected}, got {actual}");
         }
         "current_interval" => {
-            let input: CurrentTimeInput = serde_json::from_value(test.input.clone())?;
-            let expected = test
-                .output
-                .interval
-                .ok_or_else(|| anyhow!("Missing output.interval"))?;
-            let genesis_ms = input.genesis_time * 1000;
-            let actual = if input.current_time_ms <= genesis_ms {
+            let genesis_time = param_u64("genesisTime", None)?;
+            let current_time_ms = param_u64("currentTimeMs", Some("currentTimeMilliseconds"))?;
+            let expected =
+                test.output.interval.ok_or_else(|| anyhow!("Missing output.interval"))?;
+            let genesis_ms = genesis_time * 1000;
+            let actual = if current_time_ms <= genesis_ms {
                 0
             } else {
-                let elapsed = input.current_time_ms - genesis_ms;
+                let elapsed = current_time_ms - genesis_ms;
                 (elapsed % ms_per_slot) / ms_per_interval
             };
             ensure!(
@@ -70,44 +97,39 @@ pub fn run_slot_clock_test(test_name: &str, test: &SlotClockTest) -> anyhow::Res
             );
         }
         "total_intervals" => {
-            let input: CurrentTimeInput = serde_json::from_value(test.input.clone())?;
+            let genesis_time = param_u64("genesisTime", None)?;
+            let current_time_ms = param_u64("currentTimeMs", Some("currentTimeMilliseconds"))?;
             let expected = test
                 .output
                 .total_intervals
                 .ok_or_else(|| anyhow!("Missing output.totalIntervals"))?;
-            let genesis_ms = input.genesis_time * 1000;
-            let actual = if input.current_time_ms <= genesis_ms {
+            let genesis_ms = genesis_time * 1000;
+            let actual = if current_time_ms <= genesis_ms {
                 0
             } else {
-                (input.current_time_ms - genesis_ms) / ms_per_interval
+                (current_time_ms - genesis_ms) / ms_per_interval
             };
             ensure!(
                 actual == expected,
                 "total_intervals mismatch: expected {expected}, got {actual}"
             );
         }
         "from_slot" => {
-            let input: FromSlotInput = serde_json::from_value(test.input.clone())?;
-            let expected = test
-                .output
-                .interval
-                .ok_or_else(|| anyhow!("Missing output.interval"))?;
-            let actual = input.slot * cfg.intervals_per_slot;
-            ensure!(
-                actual == expected,
-                "from_slot mismatch: expected {expected}, got {actual}"
-            );
+            let slot = param_u64("slot", None)?;
+            let expected =
+                test.output.interval.ok_or_else(|| anyhow!("Missing output.interval"))?;
+            let actual = slot * cfg.intervals_per_slot;
+            ensure!(actual == expected, "from_slot mismatch: expected {expected}, got {actual}");
         }
         "from_unix_time" => {
-            let input: FromUnixTimeInput = serde_json::from_value(test.input.clone())?;
-            let expected = test
-                .output
-                .interval
-                .ok_or_else(|| anyhow!("Missing output.interval"))?;
-            let actual = if input.unix_seconds <= input.genesis_time {
+            let genesis_time = param_u64("genesisTime", None)?;
+            let unix_seconds = param_u64("unixSeconds", None)?;
+            let expected =
+                test.output.interval.ok_or_else(|| anyhow!("Missing output.interval"))?;
+            let actual = if unix_seconds <= genesis_time {
                 0
             } else {
-                ((input.unix_seconds - input.genesis_time) * 1000) / ms_per_interval
+                ((unix_seconds - genesis_time) * 1000) / ms_per_interval
             };
             ensure!(
                 actual == expected,

testing/lean-spec-tests/src/types/slot_clock.rs

@@ -4,15 +4,23 @@ use serde::Deserialize;
 #[serde(rename_all = "camelCase")]
 pub struct SlotClockTest {
     pub network: String,
-    pub operation: String,
-    pub input: serde_json::Value,
+    /// devnet4: plain string; devnet5: object with `kind` and input params
+    pub operation: serde_json::Value,
+    /// devnet4 only — params moved into `operation` in devnet5
+    #[serde(default)]
+    pub input: Option<serde_json::Value>,
     pub output: SlotClockOutput,
+    /// devnet5: top-level; devnet4: inside `output`
+    #[serde(default)]
+    pub config: Option<SlotClockConfig>,
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SlotClockOutput {
-    pub config: SlotClockConfig,
+    /// devnet4 only — moved to top-level in devnet5
+    #[serde(default)]
+    pub config: Option<SlotClockConfig>,
     #[serde(default)]
     pub slot: Option<u64>,
     #[serde(default)]
@@ -21,30 +29,10 @@ pub struct SlotClockOutput {
     pub total_intervals: Option<u64>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SlotClockConfig {
     pub seconds_per_slot: u64,
     pub intervals_per_slot: u64,
     pub milliseconds_per_interval: u64,
 }
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CurrentTimeInput {
-    pub genesis_time: u64,
-    pub current_time_ms: u64,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FromSlotInput {
-    pub slot: u64,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct FromUnixTimeInput {
-    pub unix_seconds: u64,
-    pub genesis_time: u64,
-}