use super::support::logged_argv;
use crate::languages::runner::*;
use crate::test_support::fake_go::{self, Vet};
fn strings(items: &[&str]) -> Vec<String> {
items.iter().map(|s| (*s).to_owned()).collect()
}
fn reported(outcome: &ToolOutcome) -> Vec<&str> {
outcome
.findings
.iter()
.map(|f| f.file_path.as_str())
.collect()
}
#[tokio::test]
async fn each_package_directory_is_handed_over_once() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let files = [
"internal/b/y.go",
"cmd/a/main.go",
"internal/b/x.go",
"root.go",
"-dash/z.go",
];
let log = fake_go::workspace(root, &files, Vet::default());
let outcome = run_tool(&fake_go::spec(), root, &strings(&files)).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert_eq!(
logged_argv(&log),
vec!["vet", ".", "./-dash", "./cmd/a", "./internal/b"]
);
assert!(outcome.excluded.is_empty());
}
#[tokio::test]
async fn a_diff_spanning_two_packages_is_vetted_without_error() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let files = ["cmd/healthgate/main.go", "cmd/temporal-gateway/main.go"];
fake_go::workspace(root, &files, Vet::default());
let outcome = run_tool(&fake_go::spec(), root, &strings(&files)).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert!(outcome.findings.is_empty(), "{:?}", outcome.findings);
assert!(outcome.compilation_succeeded);
fake_go::workspace(
root,
&files,
Vet {
stderr: "cmd/temporal-gateway/main.go:7:2: unreachable code",
exit: 1,
},
);
let outcome = run_tool(&fake_go::spec(), root, &strings(&files)).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert_eq!(reported(&outcome), vec!["cmd/temporal-gateway/main.go"]);
}
#[tokio::test]
async fn a_file_the_build_excludes_is_reported_as_excluded_and_not_vetted() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let log = fake_go::workspace(
root,
&["tools/tools_ignored.go", "pkg/a.go"],
Vet::default(),
);
let outcome = run_tool(
&fake_go::spec(),
root,
&strings(&["tools/tools_ignored.go", "pkg/a.go"]),
)
.await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert_eq!(logged_argv(&log), vec!["vet", "./pkg"]);
assert_eq!(outcome.excluded, vec!["tools/tools_ignored.go"]);
assert!(outcome.compilation_succeeded);
}
#[tokio::test]
async fn when_the_build_excludes_every_file_vet_is_not_run() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let log = fake_go::workspace(root, &["tools/tools_ignored.go"], Vet::default());
let outcome = run_tool(
&fake_go::spec(),
root,
&strings(&["tools/tools_ignored.go"]),
)
.await;
assert_eq!(
outcome.status,
ToolStatus::Skipped,
"detail: {}",
outcome.detail
);
assert!(logged_argv(&log).is_empty(), "vet must not run");
assert_eq!(outcome.excluded, vec!["tools/tools_ignored.go"]);
assert!(!outcome.compilation_succeeded);
}
#[tokio::test]
async fn a_package_that_fails_to_load_reports_its_errors_and_vet_is_not_run() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let log = fake_go::workspace(
root,
&[
"broken/a.go",
"broken/b.go",
"pkg/a.go",
"tools/tools_ignored.go",
],
Vet::default(),
);
let outcome = run_tool(
&fake_go::spec(),
root,
&strings(&["broken/a.go", "pkg/a.go", "tools/tools_ignored.go"]),
)
.await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert!(logged_argv(&log).is_empty(), "vet must not run");
assert_eq!(outcome.excluded, vec!["tools/tools_ignored.go"]);
assert_eq!(reported(&outcome), vec!["broken/b.go"]);
assert_eq!(outcome.findings[0].line, 3);
assert!(outcome.findings[0].message.contains("ex/nope"));
assert!(!outcome.compilation_succeeded);
}
#[tokio::test]
async fn a_type_check_failure_in_an_untouched_file_is_kept() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
fake_go::workspace(
root,
&["pkg/a.go", "pkg/b.go", "pkg/c.go"],
Vet {
stderr: "# ex/pkg\nvet: pkg/b.go:3:29: not enough arguments in call to Foo\npkg/c.go:5:2: fmt.Printf format %d has arg \"s\" of wrong type string",
exit: 1,
},
);
let outcome = run_tool(&fake_go::spec(), root, &strings(&["pkg/a.go"])).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert_eq!(reported(&outcome), vec!["pkg/b.go"]);
assert_eq!(outcome.findings[0].kind, TYPE_CHECK_KIND);
}
#[tokio::test]
async fn a_file_with_a_malformed_build_line_is_reported_not_excluded() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let log = fake_go::workspace(root, &["pkg/a.go", "pkg/bad_invalid.go"], Vet::default());
let outcome = run_tool(&fake_go::spec(), root, &strings(&["pkg/bad_invalid.go"])).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert!(outcome.excluded.is_empty(), "{:?}", outcome.excluded);
assert!(logged_argv(&log).is_empty(), "vet must not run");
assert_eq!(reported(&outcome), vec!["pkg/bad_invalid.go"]);
assert!(outcome.findings[0].message.contains("//go:build"));
}
#[tokio::test]
async fn a_directory_go_cannot_place_is_unavailable_with_its_reason() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
fake_go::workspace(root, &["outside/a.go", "pkg/a.go"], Vet::default());
let outcome = run_tool(
&fake_go::spec(),
root,
&strings(&["outside/a.go", "pkg/a.go"]),
)
.await;
assert_eq!(outcome.status, ToolStatus::Unavailable);
assert!(
outcome.detail.contains("not one of the workspace modules"),
"detail: {}",
outcome.detail
);
}
#[tokio::test]
async fn an_analyzer_finding_in_a_sibling_file_is_dropped() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
fake_go::workspace(
root,
&["pkg/asked.go", "pkg/sibling_test.go"],
Vet {
stderr: "pkg/asked.go:4:2: unreachable code\npkg/sibling_test.go:9:2: unreachable code",
exit: 1,
},
);
let outcome = run_tool(&fake_go::spec(), root, &strings(&["pkg/asked.go"])).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert_eq!(reported(&outcome), vec!["pkg/asked.go"]);
}
#[tokio::test]
async fn a_dependency_that_fails_to_compile_is_kept() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
fake_go::workspace(
root,
&["pkg/a.go", "pkg/b.go"],
Vet {
stderr: "# ex/dep\ndep/dep.go:3:9: undefined: missing\n# ex/pkg\npkg/b.go:4:2: unreachable code",
exit: 1,
},
);
let outcome = run_tool(&fake_go::spec(), root, &strings(&["pkg/a.go"])).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert_eq!(reported(&outcome), vec!["dep/dep.go"]);
}
#[tokio::test]
async fn a_dependency_directory_holding_only_an_excluded_requested_file_is_kept() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let files = ["pkg/a.go", "dep/dep_ignored.go"];
fake_go::workspace(
root,
&files,
Vet {
stderr: "# ex/dep\ndep/dep.go:3:9: undefined: missing",
exit: 1,
},
);
let outcome = run_tool(&fake_go::spec(), root, &strings(&files)).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert_eq!(reported(&outcome), vec!["dep/dep.go"]);
assert_eq!(outcome.excluded, vec!["dep/dep_ignored.go"]);
}
#[test]
fn a_load_error_position_is_split_from_the_right() {
use crate::languages::runner::go_packages::position;
assert_eq!(
position("broken/b.go:3:8"),
Some(("broken/b.go", 3, Some(8)))
);
assert_eq!(position("broken/b.go:3"), Some(("broken/b.go", 3, None)));
assert_eq!(
position(r"C:\src\b.go:3:8"),
Some((r"C:\src\b.go", 3, Some(8)))
);
assert_eq!(position("broken/b.go"), Some(("broken/b.go", 1, None)));
assert_eq!(position(""), None);
}
#[tokio::test]
async fn a_sibling_finding_spelled_with_dot_dot_segments_is_still_dropped() {
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
fake_go::workspace(
root,
&["pkg/asked.go", "pkg/sibling.go"],
Vet {
stderr: "pkg/../pkg/sibling.go:9:2: unreachable code",
exit: 1,
},
);
let outcome = run_tool(&fake_go::spec(), root, &strings(&["pkg/asked.go"])).await;
assert_eq!(outcome.status, ToolStatus::Ok, "detail: {}", outcome.detail);
assert!(reported(&outcome).is_empty(), "{:?}", outcome.findings);
}