135 lines
4.0 KiB
Rust
135 lines
4.0 KiB
Rust
//! Integration: spawn the kebab binary and parse `kebab schema [--json]`.
|
|
//!
|
|
//! Each test builds an isolated TempDir-rooted XDG layout, runs
|
|
//! `kebab ingest` over an empty workspace (which creates and migrates
|
|
//! kebab.sqlite), then exercises `kebab schema` in JSON and text modes.
|
|
//! Using an empty workspace avoids the embedding model dependency while
|
|
//! still seeding the DB so `open_existing` inside schema_with_config
|
|
//! succeeds (a NotIndexed error fires when the DB file is absent).
|
|
|
|
use std::process::Command;
|
|
|
|
fn kebab_bin() -> std::path::PathBuf {
|
|
let manifest = env!("CARGO_MANIFEST_DIR");
|
|
std::path::PathBuf::from(manifest)
|
|
.parent()
|
|
.unwrap()
|
|
.parent()
|
|
.unwrap()
|
|
.join("target/debug/kebab")
|
|
}
|
|
|
|
fn xdg_envs(tmp: &std::path::Path) -> [(&'static str, std::path::PathBuf); 4] {
|
|
[
|
|
("XDG_CONFIG_HOME", tmp.join("cfg")),
|
|
("XDG_DATA_HOME", tmp.join("data")),
|
|
("XDG_CACHE_HOME", tmp.join("cache")),
|
|
("XDG_STATE_HOME", tmp.join("state")),
|
|
]
|
|
}
|
|
|
|
/// Seed kebab.sqlite by running `kebab ingest` over an empty workspace dir.
|
|
/// This is the minimum required for `kebab schema` to succeed: the store
|
|
/// uses `open_existing`, which errors when the DB file is absent.
|
|
fn seed_db(tmp: &tempfile::TempDir) {
|
|
let ws = tmp.path().join("ws");
|
|
std::fs::create_dir_all(&ws).unwrap();
|
|
|
|
let mut cmd = Command::new(kebab_bin());
|
|
cmd.args(["ingest", "--root", ws.to_str().unwrap(), "--summary-only"]);
|
|
for (k, v) in xdg_envs(tmp.path()) {
|
|
cmd.env(k, v);
|
|
}
|
|
let out = cmd.output().unwrap();
|
|
assert!(
|
|
out.status.success(),
|
|
"seed ingest failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cli_schema_json_emits_schema_v1() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
seed_db(&tmp);
|
|
|
|
let mut cmd = Command::new(kebab_bin());
|
|
cmd.args(["--json", "schema"]);
|
|
for (k, v) in xdg_envs(tmp.path()) {
|
|
cmd.env(k, v);
|
|
}
|
|
let out = cmd.output().unwrap();
|
|
assert!(
|
|
out.status.success(),
|
|
"kebab --json schema failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
|
|
let stdout = String::from_utf8(out.stdout).unwrap();
|
|
let v: serde_json::Value = serde_json::from_str(&stdout).expect("stdout must be valid JSON");
|
|
|
|
assert_eq!(
|
|
v.get("schema_version").and_then(|s| s.as_str()),
|
|
Some("schema.v1"),
|
|
"schema_version must be schema.v1"
|
|
);
|
|
assert!(
|
|
v.get("kebab_version")
|
|
.and_then(|s| s.as_str())
|
|
.map(|s| !s.is_empty())
|
|
.unwrap_or(false),
|
|
"kebab_version must be a non-empty string"
|
|
);
|
|
|
|
let caps = v
|
|
.get("capabilities")
|
|
.and_then(|c| c.as_object())
|
|
.expect("capabilities must be a JSON object");
|
|
assert_eq!(
|
|
caps.get("json_mode").and_then(|b| b.as_bool()),
|
|
Some(true),
|
|
"capabilities.json_mode must be true"
|
|
);
|
|
assert_eq!(
|
|
caps.get("mcp_server").and_then(|b| b.as_bool()),
|
|
Some(true),
|
|
"capabilities.mcp_server must be true (fb-30)"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cli_schema_text_mode_runs() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
seed_db(&tmp);
|
|
|
|
let mut cmd = Command::new(kebab_bin());
|
|
cmd.args(["schema"]);
|
|
for (k, v) in xdg_envs(tmp.path()) {
|
|
cmd.env(k, v);
|
|
}
|
|
let out = cmd.output().unwrap();
|
|
assert!(
|
|
out.status.success(),
|
|
"kebab schema (text) failed: {}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
|
|
let stdout = String::from_utf8(out.stdout).unwrap();
|
|
assert!(
|
|
stdout.contains("kebab v"),
|
|
"text output must contain 'kebab v', got: {stdout}"
|
|
);
|
|
assert!(
|
|
stdout.contains("capabilities"),
|
|
"text output must contain 'capabilities', got: {stdout}"
|
|
);
|
|
assert!(
|
|
stdout.contains("models"),
|
|
"text output must contain 'models', got: {stdout}"
|
|
);
|
|
assert!(
|
|
stdout.contains("stats"),
|
|
"text output must contain 'stats', got: {stdout}"
|
|
);
|
|
}
|