code_ownership 2.1.1 → 2.1.3

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.3}/src/runner.rs

@@ -1,6 +1,8 @@
-use std::{path::Path, process::Command};
+use std::path::{Path, PathBuf};
+use std::process::Command;
 
 use error_stack::{Result, ResultExt};
+use fast_glob::glob_match;
 use serde::Serialize;
 
 use crate::{
@@ -20,6 +22,7 @@ pub struct Runner {
     ownership: Ownership,
     cache: Cache,
     config: Config,
+    codeowners_file_path: PathBuf,
 }
 
 pub fn version() -> String {
@@ -36,7 +39,7 @@ where
         Ok(runner) => runner,
         Err(err) => {
             return RunResult {
-                io_errors: vec![err.to_string()],
+                io_errors: vec![format!("{:?}", err)],
                 ..Default::default()
             };
         }
@@ -44,15 +47,41 @@ where
     runnable(runner)
 }
 
-pub(crate) fn config_from_path(path: &Path) -> Result<Config, Error> {
-    match crate::config::Config::load_from_path(path) {
-        Ok(c) => Ok(c),
+pub(crate) fn config_from_run_config(run_config: &RunConfig) -> Result<Config, Error> {
+    match crate::config::Config::load_from_path(&run_config.config_path) {
+        Ok(mut c) => {
+            if let Some(executable_name) = &run_config.executable_name {
+                c.executable_name = executable_name.clone();
+            }
+            Ok(c)
+        }
         Err(msg) => Err(error_stack::Report::new(Error::Io(msg))),
     }
 }
+
+/// Resolves the CODEOWNERS file path with the following priority:
+/// 1. Explicit `codeowners_file_path` in `RunConfig` (if provided from e.g. CLI flag)
+/// 2. `CODEOWNERS_PATH` environment variable (if set and not empty)
+/// 3. Computed from `codeowners_path` directory path in config + "CODEOWNERS" filename
+/// 4. Default fallback to `.github/CODEOWNERS` (using default codeowners_path from config)
+pub(crate) fn resolve_codeowners_file_path(run_config: &RunConfig, config: &Config) -> PathBuf {
+    if let Some(ref path) = run_config.codeowners_file_path {
+        return path.clone();
+    }
+
+    if let Ok(env_path) = std::env::var("CODEOWNERS_PATH")
+        && !env_path.is_empty()
+    {
+        return run_config.project_root.join(env_path);
+    }
+
+    run_config.project_root.join(&config.codeowners_path).join("CODEOWNERS")
+}
+
 impl Runner {
     pub fn new(run_config: &RunConfig) -> Result<Self, Error> {
-        let config = config_from_path(&run_config.config_path)?;
+        let config = config_from_run_config(run_config)?;
+        let codeowners_file_path = resolve_codeowners_file_path(run_config, &config);
 
         let cache: Cache = if run_config.no_cache {
             NoopCache::default().into()
@@ -66,12 +95,7 @@ impl Runner {
                 .into()
         };
 
-        let mut project_builder = ProjectBuilder::new(
-            &config,
-            run_config.project_root.clone(),
-            run_config.codeowners_file_path.clone(),
-            &cache,
-        );
+        let mut project_builder = ProjectBuilder::new(&config, run_config.project_root.clone(), codeowners_file_path.clone(), &cache);
         let project = project_builder.build().change_context(Error::Io(format!(
             "Can't build project: {}",
             &run_config.config_path.to_string_lossy()
@@ -88,6 +112,7 @@ impl Runner {
             ownership,
             cache,
             config,
+            codeowners_file_path,
         })
     }
 
@@ -113,7 +138,25 @@ impl Runner {
         let mut unowned_files = Vec::new();
         let mut io_errors = Vec::new();
 
-        for file_path in file_paths {
+        // Filter files based on owned_globs and unowned_globs configuration
+        // Only validate files that match owned_globs and don't match unowned_globs
+        let filtered_paths: Vec<String> = file_paths
+            .into_iter()
+            .filter(|file_path| {
+                // Convert to relative path for glob matching
+                let path = Path::new(file_path);
+                let relative_path = if path.is_absolute() {
+                    path.strip_prefix(&self.run_config.project_root).unwrap_or(path)
+                } else {
+                    path
+                };
+
+                // Mirror the filtering applied by ProjectBuilder when walking the project
+                matches_globs(relative_path, &self.config.owned_globs) && !matches_globs(relative_path, &self.config.unowned_globs)
+            })
+            .collect();
+
+        for file_path in filtered_paths {
             match team_for_file_from_codeowners(&self.run_config, &file_path) {
                 Ok(Some(_)) => {}
                 Ok(None) => unowned_files.push(file_path),
@@ -145,10 +188,10 @@ impl Runner {
 
     pub fn generate(&self, git_stage: bool) -> RunResult {
         let content = self.ownership.generate_file();
-        if let Some(parent) = &self.run_config.codeowners_file_path.parent() {
+        if let Some(parent) = &self.codeowners_file_path.parent() {
             let _ = std::fs::create_dir_all(parent);
         }
-        match std::fs::write(&self.run_config.codeowners_file_path, content) {
+        match std::fs::write(&self.codeowners_file_path, content) {
             Ok(_) => {
                 if git_stage {
                     self.git_stage();
@@ -173,7 +216,7 @@ impl Runner {
     fn git_stage(&self) {
         let _ = Command::new("git")
             .arg("add")
-            .arg(&self.run_config.codeowners_file_path)
+            .arg(&self.codeowners_file_path)
             .current_dir(&self.run_config.project_root)
             .output();
     }
@@ -389,6 +432,14 @@ impl RunResult {
     }
 }
 
+/// Returns true if `path` matches any of the provided glob patterns.
+fn matches_globs(path: &Path, globs: &[String]) -> bool {
+    match path.to_str() {
+        Some(s) => globs.iter().any(|glob| glob_match(glob, s)),
+        None => false,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.3}/src/tracked_files.rs

@@ -6,7 +6,7 @@ use std::{
 
 pub(crate) fn find_tracked_files(base_path: &Path) -> Option<HashMap<PathBuf, bool>> {
     let output = Command::new("git")
-        .args(["ls-files", "--full-name", "-z", "--", "."])
+        .args(["ls-files", "-z", "--", "."])
         .current_dir(base_path)
         .output()
         .ok()?;
@@ -55,4 +55,32 @@ mod tests {
         assert!(tracked.len() == 1);
         assert!(tracked.get(&tmp_dir.path().join("test.txt")).unwrap());
     }
+
+    #[test]
+    fn test_tracked_files_from_subdirectory() {
+        let tmp_dir = tempfile::tempdir().unwrap();
+        let backend_dir = tmp_dir.path().join("backend");
+        let tracked_file = backend_dir.join("app/models/foo.rb");
+
+        std::process::Command::new("git")
+            .arg("init")
+            .current_dir(tmp_dir.path())
+            .output()
+            .expect("failed to run git init");
+
+        std::fs::create_dir_all(tracked_file.parent().unwrap()).unwrap();
+        std::fs::write(&tracked_file, "class Foo; end").unwrap();
+        std::fs::write(tmp_dir.path().join("README.md"), "readme").unwrap();
+
+        std::process::Command::new("git")
+            .args(["add", "--all"])
+            .current_dir(tmp_dir.path())
+            .output()
+            .expect("failed to add tracked files");
+
+        let tracked = find_tracked_files(&backend_dir).unwrap();
+        assert_eq!(tracked.len(), 1);
+        assert!(tracked.get(&tracked_file).unwrap());
+        assert!(!tracked.contains_key(&backend_dir.join("backend/app/models/foo.rb")));
+    }
 }

data/ext/cargo-vendor/codeowners-0.3.3/tests/codeowners_path_test.rs

@@ -0,0 +1,92 @@
+use predicates::prelude::predicate;
+use std::{error::Error, fs, path::Path};
+
+mod common;
+
+use common::OutputStream;
+use common::git_add_all_files;
+use common::run_codeowners;
+use common::setup_fixture_repo;
+
+#[test]
+fn test_generate_uses_codeowners_path_from_config() -> Result<(), Box<dyn Error>> {
+    let fixture_root = Path::new("tests/fixtures/custom_codeowners_path");
+    let temp_dir = setup_fixture_repo(fixture_root);
+    let project_root = temp_dir.path();
+    git_add_all_files(project_root);
+
+    let mut cmd = assert_cmd::Command::cargo_bin("codeowners")?;
+    cmd.arg("--project-root")
+        .arg(project_root)
+        .arg("--no-cache")
+        .arg("generate")
+        .assert()
+        .success();
+
+    let expected_codeowners: String = std::fs::read_to_string(Path::new("tests/fixtures/custom_codeowners_path/expected/CODEOWNERS"))?;
+    let actual_codeowners: String = std::fs::read_to_string(project_root.join("docs/CODEOWNERS"))?;
+
+    assert_eq!(expected_codeowners, actual_codeowners);
+
+    Ok(())
+}
+
+#[test]
+fn test_cli_overrides_codeowners_path_from_config() -> Result<(), Box<dyn Error>> {
+    fs::create_dir_all("tmp")?;
+    let codeowners_abs = std::env::current_dir()?.join("tmp/CODEOWNERS");
+    let codeowners_str = codeowners_abs.to_str().unwrap();
+
+    run_codeowners(
+        "custom_codeowners_path",
+        &["--codeowners-file-path", codeowners_str, "generate"],
+        true,
+        OutputStream::Stdout,
+        predicate::eq(""),
+    )?;
+
+    let expected_codeowners: String = std::fs::read_to_string(Path::new("tests/fixtures/custom_codeowners_path/expected/CODEOWNERS"))?;
+    let actual_codeowners: String = std::fs::read_to_string(Path::new("tmp/CODEOWNERS"))?;
+
+    assert_eq!(expected_codeowners, actual_codeowners);
+
+    Ok(())
+}
+
+#[test]
+fn test_validate_uses_codeowners_path_from_config() -> Result<(), Box<dyn Error>> {
+    run_codeowners(
+        "custom_codeowners_path",
+        &["validate"],
+        true,
+        OutputStream::Stdout,
+        predicate::eq(""),
+    )?;
+
+    Ok(())
+}
+
+#[test]
+fn test_validate_uses_cli_override() -> Result<(), Box<dyn Error>> {
+    fs::create_dir_all("tmp")?;
+    let codeowners_abs = std::env::current_dir()?.join("tmp/CODEOWNERS");
+    let codeowners_str = codeowners_abs.to_str().unwrap();
+
+    run_codeowners(
+        "custom_codeowners_path",
+        &["--codeowners-file-path", codeowners_str, "generate"],
+        true,
+        OutputStream::Stdout,
+        predicate::eq(""),
+    )?;
+
+    run_codeowners(
+        "custom_codeowners_path",
+        &["--codeowners-file-path", codeowners_str, "validate"],
+        true,
+        OutputStream::Stdout,
+        predicate::eq(""),
+    )?;
+
+    Ok(())
+}

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.3}/tests/common/mod.rs

@@ -154,9 +154,10 @@ pub fn build_run_config(project_root: &Path, codeowners_rel_path: &str) -> RunCo
     let config_path = project_root.join("config/code_ownership.yml");
     RunConfig {
         project_root,
-        codeowners_file_path,
+        codeowners_file_path: Some(codeowners_file_path),
         config_path,
         no_cache: true,
+        executable_name: None,
     }
 }
 

data/ext/cargo-vendor/codeowners-0.3.3/tests/executable_name_config_test.rs

@@ -0,0 +1,88 @@
+use indoc::indoc;
+use predicates::prelude::*;
+use std::error::Error;
+
+mod common;
+use common::OutputStream;
+use common::run_codeowners;
+
+#[test]
+fn test_validate_with_custom_executable_name() -> Result<(), Box<dyn Error>> {
+    // When executable_name is configured, error should show that command
+    run_codeowners(
+        "custom_executable_name",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::str::contains("Run `bin/codeownership validate`"),
+    )?;
+    Ok(())
+}
+
+#[test]
+fn test_validate_with_default_executable_name() -> Result<(), Box<dyn Error>> {
+    // When executable_name is not configured, error should show default "codeowners"
+    run_codeowners(
+        "default_executable_name",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::str::contains("Run `codeowners generate`"),
+    )?;
+    Ok(())
+}
+
+#[test]
+fn test_custom_executable_name_full_error_message() -> Result<(), Box<dyn Error>> {
+    // Verify the complete error message format with custom executable
+    run_codeowners(
+        "custom_executable_name",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::eq(indoc! {r#"
+
+    CODEOWNERS out of date. Run `bin/codeownership validate` to update the CODEOWNERS file
+    The following changes are required (- current, + expected):
+    -# Outdated content to trigger validation error
+    -/app/old.rb @FooTeam
+    +
+    +# Annotations at the top of file
+    +/app/foo.rb @FooTeam
+    +
+    +# Team-specific owned globs
+    +/ruby/app/payments/** @PaymentTeam
+    +
+    +# Team YML ownership
+    +/config/teams/foo.yml @FooTeam
+    +/config/teams/payments.yml @PaymentTeam
+
+    "#}),
+    )?;
+    Ok(())
+}
+
+#[test]
+fn test_default_executable_name_full_error_message() -> Result<(), Box<dyn Error>> {
+    // Verify the complete error message format with default executable
+    run_codeowners(
+        "default_executable_name",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::eq(indoc! {r#"
+
+    CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file
+    The following changes are required (- current, + expected):
+    -# Outdated content to trigger validation error
+    -/app/old.rb @BarTeam
+    +# Annotations at the top of file
+    +/app/bar.rb @BarTeam
+    +
+    +# Team YML ownership
+    +/config/teams/bar.yml @BarTeam
+
+    "#}),
+    )?;
+    Ok(())
+}

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_codeowners_path/config/code_ownership.yml

@@ -0,0 +1,11 @@
+owned_globs:
+  - "{config,ruby}/**/*.{rb,yml}"
+ruby_package_paths: []
+javascript_package_paths: []
+team_file_glob:
+  - config/teams/**/*.yml
+unbuilt_gems_path: gems
+unowned_globs:
+  - config/code_ownership.yml
+codeowners_path: docs
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_codeowners_path/config/teams/test_team.yml

@@ -0,0 +1,6 @@
+name: TestTeam
+github:
+  team: "@TestTeam"
+  members:
+    - testmember
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_codeowners_path/docs/CODEOWNERS

@@ -0,0 +1,14 @@
+# STOP! - DO NOT EDIT THIS FILE MANUALLY
+# This file was automatically generated by "bin/codeownership validate".
+#
+# CODEOWNERS is used for GitHub to suggest code/file owners to various GitHub
+# teams. This is useful when developers create Pull Requests since the
+# code/file owner is notified. Reference GitHub docs for more details:
+# https://help.github.com/en/articles/about-code-owners
+
+
+# Annotations at the top of file
+/ruby/app/models/test.rb @TestTeam
+
+# Team YML ownership
+/config/teams/test_team.yml @TestTeam

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_codeowners_path/expected/CODEOWNERS

@@ -0,0 +1,14 @@
+# STOP! - DO NOT EDIT THIS FILE MANUALLY
+# This file was automatically generated by "bin/codeownership validate".
+#
+# CODEOWNERS is used for GitHub to suggest code/file owners to various GitHub
+# teams. This is useful when developers create Pull Requests since the
+# code/file owner is notified. Reference GitHub docs for more details:
+# https://help.github.com/en/articles/about-code-owners
+
+
+# Annotations at the top of file
+/ruby/app/models/test.rb @TestTeam
+
+# Team YML ownership
+/config/teams/test_team.yml @TestTeam

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_codeowners_path/ruby/app/models/test.rb

@@ -0,0 +1,3 @@
+# @team TestTeam
+class Test
+end

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_executable_name/.github/CODEOWNERS

@@ -0,0 +1,10 @@
+# STOP! - DO NOT EDIT THIS FILE MANUALLY
+# This file was automatically generated by "bin/codeownership validate".
+#
+# CODEOWNERS is used for GitHub to suggest code/file owners to various GitHub
+# teams. This is useful when developers create Pull Requests since the
+# code/file owner is notified. Reference GitHub docs for more details:
+# https://help.github.com/en/articles/about-code-owners
+
+# Outdated content to trigger validation error
+/app/old.rb @FooTeam

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_executable_name/app/foo.rb

@@ -0,0 +1,3 @@
+# @team Foo
+puts 'foo'
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_executable_name/config/code_ownership.yml

@@ -0,0 +1,4 @@
+---
+owned_globs:
+  - "{app,config}/**/*.rb"
+executable_name: "bin/codeownership validate"

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_executable_name/config/teams/foo.yml

@@ -0,0 +1,5 @@
+---
+name: Foo
+github:
+  team: '@FooTeam'
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_executable_name/config/teams/payments.yml

@@ -0,0 +1,6 @@
+name: Payments
+github:
+  team: "@PaymentTeam"
+owned_globs:
+  - ruby/app/payments/**
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/custom_executable_name/ruby/app/payments/foo.rb

@@ -0,0 +1,4 @@
+# A file owned by Payments
+class Foo
+end
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/default_executable_name/.github/CODEOWNERS

@@ -0,0 +1,11 @@
+# STOP! - DO NOT EDIT THIS FILE MANUALLY
+# This file was automatically generated by "bin/codeownership validate".
+#
+# CODEOWNERS is used for GitHub to suggest code/file owners to various GitHub
+# teams. This is useful when developers create Pull Requests since the
+# code/file owner is notified. Reference GitHub docs for more details:
+# https://help.github.com/en/articles/about-code-owners
+
+# Outdated content to trigger validation error
+/app/old.rb @BarTeam
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/default_executable_name/app/bar.rb

@@ -0,0 +1,3 @@
+# @team Bar
+puts 'bar'
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/default_executable_name/config/code_ownership.yml

@@ -0,0 +1,5 @@
+---
+owned_globs:
+  - "{app,config}/**/*.rb"
+# No executable_name specified - should use default
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/default_executable_name/config/teams/bar.yml

@@ -0,0 +1,5 @@
+---
+name: Bar
+github:
+  team: '@BarTeam'
+

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/missing_github_team/.github/CODEOWNERS

@@ -0,0 +1,10 @@
+# STOP! - DO NOT EDIT THIS FILE MANUALLY
+# This file was automatically generated by "bin/codeownership validate".
+#
+# CODEOWNERS is used for GitHub to suggest code/file owners to various GitHub
+# teams. This is useful when developers create Pull Requests since the
+# code/file owner is notified. Reference GitHub docs for more details:
+# https://help.github.com/en/articles/about-code-owners
+
+# Match all files to GoodTeam so for-file --from-codeowners hits the parser path
+* @GoodTeam

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/missing_github_team/config/code_ownership.yml

@@ -0,0 +1,10 @@
+owned_globs:
+  - "{gems}/**/*.{rb,tsx,erb}"
+team_file_glob:
+  - config/teams/**/*.yml
+unbuilt_gems_path: gems
+unowned_globs:
+vendored_gems:
+  path: "gems"
+cache_directory: tmp/cache/codeowners
+ignore_dirs: []

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/missing_github_team/config/teams/bad_team.yml

@@ -0,0 +1 @@
+name: MissingGithub

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/missing_github_team/config/teams/good.yml

@@ -0,0 +1,3 @@
+name: Good
+github:
+  team: '@GoodTeam'

data/ext/cargo-vendor/codeowners-0.3.3/tests/fixtures/valid_project/gems/pets/dog.rb

@@ -0,0 +1,5 @@
+# generated
+# next line should be ignored
+# @team Payments
+
+class Dog; end

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.3}/tests/git_stage_test.rs

@@ -38,7 +38,10 @@ where
     let result = func(&run_config, stage);
     assert_no_run_errors(&result);
 
-    assert!(run_config.codeowners_file_path.exists(), "CODEOWNERS file was not created");
+    assert!(
+        run_config.codeowners_file_path.as_ref().unwrap().exists(),
+        "CODEOWNERS file was not created",
+    );
     let staged = is_file_staged(&run_config.project_root, CODEOWNERS_REL);
     assert_eq!(staged, expected_staged, "unexpected staged state for CODEOWNERS");
 }

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.3}/tests/invalid_project_test.rs

@@ -16,6 +16,36 @@ fn test_validate() -> Result<(), Box<dyn Error>> {
         predicate::eq(indoc! {"
 
     CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file
+    The following changes are required (- current, + expected):
+    +# STOP! - DO NOT EDIT THIS FILE MANUALLY
+    +# This file was automatically generated by \"bin/codeownership validate\".
+    +#
+    +# CODEOWNERS is used for GitHub to suggest code/file owners to various GitHub
+    +# teams. This is useful when developers create Pull Requests since the
+    +# code/file owner is notified. Reference GitHub docs for more details:
+    +# https://help.github.com/en/articles/about-code-owners
+    +
+    +# Annotations at the top of file
+    +/gems/payroll_calculator/calculator.rb @PaymentTeam
+    +/ruby/app/models/bank_account.rb @PaymentTeam
+    +/ruby/app/models/payroll.rb @PayrollTeam
+    +/ruby/app/services/multi_owned.rb @PaymentTeam
+    +
+    +# Team-specific owned globs
+    +/ruby/app/payments/**/* @PaymentTeam
+    +
+    +# Owner in .codeowner
+    +/ruby/app/services/**/** @PayrollTeam
+    +
+    +# Owner metadata key in package.yml
+    +/ruby/packages/payroll_flow/**/** @PayrollTeam
+    +
+    +# Team YML ownership
+    +/config/teams/payments.yml @PaymentTeam
+    +/config/teams/payroll.yml @PayrollTeam
+    +
+    +# Team owned gems
+    +/gems/payroll_calculator/**/** @PayrollTeam
 
     Code ownership should only be defined for each file in one way. The following files have declared ownership in multiple ways
 

data/ext/cargo-vendor/codeowners-0.3.3/tests/missing_github_team_test.rs

@@ -0,0 +1,23 @@
+use predicates::prelude::*;
+use std::error::Error;
+
+mod common;
+use common::OutputStream;
+use common::run_codeowners;
+
+// Exercise the code path that skips invalid team files and prints to stderr
+// (codeowners_file_parser::teams_by_github_team_name). Uses for-file
+// --from-codeowners so the project is not built and the parser globs team
+// files; the invalid bad_team.yml is skipped and an error is printed.
+// With the fix: stderr contains "Error parsing team file:" and "missing field `github`".
+// Without the fix (reverted): stderr only has generic "YAML serialization/deserialization failed".
+#[test]
+fn test_missing_github_team_in_team_file_is_reported_on_stderr() -> Result<(), Box<dyn Error>> {
+    run_codeowners(
+        "missing_github_team",
+        &["for-file", "--from-codeowners", "ruby/foo.rb"],
+        true, // command succeeds; invalid file is skipped
+        OutputStream::Stderr,
+        predicate::str::contains("Error parsing team file:").and(predicate::str::contains("missing field `github`")),
+    )
+}