testing-conventions 0.0.2__tar.gz → 0.0.4__tar.gz

{testing_conventions-0.0.2 → testing_conventions-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testing-conventions
-Version: 0.0.2
+Version: 0.0.4
 Summary: Enforce testing conventions in libraries (Python, TypeScript, and Rust).
 Author-email: Kevin Scott <me@thekevinscott.com>
 License: MIT

testing_conventions-0.0.4/rust/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+All notable changes to this package are documented here.
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## Unreleased
+
+### Added
+
+- `config` module — `load_config()` parses one TOML config file into the new
+  in-memory `Config` schema (per-language `coverage` thresholds under the
+  `[python]` / `[typescript]` / `[rust]` tables) and self-validates on load:
+  unknown keys and malformed TOML are rejected. The parsed config is not
+  consumed yet. (#12)
+- `location` module — `missing_unit_tests(root, language)` walks a directory tree
+  and returns every source file with no colocated unit test (sorted), enforcing
+  the README's "Location & Naming" rule per `Language`:
+  - **Python** (#15) — `foo.py` → `foo_test.py`; `*_test.py` and `__init__.py` are exempt.
+  - **TypeScript** (#18) — `foo-bar.ts` → `foo-bar.test.ts` across `.ts`/`.tsx`/`.mts`/`.cts`; `*.test.{ts,tsx,mts,cts}` are tests, `*.d.ts`/`*.d.mts`/`*.d.cts` are ignored, nothing is exempt.
+- `unit-location [--lang python|typescript] <PATH>` CLI subcommand — runs the check
+  over a directory and exits non-zero, printing each source file missing its
+  colocated test. `--lang` defaults to `python`. (#15, #18)
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed

{testing_conventions-0.0.2 → testing_conventions-0.0.4}/rust/Cargo.lock

@@ -226,7 +226,7 @@ dependencies = [
 
 [[package]]
 name = "testing-conventions"
-version = "0.0.2"
+version = "0.0.4"
 dependencies = [
  "anyhow",
  "clap",

{testing_conventions-0.0.2 → testing_conventions-0.0.4}/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "testing-conventions"
-version = "0.0.2"
+version = "0.0.4"
 edition = "2021"
 license = "MIT"
 authors = ["Kevin Scott <me@thekevinscott.com>"]

{testing_conventions-0.0.2 → testing_conventions-0.0.4}/rust/MIGRATIONS.md

@@ -21,9 +21,19 @@ reads one TOML file into it and validates the config itself (the self-guard) —
 unknown keys and malformed TOML are rejected rather than silently accepted.
 Purely additive; nothing consumes the parsed config yet.
 
+Also adds the first structural rule — unit-test location/naming — for two
+languages. `missing_unit_tests(root, language)` walks a directory and returns
+every source file with no colocated test, and `unit-location [--lang …] <PATH>`
+runs that check and exits non-zero on any orphan. Python (#15): `foo.py` →
+`foo_test.py`, `__init__.py` exempt. TypeScript (#18): `foo-bar.ts` →
+`foo-bar.test.ts` (`.ts`/`.tsx`/`.mts`/`.cts`), `*.d.ts`/`*.d.mts`/`*.d.cts`
+ignored. Purely additive.
+
 ### Required changes
 
-None. New, additive API: `testing_conventions::config::{Config, load_config}`.
+None. New, additive API: `testing_conventions::config::{Config, load_config}`,
+`testing_conventions::location::{missing_unit_tests, Language}`, and the
+`unit-location [--lang python|typescript] <PATH>` CLI subcommand.
 
 ### Deprecations removed
 
@@ -41,3 +51,11 @@ cd packages/rust && cargo test --test config_loader
 
 Expected: the loader's integration tests pass — the canonical config loads into
 memory, and unknown-key, malformed, and missing-file configs are rejected.
+
+```
+cd packages/rust && cargo test --test unit_location
+```
+
+Expected: the location check's integration tests pass for both languages — each
+clean fixture reports no orphans, each red fixture reports its missing twins, and
+`unit-location` exits non-zero on the red fixtures.

{testing_conventions-0.0.2 → testing_conventions-0.0.4}/rust/src/lib.rs

@@ -1,4 +1,7 @@
 pub mod config;
+pub mod location;
+
+use std::path::{Path, PathBuf};
 
 use clap::{Parser, Subcommand};
 
@@ -18,6 +21,14 @@ pub struct Cli {
 enum Command {
     /// Check the repository against its testing-conventions config.
     Check,
+    /// Check that every source file has a colocated unit test.
+    UnitLocation {
+        /// Directory to scan recursively.
+        path: PathBuf,
+        /// Language convention to enforce.
+        #[arg(long, value_enum, default_value = "python")]
+        lang: location::Language,
+    },
 }
 
 pub fn run<I, T>(args: I) -> anyhow::Result<i32>
@@ -27,9 +38,30 @@ where
 {
     let cli = Cli::try_parse_from(args)?;
     match cli.command {
-        // Rules aren't implemented yet; the scaffold just proves the wiring.
+        // The config-driven `check` umbrella isn't wired yet; the scaffold
+        // proves the wiring while individual rules land as their own subcommand.
         Some(Command::Check) | None => Ok(0),
+        Some(Command::UnitLocation { path, lang }) => run_unit_location(&path, lang),
+    }
+}
+
+/// Run the unit-test location check over `root` for `language`, reporting orphans.
+///
+/// Returns `0` when every source file has its colocated unit test; otherwise
+/// prints each orphan to stderr and returns `1`.
+fn run_unit_location(root: &Path, language: location::Language) -> anyhow::Result<i32> {
+    let orphans = location::missing_unit_tests(root, language)?;
+    if orphans.is_empty() {
+        return Ok(0);
+    }
+    for orphan in &orphans {
+        eprintln!("missing colocated unit test: {}", orphan.display());
     }
+    eprintln!(
+        "error: {} source file(s) missing a colocated unit test",
+        orphans.len()
+    );
+    Ok(1)
 }
 
 #[cfg(test)]

testing_conventions-0.0.4/rust/src/location.rs

@@ -0,0 +1,241 @@
+//! Unit-test location/naming check (Python — issue #15; TypeScript — issue #18).
+//!
+//! Convention (README "Location & Naming"; `internals/*/testing.md`): a source
+//! file is unit-tested by a *colocated* test named after it — `foo.py` →
+//! `foo_test.py` (Python), `foo-bar.ts` → `foo-bar.test.ts` (TypeScript).
+//! [`missing_unit_tests`] walks a tree for a [`Language`] and returns every
+//! source file with no such sibling — an "orphan". Test files are what the
+//! check looks *for*, never subjects.
+
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result};
+
+/// A language whose unit-test location/naming convention can be checked.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
+pub enum Language {
+    /// `foo.py` → colocated `foo_test.py`; `__init__.py` is exempt.
+    #[value(name = "python")]
+    Python,
+    /// `foo-bar.ts` → colocated `foo-bar.test.ts`, across `.ts`/`.tsx`/`.mts`/`.cts`;
+    /// declaration files (`.d.ts`/`.d.mts`/`.d.cts`) are ignored.
+    #[value(name = "typescript")]
+    TypeScript,
+}
+
+impl Language {
+    /// `true` for a file this language's check tracks (source *or* test).
+    fn tracks(self, path: &Path) -> bool {
+        match self {
+            Language::Python => has_extension(path, &["py"]),
+            Language::TypeScript => {
+                has_extension(path, &["ts", "tsx", "mts", "cts"]) && !is_declaration(path)
+            }
+        }
+    }
+
+    /// `true` when `path` is itself a unit test, never a subject.
+    fn is_test(self, path: &Path) -> bool {
+        match self {
+            Language::Python => stem_of(path).ends_with("_test"),
+            Language::TypeScript => {
+                let name = file_name_of(path);
+                name.ends_with(".test.ts")
+                    || name.ends_with(".test.tsx")
+                    || name.ends_with(".test.mts")
+                    || name.ends_with(".test.cts")
+            }
+        }
+    }
+
+    /// `true` for a file exempt from needing a colocated test.
+    fn is_exempt(self, path: &Path) -> bool {
+        match self {
+            Language::Python => file_name_of(path) == "__init__.py",
+            Language::TypeScript => false,
+        }
+    }
+
+    /// The colocated test `source` is expected to have.
+    fn expected_test_path(self, source: &Path) -> PathBuf {
+        match self {
+            Language::Python => source.with_file_name(format!("{}_test.py", stem_of(source))),
+            Language::TypeScript => {
+                source.with_file_name(format!("{}.test.{}", stem_of(source), extension_of(source)))
+            }
+        }
+    }
+}
+
+/// Walk `root` recursively and return every source file (for `language`) that
+/// has no colocated unit test, sorted for deterministic output.
+///
+/// A file that is itself a test is never treated as a subject; every other
+/// source file must have its colocated test sibling. Returns an error if the
+/// tree under `root` cannot be read.
+pub fn missing_unit_tests(root: impl AsRef<Path>, language: Language) -> Result<Vec<PathBuf>> {
+    let mut files = Vec::new();
+    collect_files(root.as_ref(), language, &mut files)?;
+
+    // Every tracked path we found, so a subject's expected twin is a lookup
+    // rather than a second pass over the filesystem.
+    let present: HashSet<&Path> = files.iter().map(PathBuf::as_path).collect();
+
+    let mut orphans: Vec<PathBuf> = Vec::new();
+    for source in &files {
+        if language.is_test(source) || language.is_exempt(source) {
+            continue;
+        }
+        if !present.contains(language.expected_test_path(source).as_path()) {
+            orphans.push(source.clone());
+        }
+    }
+    orphans.sort();
+    Ok(orphans)
+}
+
+/// Recursively collect every file `language` tracks under `dir` into `out`.
+fn collect_files(dir: &Path, language: Language, out: &mut Vec<PathBuf>) -> Result<()> {
+    let entries =
+        std::fs::read_dir(dir).with_context(|| format!("reading directory `{}`", dir.display()))?;
+    for entry in entries {
+        let path = entry
+            .with_context(|| format!("reading an entry under `{}`", dir.display()))?
+            .path();
+        if path.is_dir() {
+            collect_files(&path, language, out)?;
+        } else if language.tracks(&path) {
+            out.push(path);
+        }
+    }
+    Ok(())
+}
+
+/// `true` when the file's extension is one of `extensions`.
+fn has_extension(path: &Path, extensions: &[&str]) -> bool {
+    path.extension()
+        .and_then(|ext| ext.to_str())
+        .is_some_and(|ext| extensions.contains(&ext))
+}
+
+/// `true` for a TypeScript declaration file (`*.d.ts` / `*.d.mts` / `*.d.cts`) —
+/// no runtime code, so never a unit-test subject.
+fn is_declaration(path: &Path) -> bool {
+    let name = file_name_of(path);
+    name.ends_with(".d.ts") || name.ends_with(".d.mts") || name.ends_with(".d.cts")
+}
+
+/// The file extension, lossily decoded (empty if there is none).
+fn extension_of(path: &Path) -> String {
+    path.extension()
+        .map(|ext| ext.to_string_lossy().into_owned())
+        .unwrap_or_default()
+}
+
+/// The file name, lossily decoded.
+fn file_name_of(path: &Path) -> String {
+    path.file_name()
+        .map(|name| name.to_string_lossy().into_owned())
+        .unwrap_or_default()
+}
+
+/// The file stem (the name without its extension), lossily decoded.
+fn stem_of(path: &Path) -> String {
+    path.file_stem()
+        .map(|stem| stem.to_string_lossy().into_owned())
+        .unwrap_or_default()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn python_tracks_py_files() {
+        assert!(Language::Python.tracks(Path::new("a.py")));
+        assert!(Language::Python.tracks(Path::new("pkg/widget.py")));
+        assert!(!Language::Python.tracks(Path::new("a.pyi")));
+        assert!(!Language::Python.tracks(Path::new("a.txt")));
+        assert!(!Language::Python.tracks(Path::new("README")));
+    }
+
+    #[test]
+    fn python_recognizes_test_files_by_stem_suffix() {
+        assert!(Language::Python.is_test(Path::new("widget_test.py")));
+        assert!(Language::Python.is_test(Path::new("pkg/helper_test.py")));
+        assert!(!Language::Python.is_test(Path::new("widget.py")));
+    }
+
+    #[test]
+    fn python_exempts_the_package_marker() {
+        assert!(Language::Python.is_exempt(Path::new("__init__.py")));
+        assert!(Language::Python.is_exempt(Path::new("pkg/__init__.py")));
+        assert!(!Language::Python.is_exempt(Path::new("conftest.py")));
+        assert!(!Language::Python.is_exempt(Path::new("widget.py")));
+    }
+
+    #[test]
+    fn python_expected_test_path_is_the_colocated_twin() {
+        assert_eq!(
+            Language::Python.expected_test_path(Path::new("pkg/widget.py")),
+            PathBuf::from("pkg/widget_test.py")
+        );
+        assert_eq!(
+            Language::Python.expected_test_path(Path::new("widget.py")),
+            PathBuf::from("widget_test.py")
+        );
+    }
+
+    #[test]
+    fn typescript_tracks_ts_tsx_mts_cts_but_not_declarations() {
+        assert!(Language::TypeScript.tracks(Path::new("widget.ts")));
+        assert!(Language::TypeScript.tracks(Path::new("pkg/button.tsx")));
+        assert!(Language::TypeScript.tracks(Path::new("service.mts")));
+        assert!(Language::TypeScript.tracks(Path::new("legacy.cts")));
+        assert!(!Language::TypeScript.tracks(Path::new("types.d.ts")));
+        assert!(!Language::TypeScript.tracks(Path::new("ambient.d.mts")));
+        assert!(!Language::TypeScript.tracks(Path::new("globals.d.cts")));
+        assert!(!Language::TypeScript.tracks(Path::new("widget.py")));
+        assert!(!Language::TypeScript.tracks(Path::new("README")));
+    }
+
+    #[test]
+    fn typescript_recognizes_test_files_by_suffix() {
+        assert!(Language::TypeScript.is_test(Path::new("widget.test.ts")));
+        assert!(Language::TypeScript.is_test(Path::new("pkg/button.test.tsx")));
+        assert!(Language::TypeScript.is_test(Path::new("service.test.mts")));
+        assert!(Language::TypeScript.is_test(Path::new("legacy.test.cts")));
+        assert!(!Language::TypeScript.is_test(Path::new("widget.ts")));
+        assert!(!Language::TypeScript.is_test(Path::new("button.tsx")));
+        assert!(!Language::TypeScript.is_test(Path::new("service.mts")));
+    }
+
+    #[test]
+    fn typescript_has_no_exemptions() {
+        // Unlike Python's `__init__.py`, nothing in TS is language-mandated;
+        // `index.ts` is a deliberate file and therefore a subject.
+        assert!(!Language::TypeScript.is_exempt(Path::new("index.ts")));
+        assert!(!Language::TypeScript.is_exempt(Path::new("pkg/index.ts")));
+    }
+
+    #[test]
+    fn typescript_expected_test_path_keeps_the_extension() {
+        assert_eq!(
+            Language::TypeScript.expected_test_path(Path::new("pkg/widget.ts")),
+            PathBuf::from("pkg/widget.test.ts")
+        );
+        assert_eq!(
+            Language::TypeScript.expected_test_path(Path::new("button.tsx")),
+            PathBuf::from("button.test.tsx")
+        );
+        assert_eq!(
+            Language::TypeScript.expected_test_path(Path::new("service.mts")),
+            PathBuf::from("service.test.mts")
+        );
+        assert_eq!(
+            Language::TypeScript.expected_test_path(Path::new("legacy.cts")),
+            PathBuf::from("legacy.test.cts")
+        );
+    }
+}

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/clean/pkg/helper.py

@@ -0,0 +1 @@
+# unit_location clean fixture: nested source colocated with helper_test.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/clean/pkg/helper_test.py

@@ -0,0 +1 @@
+# unit_location clean fixture: nested unit test for helper.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/clean/widget.py

@@ -0,0 +1 @@
+# unit_location clean fixture: source colocated with widget_test.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/clean/widget_test.py

@@ -0,0 +1 @@
+# unit_location clean fixture: unit test for widget.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/exempt/__init__.py

@@ -0,0 +1 @@
+# unit_location exempt fixture: package marker — never a unit-test subject

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/exempt/pkg/__init__.py

@@ -0,0 +1 @@
+# unit_location exempt fixture: nested package marker — never a unit-test subject

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/exempt/widget.py

@@ -0,0 +1 @@
+# unit_location exempt fixture: real source colocated with widget_test.py (OK)

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/exempt/widget_test.py

@@ -0,0 +1 @@
+# unit_location exempt fixture: unit test for widget.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/red/lonely.py

@@ -0,0 +1 @@
+# unit_location red fixture: ORPHAN — no colocated lonely_test.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/red/pkg/orphan.py

@@ -0,0 +1 @@
+# unit_location red fixture: ORPHAN — no colocated orphan_test.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/red/pkg/paired.py

@@ -0,0 +1 @@
+# unit_location red fixture: nested source colocated with paired_test.py (OK)

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/red/pkg/paired_test.py

@@ -0,0 +1 @@
+# unit_location red fixture: nested unit test for paired.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/red/widget.py

@@ -0,0 +1 @@
+# unit_location red fixture: source colocated with widget_test.py (paired, OK)

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/red/widget_test.py

@@ -0,0 +1 @@
+# unit_location red fixture: unit test for widget.py

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/ambient.d.mts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: ESM declaration file (.d.mts) — never a subject, ignored

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/button.test.tsx

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: unit test for button.tsx

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/button.tsx

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: tsx source colocated with button.test.tsx

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/legacy.cts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: CJS (.cts) source colocated with legacy.test.cts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/legacy.test.cts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: unit test for legacy.cts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/pkg/helper.test.ts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: nested unit test for helper.ts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/pkg/helper.ts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: nested source colocated with helper.test.ts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/service.mts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: ESM (.mts) source colocated with service.test.mts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/service.test.mts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: unit test for service.mts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/types.d.ts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: declaration file — never a subject, ignored

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/widget.test.ts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: unit test for widget.ts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/clean/widget.ts

@@ -0,0 +1 @@
+// unit_location typescript clean fixture: source colocated with widget.test.ts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/red/bridge.cts

@@ -0,0 +1 @@
+// unit_location typescript red fixture: CJS (.cts) source with no colocated bridge.test.cts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/red/lonely.ts

@@ -0,0 +1 @@
+// unit_location typescript red fixture: ORPHAN — no colocated lonely.test.ts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/red/pkg/orphan.ts

@@ -0,0 +1 @@
+// unit_location typescript red fixture: nested ORPHAN — no colocated orphan.test.ts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/red/shapes.d.cts

@@ -0,0 +1 @@
+// unit_location typescript red fixture: CJS declaration file (.d.cts) — never a subject, ignored

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/red/shapes.d.ts

@@ -0,0 +1 @@
+// unit_location typescript red fixture: declaration file — ignored, not an orphan

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/red/solo.mts

@@ -0,0 +1 @@
+// unit_location typescript red fixture: ESM (.mts) source with no colocated solo.test.mts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/red/widget.test.ts

@@ -0,0 +1 @@
+// unit_location typescript red fixture: unit test for widget.ts

testing_conventions-0.0.4/rust/tests/fixtures/unit_location/typescript/red/widget.ts

@@ -0,0 +1 @@
+// unit_location typescript red fixture: source colocated with widget.test.ts (OK)

testing_conventions-0.0.4/rust/tests/unit_location.rs

@@ -0,0 +1,125 @@
+//! Integration tests for the unit-test location/naming check
+//! (Python — issue #15; TypeScript — issue #18).
+//!
+//! A source file must have a *colocated* test named after it: `foo.py` →
+//! `foo_test.py`, `foo-bar.ts` → `foo-bar.test.ts`. `missing_unit_tests`
+//! returns the source files missing their twin; the `unit-location`
+//! subcommand turns a non-empty result into a non-zero exit.
+//!
+//! Per the #3 guardrail, each language ships a clean fixture (every source
+//! paired — must pass) and a red fixture (orphans present — must fail).
+
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+
+use testing_conventions::location::{missing_unit_tests, Language};
+use testing_conventions::run;
+
+/// Absolute path to a fixture tree under `tests/fixtures/unit_location/`.
+fn fixture(name: &str) -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests/fixtures/unit_location")
+        .join(name)
+}
+
+/// Orphans reported under `root` for `language`, as `/`-joined relative paths.
+fn relative_orphans(root: &Path, language: Language) -> Vec<String> {
+    missing_unit_tests(root, language)
+        .expect("walking a readable tree should succeed")
+        .iter()
+        .map(|path| {
+            path.strip_prefix(root)
+                .expect("an orphan must live under the scanned root")
+                .to_string_lossy()
+                .replace('\\', "/")
+        })
+        .collect()
+}
+
+/// Exit code of `unit-location [--lang <lang>] <fixture>`.
+fn unit_location_exit(fixture_name: &str, lang: Option<&str>) -> i32 {
+    let mut argv: Vec<OsString> = vec!["testing-conventions".into(), "unit-location".into()];
+    if let Some(lang) = lang {
+        argv.push("--lang".into());
+        argv.push(lang.into());
+    }
+    argv.push(fixture(fixture_name).into_os_string());
+    run(argv).expect("a readable tree should not error")
+}
+
+// ---- Python (#15) --------------------------------------------------------
+
+#[test]
+fn python_clean_tree_reports_no_orphans() {
+    assert!(
+        relative_orphans(&fixture("clean"), Language::Python).is_empty(),
+        "every source in the clean tree has a colocated _test.py"
+    );
+}
+
+#[test]
+fn python_red_tree_reports_every_missing_twin() {
+    assert_eq!(
+        relative_orphans(&fixture("red"), Language::Python),
+        vec!["lonely.py", "pkg/orphan.py"],
+    );
+}
+
+#[test]
+fn python_package_markers_are_not_orphans() {
+    assert!(
+        relative_orphans(&fixture("exempt"), Language::Python).is_empty(),
+        "__init__.py is a package marker, never a unit-test subject"
+    );
+}
+
+#[test]
+fn python_missing_root_is_an_error() {
+    assert!(
+        missing_unit_tests(fixture("does_not_exist"), Language::Python).is_err(),
+        "an unreadable root must be an error"
+    );
+}
+
+#[test]
+fn python_subcommand_exits_zero_on_a_clean_tree() {
+    assert_eq!(unit_location_exit("clean", None), 0);
+}
+
+#[test]
+fn python_subcommand_exits_nonzero_on_a_red_tree() {
+    assert_eq!(unit_location_exit("red", None), 1);
+}
+
+// ---- TypeScript (#18) ----------------------------------------------------
+
+#[test]
+fn typescript_clean_tree_reports_no_orphans() {
+    // The clean tree pairs .ts/.tsx/.mts/.cts sources and holds `*.d.ts` /
+    // `*.d.mts` declarations with no twin; declarations must be ignored.
+    assert!(
+        relative_orphans(&fixture("typescript/clean"), Language::TypeScript).is_empty(),
+        "every .ts/.tsx/.mts/.cts source is paired; declaration files are ignored"
+    );
+}
+
+#[test]
+fn typescript_red_tree_reports_every_missing_twin() {
+    assert_eq!(
+        relative_orphans(&fixture("typescript/red"), Language::TypeScript),
+        vec!["bridge.cts", "lonely.ts", "pkg/orphan.ts", "solo.mts"],
+    );
+}
+
+#[test]
+fn typescript_subcommand_exits_zero_on_a_clean_tree() {
+    assert_eq!(
+        unit_location_exit("typescript/clean", Some("typescript")),
+        0
+    );
+}
+
+#[test]
+fn typescript_subcommand_exits_nonzero_on_a_red_tree() {
+    assert_eq!(unit_location_exit("typescript/red", Some("typescript")), 1);
+}

testing_conventions-0.0.2/rust/CHANGELOG.md

@@ -1,22 +0,0 @@
-# Changelog
-
-All notable changes to this package are documented here.
-Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
-
-## Unreleased
-
-### Added
-
-- `config` module — `load_config()` parses one TOML config file into the new
-  in-memory `Config` schema (per-language `coverage` thresholds under the
-  `[python]` / `[typescript]` / `[rust]` tables) and self-validates on load:
-  unknown keys and malformed TOML are rejected. The parsed config is not
-  consumed yet. (#12)
-
-### Changed
-
-### Deprecated
-
-### Removed
-
-### Fixed