blob: 19ce38790abf407215e50fd37e878da973df858b [file]
// Copyright 2026 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use starlark::{environment::GlobalsBuilder, eval::Evaluator, values::Value};
use starlark_derive::starlark_module;
use crate::args::Args;
#[starlark_module]
pub(crate) fn register_args_test_globals(builder: &mut GlobalsBuilder) {
fn args<'v>(eval: &mut Evaluator<'v, '_, '_>) -> starlark::Result<Value<'v>> {
Ok(eval.heap().alloc(Args::default()))
}
fn identity<'v>(x: Value<'v>) -> starlark::Result<Value<'v>> {
Ok(x)
}
}
struct ArgsAssert {
assert: testutils::Assert,
}
impl ArgsAssert {
fn new() -> Self {
let mut a = testutils::Assert::default();
a.modify_globals(|builder| {
register_args_test_globals(builder);
depset::depset_globals!(builder, testutils::FakeEvalContext);
});
Self { assert: a }
}
#[track_caller]
fn assert_expands_to(&mut self, code: &str, expected: Result<&[&str], &str>) {
use starlark::values::UnpackValue as _;
use crate::unpack::FrozenArgsSequence;
let val = self.assert.pass(code);
let res = starlark::environment::Module::with_temp_heap(|module| {
let mut eval = starlark::eval::Evaluator::new(&module);
let val_ref = eval.heap().access_owned_frozen_value(&val);
let seq = FrozenArgsSequence::unpack_value_err(val_ref).unwrap();
seq.expand(&mut eval)
});
match expected {
Ok(expected_cmd) => {
assert_eq!(res.unwrap(), expected_cmd);
},
Err(expected_err) => {
let err_str = res.unwrap_err().to_string();
assert!(
err_str.contains(expected_err),
"Expected error containing: {expected_err}\nGot error: {err_str}"
);
},
}
}
#[track_caller]
fn fail(&mut self, code: &str, expected_error: &str) {
self.assert.fail(code, expected_error);
}
}
#[test]
fn test_combine_string_and_args() {
let mut a = ArgsAssert::new();
a.assert_expands_to(
r#"["foo", args().add("bar"), "baz"]"#,
Ok(&["foo", "bar", "baz"]),
);
}
#[test]
fn test_args_add() {
let mut a = ArgsAssert::new();
a.assert_expands_to(r#"[args().add("--foo")]"#, Ok(&["--foo"]));
a.assert_expands_to(r#"[args().add(make_file("a/b.cc"))]"#, Ok(&["a/b.cc"]));
a.assert_expands_to(r#"[args().add("--bar", "baz")]"#, Ok(&["--bar", "baz"]));
a.assert_expands_to(r#"[args().add("--qux", None)]"#, Ok(&[]));
a.assert_expands_to(
r#"[args().add("--val", 1, format="before %s after")]"#,
Ok(&["--val", "before 1 after"]),
);
a.fail(
r#"[args().add("--val", 1, format="no percent s")]"#,
"Format string must contain exactly one '%s'",
);
a.fail(
r#"[args().add("--val", 1, format="two %s %s")]"#,
"Format string must contain exactly one '%s'",
);
}
#[test]
fn test_args_add_all() {
let mut a = ArgsAssert::new();
a.assert_expands_to(r#"[args().add_all([1, 2])]"#, Ok(&["1", "2"]));
a.assert_expands_to(
r#"[args().add_all("--flag", ["3", "4"], before_each = "-b")]"#,
Ok(&["--flag", "-b", "3", "-b", "4"]),
);
a.assert_expands_to(
r#"[args().add_all(["x", "y"], before_each="-b", format_each=".%s.", terminate_with="--end")]"#,
Ok(&["-b", ".x.", "-b", ".y.", "--end"]),
);
a.assert_expands_to(
r#"[args().add_all([make_file("x.cc"), make_file("y.cc")])]"#,
Ok(&["x.cc", "y.cc"]),
);
a.assert_expands_to(
r#"[args().add_all(["a", None])]"#,
Err("None is not allowed unless mapped by map_each"),
);
}
#[test]
fn test_args_add_joined() {
let mut a = ArgsAssert::new();
a.assert_expands_to(
r#"[args().add_joined([1, 2], join_with = ',')]"#,
Ok(&["1,2"]),
);
a.assert_expands_to(
r#"[args().add_joined("--flag", ["c", "d"], join_with=":")]"#,
Ok(&["--flag", "c:d"]),
);
a.assert_expands_to(
r#"[args().add_joined(depset(["a", "b"]), join_with = ",")]"#,
Ok(&["a,b"]),
);
a.assert_expands_to(
r#"
[
args()
.add_joined(
[make_file("a/b.cc"), make_file("c/d.cc")],
join_with = ":",
)
]
"#,
Ok(&["a/b.cc:c/d.cc"]),
);
a.assert_expands_to(
r#"[args().add_joined([1, 2], join_with=",", format_each=".%s.", format_joined="list=%s")]"#,
Ok(&["list=.1.,.2."]),
);
}
#[test]
fn test_args_omit_if_empty() {
let mut a = ArgsAssert::new();
a.assert_expands_to(
r#"[args().add_all("--flag", [], terminate_with = "after")]"#,
Ok(&[]),
);
a.assert_expands_to(
r#"[args().add_joined("--flag", [], join_with=",", omit_if_empty=False)]"#,
Ok(&["--flag", ""]),
);
a.assert_expands_to(
r#"[args().add_all("--flag", [None], map_each=identity, allow_closure=False, omit_if_empty=True)]"#,
Ok(&[]),
);
}
#[test]
fn test_args_map_each() {
let mut a = ArgsAssert::new();
a.assert_expands_to(
r#"[args().add_all(["abc", ["def", "ghi"], None], map_each=identity, allow_closure=False)]"#,
Ok(&["abc", "def", "ghi"]),
);
a.assert_expands_to(
r#"[args().add_all([[1]], map_each=identity, allow_closure=False)]"#,
Err("map_each must return a list[str], str, or None"),
);
a.assert_expands_to(
r#"[args().add_all([1], map_each=identity, allow_closure=False)]"#,
Err("map_each must return a list[str], str, or None"),
);
a.fail(
r#"[args().add_all([1], map_each=identity)]"#,
"map_each was specified without allow_closure",
);
a.assert_expands_to(
r#"[args().add_all([1], map_each=fail, allow_closure=False)]"#,
Err("fail: 1"),
);
}
#[test]
fn test_args_uniquify() {
let mut a = ArgsAssert::new();
a.assert_expands_to(
r#"[args().add_all(["a", "b", "a", "c"])]"#,
Ok(&["a", "b", "a", "c"]),
);
a.assert_expands_to(
r#"[args().add_all(["a", "b", "a", "c"], uniquify=True)]"#,
Ok(&["a", "b", "c"]),
);
a.assert_expands_to(
r#"[args().add_joined(["a", "b", "a", "c"], join_with=",", uniquify=True)]"#,
Ok(&["a,b,c"]),
);
a.assert_expands_to(
r#"[args().add_all(["a", "b", "a", "c"], before_each="-b", uniquify=True)]"#,
Ok(&["-b", "a", "-b", "b", "-b", "c"]),
);
a.assert_expands_to(
r#"
def map_to_constant(x):
return "constant"
[args().add_joined(["a", "b", "c"], map_each=map_to_constant, allow_closure=False, uniquify=True, join_with=",")]
"#,
Ok(&["constant"]),
);
}
#[test]
fn test_args_chaining() {
let mut a = ArgsAssert::new();
a.assert_expands_to(
r#"
[
args()
.add("--foo")
.add_all(["bar", "baz"])
.add_joined(["x", "y"], join_with=":")
]
"#,
Ok(&["--foo", "bar", "baz", "x:y"]),
);
}
#[test]
fn test_mutate_frozen_args_fails() {
let mut a = ArgsAssert::new();
a.assert.modify_globals(|builder| {
builder.set("frozen_args", crate::args::FrozenArgs::default());
});
a.fail(
"frozen_args.add('foo')",
"trying to mutate a frozen Args value",
);
}