use crate::node::{Node, Visit, walk};
use crate::role::Role;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TestModel {
pub language: String,
pub test_name_prefixes: Vec<String>,
pub test_attributes: Vec<String>,
pub test_invocations: Vec<String>,
pub test_kinds: Vec<String>,
pub iteration_methods: Vec<String>,
pub assertion_prefixes: Vec<String>,
pub assertion_kinds: Vec<String>,
}
pub const LANGUAGES: &[&str] = &[
"bash",
"c",
"cpp",
"java",
"javascript",
"python",
"ruby",
"rust",
"typescript",
"zig",
];
fn owned(values: &[&str]) -> Vec<String> {
values.iter().map(|value| (*value).to_string()).collect()
}
impl TestModel {
pub fn for_language(language: &str) -> Option<TestModel> {
Some(match language {
"python" => TestModel::python(),
"ruby" => TestModel::ruby(),
"rust" => TestModel::rust(),
"java" => TestModel::java(),
"typescript" => TestModel::typescript(),
"javascript" => TestModel::javascript(),
"c" => TestModel::c(),
"cpp" => TestModel::cpp(),
"bash" => TestModel::bash(),
"zig" => TestModel::zig(),
_ => return None,
})
}
fn base(language: &str) -> TestModel {
TestModel {
language: language.to_string(),
test_name_prefixes: Vec::new(),
test_attributes: Vec::new(),
test_invocations: Vec::new(),
test_kinds: Vec::new(),
iteration_methods: Vec::new(),
assertion_prefixes: Vec::new(),
assertion_kinds: Vec::new(),
}
}
pub fn python() -> Self {
TestModel {
test_name_prefixes: owned(&["test_", "test"]),
assertion_prefixes: owned(&["assert", "self.assert", "self.fail", "expect"]),
assertion_kinds: owned(&["assert_statement"]),
..TestModel::base("python")
}
}
pub fn ruby() -> Self {
TestModel {
test_name_prefixes: owned(&["test_"]),
test_invocations: owned(&["it", "test", "specify", "example", "scenario"]),
iteration_methods: owned(&[
"each",
"each_with_index",
"each_with_object",
"each_pair",
"map",
"flat_map",
"times",
"select",
"reject",
"detect",
"upto",
"downto",
]),
assertion_prefixes: owned(&["assert", "refute", "expect", "should"]),
..TestModel::base("ruby")
}
}
pub fn rust() -> Self {
TestModel {
test_name_prefixes: owned(&["test_"]),
test_attributes: owned(&["test", "rstest", "proptest", "test_case", "bench"]),
assertion_prefixes: owned(&["assert", "debug_assert", "expect", "panic"]),
..TestModel::base("rust")
}
}
pub fn java() -> Self {
TestModel {
test_name_prefixes: owned(&["test"]),
test_attributes: owned(&[
"Test",
"ParameterizedTest",
"RepeatedTest",
"TestFactory",
"TestTemplate",
]),
assertion_prefixes: owned(&["assert", "Assert.", "assertThat", "verify", "expect"]),
..TestModel::base("java")
}
}
pub fn typescript() -> Self {
TestModel {
test_invocations: owned(&["it", "test", "specify", "bench"]),
iteration_methods: owned(&["forEach", "map", "flatMap", "filter", "each"]),
assertion_prefixes: owned(&["expect", "assert", "should"]),
..TestModel::base("typescript")
}
}
pub fn javascript() -> Self {
TestModel::typescript().relabel("javascript")
}
pub fn c() -> Self {
TestModel {
test_name_prefixes: owned(&["test_"]),
test_invocations: owned(&[
"TEST",
"TEST_F",
"TEST_P",
"TEST_CASE",
"RUN_TEST",
"BOOST_AUTO_TEST_CASE",
]),
assertion_prefixes: owned(&["EXPECT_", "ASSERT_", "TEST_ASSERT", "CHECK", "REQUIRE"]),
..TestModel::base("c")
}
}
pub fn cpp() -> Self {
TestModel {
test_invocations: owned(&[
"TEST",
"TEST_F",
"TEST_P",
"TYPED_TEST",
"TYPED_TEST_P",
"TEST_CASE",
"SCENARIO",
"BOOST_AUTO_TEST_CASE",
]),
..TestModel::c()
}
.relabel("cpp")
}
pub fn bash() -> Self {
TestModel {
test_name_prefixes: owned(&["test_", "it_", "should_"]),
assertion_prefixes: owned(&["assert", "refute"]),
..TestModel::base("bash")
}
}
pub fn zig() -> Self {
TestModel {
test_kinds: owned(&["test_declaration"]),
assertion_prefixes: owned(&["expect", "try expect", "std.testing."]),
..TestModel::base("zig")
}
}
fn relabel(mut self, language: &str) -> Self {
self.language = language.to_string();
self
}
pub fn is_test<'t, N: Node<'t>>(&self, node: N) -> bool {
if self.test_kinds.iter().any(|kind| kind == node.kind()) {
return true;
}
if node.has_role(Role::Callable) {
if self.has_test_attribute(node) {
return true;
}
if callable_name(node).is_some_and(|name| self.names_a_test(name)) {
return true;
}
}
if node.has_role(Role::Invocation)
&& callee_name(node)
.is_some_and(|callee| self.test_invocations.iter().any(|name| name == callee))
{
return takes_a_body(node);
}
false
}
fn names_a_test(&self, name: &str) -> bool {
self.test_invocations.iter().any(|exact| exact == name)
|| self
.test_name_prefixes
.iter()
.any(|prefix| name.starts_with(prefix.as_str()))
}
fn has_test_attribute<'t, N: Node<'t>>(&self, callable: N) -> bool {
if self.test_attributes.is_empty() {
return false;
}
let mut found = false;
for child in callable.children() {
if child.has_role(Role::Body) || child.has_role(Role::Scope) {
continue;
}
walk(child, &mut |node| {
if !node.has_role(Role::Attribute) {
return Visit::Descend;
}
let name = attribute_name(node.text());
if self.test_attributes.iter().any(|wanted| wanted == name) {
found = true;
}
Visit::Skip
});
if found {
return true;
}
}
false
}
pub fn is_iteration<'t, N: Node<'t>>(&self, node: N) -> bool {
self.iteration_method(node).is_some()
}
pub fn iteration_method<'t, N: Node<'t>>(&self, node: N) -> Option<&'t str> {
if self.iteration_methods.is_empty() || !node.has_role(Role::Invocation) {
return None;
}
let callee = callee_name(node)?;
if self.iteration_methods.iter().any(|name| name == callee) && takes_a_body(node) {
Some(callee)
} else {
None
}
}
pub fn is_assertion<'t, N: Node<'t>>(&self, node: N) -> bool {
if self.assertion_kinds.iter().any(|kind| kind == node.kind()) {
return true;
}
if !node.has_role(Role::Invocation) {
return false;
}
let callee = node
.child_by_field("function")
.map(|function| function.text())
.or_else(|| callee_name(node))
.unwrap_or_default();
self.assertion_prefixes
.iter()
.any(|prefix| callee.starts_with(prefix.as_str()))
}
}
fn callable_name<'t, N: Node<'t>>(callable: N) -> Option<&'t str> {
if let Some(name) = callable.child_by_field("name") {
return Some(name.text());
}
let head = callable.text().lines().next()?;
let head = head.split('(').next().unwrap_or(head);
head.split_whitespace().last()
}
fn callee_name<'t, N: Node<'t>>(node: N) -> Option<&'t str> {
if let Some(callee) = node
.child_by_field("function")
.or_else(|| node.child_by_field("method"))
{
return Some(last_segment(callee.text()));
}
let head = node.text().lines().next()?;
let head = head.split(['(', '{']).next().unwrap_or(head);
Some(last_segment(head.split_whitespace().next()?))
}
fn takes_a_body<'t, N: Node<'t>>(node: N) -> bool {
let mut found = false;
for child in node.children() {
walk(child, &mut |inner| {
if inner.has_role(Role::Callable) || inner.has_role(Role::Body) {
found = true;
return Visit::Skip;
}
Visit::Descend
});
if found {
return true;
}
}
false
}
fn attribute_name(text: &str) -> &str {
let text = text.trim();
let text = text.trim_start_matches(['#', '@', '[']);
let text = text.split('(').next().unwrap_or(text);
last_segment(text.trim_end_matches([']', ',']).trim())
}
fn last_segment(text: &str) -> &str {
text.rsplit(['.', ':']).next().unwrap_or(text).trim()
}
#[cfg(test)]
mod tests {
use super::{LANGUAGES, TestModel, attribute_name, last_segment};
#[test]
fn every_language_treebank_serves_has_a_model() {
for language in LANGUAGES {
let model = TestModel::for_language(language)
.unwrap_or_else(|| panic!("no test model for {language}"));
assert_eq!(&model.language, language);
}
assert!(
TestModel::for_language("cobol").is_none(),
"a language with no pack should not get a guessed model"
);
}
#[test]
fn every_model_can_recognise_a_test_some_way() {
for language in LANGUAGES {
let Some(model) = TestModel::for_language(language) else {
continue;
};
assert!(
!model.test_name_prefixes.is_empty()
|| !model.test_attributes.is_empty()
|| !model.test_invocations.is_empty()
|| !model.test_kinds.is_empty(),
"{language} has no way to recognise a test at all"
);
}
}
#[test]
fn a_suite_is_not_a_test() {
for language in LANGUAGES {
let Some(model) = TestModel::for_language(language) else {
continue;
};
assert!(
!model.test_invocations.iter().any(|name| name == "describe"),
"{language} treats `describe` as a test, so every loop that \
generates cases is a finding"
);
}
}
#[test]
fn an_attribute_reduces_to_the_name_a_table_can_carry() {
assert_eq!(attribute_name("#[test]"), "test");
assert_eq!(attribute_name("#[tokio::test]"), "test");
assert_eq!(attribute_name("#[test_case(1, 2)]"), "test_case");
assert_eq!(attribute_name("@Test"), "Test");
assert_eq!(
attribute_name("@pytest.mark.parametrize('n', xs)"),
"parametrize"
);
assert_eq!(attribute_name("test"), "test");
}
#[test]
fn a_path_reduces_to_its_last_segment() {
assert_eq!(last_segment("xs.each"), "each");
assert_eq!(last_segment("std::testing::expect"), "expect");
assert_eq!(last_segment("it"), "it");
}
}