#![cfg(test)]
use super::*;
#[test]
fn generated_configuration_writes_the_operational_defaults() -> anyhow::Result<()> {
let home = tempfile::tempdir()?;
let text = configuration(home.path())?;
let path = home.path().join("liminal.toml");
write_configuration(&path, &text)?;
let server = load_configuration(&path)?;
let defaults = liminal_server::config::LimitsConfig::default();
assert_eq!(server.limits.max_connections, defaults.max_connections);
assert_eq!(
server.limits.max_subscriptions_per_connection,
defaults.max_subscriptions_per_connection
);
assert_eq!(
server.limits.max_conversations_per_connection,
defaults.max_conversations_per_connection
);
assert_eq!(
server.limits.max_pending_pushes_per_connection,
defaults.max_pending_pushes_per_connection
);
assert_eq!(
server
.limits
.max_pending_conversation_replies_per_connection,
defaults.max_pending_conversation_replies_per_connection
);
assert_eq!(
server.limits.max_pending_replies_per_conversation,
defaults.max_pending_replies_per_conversation
);
assert_eq!(
server.limits.max_connection_inbox_bytes,
defaults.max_connection_inbox_bytes
);
assert_eq!(
server.limits.max_connection_outbound_bytes,
defaults.max_connection_outbound_bytes
);
assert_eq!(
server.limits.max_subscription_inbox_depth,
defaults.max_subscription_inbox_depth
);
assert_eq!(
server.limits.delivery_slice_budget,
defaults.delivery_slice_budget
);
assert_eq!(server.limits.reply_timeout_ms, defaults.reply_timeout_ms);
assert_eq!(server.limits.max_channels, Some(512));
assert!(server.extra_listen_addresses.is_empty());
assert!(server.channels.is_empty());
assert!(server.routing_rules.is_empty());
assert_eq!(server.drain_timeout_ms, 0);
assert_eq!(server.open_reach().word(), "loopback");
let services = liminal_server::config::ServicesConfig::default();
assert_eq!(server.services.profile, services.profile);
assert_eq!(
server.services.self_streams.cost_rows,
services.self_streams.cost_rows
);
assert_eq!(
server.services.self_streams.events_rows,
services.self_streams.events_rows
);
assert_eq!(
server.agents,
Some(liminal_server::agents::config::AgentsConfig::default())
);
assert_eq!(server.limits.max_subscriptions_per_connection, 1024);
let agents = server
.agents
.ok_or_else(|| anyhow::anyhow!("[agents] absent"))?;
assert_eq!(
(agents.max_listened_subjects, agents.max_per_owner),
(1024, 64)
);
assert_eq!(server.listen_address.to_string(), "127.0.0.1:7400");
assert_eq!(server.health_listen_address.to_string(), "127.0.0.1:7401");
assert_eq!(server.persistence_path, Some(home.path().join("store")));
assert!(server.auth.is_none());
assert!(server.websocket.is_none());
assert!(server.cluster.is_none());
assert!(server.participant.is_some());
assert!(server.agents.is_some());
Ok(())
}
#[test]
fn an_occupied_port_names_its_configuration_key() -> anyhow::Result<()> {
let held = std::net::TcpListener::bind("127.0.0.1:0")?;
let address = held.local_addr()?;
let error = reserve(address, "console.listen")
.err()
.ok_or_else(|| anyhow::anyhow!("occupied socket was admitted"))?;
let words = error.to_string();
assert!(words.contains(&address.port().to_string()));
assert!(words.contains("console.listen"));
Ok(())
}
#[test]
fn a_legacy_document_has_no_console_or_assistant() -> anyhow::Result<()> {
let table: toml::Table = toml::from_str(
"listen_address = '127.0.0.1:7400'\nhealth_listen_address = '127.0.0.1:7401'\ndrain_timeout_ms = 0\nchannels = []\nrouting_rules = []\n",
)?;
assert!(console_configuration(&table)?.is_none());
Ok(())
}
#[test]
fn a_console_document_starts_no_assistant_unless_written() -> anyhow::Result<()> {
let table: toml::Table = toml::from_str("[console]\nlisten = '127.0.0.1:7480'\n")?;
let console =
console_configuration(&table)?.ok_or_else(|| anyhow::anyhow!("console absent"))?;
assert!(!console.assistant);
assert_eq!(console.listen.port(), 7480);
let invalid: toml::Table =
toml::from_str("[console]\nlisten = '127.0.0.1:7480'\nassitant = true\n")?;
assert!(console_configuration(&invalid).is_err());
Ok(())
}
#[test]
fn embedded_index_and_an_asset_are_the_dist_bytes() -> anyhow::Result<()> {
let dist =
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../apps/liminal-console/dist");
let (kind, index) =
console::asset("/").ok_or_else(|| anyhow::anyhow!("embedded index absent"))?;
assert_eq!(kind, "text/html; charset=utf-8");
assert_eq!(index, std::fs::read(dist.join("index.html"))?);
let entry = std::fs::read_dir(dist.join("assets"))?
.find_map(|entry| match entry {
Ok(entry)
if entry
.path()
.extension()
.is_some_and(|extension| extension == "js") =>
{
Some(Ok(entry.path()))
}
Ok(_) => None,
Err(error) => Some(Err(error)),
})
.ok_or_else(|| anyhow::anyhow!("dist has no JavaScript asset"))??;
let name = entry
.file_name()
.and_then(std::ffi::OsStr::to_str)
.ok_or_else(|| anyhow::anyhow!("asset has no Unicode filename"))?;
let (kind, bytes) = console::asset(&format!("/assets/{name}"))
.ok_or_else(|| anyhow::anyhow!("embedded asset absent"))?;
assert_eq!(kind, "text/javascript; charset=utf-8");
assert_eq!(bytes, std::fs::read(entry)?);
assert!(console::asset("/../outside").is_none());
Ok(())
}
#[path = "../build/assets.rs"]
mod assets;
#[test]
fn the_build_names_a_missing_dist_and_embeds_packaged_or_workspace_bytes() -> anyhow::Result<()> {
let directory = tempfile::tempdir()?;
let manifest = directory.path().join("project/crates/liminal-cli");
std::fs::create_dir_all(&manifest)?;
let words = assets::dist(&manifest)
.err()
.ok_or_else(|| anyhow::anyhow!("a missing dist was admitted"))?;
assert!(
words.contains("apps/liminal-console/dist")
&& words.contains("console-dist")
&& words.contains("bun run build"),
"{words}"
);
let workspace = directory.path().join("project/apps/liminal-console/dist");
std::fs::create_dir_all(workspace.join("assets"))?;
std::fs::write(workspace.join("index.html"), b"<html>fixture</html>")?;
std::fs::write(workspace.join("assets/fixture.wasm"), b"\0asm")?;
let found = assets::dist(&manifest).map_err(anyhow::Error::msg)?;
assert_eq!(
std::fs::canonicalize(&found)?,
std::fs::canonicalize(&workspace)?
);
let (generated, files) = assets::table(&found).map_err(|error| anyhow::anyhow!("{error}"))?;
assert_eq!(files.len(), 2);
assert!(generated.contains("include_bytes!") && generated.contains("application/wasm"));
assert!(
generated.contains("\"/index.html\"") && generated.contains("\"/assets/fixture.wasm\"")
);
let packaged = manifest.join("console-dist");
std::fs::create_dir_all(&packaged)?;
std::fs::write(packaged.join("index.html"), b"<html>packaged</html>")?;
assert_eq!(
assets::dist(&manifest).map_err(anyhow::Error::msg)?,
packaged
);
Ok(())
}
#[test]
fn harness_refusals_keep_their_words_without_promoting_other_frames() {
assert_eq!(assistant::harness_words(br#"{"jsonrpc":"2.0","id":3,"error":{"code":-32603,"message":"Claude Code fixture: sign in required"}}"#).as_deref(), Some("Claude Code fixture: sign in required"));
assert_eq!(
assistant::harness_words(br#"{"jsonrpc":"2.0","id":3,"result":{}}"#),
None
);
assert_eq!(assistant::harness_words(b"not JSON"), None);
}