code_ownership 2.1.4 → 2.2.0

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

@@ -1,9 +1,10 @@
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use error_stack::{Result, ResultExt};
+use error_stack::{Report, ResultExt};
 use fast_glob::glob_match;
 use serde::Serialize;
+use tracing::debug_span;
 
 use crate::{
     cache::{Cache, Caching, file::GlobalCache, noop::NoopCache},
@@ -47,7 +48,7 @@ where
     runnable(runner)
 }
 
-pub(crate) fn config_from_run_config(run_config: &RunConfig) -> Result<Config, Error> {
+pub(crate) fn config_from_run_config(run_config: &RunConfig) -> Result<Config, Report<Error>> {
     match crate::config::Config::load_from_path(&run_config.config_path) {
         Ok(mut c) => {
             if let Some(executable_name) = &run_config.executable_name {
@@ -55,7 +56,7 @@ pub(crate) fn config_from_run_config(run_config: &RunConfig) -> Result<Config, E
             }
             Ok(c)
         }
-        Err(msg) => Err(error_stack::Report::new(Error::Io(msg))),
+        Err(msg) => Err(Report::new(Error::Io(msg))),
     }
 }
 
@@ -79,33 +80,37 @@ pub(crate) fn resolve_codeowners_file_path(run_config: &RunConfig, config: &Conf
 }
 
 impl Runner {
-    pub fn new(run_config: &RunConfig) -> Result<Self, Error> {
-        let config = config_from_run_config(run_config)?;
+    pub fn new(run_config: &RunConfig) -> Result<Self, Report<Error>> {
+        let config = debug_span!("config_load").in_scope(|| 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()
-        } else {
-            GlobalCache::new(run_config.project_root.clone(), config.cache_directory.clone())
-                .change_context(Error::Io(format!(
-                    "Can't create cache: {}",
-                    &run_config.config_path.to_string_lossy()
-                )))
-                .attach_printable(format!("Can't create cache: {}", &run_config.config_path.to_string_lossy()))?
-                .into()
-        };
+        let cache: Cache = debug_span!("cache_init").in_scope(|| -> Result<Cache, Report<Error>> {
+            if run_config.no_cache {
+                Ok(NoopCache::default().into())
+            } else {
+                Ok(GlobalCache::new(run_config.project_root.clone(), config.cache_directory.clone())
+                    .change_context(Error::Io(format!(
+                        "Can't create cache: {}",
+                        run_config.config_path.to_string_lossy()
+                    )))
+                    .attach(format!("Can't create cache: {}", run_config.config_path.to_string_lossy()))?
+                    .into())
+            }
+        })?;
 
         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()
+            run_config.config_path.to_string_lossy()
         )))?;
         let ownership = Ownership::build(project);
 
-        cache.persist_cache().change_context(Error::Io(format!(
-            "Can't persist cache: {}",
-            &run_config.config_path.to_string_lossy()
-        )))?;
+        debug_span!("cache_persist").in_scope(|| {
+            cache.persist_cache().change_context(Error::Io(format!(
+                "Can't persist cache: {}",
+                run_config.config_path.to_string_lossy()
+            )))
+        })?;
 
         Ok(Self {
             run_config: run_config.clone(),
@@ -128,6 +133,9 @@ impl Runner {
         match self.ownership.validate() {
             Ok(_) => RunResult::default(),
             Err(err) => RunResult {
+                // The stale-CODEOWNERS diff (if any) rides along as informational output,
+                // printed ahead of the errors, so the actionable headline isn't buried.
+                info_messages: err.info_messages(),
                 validation_errors: vec![format!("{}", err)],
                 ..Default::default()
             },
@@ -156,13 +164,15 @@ impl Runner {
             })
             .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),
-                Err(err) => io_errors.push(format!("{}: {}", file_path, err)),
+        debug_span!("per_file_query").in_scope(|| {
+            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),
+                    Err(err) => io_errors.push(format!("{}: {}", file_path, err)),
+                }
             }
-        }
+        });
 
         if !unowned_files.is_empty() {
             let validation_errors = std::iter::once("Unowned files detected:".to_string())
@@ -247,7 +257,7 @@ impl Runner {
     pub fn delete_cache(&self) -> RunResult {
         match self.cache.delete_cache().change_context(Error::Io(format!(
             "Can't delete cache: {}",
-            &self.run_config.config_path.to_string_lossy()
+            self.run_config.config_path.to_string_lossy()
         ))) {
             Ok(_) => RunResult::default(),
             Err(err) => RunResult {
@@ -261,7 +271,7 @@ impl Runner {
         crate::crosscheck::crosscheck_owners(&self.run_config, &self.cache)
     }
 
-    pub fn owners_for_file(&self, file_path: &str) -> Result<Vec<FileOwner>, Error> {
+    pub fn owners_for_file(&self, file_path: &str) -> Result<Vec<FileOwner>, Report<Error>> {
         use crate::ownership::file_owner_resolver::find_file_owners;
         let owners = find_file_owners(&self.run_config.project_root, &self.config, std::path::Path::new(file_path)).map_err(Error::Io)?;
         Ok(owners)

data/ext/cargo-vendor/codeowners-0.5.0/tests/annotation_in_unowned_team_glob_test.rs

@@ -0,0 +1,64 @@
+use assert_cmd::prelude::*;
+use indoc::indoc;
+use predicates::prelude::*;
+use std::error::Error;
+use std::path::Path;
+use std::process::Command;
+use tempfile::TempDir;
+
+mod common;
+use common::OutputStream;
+use common::git_add_all_files;
+use common::run_codeowners;
+use common::setup_fixture_repo;
+
+// Alpha owns ruby/app/**/* but excludes beta_owned.rb through unowned_globs, and Beta owns that file
+// through an annotation. GitHub applies the last matching CODEOWNERS line, so the annotation line must
+// come after Alpha's broader glob for GitHub to agree with for-file.
+const FIXTURE: &str = "annotation_in_unowned_team_glob";
+
+// Copies the fixture and regenerates its CODEOWNERS, so assertions exercise the generator rather than
+// the committed file.
+fn fixture_with_generated_codeowners() -> Result<TempDir, Box<dyn Error>> {
+    let temp_dir = setup_fixture_repo(&Path::new("tests/fixtures").join(FIXTURE));
+    git_add_all_files(temp_dir.path());
+    codeowners(temp_dir.path(), &["generate"])?.assert().success();
+    Ok(temp_dir)
+}
+
+fn codeowners(project_root: &Path, args: &[&str]) -> Result<Command, Box<dyn Error>> {
+    let mut cmd = Command::cargo_bin("codeowners")?;
+    cmd.arg("--project-root").arg(project_root).arg("--no-cache").args(args);
+    Ok(cmd)
+}
+
+#[test]
+fn test_validate_accepts_generated_order() -> Result<(), Box<dyn Error>> {
+    run_codeowners(FIXTURE, &["validate"], true, OutputStream::Stdout, predicate::eq(""))?;
+    Ok(())
+}
+
+#[test]
+fn test_generated_codeowners_agrees_with_for_file() -> Result<(), Box<dyn Error>> {
+    let temp_dir = fixture_with_generated_codeowners()?;
+    codeowners(temp_dir.path(), &["crosscheck-owners"])?
+        .assert()
+        .success()
+        .stdout(predicate::eq(indoc! {"
+            Success! All files match between CODEOWNERS and for-file command.
+        "}));
+    Ok(())
+}
+
+#[test]
+fn test_for_file_from_generated_codeowners_returns_annotated_owner() -> Result<(), Box<dyn Error>> {
+    let temp_dir = fixture_with_generated_codeowners()?;
+    codeowners(
+        temp_dir.path(),
+        &["for-file", "--from-codeowners", "ruby/app/services/beta_owned.rb"],
+    )?
+    .assert()
+    .success()
+    .stdout(predicate::str::contains("Team: Beta"));
+    Ok(())
+}

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

@@ -49,7 +49,7 @@ pub fn teardown() {
         .filter_map(Result::ok)
         .for_each(|cache_dir| {
             if let Err(err) = fs::remove_dir_all(&cache_dir) {
-                eprintln!("Failed to remove {} during test teardown: {}", &cache_dir.display(), err);
+                eprintln!("Failed to remove {} during test teardown: {}", cache_dir.display(), err);
             }
         });
 }

data/ext/cargo-vendor/codeowners-0.5.0/tests/directory_codeowner_github_team_test.rs

@@ -0,0 +1,22 @@
+use predicates::prelude::*;
+use std::error::Error;
+
+mod common;
+use common::OutputStream;
+use common::run_codeowners;
+
+/// `teams_by_name` is keyed by both `name` and `github_team`, so a `.codeowner` holding
+/// either form generates a correct line. Validation has to accept both, or it fails a
+/// project whose CODEOWNERS is already right — with no command that fixes it.
+#[test]
+fn test_validate_accepts_directory_codeowner_by_name_or_github_team() -> Result<(), Box<dyn Error>> {
+    run_codeowners(
+        "directory-codeowner-github-team",
+        &["validate"],
+        true,
+        OutputStream::Stdout,
+        predicate::str::contains("invalid team").not(),
+    )?;
+
+    Ok(())
+}

data/ext/cargo-vendor/codeowners-0.5.0/tests/empty_directory_codeowner_test.rs

@@ -0,0 +1,26 @@
+use indoc::indoc;
+use predicates::prelude::*;
+use std::error::Error;
+
+mod common;
+use common::OutputStream;
+use common::run_codeowners;
+
+/// `owner` is `content.trim()` (`project_builder.rs:278`), so an empty or whitespace-only
+/// `.codeowner` yields `""` and hits the same silent-inheritance path as a typo'd name.
+/// Reporting it as `an invalid team - ''` would give no hint the file is empty.
+#[test]
+fn test_validate_reports_empty_directory_codeowner() -> Result<(), Box<dyn Error>> {
+    run_codeowners(
+        "empty-directory-codeowner",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::str::contains(indoc! {"
+            Found invalid team references
+            - app/services/nested/.codeowner is empty and names no team; this directory is currently inheriting its owner from app/services
+        "}),
+    )?;
+
+    Ok(())
+}

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/annotation_in_unowned_team_glob/.github/CODEOWNERS

@@ -0,0 +1,18 @@
+# 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
+
+
+# Team-specific owned globs
+/ruby/app/**/* @AlphaTeam
+
+# Team YML ownership
+/config/teams/alpha.yml @AlphaTeam
+/config/teams/beta.yml @BetaTeam
+
+# Annotations at the top of file
+/ruby/app/services/beta_owned.rb @BetaTeam

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/annotation_in_unowned_team_glob/config/code_ownership.yml

@@ -0,0 +1,4 @@
+owned_globs:
+  - "ruby/**/*.rb"
+team_file_glob:
+  - config/teams/**/*.yml

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/annotation_in_unowned_team_glob/config/teams/alpha.yml

@@ -0,0 +1,7 @@
+name: Alpha
+github:
+  team: '@AlphaTeam'
+owned_globs:
+  - ruby/app/**/*
+unowned_globs:
+  - ruby/app/services/beta_owned.rb

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/annotation_in_unowned_team_glob/config/teams/beta.yml

@@ -0,0 +1,3 @@
+name: Beta
+github:
+  team: '@BetaTeam'

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/annotation_in_unowned_team_glob/ruby/app/services/alpha_owned.rb

@@ -0,0 +1,2 @@
+class AlphaOwned
+end

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/annotation_in_unowned_team_glob/ruby/app/services/beta_owned.rb

@@ -0,0 +1,4 @@
+# @team Beta
+
+class BetaOwned
+end

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/directory-codeowner-github-team/.github/CODEOWNERS

@@ -0,0 +1,15 @@
+# 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
+
+
+# Owner in .codeowner
+/app/by_handle/**/** @footeam
+/app/by_name/**/** @footeam
+
+# Team YML ownership
+/config/teams/foo.yml @footeam

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/directory-codeowner-github-team/app/by_handle/.codeowner

@@ -0,0 +1 @@
+@footeam

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/directory-codeowner-github-team/app/by_handle/handled.rb

@@ -0,0 +1,2 @@
+class Handled
+end

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/directory-codeowner-github-team/app/by_name/named.rb

@@ -0,0 +1,2 @@
+class Named
+end

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/empty-directory-codeowner/.github/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
+
+
+# Owner in .codeowner
+/app/services/**/** @footeam
+
+# Team YML ownership
+/config/teams/foo.yml @footeam

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/empty-directory-codeowner/app/services/.codeowner

@@ -0,0 +1 @@
+Foo

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/empty-directory-codeowner/app/services/nested/.codeowner

@@ -0,0 +1 @@
+   

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/empty-directory-codeowner/app/services/nested/nested_file.rb

@@ -0,0 +1,2 @@
+class NestedFile
+end

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/empty-directory-codeowner/config/code_ownership.yml

@@ -0,0 +1,10 @@
+---
+owned_globs:
+  - "{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx,json,yml}"
+unowned_globs:
+  - config/code_ownership.yml
+javascript_package_paths:
+  - javascript/packages/**
+vendored_gems_path: gems
+team_file_glob:
+  - config/teams/**/*.yml

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/empty-directory-codeowner/config/teams/foo.yml

@@ -0,0 +1,5 @@
+name: Foo
+github:
+  team: "@footeam"
+  members:
+    - fooer

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/invalid-directory-codeowner/.github/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
+
+
+# Owner in .codeowner
+/app/services/**/** @footeam
+
+# Team YML ownership
+/config/teams/foo.yml @footeam

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/invalid-directory-codeowner/app/services/.codeowner

@@ -0,0 +1 @@
+Foo

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/invalid-directory-codeowner/app/services/nested/.codeowner

@@ -0,0 +1 @@
+Web3

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/invalid-directory-codeowner/app/services/nested/nested_file.rb

@@ -0,0 +1,2 @@
+class NestedFile
+end

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/invalid-directory-codeowner/config/code_ownership.yml

@@ -0,0 +1,10 @@
+---
+owned_globs:
+  - "{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx,json,yml}"
+unowned_globs:
+  - config/code_ownership.yml
+javascript_package_paths:
+  - javascript/packages/**
+vendored_gems_path: gems
+team_file_glob:
+  - config/teams/**/*.yml

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/invalid-directory-codeowner/config/teams/foo.yml

@@ -0,0 +1,5 @@
+name: Foo
+github:
+  team: "@footeam"
+  members:
+    - fooer

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/multiple-directory-owners/app/services/.codeowner

@@ -0,0 +1 @@
+Foo

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/multiple-directory-owners/config/code_ownership.yml

@@ -0,0 +1,10 @@
+---
+owned_globs:
+  - "{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx,json,yml}"
+unowned_globs:
+  - config/code_ownership.yml
+javascript_package_paths:
+  - javascript/packages/**
+vendored_gems_path: gems
+team_file_glob:
+  - config/teams/**/*.yml

data/ext/cargo-vendor/codeowners-0.5.0/tests/fixtures/multiple-directory-owners/config/teams/foo.yml

@@ -0,0 +1,5 @@
+name: Foo
+github:
+  team: "@footeam"
+  members:
+    - fooer

data/ext/cargo-vendor/codeowners-0.5.0/tests/global_gitignore_test.rs

@@ -0,0 +1,50 @@
+use assert_cmd::prelude::*;
+use std::{error::Error, fs, path::Path, process::Command};
+
+mod common;
+use common::{git_add_all_files, setup_fixture_repo};
+
+const FIXTURE: &str = "tests/fixtures/valid_project";
+
+/// A directory can be force-tracked in git even when it matches a
+/// gitignore-style rule that lives outside the tracked tree (a personal
+/// global `core.excludesFile`, or a local, uncommitted `.git/info/exclude`
+/// entry). `generate` must still emit ownership for such directories:
+/// inclusion is decided by `tracked_files` (git ls-files), so also honoring
+/// git's own ignore semantics at the directory-walk level can silently prune
+/// tracked, owned files depending on the machine's git config alone --
+/// nothing committed to the repo. `.git/info/exclude` is used here as a
+/// reliable stand-in for a developer's global gitignore, which is what
+/// originally surfaced this bug (see PR discussion).
+#[test]
+fn test_generate_ignores_local_exclude_rules_for_tracked_directories() -> Result<(), Box<dyn Error>> {
+    let temp_dir = setup_fixture_repo(Path::new(FIXTURE));
+    let project_root = temp_dir.path();
+    git_add_all_files(project_root);
+
+    let exclude_path = project_root.join(".git/info/exclude");
+    let mut existing = fs::read_to_string(&exclude_path).unwrap_or_default();
+    existing.push_str("\nruby/app/payroll/\n");
+    fs::write(&exclude_path, existing)?;
+
+    let codeowners_path = project_root.join("tmp/CODEOWNERS");
+    fs::create_dir_all(codeowners_path.parent().unwrap())?;
+
+    Command::cargo_bin("codeowners")?
+        .arg("--project-root")
+        .arg(project_root)
+        .arg("--codeowners-file-path")
+        .arg(&codeowners_path)
+        .arg("--no-cache")
+        .arg("generate")
+        .assert()
+        .success();
+
+    let actual_codeowners = fs::read_to_string(&codeowners_path)?;
+    assert!(
+        actual_codeowners.contains("/ruby/app/payroll/**/** @PayrollTeam"),
+        "expected ruby/app/payroll ownership to survive a local .git/info/exclude rule matching it, got:\n{actual_codeowners}"
+    );
+
+    Ok(())
+}

data/ext/cargo-vendor/codeowners-0.5.0/tests/invalid_directory_codeowner_test.rs

@@ -0,0 +1,26 @@
+use indoc::indoc;
+use predicates::prelude::*;
+use std::error::Error;
+
+mod common;
+use common::OutputStream;
+use common::run_codeowners;
+
+/// A nested `.codeowner` naming an unregistered team, under one naming a real team:
+/// ownership falls through to the ancestor, so nothing else reports the bad name. The
+/// message names that ancestor, since the silent inheritance is the surprising part.
+#[test]
+fn test_validate_reports_directory_codeowner_with_invalid_team() -> Result<(), Box<dyn Error>> {
+    run_codeowners(
+        "invalid-directory-codeowner",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::str::contains(indoc! {"
+            Found invalid team references
+            - app/services/nested/.codeowner is referencing an invalid team - 'Web3'; this directory is currently inheriting its owner from app/services
+        "}),
+    )?;
+
+    Ok(())
+}

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

@@ -14,8 +14,6 @@ fn test_validate() -> Result<(), Box<dyn Error>> {
         false,
         OutputStream::Stdout,
         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\".
@@ -25,12 +23,6 @@ fn test_validate() -> Result<(), Box<dyn Error>> {
     +# 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
     +
@@ -46,6 +38,14 @@ fn test_validate() -> Result<(), Box<dyn Error>> {
     +
     +# Team owned gems
     +/gems/payroll_calculator/**/** @PayrollTeam
+    +
+    +# 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
+
+    CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file
 
     Code ownership should only be defined for each file in one way. The following files have declared ownership in multiple ways
 
@@ -61,7 +61,7 @@ fn test_validate() -> Result<(), Box<dyn Error>> {
      owner: Payroll
       - Owner specified in `ruby/app/services/.codeowner`
 
-    Found invalid team annotations
+    Found invalid team references
     - ruby/app/models/blockchain.rb is referencing an invalid team - 'Web3'
 
     Some files are missing ownership