use serde_json::Value;
use std::process::Command;
#[test]
fn distribution_contains_project_codex_logs_and_browsable_source() {
let package = ontology::Package::from_bytes(include_bytes!("../data/docs.ontology")).unwrap();
let manifest: Value =
serde_json::from_slice(&package.asset("creation-session-manifest").unwrap().bytes).unwrap();
assert_eq!(
manifest["creation_session_id"],
"01a14596-fae8-7a92-aa77-cce1be9673d1"
);
let sessions = manifest["sessions"].as_array().unwrap();
assert_eq!(sessions.len(), 6);
assert!(include_bytes!("../data/docs.ontology").len() < 9 * 1024 * 1024);
assert_eq!(package.images().len(), 1);
assert!(manifest["demo"]["image_payloads_omitted"].as_u64().unwrap() > 0);
let catalog: Value =
serde_json::from_slice(&package.asset("logs-catalog").unwrap().bytes).unwrap();
let files = catalog["files"].as_array().unwrap();
assert_eq!(files.len(), sessions.len());
for session in sessions {
let file = files
.iter()
.find(|f| f["metadata"]["id"] == session["session_id"])
.unwrap();
assert_eq!(file["source_sha256"], session["archive_sha256"]);
assert!(session["retained_records"].as_u64().unwrap() > 0);
assert_eq!(
session["sanitization"]["marker"],
ontology::sanitize::MARKER
);
}
let recorded_invitation_redactions = sessions
.iter()
.flat_map(|s| {
std::iter::once(&s["sanitization"])
.chain(s["sanitization_history"].as_array().into_iter().flatten())
})
.filter_map(|p| p["counts"]["redactions"]["icq-invitation"].as_u64())
.sum::<u64>();
assert!(
recorded_invitation_redactions >= 2,
"the known invitation miss must retain positive redaction evidence"
);
assert!(
package
.asset("ontology-source")
.unwrap()
.bytes
.starts_with(b"PK\x03\x04")
);
let source_file = package
.assets()
.iter()
.find(|a| a.path == "source/src/lib.rs")
.unwrap();
let object = package
.object(&format!("asset:{}", source_file.id))
.unwrap();
assert_eq!(
object.metadata["original"]["file"]["git"]["path"],
"src/lib.rs"
);
assert!(object.metadata["original"]["file"]["git"]["history"].is_array());
let source: Value =
serde_json::from_slice(&package.asset("ontology-source-manifest").unwrap().bytes).unwrap();
let paths = source["files"].as_array().unwrap();
assert!(paths.iter().any(|f| f["path"] == "src/dashboard/browse.js"));
assert!(
!paths
.iter()
.any(|f| f["path"] == "ontology-docs/data/docs.ontology")
);
}
#[test]
fn distributed_full_records_have_no_protected_invitation_and_keep_branded_redactions() {
let pattern = format!("*icqg1:{}*", "[A-Za-z0-9_+/=.-]".repeat(32));
let sql = format!(
"SELECT count(*) AS records, sum(valid_json) AS valid, sum(text GLOB '{pattern}') AS invitations, sum(instr(text, '<redacted by ontology>') > 0) AS redacted FROM log_records"
);
let result = Command::new(env!("CARGO_BIN_EXE_ontology-docs"))
.args(["query", "--sql", &sql])
.output()
.unwrap();
assert!(
result.status.success(),
"{}",
String::from_utf8_lossy(&result.stderr)
);
let value: Value = serde_json::from_slice(&result.stdout).unwrap();
let row = &value["data"]["rows"][0];
let package = ontology::Package::from_bytes(include_bytes!("../data/docs.ontology")).unwrap();
let manifest: Value =
serde_json::from_slice(&package.asset("creation-session-manifest").unwrap().bytes).unwrap();
let sessions = manifest["sessions"].as_array().unwrap();
let retained = sessions
.iter()
.map(|s| s["retained_records"].as_u64().unwrap())
.sum::<u64>();
let available = sessions
.iter()
.map(|s| {
s["demo_derivation"]["source_snapshot_records"]
.as_u64()
.unwrap()
})
.sum::<u64>();
assert_eq!(available, 11008);
assert!(retained > 0 && retained <= 6 * 256 && retained < available);
assert_eq!(row["records"], retained);
assert_eq!(row["valid"], retained);
assert_eq!(row["invitations"], 0);
assert!(row["redacted"].as_u64().unwrap() > 0);
let report = Command::new(env!("CARGO_BIN_EXE_ontology-docs"))
.arg("sanitization")
.output()
.unwrap();
let value: Value = serde_json::from_slice(&report.stdout).unwrap();
assert_eq!(value["data"]["enabled"], true);
assert_eq!(value["data"]["marker"], ontology::sanitize::MARKER);
}
#[test]
fn embedded_demo_discovers_queries_images_and_skills_without_runtime_files() {
let exe = env!("CARGO_BIN_EXE_ontology-docs");
let dir = tempfile::tempdir().unwrap();
for args in [
&[][..],
&["search", "encryption"][..],
&["images"][..],
&["skills", "list"][..],
&["tables"][..],
&[
"query",
"--sql",
"SELECT count(*) AS documents FROM documents",
][..],
&[
"export",
"--format",
"parquet",
"--table",
"documents",
"--limit",
"1",
][..],
] {
let result = Command::new(exe)
.args(args)
.current_dir(dir.path())
.output()
.unwrap();
assert!(result.status.success());
assert!(result.stderr.is_empty());
let value: Value = serde_json::from_slice(&result.stdout).unwrap();
assert_eq!(value["ok"], true);
}
let output = dir.path().join("export");
let result = Command::new(exe)
.args([
"skills",
"export",
"ontology-authoring",
"--output",
output.to_str().unwrap(),
])
.output()
.unwrap();
assert!(result.status.success());
assert!(output.join("ontology-authoring/SKILL.md").is_file());
let path = dir.path().join("docs.sqlite");
let result = Command::new(exe)
.args(["export", "--format", "sqlite", "--table", "documents"])
.arg("--output")
.arg(&path)
.env("PATH", "/nonexistent")
.output()
.unwrap();
assert!(
result.status.success(),
"{}",
String::from_utf8_lossy(&result.stderr)
);
assert!(
std::fs::read(path)
.unwrap()
.starts_with(b"SQLite format 3\0")
);
}
#[test]
fn next_calls_advance_documents_and_keep_opened_child_scope() {
let exe = env!("CARGO_BIN_EXE_ontology-docs");
let call = |args: &[&str]| {
let result = Command::new(exe).args(args).output().unwrap();
assert!(
result.status.success(),
"{}",
String::from_utf8_lossy(&result.stderr)
);
serde_json::from_slice::<Value>(&result.stdout).unwrap()
};
let read = call(&["read", "usage"]);
assert!(
read["next"]
.as_array()
.unwrap()
.iter()
.any(|v| v["argv"][1] == "links")
);
assert!(
!read["next"]
.as_array()
.unwrap()
.iter()
.any(|v| v["argv"][1] == "read" && v["argv"][2] == "usage")
);
let open = call(&["open", "nested-example"]);
let argv = open["next"][0]["argv"].as_array().unwrap();
assert!(
argv.windows(2)
.any(|v| v[0] == "--package-path" && v[1] == "nested-example")
);
let result = Command::new(exe)
.args(argv.iter().skip(1).map(|v| v.as_str().unwrap()))
.output()
.unwrap();
assert!(result.status.success());
let value: Value = serde_json::from_slice(&result.stdout).unwrap();
assert_eq!(value["data"]["manifest"]["name"], "Nested example");
let objects = call(&["objects", "--package-path", "nested-example"]);
assert!(
objects["data"]["objects"]
.as_array()
.unwrap()
.iter()
.any(|v| v["id"] == "document:usage" && v["title"] == "Nested usage")
);
let rows = call(&[
"query",
"--package-path",
"nested-example",
"--sql",
"SELECT title FROM documents",
]);
assert_eq!(
rows["data"]["rows"],
serde_json::json!([{"title":"Nested usage"}])
);
}