Add files via upload

Author: SIGNIAINDEX

tests/e2e/console_smoke.ts

@@ -0,0 +1,51 @@
+// console_smoke.ts
+//
+// E2E smoke for Console web + Interface service.
+// This script is intentionally dependency-light.
+// Run it from repo root after starting the stack.
+//
+// Usage:
+//   node tests/e2e/console_smoke.ts
+//
+// Environment:
+//   SIGNIA_CONSOLE_URL (default http://127.0.0.1:3000)
+//   SIGNIA_INTERFACE_URL (default http://127.0.0.1:7071)
+
+const consoleUrl = process.env.SIGNIA_CONSOLE_URL ?? "http://127.0.0.1:3000";
+const interfaceUrl = process.env.SIGNIA_INTERFACE_URL ?? "http://127.0.0.1:7071";
+
+async function mustFetch(url: string, init?: RequestInit) {
+  const res = await fetch(url, init);
+  if (!res.ok) {
+    const txt = await res.text().catch(() => "");
+    throw new Error(`request failed: ${res.status} ${url}\n${txt}`);
+  }
+  return res;
+}
+
+async function main() {
+  await mustFetch(`${consoleUrl}/`);
+  await mustFetch(`${consoleUrl}/compile`);
+  await mustFetch(`${consoleUrl}/verify`);
+
+  const q = {
+    question: "What is SIGNIA?",
+    topK: 5
+  };
+
+  const res = await mustFetch(`${interfaceUrl}/ask`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(q),
+  });
+  const data = await res.json();
+  if (!data || typeof data.answer !== "string") {
+    throw new Error("invalid interface response");
+  }
+  console.log("ok");
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

tests/e2e/docker_compose_up.rs

@@ -0,0 +1,55 @@
+//! docker_compose_up.rs
+//!
+//! End-to-end smoke that checks Docker Compose can bring up the stack.
+//! This test is skipped unless SIGNIA_RUN_E2E=1.
+//!
+//! Expected file at repo root: docker-compose.yml
+//!
+//! It will run:
+//! - docker compose up -d
+//! - docker compose ps
+//! - docker compose down
+//!
+//! No external Rust dependencies.
+
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
+
+fn repo_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).parent().unwrap().to_path_buf()
+}
+
+#[test]
+fn docker_compose_stack_up_down() {
+    if env::var("SIGNIA_RUN_E2E").ok().as_deref() != Some("1") {
+        eprintln!("skip: set SIGNIA_RUN_E2E=1 to enable docker compose test");
+        return;
+    }
+
+    let root = repo_root();
+    let compose = root.join("docker-compose.yml");
+    if !compose.exists() {
+        eprintln!("skip: docker-compose.yml not found at {}", compose.display());
+        return;
+    }
+
+    let up = Command::new("sh")
+        .arg("-lc")
+        .arg("docker compose up -d")
+        .current_dir(&root)
+        .status();
+
+    match up {
+        Ok(s) if s.success() => {}
+        _ => {
+            eprintln!("skip: docker compose not available or failed to start");
+            return;
+        }
+    }
+
+    let _ = Command::new("sh").arg("-lc").arg("docker compose ps").current_dir(&root).status();
+    let down = Command::new("sh").arg("-lc").arg("docker compose down -v").current_dir(&root).status();
+
+    assert!(down.map(|s| s.success()).unwrap_or(false), "docker compose down failed");
+}

tests/fixtures/dataset_small/sample.csv

@@ -0,0 +1,4 @@
+id,name,score
+1,alpha,10
+2,beta,20
+3,gamma,30

tests/fixtures/openapi_petstore/petstore.yaml

@@ -0,0 +1,11 @@
+openapi: 3.0.0
+info:
+  title: Petstore
+  version: "1.0.0"
+paths:
+  /pets:
+    get:
+      summary: List pets
+      responses:
+        "200":
+          description: OK

tests/fixtures/repo_small/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "repo_small"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/lib.rs"

tests/fixtures/repo_small/README.md

@@ -0,0 +1,3 @@
+# repo_small
+
+A tiny local fixture repository for SIGNIA tests.

tests/fixtures/repo_small/src/lib.rs

@@ -0,0 +1,10 @@
+pub fn add(a: i32, b: i32) -> i32 { a + b }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn it_adds() {
+        assert_eq!(add(2, 3), 5);
+    }
+}

tests/fixtures/workflow_small/pipeline.yml

@@ -0,0 +1,11 @@
+version: 1
+name: workflow-small
+steps:
+  - id: fetch
+    kind: http_get
+    with:
+      url: https://example.com/data.json
+  - id: publish
+    kind: signia_publish
+    with:
+      target: registry

tests/integration/api_compile_flow.rs

@@ -0,0 +1,81 @@
+//! api_compile_flow.rs
+//!
+//! Starts `signia-api` as a subprocess and calls /v1/compile.
+//!
+//! This is an optional integration test and will be skipped unless:
+//! - the `signia-api` binary exists (or SIGNIA_API_BIN is set)
+//! - the selected port is free
+//!
+//! Environment:
+//! - SIGNIA_API_BIN: path to the signia-api binary
+//! - SIGNIA_API_PORT: port to bind (default 8787)
+
+use std::env;
+use std::net::TcpListener;
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+use std::thread;
+use std::time::Duration;
+
+fn repo_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).parent().unwrap().to_path_buf()
+}
+
+fn api_bin() -> Option<PathBuf> {
+    if let Ok(p) = env::var("SIGNIA_API_BIN") {
+        let pb = PathBuf::from(p);
+        if pb.exists() { return Some(pb); }
+    }
+    let p = repo_root().join("target").join("debug").join(if cfg!(windows) { "signia-api.exe" } else { "signia-api" });
+    if p.exists() { Some(p) } else { None }
+}
+
+fn can_bind(port: u16) -> bool {
+    TcpListener::bind(("127.0.0.1", port)).is_ok()
+}
+
+#[test]
+fn api_compile_smoke() {
+    let Some(bin) = api_bin() else {
+        eprintln!("skip: signia-api binary not found (set SIGNIA_API_BIN or build signia-api)");
+        return;
+    };
+
+    let port: u16 = env::var("SIGNIA_API_PORT").ok().and_then(|s| s.parse().ok()).unwrap_or(8787);
+    if !can_bind(port) {
+        eprintln!("skip: port {} is not available", port);
+        return;
+    }
+
+    let mut child = Command::new(&bin)
+        .env("SIGNIA_BIND_ADDR", format!("127.0.0.1:{port}"))
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("failed to start signia-api");
+
+    // give it time to boot
+    thread::sleep(Duration::from_millis(700));
+
+    // Use curl if available (no external Rust deps).
+    let payload = r#"{"type":"dataset","content":"id,name\n1,a\n"}"#;
+
+    let status = Command::new("sh")
+        .arg("-lc")
+        .arg(format!(
+            "curl -fsS -H 'content-type: application/json' -d '{}' http://127.0.0.1:{}/v1/compile > /dev/null",
+            payload.replace("'", "'\"'\"'"),
+            port
+        ))
+        .status();
+
+    // best effort cleanup
+    let _ = child.kill();
+
+    match status {
+        Ok(s) => assert!(s.success(), "curl request to /v1/compile failed"),
+        Err(_) => {
+            eprintln!("skip: curl is not available in this environment");
+        }
+    }
+}

tests/integration/determinism_roundtrip.rs

@@ -0,0 +1,74 @@
+//! determinism_roundtrip.rs
+//!
+//! Black-box determinism test:
+//! same input => same output byte-for-byte.
+//!
+//! This test executes the `signia` CLI twice and compares produced bundles.
+//!
+//! How to run:
+//! - build CLI: `cargo build -p signia-cli`
+//! - then: `cargo test -q` (from workspace root)
+//!
+//! Notes:
+//! - The CLI path can be overridden via SIGNIA_BIN.
+//! - If the CLI binary is not found, the test is skipped.
+
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+fn repo_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).parent().unwrap().to_path_buf()
+}
+
+fn signia_bin() -> Option<PathBuf> {
+    if let Ok(p) = env::var("SIGNIA_BIN") {
+        let pb = PathBuf::from(p);
+        if pb.exists() { return Some(pb); }
+    }
+    let p = repo_root().join("target").join("debug").join(if cfg!(windows) { "signia.exe" } else { "signia" });
+    if p.exists() { Some(p) } else { None }
+}
+
+fn run_compile(bin: &Path, input: &Path, typ: &str, out: &Path) {
+    let status = Command::new(bin)
+        .arg("compile")
+        .arg(input)
+        .arg("--type").arg(typ)
+        .arg("--out").arg(out)
+        .status()
+        .expect("failed to spawn signia");
+    assert!(status.success(), "signia compile failed");
+}
+
+fn read_bytes(p: &Path) -> Vec<u8> {
+    fs::read(p).unwrap_or_else(|e| panic!("failed to read {}: {e}", p.display()))
+}
+
+#[test]
+fn determinism_dataset() {
+    let Some(bin) = signia_bin() else {
+        eprintln!("skip: signia CLI not found (set SIGNIA_BIN or build signia-cli)");
+        return;
+    };
+
+    let root = repo_root();
+    let input = root.join("tests").join("fixtures").join("dataset_small").join("sample.csv");
+
+    let out1 = root.join("target").join("tmp").join("signia_test_determinism_1");
+    let out2 = root.join("target").join("tmp").join("signia_test_determinism_2");
+    let _ = fs::remove_dir_all(&out1);
+    let _ = fs::remove_dir_all(&out2);
+    fs::create_dir_all(&out1).unwrap();
+    fs::create_dir_all(&out2).unwrap();
+
+    run_compile(&bin, &input, "dataset", &out1);
+    run_compile(&bin, &input, "dataset", &out2);
+
+    for name in ["schema.json", "manifest.json", "proof.json"] {
+        let b1 = read_bytes(&out1.join(name));
+        let b2 = read_bytes(&out2.join(name));
+        assert_eq!(b1, b2, "bundle file differs: {name}");
+    }
+}