Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust
6.4 KB
Raw Blame
use pretty_assertions::assert_eq;

use super::AliasPlan;
use super::SkillLocator;
use crate::catalog::SkillSourceKind;

#[test]
fn assigns_aliases_in_first_seen_order() {
    let roots = [
        "/skills/beta",
        "/skills/alpha",
        "/skills/beta",
        "/skills/alpha",
    ];
    let plan = AliasPlan::build(&SkillSourceKind::Host, &roots).expect("alias plan should build");

    assert_eq!(
        vec!["- `r0` = `/skills/beta`", "- `r1` = `/skills/alpha`"],
        plan.root_lines()
    );
}

#[test]
fn reuses_aliases_for_duplicate_roots() {
    let root = "/skills/shared";
    let plan = AliasPlan::build(&SkillSourceKind::Host, &[root, root, root])
        .expect("alias plan should build");

    assert_eq!(vec!["- `r0` = `/skills/shared`"], plan.root_lines());
    assert_eq!(
        Some("r0/alpha/SKILL.md".to_string()),
        plan.shorten("/skills/shared/alpha/SKILL.md")
    );
    assert_eq!(
        Some("r0/beta/SKILL.md".to_string()),
        plan.shorten("/skills/shared/beta/SKILL.md")
    );
}

#[test]
fn shortens_filesystem_and_skill_resource_locators() {
    for (source, root, locator, expected) in [
        (
            SkillSourceKind::Host,
            "/skills/shared",
            "/skills/shared/alpha/SKILL.md",
            "r0/alpha/SKILL.md",
        ),
        (
            SkillSourceKind::Executor,
            "skill://executor/workspace/skills",
            "skill://executor/workspace/skills/alpha/SKILL.md",
            "e0/alpha/SKILL.md",
        ),
        (
            SkillSourceKind::Cloud,
            "skill://plugin",
            "skill://plugin/alpha",
            "c0/alpha",
        ),
    ] {
        let plan = AliasPlan::build(&source, &[root, root]).expect("alias plan should build");

        let shortened = plan.shorten(locator).expect("known root");
        assert_eq!(shortened, expected);
        assert_eq!(plan.expand(&shortened).as_deref(), Some(locator));
        let json = serde_json::to_string(&shortened).unwrap();
        let parsed: SkillLocator = serde_json::from_str(&json).unwrap();
        assert_eq!(parsed.alias_source(), Some(&source));
        assert_eq!(parsed.as_str(), expected);
        assert_eq!(serde_json::to_string(&parsed).unwrap(), json);
    }
}

#[test]
fn rejects_unknown_roots_and_locators_outside_the_root() {
    let root = "/skills/shared";
    let plan =
        AliasPlan::build(&SkillSourceKind::Host, &[root, root]).expect("alias plan should build");

    assert_eq!(None, plan.shorten("/skills/other/alpha"));
    assert_eq!(None, plan.shorten("/skills/shared-other/alpha"));
    assert_eq!(None, plan.shorten(root));
}

#[test]
fn returns_none_when_no_roots_are_provided() {
    assert!(AliasPlan::build(&SkillSourceKind::Host, &[]).is_none());
}

#[test]
fn aliases_roots_used_by_only_one_skill() {
    let root = "/skills/singleton";
    let plan = AliasPlan::build(&SkillSourceKind::Host, &[root])
        .expect("singleton root should produce an alias");

    assert_eq!(vec!["- `r0` = `/skills/singleton`"], plan.root_lines());
    assert_eq!(
        Some("r0/alpha/SKILL.md".to_string()),
        plan.shorten("/skills/singleton/alpha/SKILL.md")
    );
}

#[test]
fn locator_serde_recognizes_aliases_and_preserves_package_strings() {
    for (value, expected_source) in [
        ("c0/release", Some(SkillSourceKind::Cloud)),
        ("e12/references/details.md", Some(SkillSourceKind::Executor)),
        ("r1/release/SKILL.md", Some(SkillSourceKind::Host)),
        ("skill://Plugin_123/release", None),
        ("/skills/release/SKILL.md", None),
        (r"C:\skills\release\SKILL.md", None),
        ("cloud/release", None),
        ("c/release", None),
        ("c00/release", None),
        ("e-1/release", None),
        ("e+1/release", None),
        ("c0", None),
        ("c0/", None),
        ("/release", None),
        ("é0/release", None),
        ("e999999999999999999999999999999/release", None),
    ] {
        let json = serde_json::to_string(value).unwrap();
        let locator: SkillLocator = serde_json::from_str(&json).unwrap();
        assert_eq!(locator.alias_source(), expected_source.as_ref(), "{value}");
        assert_eq!(locator.as_str(), value);
        assert_eq!(serde_json::to_string(&locator).unwrap(), json);
    }
}

#[test]
fn appended_aliases_preserve_captured_steps_and_existing_locators() {
    let mut aliases = std::sync::Arc::new(AliasPlan::default());
    let mut budget = super::AliasBudget::default();
    aliases.extend_alias_plan("e", ["skill://root"], &mut budget);
    let previous = std::sync::Arc::clone(&aliases);
    let locator = "skill://root/nested/demo";
    let original = aliases.shorten(locator).unwrap();

    aliases.extend_alias_plan("e", ["skill://root/nested", "skill://root"], &mut budget);
    assert_eq!(previous.root_lines(), vec!["- `e0` = `skill://root`"]);
    assert_eq!(previous.shorten(locator), Some(original.clone()));
    assert_eq!(aliases.shorten(locator), Some("e1/demo".into()));
    assert_eq!(aliases.expand(&original).as_deref(), Some(locator));
    assert_eq!(aliases.expand("e1/demo").as_deref(), Some(locator));
    assert_eq!(
        aliases.root_lines_for(&std::collections::HashSet::from(["e1".to_string()])),
        vec!["- `e1` = `skill://root/nested`"]
    );
}

#[test]
fn alias_number_and_byte_budgets_are_shared_without_reassigning_existing_roots() {
    let mut cloud = std::sync::Arc::new(AliasPlan::default());
    let mut executor = std::sync::Arc::new(AliasPlan::default());
    let mut budget = super::AliasBudget {
        roots: super::MAX_ALIAS_ROOTS - 2,
        ..Default::default()
    };
    cloud.extend_alias_plan("c", ["skill://cloud"], &mut budget);
    executor.extend_alias_plan("e", ["skill://first", "skill://second"], &mut budget);
    assert_eq!(budget.roots, super::MAX_ALIAS_ROOTS);
    assert_eq!(executor.root_lines(), vec!["- `e0` = `skill://first`"]);
    assert_eq!(executor.shorten("skill://second/demo"), None);
    assert_eq!(cloud.shorten("skill://cloud/demo"), Some("c0/demo".into()));

    let mut budget = super::AliasBudget::default();
    let mut aliases = std::sync::Arc::new(AliasPlan::default());
    let oversized = "x".repeat(super::MAX_ALIAS_BYTES);
    aliases.extend_alias_plan("e", ["skill://first", &oversized], &mut budget);
    aliases.extend_alias_plan("e", ["skill://second"], &mut budget);
    assert_eq!(
        aliases.root_lines(),
        vec!["- `e0` = `skill://first`", "- `e1` = `skill://second`"]
    );
    assert_eq!(aliases.shorten(&format!("{oversized}/demo")), None);
}