skenion-runtime 0.43.0

Skenion native runtime
Documentation
use std::{
    fs,
    path::{Path, PathBuf},
    sync::atomic::{AtomicUsize, Ordering},
};

use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use skenion_runtime::{
    NodeDefinitionCurrent, ProjectRequestCurrent, build_execution_plan_request_current,
    validate_project_request_current,
};

static TEMP_COUNTER: AtomicUsize = AtomicUsize::new(0);

struct TempDir {
    path: PathBuf,
}

impl TempDir {
    fn new(name: &str) -> Self {
        let id = TEMP_COUNTER.fetch_add(1, Ordering::SeqCst);
        let path = std::env::temp_dir().join(format!(
            "skenion-runtime-loader-{name}-{}-{id}",
            std::process::id()
        ));
        let _ = fs::remove_dir_all(&path);
        fs::create_dir_all(&path).expect("temp dir should be created");
        Self { path }
    }

    fn file(&self, name: &str) -> PathBuf {
        self.path.join(name)
    }
}

impl Drop for TempDir {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.path);
    }
}

fn read_json_file<T: DeserializeOwned>(path: impl AsRef<Path>) -> T {
    let path = path.as_ref();
    let bytes = fs::read(path)
        .unwrap_or_else(|error| panic!("expected JSON fixture at {}: {error}", path.display()));
    serde_json::from_slice(&bytes)
        .unwrap_or_else(|error| panic!("expected {} to parse: {error}", path.display()))
}

fn valid_definition_current() -> Value {
    json!({
      "schema": "skenion.node.definition",
      "schemaVersion": "0.1.0",
      "id": "core.loader",
      "version": "0.1.0",
      "displayName": "Loader",
      "category": "Core",
      "ports": [
        {
          "id": "out",
          "direction": "output",
          "type": "value.number",
          "rate": "control"
        }
      ],
      "execution": { "model": "value" },
      "state": { "persistent": false },
      "permissions": [],
      "capabilities": []
    })
}

fn valid_project_request_current() -> Value {
    json!({
      "graph": {
        "schema": "skenion.graph",
        "schemaVersion": "0.1.0",
        "id": "loader-graph-current",
        "revision": "1",
        "nodes": [
          {
            "id": "node",
            "kind": "core.loader",
            "kindVersion": "0.1.0",
            "params": {},
            "ports": [
              {
                "id": "out",
                "direction": "output",
                "type": "value.number",
                "rate": "control"
              }
            ]
          }
        ],
        "edges": []
      },
      "nodes": [valid_definition_current()]
    })
}

#[test]
fn loads_current_current_node_definition_and_project_request() {
    let temp = TempDir::new("valid");
    let definition_path = temp.file("node.json");
    let project_path = temp.file("project.json");
    fs::write(&definition_path, valid_definition_current().to_string()).unwrap();
    fs::write(&project_path, valid_project_request_current().to_string()).unwrap();

    let definition: NodeDefinitionCurrent = read_json_file(&definition_path);
    let request: ProjectRequestCurrent = read_json_file(&project_path);

    assert_eq!(definition.schema_version, "0.1.0");
    assert_eq!(definition.id, "core.loader");
    assert_eq!(request.graph.schema_version, "0.1.0");
    assert_eq!(request.graph.id, "loader-graph-current");
    validate_project_request_current(&request)
        .expect("current 0.1 project request should validate");
}

#[test]
fn rejects_unsupported_project_versions_under_current_surface() {
    let mut payload = valid_project_request_current();
    payload["graph"]["schemaVersion"] = json!("9.9.9");
    let request: ProjectRequestCurrent =
        serde_json::from_value(payload).expect("payload shape should still deserialize");

    let diagnostics = validate_project_request_current(&request)
        .expect_err("active Runtime project validation must reject non-current graph versions");
    assert_eq!(
        diagnostics[0].code.as_deref(),
        Some("graph.invalid-contract")
    );
    assert_eq!(diagnostics[0].details.as_ref().unwrap()["surface"], "graph");
    assert_eq!(
        diagnostics[0].details.as_ref().unwrap()["expectedSchemaVersion"],
        "0.1.0"
    );
    assert_eq!(
        diagnostics[0].details.as_ref().unwrap()["receivedSchemaVersion"],
        "9.9.9"
    );
}

#[test]
fn current_project_request_plans_value_number_graph() {
    let project: ProjectRequestCurrent = serde_json::from_value(valid_project_request_current())
        .expect("current project request should parse");

    let source_node = project
        .graph
        .nodes
        .first()
        .expect("graph should include node");
    let source_port = source_node
        .ports
        .iter()
        .find(|port| port.id == "out")
        .expect("source should expose value output");

    assert_eq!(project.graph.schema_version, "0.1.0");
    assert_eq!(source_port.port_type, "value.number");

    validate_project_request_current(&project)
        .expect("canonical current 0.1 project should validate");
    let (plan, diagnostics) = build_execution_plan_request_current(&project)
        .expect("canonical current 0.1 project should plan");

    assert!(diagnostics.is_empty());
    assert_eq!(plan.graph_id(), "loader-graph-current");
    assert!(plan.contains_node("node"));
}