use std::path::Path;
use std::process::{Command, Output};
use cerulion_core::codegen::{FieldDef, FieldType, MessageSchema};
use cerulion_core::message::ShmMessage;
use native_ros2_messages::sensor_msgs::Image;
fn build_workspace(root: &Path) {
std::fs::create_dir_all(root.join("graphs")).unwrap();
std::fs::create_dir_all(root.join("schemas")).unwrap();
std::fs::write(
root.join("Cargo.toml"),
"[workspace]\nresolver = \"2\"\nmembers = []\n",
)
.unwrap();
}
fn run_schema(root: &Path, args: &[&str]) -> Output {
Command::new(env!("CARGO_BIN_EXE_cerulion"))
.arg("schema")
.args(args)
.current_dir(root)
.env("CERULION_NETWORK", "off")
.output()
.expect("failed to spawn cerulion binary")
}
fn stdout_of(out: &Output) -> String {
String::from_utf8_lossy(&out.stdout).into_owned()
}
fn stderr_of(out: &Output) -> String {
String::from_utf8_lossy(&out.stderr).into_owned()
}
#[test]
fn schema_info_collision_warns_on_stderr_and_workspace_wins() {
let tmp = tempfile::tempdir().unwrap();
build_workspace(tmp.path());
let content = "schemas:\n Image:\n description: \"local override\"\n fields:\n \
uint32 height:\n";
std::fs::write(tmp.path().join("schemas/Image.yaml"), content).unwrap();
let mut oracle = MessageSchema::new("Image");
oracle.add_field(FieldDef::new("height", FieldType::U32));
let workspace_hash = oracle.schema_hash();
let out = run_schema(tmp.path(), &["info", "Image"]);
assert_eq!(out.status.code(), Some(0), "stderr: {}", stderr_of(&out));
let stderr = stderr_of(&out);
assert!(
stderr.contains(
"WARNING: workspace schema 'Image' shadows built-in 'sensor_msgs/Image' \
— workspace wins for schema info"
),
"stderr must carry the loud shadow warning: {stderr}"
);
let stdout = stdout_of(&out);
assert!(stdout.contains("source: workspace"), "stdout: {stdout}");
assert!(
stdout.contains(&format!("hash: 0x{:016x}", workspace_hash)),
"stdout must render the WORKSPACE schema's hash: {stdout}"
);
assert!(
!stdout.contains(&format!("{:016x}", <Image as ShmMessage>::SCHEMA_HASH)),
"stdout must NOT render the shadowed built-in's hash: {stdout}"
);
}
#[test]
fn schema_info_double_colon_entry_warns_at_the_binary() {
let tmp = tempfile::tempdir().unwrap();
build_workspace(tmp.path());
std::fs::write(
tmp.path().join("schemas/mystring.yaml"),
"schemas:\n std_msgs::String:\n fields:\n uint32 a:\n",
)
.unwrap();
let mut oracle = MessageSchema::new("std_msgs::String");
oracle.add_field(FieldDef::new("a", FieldType::U32));
let workspace_hash = oracle.schema_hash();
let out = run_schema(tmp.path(), &["info", "std_msgs/String"]);
assert_eq!(out.status.code(), Some(0), "stderr: {}", stderr_of(&out));
let stderr = stderr_of(&out);
assert!(
stderr.contains(
"WARNING: workspace schema 'std_msgs::String' shadows built-in \
'std_msgs/String' — workspace wins for schema info"
),
"the `::` spelling must get the warning its `/` twin gets, naming the \
entry as DECLARED: {stderr}"
);
let stdout = stdout_of(&out);
assert!(stdout.contains("source: workspace"), "stdout: {stdout}");
assert!(
stdout.contains(&format!("hash: 0x{:016x}", workspace_hash)),
"stdout must render the WORKSPACE schema's hash: {stdout}"
);
}
#[test]
fn schema_info_builtin_qualified_resolves_from_binary() {
let tmp = tempfile::tempdir().unwrap();
build_workspace(tmp.path());
let out = run_schema(tmp.path(), &["info", "sensor_msgs::Image"]);
assert_eq!(out.status.code(), Some(0), "stderr: {}", stderr_of(&out));
let stderr = stderr_of(&out);
assert!(
!stderr.contains("WARNING"),
"no shadow → no warning: {stderr}"
);
let stdout = stdout_of(&out);
assert!(
stdout.contains("schema: sensor_msgs/Image"),
"stdout: {stdout}"
);
assert!(
stdout.contains("source: built-in (ROS 2)"),
"stdout: {stdout}"
);
assert!(
stdout.contains(&format!(
"hash: 0x{:016x}",
<Image as ShmMessage>::SCHEMA_HASH
)),
"stdout must render the generated SCHEMA_HASH: {stdout}"
);
}
#[test]
fn schema_list_renders_builtin_groups_from_binary() {
let tmp = tempfile::tempdir().unwrap();
build_workspace(tmp.path());
let out = run_schema(tmp.path(), &["list"]);
assert_eq!(out.status.code(), Some(0), "stderr: {}", stderr_of(&out));
let stdout = stdout_of(&out);
assert!(
stdout.contains("Built-in ROS 2 messages: 254 in 22 packages"),
"stdout: {stdout}"
);
assert!(
stdout.contains(" builtin_interfaces (2):"),
"stdout: {stdout}"
);
}
#[test]
fn schema_info_unknown_qualified_exits_nonzero_with_remedy() {
let tmp = tempfile::tempdir().unwrap();
build_workspace(tmp.path());
let out = run_schema(tmp.path(), &["info", "fake_msgs/Nope"]);
assert_ne!(out.status.code(), Some(0), "must exit nonzero");
let stderr = stderr_of(&out);
assert!(
stderr.contains("Schema 'fake_msgs/Nope' not found"),
"stderr: {stderr}"
);
assert!(
stderr.contains("built-in ROS 2 messages use qualified 'pkg/Type' names"),
"stderr must carry the honest two-source remedy: {stderr}"
);
assert!(
stderr.contains("cerulion schema list"),
"stderr must point at the discovery command (review MEDIUM-6): {stderr}"
);
}
#[test]
fn schema_info_multi_package_collision_warns_per_pair() {
let tmp = tempfile::tempdir().unwrap();
build_workspace(tmp.path());
let content = "schemas:\n Pose2D:\n fields:\n uint32 x:\n";
std::fs::write(tmp.path().join("schemas/Pose2D.yaml"), content).unwrap();
let out = run_schema(tmp.path(), &["info", "Pose2D"]);
assert_eq!(out.status.code(), Some(0), "stderr: {}", stderr_of(&out));
let stderr = stderr_of(&out);
assert!(
stderr.contains(
"WARNING: workspace schema 'Pose2D' shadows built-in 'geometry_msgs/Pose2D' \
— workspace wins for schema info"
),
"stderr must warn for the geometry_msgs pair: {stderr}"
);
assert!(
stderr.contains(
"WARNING: workspace schema 'Pose2D' shadows built-in 'vision_msgs/Pose2D' \
— workspace wins for schema info"
),
"stderr must warn for the vision_msgs pair: {stderr}"
);
let stdout = stdout_of(&out);
assert!(stdout.contains("source: workspace"), "stdout: {stdout}");
}