use std::fs;
use std::path::Path;
use std::process::{Command, ExitStatus};
use tempfile::TempDir;
fn write(dir: &Path, relative: &str, contents: &str) {
let path = dir.join(relative);
if let Some(parent) = path.parent() {
fs::create_dir_all(parent).unwrap();
}
fs::write(&path, contents).unwrap();
}
struct Output {
status: ExitStatus,
stdout: String,
stderr: String,
}
fn run_in(dir: &Path, args: &[&str]) -> Output {
let output = Command::new(env!("CARGO_BIN_EXE_import-lint"))
.args(args)
.current_dir(dir)
.output()
.expect("spawn import-lint");
Output {
status: output.status,
stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
}
}
fn write_violation_fixture(dir: &Path) {
write(
dir,
"src/consumer.ts",
"import { helper } from \"./internal/util\";\nconsole.log(helper);\n",
);
write(
dir,
"src/internal/util.ts",
"/** @package */\nexport const helper = 1;\n",
);
}
fn has_location_line(stdout: &str, severity: &str) -> bool {
stdout.lines().any(|line| {
let trimmed = line.trim_start();
let Some(loc) = trimmed.split_whitespace().next() else {
return false;
};
let mut parts = loc.split(':');
let (Some(l), Some(c), None) = (parts.next(), parts.next(), parts.next()) else {
return false;
};
l.parse::<u32>().is_ok() && c.parse::<u32>().is_ok() && trimmed.contains(severity)
})
}
#[test]
fn clean_project_exits_0_with_empty_stdout() {
let dir = TempDir::new().unwrap();
write(dir.path(), "src/a.ts", "export const a = 1;\n");
let out = run_in(dir.path(), &[]);
assert!(out.status.success(), "stderr: {}", out.stderr);
assert_eq!(out.stdout, "");
}
#[test]
fn package_violation_pretty_output_exits_1_with_no_ansi() {
let dir = TempDir::new().unwrap();
write_violation_fixture(dir.path());
let out = run_in(dir.path(), &[]);
assert_eq!(out.status.code(), Some(1));
assert!(out.stdout.contains("src/consumer.ts") || out.stdout.contains("src\\consumer.ts"));
assert!(
out.stdout
.contains("Cannot import a package-private export 'helper'")
);
assert!(out.stdout.contains("package-access"));
assert!(has_location_line(&out.stdout, "error"));
assert!(!out.stdout.contains('\x1b'), "stdout: {}", out.stdout);
}
#[test]
fn severity_warn_exits_0_and_renders_as_warning() {
let dir = TempDir::new().unwrap();
write_violation_fixture(dir.path());
write(
dir.path(),
".importlintrc.jsonc",
r#"{ "rules": { "package-access": { "severity": "warn" } } }"#,
);
let out = run_in(dir.path(), &[]);
assert!(out.status.success(), "stderr: {}", out.stderr);
assert!(has_location_line(&out.stdout, "warning"));
assert!(
out.stdout
.contains("Cannot import a package-private export 'helper'")
);
}
#[test]
fn severity_warn_with_quiet_suppresses_all_output() {
let dir = TempDir::new().unwrap();
write_violation_fixture(dir.path());
write(
dir.path(),
".importlintrc.jsonc",
r#"{ "rules": { "package-access": { "severity": "warn" } } }"#,
);
let out = run_in(dir.path(), &["--quiet"]);
assert!(out.status.success(), "stderr: {}", out.stderr);
assert_eq!(out.stdout, "");
}
#[test]
fn severity_off_exits_0_with_no_output() {
let dir = TempDir::new().unwrap();
write_violation_fixture(dir.path());
write(
dir.path(),
".importlintrc.jsonc",
r#"{ "rules": { "package-access": { "severity": "off" } } }"#,
);
let out = run_in(dir.path(), &[]);
assert!(out.status.success(), "stderr: {}", out.stderr);
assert_eq!(out.stdout, "");
}
#[test]
fn json_format_matches_eslint_shape() {
let dir = TempDir::new().unwrap();
write_violation_fixture(dir.path());
write(dir.path(), "src/clean.ts", "export const clean = 1;\n");
let out = run_in(dir.path(), &["--format", "json"]);
assert_eq!(out.status.code(), Some(1), "stderr: {}", out.stderr);
let value: serde_json::Value =
serde_json::from_str(out.stdout.trim()).expect("stdout should be valid JSON");
let entries = value.as_array().expect("top-level JSON value is an array");
assert!(entries.iter().all(|entry| {
Path::new(entry["filePath"].as_str().expect("filePath is a string")).is_absolute()
}));
let clean_entry = entries
.iter()
.find(|entry| entry["filePath"].as_str().unwrap().ends_with("clean.ts"))
.expect("clean.ts should have an entry even with no messages");
assert_eq!(clean_entry["messages"].as_array().unwrap().len(), 0);
assert_eq!(clean_entry["errorCount"], 0);
assert_eq!(clean_entry["fixableErrorCount"], 0);
assert_eq!(clean_entry["fixableWarningCount"], 0);
let consumer_entry = entries
.iter()
.find(|entry| entry["filePath"].as_str().unwrap().ends_with("consumer.ts"))
.expect("consumer.ts should have the violation");
assert_eq!(consumer_entry["errorCount"], 1);
assert_eq!(consumer_entry["warningCount"], 0);
let message = &consumer_entry["messages"][0];
assert_eq!(message["ruleId"], "package-access");
assert_eq!(message["severity"], 2);
assert_eq!(message["messageId"], "package");
}
#[test]
fn github_format_produces_error_workflow_command() {
let dir = TempDir::new().unwrap();
write_violation_fixture(dir.path());
let out = run_in(dir.path(), &["--format", "github"]);
assert_eq!(out.status.code(), Some(1), "stderr: {}", out.stderr);
assert!(
out.stdout
.lines()
.any(|line| { line.starts_with("::error file=") && line.contains("src/consumer.ts") })
);
}
#[test]
fn config_discovery_walks_up_and_include_limits_lint_targets() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
".importlintrc.jsonc",
r#"{ "include": ["src"] }"#,
);
write_violation_fixture(dir.path());
write(
dir.path(),
"other/consumer.ts",
"import { helper } from \"./internal/util\";\nconsole.log(helper);\n",
);
write(
dir.path(),
"other/internal/util.ts",
"/** @package */\nexport const helper = 1;\n",
);
let subdir = dir.path().join("tools/nested");
fs::create_dir_all(&subdir).unwrap();
let out = run_in(&subdir, &[]);
assert_eq!(out.status.code(), Some(1), "stderr: {}", out.stderr);
assert!(out.stdout.contains("src/consumer.ts") || out.stdout.contains("src\\consumer.ts"));
assert!(
!out.stdout.contains("other/consumer.ts") && !out.stdout.contains("other\\consumer.ts")
);
}
#[test]
fn exclude_glob_excludes_the_violating_file() {
let dir = TempDir::new().unwrap();
write_violation_fixture(dir.path());
write(
dir.path(),
".importlintrc.jsonc",
r#"{ "exclude": ["src/consumer.ts"] }"#,
);
let out = run_in(dir.path(), &[]);
assert!(out.status.success(), "stderr: {}", out.stderr);
assert_eq!(out.stdout, "");
}
#[test]
fn unknown_config_key_exits_2_and_mentions_key_and_file() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
".importlintrc.jsonc",
r#"{ "includ": ["src"] }"#,
);
let out = run_in(dir.path(), &[]);
assert_eq!(out.status.code(), Some(2));
assert!(out.stderr.contains("includ"), "stderr: {}", out.stderr);
assert!(
out.stderr.contains(".importlintrc.jsonc"),
"stderr: {}",
out.stderr
);
}
#[test]
fn jsdoc_rule_key_exits_2_and_prints_the_rename_hint() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
".importlintrc.jsonc",
r#"{ "rules": { "jsdoc": { "severity": "warn" } } }"#,
);
let out = run_in(dir.path(), &[]);
assert_eq!(out.status.code(), Some(2));
assert!(
out.stderr
.contains("the rule \"jsdoc\" was renamed to \"package-access\"; update your config"),
"stderr: {}",
out.stderr
);
}
#[test]
fn report_unresolved_emits_warning_and_exits_0() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
"src/a.ts",
"import { x } from \"./missing\";\nconsole.log(x);\n",
);
let out = run_in(dir.path(), &["--report-unresolved"]);
assert!(out.status.success(), "stderr: {}", out.stderr);
assert!(has_location_line(&out.stdout, "warning"));
assert!(
out.stdout
.contains("Unresolved import specifier './missing'")
);
assert!(out.stdout.contains("import-access/unresolved"));
}
#[test]
fn report_unresolved_without_the_flag_stays_silent() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
"src/a.ts",
"import { x } from \"./missing\";\nconsole.log(x);\n",
);
let out = run_in(dir.path(), &[]);
assert!(out.status.success(), "stderr: {}", out.stderr);
assert_eq!(out.stdout, "");
}
#[test]
fn nonexistent_explicit_config_exits_2() {
let dir = TempDir::new().unwrap();
write(dir.path(), "src/a.ts", "export const a = 1;\n");
let out = run_in(dir.path(), &["--config", "does-not-exist.jsonc"]);
assert_eq!(out.status.code(), Some(2));
assert!(
out.stderr.contains("does-not-exist.jsonc"),
"stderr: {}",
out.stderr
);
}
#[test]
fn invalid_config_json_exits_2_and_mentions_file() {
let dir = TempDir::new().unwrap();
write(dir.path(), ".importlintrc.jsonc", "{ not valid json ");
let out = run_in(dir.path(), &[]);
assert_eq!(out.status.code(), Some(2));
assert!(
out.stderr.contains(".importlintrc.jsonc"),
"stderr: {}",
out.stderr
);
}
#[test]
fn invalid_format_value_exits_2() {
let dir = TempDir::new().unwrap();
write(dir.path(), "src/a.ts", "export const a = 1;\n");
let out = run_in(dir.path(), &["--format", "yaml"]);
assert_eq!(out.status.code(), Some(2));
}
#[test]
fn explicit_config_flag_is_used_over_discovery() {
let dir = TempDir::new().unwrap();
write_violation_fixture(dir.path());
let config_dir = dir.path().join("config");
fs::create_dir_all(&config_dir).unwrap();
write(&config_dir, "custom.jsonc", r#"{ "include": ["../src"] }"#);
let out = run_in(dir.path(), &["--config", "config/custom.jsonc"]);
assert_eq!(out.status.code(), Some(1), "stderr: {}", out.stderr);
assert!(out.stdout.contains("consumer.ts"));
}
#[test]
fn disable_next_line_comment_suppresses_the_violation() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
"src/consumer.ts",
"// import-lint-disable-next-line\nimport { helper } from \"./internal/util\";\nconsole.log(helper);\n",
);
write(
dir.path(),
"src/internal/util.ts",
"/** @package */\nexport const helper = 1;\n",
);
let out = run_in(dir.path(), &[]);
assert!(out.status.success(), "stdout: {}", out.stdout);
assert!(out.stdout.is_empty(), "stdout: {}", out.stdout);
}
#[test]
fn disable_line_comment_suppresses_the_violation_on_its_own_line() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
"src/consumer.ts",
"import { helper } from \"./internal/util\"; // import-lint-disable-line\nconsole.log(helper);\n",
);
write(
dir.path(),
"src/internal/util.ts",
"/** @package */\nexport const helper = 1;\n",
);
let out = run_in(dir.path(), &[]);
assert!(out.status.success(), "stdout: {}", out.stdout);
assert!(out.stdout.is_empty(), "stdout: {}", out.stdout);
}
#[test]
fn disable_next_line_with_matching_rule_name_suppresses() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
"src/consumer.ts",
"// import-lint-disable-next-line package-access -- migration, see #2\nimport { helper } from \"./internal/util\";\nconsole.log(helper);\n",
);
write(
dir.path(),
"src/internal/util.ts",
"/** @package */\nexport const helper = 1;\n",
);
let out = run_in(dir.path(), &[]);
assert!(out.status.success(), "stdout: {}", out.stdout);
assert!(out.stdout.is_empty(), "stdout: {}", out.stdout);
}
#[test]
fn disable_next_line_with_other_rule_name_does_not_suppress() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
"src/consumer.ts",
"// import-lint-disable-next-line some-other-rule\nimport { helper } from \"./internal/util\";\nconsole.log(helper);\n",
);
write(
dir.path(),
"src/internal/util.ts",
"/** @package */\nexport const helper = 1;\n",
);
let out = run_in(dir.path(), &[]);
assert_eq!(out.status.code(), Some(1));
assert!(
out.stdout
.contains("Cannot import a package-private export 'helper'")
);
}
#[test]
fn disable_next_line_covers_only_its_own_line_of_a_multiline_import() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
"src/consumer.ts",
"import {\n // import-lint-disable-next-line\n helper,\n other,\n} from \"./internal/util\";\nconsole.log(helper, other);\n",
);
write(
dir.path(),
"src/internal/util.ts",
"/** @package */\nexport const helper = 1;\n/** @package */\nexport const other = 2;\n",
);
let out = run_in(dir.path(), &[]);
assert_eq!(out.status.code(), Some(1));
assert!(
!out.stdout
.contains("Cannot import a package-private export 'helper'"),
"stdout: {}",
out.stdout
);
assert!(
out.stdout
.contains("Cannot import a package-private export 'other'")
);
}
#[test]
fn disable_next_line_suppresses_unresolved_warning_too() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
"src/consumer.ts",
"// import-lint-disable-next-line\nimport { gone } from \"./does-not-exist\";\nconsole.log(gone);\n",
);
let out = run_in(dir.path(), &["--report-unresolved"]);
assert!(out.status.success(), "stdout: {}", out.stdout);
assert!(out.stdout.is_empty(), "stdout: {}", out.stdout);
}
#[test]
fn non_ts_import_is_checked_under_package_default_importability() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
".importlintrc.jsonc",
r#"{ "rules": { "package-access": { "defaultImportability": "package" } } }"#,
);
write(dir.path(), "src/button/Button.module.css", ".button {}\n");
write(
dir.path(),
"src/button/Button.ts",
"import styles from \"./Button.module.css\";\nconsole.log(styles);\n",
);
write(
dir.path(),
"src/consumer.ts",
"import styles from \"./button/Button.module.css\";\nconsole.log(styles);\n",
);
let out = run_in(dir.path(), &[]);
assert_eq!(out.status.code(), Some(1));
assert!(out.stdout.contains("src/consumer.ts") || out.stdout.contains("src\\consumer.ts"));
assert!(
out.stdout
.contains("Cannot import a package-private export 'default'")
);
assert!(
!out.stdout.contains("Button.ts"),
"same-package import must pass: {}",
out.stdout
);
assert!(
!out.stderr.contains("unrecognized file extension"),
"stderr: {}",
out.stderr
);
}
#[test]
fn non_ts_files_option_assigns_access_per_export() {
let dir = TempDir::new().unwrap();
write(
dir.path(),
".importlintrc.jsonc",
r#"{
"rules": {
"package-access": {
"defaultImportability": "package",
"nonTsFiles": {
"**/*.module.css": { "default": "public", "*": "package" }
}
}
}
}"#,
);
write(dir.path(), "src/button/Button.module.css", ".button {}\n");
write(
dir.path(),
"src/consumer.ts",
"import styles from \"./button/Button.module.css\";\n\
import { button } from \"./button/Button.module.css\";\n\
console.log(styles, button);\n",
);
let out = run_in(dir.path(), &[]);
assert_eq!(out.status.code(), Some(1));
assert!(
out.stdout
.contains("Cannot import a package-private export 'button'")
);
assert!(
!out.stdout.contains("'default'"),
"default import must pass: {}",
out.stdout
);
}
#[test]
fn resolvable_non_ts_import_is_not_reported_unresolved() {
let dir = TempDir::new().unwrap();
write(dir.path(), "src/styles.css", ".a {}\n");
write(dir.path(), "src/data.json", "{}\n");
write(
dir.path(),
"src/a.ts",
"import styles from \"./styles.css\";\nimport data from \"./data.json\";\nconsole.log(styles, data);\n",
);
let out = run_in(dir.path(), &["--report-unresolved"]);
assert!(out.status.success(), "stdout: {}", out.stdout);
assert_eq!(out.stdout, "");
}