521 lines
18 KiB
Rust
521 lines
18 KiB
Rust
use crate::ArtifactBuildRequest;
|
|
use crate::ArtifactCommandOutput;
|
|
use crate::ArtifactRenderCommandRequest;
|
|
use crate::ArtifactRenderTarget;
|
|
use crate::ArtifactRuntimeManager;
|
|
use crate::ArtifactRuntimeManagerConfig;
|
|
use crate::ArtifactRuntimePlatform;
|
|
use crate::ArtifactRuntimeReleaseLocator;
|
|
use crate::ArtifactsClient;
|
|
use crate::DEFAULT_CACHE_ROOT_RELATIVE;
|
|
use crate::ExtractedRuntimeManifest;
|
|
use crate::InstalledArtifactRuntime;
|
|
use crate::JsRuntime;
|
|
use crate::PresentationRenderTarget;
|
|
use crate::ReleaseManifest;
|
|
use crate::RuntimeEntrypoints;
|
|
use crate::RuntimePathEntry;
|
|
use crate::SpreadsheetRenderTarget;
|
|
use crate::load_cached_runtime;
|
|
use codex_package_manager::ArchiveFormat;
|
|
use codex_package_manager::PackageReleaseArchive;
|
|
use pretty_assertions::assert_eq;
|
|
use sha2::Digest;
|
|
use sha2::Sha256;
|
|
use std::collections::BTreeMap;
|
|
use std::fs;
|
|
use std::io::Cursor;
|
|
use std::io::Write;
|
|
#[cfg(unix)]
|
|
use std::os::unix::fs::PermissionsExt;
|
|
use std::path::Path;
|
|
use std::path::PathBuf;
|
|
use std::time::Duration;
|
|
use tempfile::TempDir;
|
|
use wiremock::Mock;
|
|
use wiremock::MockServer;
|
|
use wiremock::ResponseTemplate;
|
|
use wiremock::matchers::method;
|
|
use wiremock::matchers::path;
|
|
use zip::ZipWriter;
|
|
use zip::write::SimpleFileOptions;
|
|
|
|
#[test]
|
|
fn release_locator_builds_manifest_url() {
|
|
let locator = ArtifactRuntimeReleaseLocator::new(
|
|
url::Url::parse("https://example.test/releases/").unwrap_or_else(|error| panic!("{error}")),
|
|
"0.1.0",
|
|
);
|
|
let url = locator
|
|
.manifest_url()
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
assert_eq!(
|
|
url.as_str(),
|
|
"https://example.test/releases/artifact-runtime-v0.1.0/artifact-runtime-v0.1.0-manifest.json"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn default_release_locator_uses_openai_codex_github_releases() {
|
|
let locator = ArtifactRuntimeReleaseLocator::default("0.1.0");
|
|
let url = locator
|
|
.manifest_url()
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
|
|
assert_eq!(
|
|
url.as_str(),
|
|
"https://github.com/openai/codex/releases/download/artifact-runtime-v0.1.0/artifact-runtime-v0.1.0-manifest.json"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn load_cached_runtime_reads_installed_runtime() {
|
|
let codex_home = TempDir::new().unwrap_or_else(|error| panic!("{error}"));
|
|
let runtime_version = "0.1.0";
|
|
let platform =
|
|
ArtifactRuntimePlatform::detect_current().unwrap_or_else(|error| panic!("{error}"));
|
|
let install_dir = codex_home
|
|
.path()
|
|
.join(DEFAULT_CACHE_ROOT_RELATIVE)
|
|
.join(runtime_version)
|
|
.join(platform.as_str());
|
|
write_installed_runtime(
|
|
&install_dir,
|
|
runtime_version,
|
|
Some(PathBuf::from("node/bin/node")),
|
|
);
|
|
|
|
let runtime = load_cached_runtime(
|
|
&codex_home.path().join(DEFAULT_CACHE_ROOT_RELATIVE),
|
|
runtime_version,
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
|
|
assert_eq!(runtime.runtime_version(), runtime_version);
|
|
assert_eq!(runtime.platform(), platform);
|
|
assert!(runtime.node_path().ends_with(Path::new("node/bin/node")));
|
|
assert!(
|
|
runtime
|
|
.build_js_path()
|
|
.ends_with(Path::new("artifact-tool/dist/artifact_tool.mjs"))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn load_cached_runtime_rejects_parent_relative_paths() {
|
|
let codex_home = TempDir::new().unwrap_or_else(|error| panic!("{error}"));
|
|
let runtime_version = "0.1.0";
|
|
let platform =
|
|
ArtifactRuntimePlatform::detect_current().unwrap_or_else(|error| panic!("{error}"));
|
|
let install_dir = codex_home
|
|
.path()
|
|
.join(DEFAULT_CACHE_ROOT_RELATIVE)
|
|
.join(runtime_version)
|
|
.join(platform.as_str());
|
|
write_installed_runtime(
|
|
&install_dir,
|
|
runtime_version,
|
|
Some(PathBuf::from("../node/bin/node")),
|
|
);
|
|
|
|
let error = load_cached_runtime(
|
|
&codex_home.path().join(DEFAULT_CACHE_ROOT_RELATIVE),
|
|
runtime_version,
|
|
)
|
|
.unwrap_err();
|
|
|
|
assert_eq!(
|
|
error.to_string(),
|
|
"runtime path `../node/bin/node` is invalid"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn load_cached_runtime_requires_build_entrypoint() {
|
|
let codex_home = TempDir::new().unwrap_or_else(|error| panic!("{error}"));
|
|
let runtime_version = "0.1.0";
|
|
let platform =
|
|
ArtifactRuntimePlatform::detect_current().unwrap_or_else(|error| panic!("{error}"));
|
|
let install_dir = codex_home
|
|
.path()
|
|
.join(DEFAULT_CACHE_ROOT_RELATIVE)
|
|
.join(runtime_version)
|
|
.join(platform.as_str());
|
|
write_installed_runtime(
|
|
&install_dir,
|
|
runtime_version,
|
|
Some(PathBuf::from("node/bin/node")),
|
|
);
|
|
fs::remove_file(install_dir.join("artifact-tool/dist/artifact_tool.mjs"))
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
|
|
let error = load_cached_runtime(
|
|
&codex_home.path().join(DEFAULT_CACHE_ROOT_RELATIVE),
|
|
runtime_version,
|
|
)
|
|
.unwrap_err();
|
|
|
|
assert_eq!(
|
|
error.to_string(),
|
|
format!(
|
|
"required runtime file is missing: {}",
|
|
install_dir
|
|
.join("artifact-tool/dist/artifact_tool.mjs")
|
|
.display()
|
|
)
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn ensure_installed_downloads_and_extracts_zip_runtime() {
|
|
let server = MockServer::start().await;
|
|
let runtime_version = "0.1.0";
|
|
let platform =
|
|
ArtifactRuntimePlatform::detect_current().unwrap_or_else(|error| panic!("{error}"));
|
|
let archive_name = format!(
|
|
"artifact-runtime-v{runtime_version}-{}.zip",
|
|
platform.as_str()
|
|
);
|
|
let archive_bytes = build_zip_archive(runtime_version);
|
|
let archive_sha = format!("{:x}", Sha256::digest(&archive_bytes));
|
|
let manifest = ReleaseManifest {
|
|
schema_version: 1,
|
|
runtime_version: runtime_version.to_string(),
|
|
release_tag: format!("artifact-runtime-v{runtime_version}"),
|
|
node_version: Some("22.0.0".to_string()),
|
|
platforms: BTreeMap::from([(
|
|
platform.as_str().to_string(),
|
|
PackageReleaseArchive {
|
|
archive: archive_name.clone(),
|
|
sha256: archive_sha,
|
|
format: ArchiveFormat::Zip,
|
|
size_bytes: Some(archive_bytes.len() as u64),
|
|
},
|
|
)]),
|
|
};
|
|
Mock::given(method("GET"))
|
|
.and(path(format!(
|
|
"/artifact-runtime-v{runtime_version}/artifact-runtime-v{runtime_version}-manifest.json"
|
|
)))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(&manifest))
|
|
.mount(&server)
|
|
.await;
|
|
Mock::given(method("GET"))
|
|
.and(path(format!(
|
|
"/artifact-runtime-v{runtime_version}/{archive_name}"
|
|
)))
|
|
.respond_with(ResponseTemplate::new(200).set_body_bytes(archive_bytes))
|
|
.mount(&server)
|
|
.await;
|
|
|
|
let codex_home = TempDir::new().unwrap_or_else(|error| panic!("{error}"));
|
|
let locator = ArtifactRuntimeReleaseLocator::new(
|
|
url::Url::parse(&format!("{}/", server.uri())).unwrap_or_else(|error| panic!("{error}")),
|
|
runtime_version,
|
|
);
|
|
let manager = ArtifactRuntimeManager::new(ArtifactRuntimeManagerConfig::new(
|
|
codex_home.path().to_path_buf(),
|
|
locator,
|
|
));
|
|
|
|
let runtime = manager
|
|
.ensure_installed()
|
|
.await
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
|
|
assert_eq!(runtime.runtime_version(), runtime_version);
|
|
assert_eq!(runtime.platform(), platform);
|
|
assert!(runtime.node_path().ends_with(Path::new("node/bin/node")));
|
|
assert_eq!(
|
|
runtime.resolve_js_runtime().expect("resolve js runtime"),
|
|
JsRuntime::node(runtime.node_path().to_path_buf())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn load_cached_runtime_uses_custom_cache_root() {
|
|
let codex_home = TempDir::new().unwrap_or_else(|error| panic!("{error}"));
|
|
let runtime_version = "0.1.0";
|
|
let custom_cache_root = codex_home.path().join("runtime-cache");
|
|
let platform =
|
|
ArtifactRuntimePlatform::detect_current().unwrap_or_else(|error| panic!("{error}"));
|
|
let install_dir = custom_cache_root
|
|
.join(runtime_version)
|
|
.join(platform.as_str());
|
|
write_installed_runtime(
|
|
&install_dir,
|
|
runtime_version,
|
|
Some(PathBuf::from("node/bin/node")),
|
|
);
|
|
|
|
let config = ArtifactRuntimeManagerConfig::with_default_release(
|
|
codex_home.path().to_path_buf(),
|
|
runtime_version,
|
|
)
|
|
.with_cache_root(custom_cache_root);
|
|
|
|
let runtime = load_cached_runtime(&config.cache_root(), runtime_version)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
|
|
assert_eq!(runtime.runtime_version(), runtime_version);
|
|
assert_eq!(runtime.platform(), platform);
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[cfg(unix)]
|
|
async fn artifacts_client_execute_build_writes_wrapped_script_and_env() {
|
|
let temp = TempDir::new().unwrap_or_else(|error| panic!("{error}"));
|
|
let output_path = temp.path().join("build-output.txt");
|
|
let wrapped_script_path = temp.path().join("wrapped-script.mjs");
|
|
let runtime = fake_installed_runtime(temp.path(), &output_path, &wrapped_script_path);
|
|
let client = ArtifactsClient::from_installed_runtime(runtime);
|
|
|
|
let output = client
|
|
.execute_build(ArtifactBuildRequest {
|
|
source: "console.log('hello');".to_string(),
|
|
cwd: temp.path().to_path_buf(),
|
|
timeout: Some(Duration::from_secs(5)),
|
|
env: BTreeMap::from([
|
|
(
|
|
"CODEX_TEST_OUTPUT".to_string(),
|
|
output_path.display().to_string(),
|
|
),
|
|
("CUSTOM_ENV".to_string(), "custom-value".to_string()),
|
|
]),
|
|
})
|
|
.await
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
|
|
assert_success(&output);
|
|
let command_log = fs::read_to_string(&output_path).unwrap_or_else(|error| panic!("{error}"));
|
|
assert!(command_log.contains("arg0="));
|
|
assert!(command_log.contains("CODEX_ARTIFACT_BUILD_ENTRYPOINT="));
|
|
assert!(command_log.contains("CODEX_ARTIFACT_RENDER_ENTRYPOINT="));
|
|
assert!(command_log.contains("CUSTOM_ENV=custom-value"));
|
|
|
|
let wrapped_script =
|
|
fs::read_to_string(wrapped_script_path).unwrap_or_else(|error| panic!("{error}"));
|
|
assert!(wrapped_script.contains("globalThis.artifacts = artifactTool;"));
|
|
assert!(wrapped_script.contains("globalThis.codexArtifacts = artifactTool;"));
|
|
assert!(wrapped_script.contains("console.log('hello');"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[cfg(unix)]
|
|
async fn artifacts_client_execute_render_passes_expected_args() {
|
|
let temp = TempDir::new().unwrap_or_else(|error| panic!("{error}"));
|
|
let output_path = temp.path().join("render-output.txt");
|
|
let wrapped_script_path = temp.path().join("unused-script-copy.mjs");
|
|
let runtime = fake_installed_runtime(temp.path(), &output_path, &wrapped_script_path);
|
|
let client = ArtifactsClient::from_installed_runtime(runtime.clone());
|
|
let render_output = temp.path().join("slide.png");
|
|
|
|
let output = client
|
|
.execute_render(ArtifactRenderCommandRequest {
|
|
cwd: temp.path().to_path_buf(),
|
|
timeout: Some(Duration::from_secs(5)),
|
|
env: BTreeMap::from([(
|
|
"CODEX_TEST_OUTPUT".to_string(),
|
|
output_path.display().to_string(),
|
|
)]),
|
|
target: ArtifactRenderTarget::Presentation(PresentationRenderTarget {
|
|
input_path: temp.path().join("deck.pptx"),
|
|
output_path: render_output.clone(),
|
|
slide_number: 3,
|
|
}),
|
|
})
|
|
.await
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
|
|
assert_success(&output);
|
|
let command_log = fs::read_to_string(&output_path).unwrap_or_else(|error| panic!("{error}"));
|
|
assert!(command_log.contains(&format!("arg0={}", runtime.render_cli_path().display())));
|
|
assert!(command_log.contains("arg1=pptx"));
|
|
assert!(command_log.contains("arg2=render"));
|
|
assert!(command_log.contains("arg5=--slide"));
|
|
assert!(command_log.contains("arg6=3"));
|
|
assert!(command_log.contains("arg7=--out"));
|
|
assert!(command_log.contains(&format!("arg8={}", render_output.display())));
|
|
}
|
|
|
|
#[test]
|
|
fn spreadsheet_render_target_to_args_includes_optional_range() {
|
|
let target = ArtifactRenderTarget::Spreadsheet(SpreadsheetRenderTarget {
|
|
input_path: PathBuf::from("/tmp/input.xlsx"),
|
|
output_path: PathBuf::from("/tmp/output.png"),
|
|
sheet_name: "Summary".to_string(),
|
|
range: Some("A1:C8".to_string()),
|
|
});
|
|
|
|
assert_eq!(
|
|
target.to_args(),
|
|
vec![
|
|
"xlsx".to_string(),
|
|
"render".to_string(),
|
|
"--in".to_string(),
|
|
"/tmp/input.xlsx".to_string(),
|
|
"--sheet".to_string(),
|
|
"Summary".to_string(),
|
|
"--out".to_string(),
|
|
"/tmp/output.png".to_string(),
|
|
"--range".to_string(),
|
|
"A1:C8".to_string(),
|
|
]
|
|
);
|
|
}
|
|
|
|
fn assert_success(output: &ArtifactCommandOutput) {
|
|
assert!(output.success());
|
|
assert_eq!(output.exit_code, Some(0));
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn fake_installed_runtime(
|
|
root: &Path,
|
|
output_path: &Path,
|
|
wrapped_script_path: &Path,
|
|
) -> InstalledArtifactRuntime {
|
|
let runtime_root = root.join("runtime");
|
|
write_installed_runtime(&runtime_root, "0.1.0", Some(PathBuf::from("node/bin/node")));
|
|
write_fake_node_script(
|
|
&runtime_root.join("node/bin/node"),
|
|
output_path,
|
|
wrapped_script_path,
|
|
);
|
|
InstalledArtifactRuntime::load(
|
|
runtime_root,
|
|
ArtifactRuntimePlatform::detect_current().unwrap_or_else(|error| panic!("{error}")),
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"))
|
|
}
|
|
|
|
fn write_installed_runtime(
|
|
install_dir: &Path,
|
|
runtime_version: &str,
|
|
node_relative: Option<PathBuf>,
|
|
) {
|
|
fs::create_dir_all(install_dir.join("node/bin")).unwrap_or_else(|error| panic!("{error}"));
|
|
fs::create_dir_all(install_dir.join("artifact-tool/dist"))
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
fs::create_dir_all(install_dir.join("granola-render/dist"))
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
let node_relative = node_relative.unwrap_or_else(|| PathBuf::from("node/bin/node"));
|
|
fs::write(
|
|
install_dir.join("manifest.json"),
|
|
serde_json::json!(sample_extracted_manifest(runtime_version, node_relative)).to_string(),
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
fs::write(install_dir.join("node/bin/node"), "#!/bin/sh\n")
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
fs::write(
|
|
install_dir.join("artifact-tool/dist/artifact_tool.mjs"),
|
|
"export const ok = true;\n",
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
fs::write(
|
|
install_dir.join("granola-render/dist/render_cli.mjs"),
|
|
"export const ok = true;\n",
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn write_fake_node_script(script_path: &Path, output_path: &Path, wrapped_script_path: &Path) {
|
|
fs::write(
|
|
script_path,
|
|
format!(
|
|
concat!(
|
|
"#!/bin/sh\n",
|
|
"printf 'arg0=%s\\n' \"$1\" > \"{}\"\n",
|
|
"cp \"$1\" \"{}\"\n",
|
|
"shift\n",
|
|
"i=1\n",
|
|
"for arg in \"$@\"; do\n",
|
|
" printf 'arg%s=%s\\n' \"$i\" \"$arg\" >> \"{}\"\n",
|
|
" i=$((i + 1))\n",
|
|
"done\n",
|
|
"printf 'CODEX_ARTIFACT_BUILD_ENTRYPOINT=%s\\n' \"$CODEX_ARTIFACT_BUILD_ENTRYPOINT\" >> \"{}\"\n",
|
|
"printf 'CODEX_ARTIFACT_RENDER_ENTRYPOINT=%s\\n' \"$CODEX_ARTIFACT_RENDER_ENTRYPOINT\" >> \"{}\"\n",
|
|
"printf 'CUSTOM_ENV=%s\\n' \"$CUSTOM_ENV\" >> \"{}\"\n",
|
|
"echo stdout-ok\n",
|
|
"echo stderr-ok >&2\n"
|
|
),
|
|
output_path.display(),
|
|
wrapped_script_path.display(),
|
|
output_path.display(),
|
|
output_path.display(),
|
|
output_path.display(),
|
|
output_path.display(),
|
|
),
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
#[cfg(unix)]
|
|
{
|
|
let mut permissions = fs::metadata(script_path)
|
|
.unwrap_or_else(|error| panic!("{error}"))
|
|
.permissions();
|
|
permissions.set_mode(0o755);
|
|
fs::set_permissions(script_path, permissions).unwrap_or_else(|error| panic!("{error}"));
|
|
}
|
|
}
|
|
|
|
fn build_zip_archive(runtime_version: &str) -> Vec<u8> {
|
|
let mut bytes = Cursor::new(Vec::new());
|
|
{
|
|
let mut zip = ZipWriter::new(&mut bytes);
|
|
let options = SimpleFileOptions::default();
|
|
let manifest = serde_json::to_vec(&sample_extracted_manifest(
|
|
runtime_version,
|
|
PathBuf::from("node/bin/node"),
|
|
))
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.start_file("artifact-runtime/manifest.json", options)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.write_all(&manifest)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.start_file(
|
|
"artifact-runtime/node/bin/node",
|
|
options.unix_permissions(0o755),
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.write_all(b"#!/bin/sh\n")
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.start_file(
|
|
"artifact-runtime/artifact-tool/dist/artifact_tool.mjs",
|
|
options,
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.write_all(b"export const ok = true;\n")
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.start_file(
|
|
"artifact-runtime/granola-render/dist/render_cli.mjs",
|
|
options,
|
|
)
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.write_all(b"export const ok = true;\n")
|
|
.unwrap_or_else(|error| panic!("{error}"));
|
|
zip.finish().unwrap_or_else(|error| panic!("{error}"));
|
|
}
|
|
bytes.into_inner()
|
|
}
|
|
|
|
fn sample_extracted_manifest(
|
|
runtime_version: &str,
|
|
node_relative: PathBuf,
|
|
) -> ExtractedRuntimeManifest {
|
|
ExtractedRuntimeManifest {
|
|
schema_version: 1,
|
|
runtime_version: runtime_version.to_string(),
|
|
node: RuntimePathEntry {
|
|
relative_path: node_relative.display().to_string(),
|
|
},
|
|
entrypoints: RuntimeEntrypoints {
|
|
build_js: RuntimePathEntry {
|
|
relative_path: "artifact-tool/dist/artifact_tool.mjs".to_string(),
|
|
},
|
|
render_cli: RuntimePathEntry {
|
|
relative_path: "granola-render/dist/render_cli.mjs".to_string(),
|
|
},
|
|
},
|
|
}
|
|
}
|