tests.nixpkgs-check-by-name: Intermediate ShardNonDir error

2 files changed, 101 insertions, 92 deletions

diff --git a/pkgs/test/nixpkgs-check-by-name/src/check_result.rs b/pkgs/test/nixpkgs-check-by-name/src/check_result.rs
index ad3d949dcb49d..b970c7d630631 100644
--- a/pkgs/test/nixpkgs-check-by-name/src/check_result.rs
+++ b/pkgs/test/nixpkgs-check-by-name/src/check_result.rs
@@ -8,6 +8,9 @@ use std::io;
 use std::path::PathBuf;
 
 pub enum CheckError {
+    ShardNonDir {
+        relative_shard_path: PathBuf,
+    },
     InvalidShardName {
         relative_shard_path: PathBuf,
         shard_name: String,
@@ -96,6 +99,12 @@ impl CheckError {
 impl fmt::Display for CheckError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            CheckError::ShardNonDir { relative_shard_path } =>
+                write!(
+                    f,
+                    "{}: This is a file, but it should be a directory.",
+                    relative_shard_path.display(),
+                ),
             CheckError::InvalidShardName { relative_shard_path, shard_name } =>
                 write!(
                     f,
diff --git a/pkgs/test/nixpkgs-check-by-name/src/structure.rs b/pkgs/test/nixpkgs-check-by-name/src/structure.rs
index fed70c97b090f..17eece94d61c8 100644
--- a/pkgs/test/nixpkgs-check-by-name/src/structure.rs
+++ b/pkgs/test/nixpkgs-check-by-name/src/structure.rs
@@ -61,118 +61,118 @@ impl Nixpkgs {
                 continue;
             }
 
-            if !shard_path.is_dir() {
-                error_writer.write(&format!(
-                    "{}: This is a file, but it should be a directory.",
-                    relative_shard_path.display(),
-                ))?;
-                // we can't check for any other errors if it's a file, since there's no subdirectories to check
-                continue;
-            }
-
-            let shard_name_valid = SHARD_NAME_REGEX.is_match(&shard_name);
-            let shard_name_valid_check_result = if !shard_name_valid {
-                CheckError::InvalidShardName {
+            let check_result = if !shard_path.is_dir() {
+                CheckError::ShardNonDir {
                     relative_shard_path: relative_shard_path.clone(),
-                    shard_name: shard_name.clone(),
                 }
                 .into_result()
+                // we can't check for any other errors if it's a file, since there's no subdirectories to check
             } else {
-                pass(())
-            };
-
-            write_check_result(error_writer, shard_name_valid_check_result)?;
-
-            let entries = utils::read_dir_sorted(&shard_path)?;
-
-            let duplicate_check_results = entries
-                .iter()
-                .zip(entries.iter().skip(1))
-                .filter(|(l, r)| {
-                    l.file_name().to_ascii_lowercase() == r.file_name().to_ascii_lowercase()
-                })
-                .map(|(l, r)| {
-                    CheckError::CaseSensitiveDuplicate {
+                let shard_name_valid = SHARD_NAME_REGEX.is_match(&shard_name);
+                let shard_name_valid_check_result = if !shard_name_valid {
+                    CheckError::InvalidShardName {
                         relative_shard_path: relative_shard_path.clone(),
-                        first: l.file_name(),
-                        second: r.file_name(),
+                        shard_name: shard_name.clone(),
                     }
-                    .into_result::<()>()
-                });
+                    .into_result()
+                } else {
+                    pass(())
+                };
+
+                write_check_result(error_writer, shard_name_valid_check_result)?;
+
+                let entries = utils::read_dir_sorted(&shard_path)?;
+
+                let duplicate_check_results = entries
+                    .iter()
+                    .zip(entries.iter().skip(1))
+                    .filter(|(l, r)| {
+                        l.file_name().to_ascii_lowercase() == r.file_name().to_ascii_lowercase()
+                    })
+                    .map(|(l, r)| {
+                        CheckError::CaseSensitiveDuplicate {
+                            relative_shard_path: relative_shard_path.clone(),
+                            first: l.file_name(),
+                            second: r.file_name(),
+                        }
+                        .into_result::<()>()
+                    });
 
-            let duplicate_check_result = flatten_check_results(duplicate_check_results, |_| ());
+                let duplicate_check_result = flatten_check_results(duplicate_check_results, |_| ());
 
-            write_check_result(error_writer, duplicate_check_result)?;
+                write_check_result(error_writer, duplicate_check_result)?;
 
-            let check_results = entries.into_iter().map(|package_entry| {
-                let package_path = package_entry.path();
-                let package_name = package_entry.file_name().to_string_lossy().into_owned();
-                let relative_package_dir =
-                    PathBuf::from(format!("{BASE_SUBPATH}/{shard_name}/{package_name}"));
+                let check_results = entries.into_iter().map(|package_entry| {
+                    let package_path = package_entry.path();
+                    let package_name = package_entry.file_name().to_string_lossy().into_owned();
+                    let relative_package_dir =
+                        PathBuf::from(format!("{BASE_SUBPATH}/{shard_name}/{package_name}"));
 
-                if !package_path.is_dir() {
-                    CheckError::PackageNonDir {
-                        relative_package_dir: relative_package_dir.clone(),
-                    }
-                    .into_result()
-                } else {
-                    let package_name_valid = PACKAGE_NAME_REGEX.is_match(&package_name);
-                    let name_check_result = if !package_name_valid {
-                        CheckError::InvalidPackageName {
+                    if !package_path.is_dir() {
+                        CheckError::PackageNonDir {
                             relative_package_dir: relative_package_dir.clone(),
-                            package_name: package_name.clone(),
                         }
                         .into_result()
                     } else {
-                        pass(())
-                    };
-
-                    let correct_relative_package_dir =
-                        Nixpkgs::relative_dir_for_package(&package_name);
-                    let shard_check_result = if relative_package_dir != correct_relative_package_dir
-                    {
-                        // Only show this error if we have a valid shard and package name
-                        // Because if one of those is wrong, you should fix that first
-                        if shard_name_valid && package_name_valid {
-                            CheckError::IncorrectShard {
+                        let package_name_valid = PACKAGE_NAME_REGEX.is_match(&package_name);
+                        let name_check_result = if !package_name_valid {
+                            CheckError::InvalidPackageName {
                                 relative_package_dir: relative_package_dir.clone(),
-                                correct_relative_package_dir: correct_relative_package_dir.clone(),
+                                package_name: package_name.clone(),
                             }
                             .into_result()
                         } else {
                             pass(())
-                        }
-                    } else {
-                        pass(())
-                    };
-
-                    let package_nix_path = package_path.join(PACKAGE_NIX_FILENAME);
-                    let package_nix_check_result = if !package_nix_path.exists() {
-                        CheckError::PackageNixNonExistent {
-                            relative_package_dir: relative_package_dir.clone(),
-                        }
-                        .into_result()
-                    } else if package_nix_path.is_dir() {
-                        CheckError::PackageNixDir {
-                            relative_package_dir: relative_package_dir.clone(),
-                        }
-                        .into_result()
-                    } else {
-                        pass(())
-                    };
-
-                    flatten_check_results(
-                        [
-                            name_check_result,
-                            shard_check_result,
-                            package_nix_check_result,
-                        ],
-                        |_| package_name.clone(),
-                    )
-                }
-            });
+                        };
+
+                        let correct_relative_package_dir =
+                            Nixpkgs::relative_dir_for_package(&package_name);
+                        let shard_check_result =
+                            if relative_package_dir != correct_relative_package_dir {
+                                // Only show this error if we have a valid shard and package name
+                                // Because if one of those is wrong, you should fix that first
+                                if shard_name_valid && package_name_valid {
+                                    CheckError::IncorrectShard {
+                                        relative_package_dir: relative_package_dir.clone(),
+                                        correct_relative_package_dir: correct_relative_package_dir
+                                            .clone(),
+                                    }
+                                    .into_result()
+                                } else {
+                                    pass(())
+                                }
+                            } else {
+                                pass(())
+                            };
+
+                        let package_nix_path = package_path.join(PACKAGE_NIX_FILENAME);
+                        let package_nix_check_result = if !package_nix_path.exists() {
+                            CheckError::PackageNixNonExistent {
+                                relative_package_dir: relative_package_dir.clone(),
+                            }
+                            .into_result()
+                        } else if package_nix_path.is_dir() {
+                            CheckError::PackageNixDir {
+                                relative_package_dir: relative_package_dir.clone(),
+                            }
+                            .into_result()
+                        } else {
+                            pass(())
+                        };
+
+                        flatten_check_results(
+                            [
+                                name_check_result,
+                                shard_check_result,
+                                package_nix_check_result,
+                            ],
+                            |_| package_name.clone(),
+                        )
+                    }
+                });
 
-            let check_result = flatten_check_results(check_results, |x| x);
+                flatten_check_results(check_results, |x| x)
+            };
 
             if let Some(shard_package_names) = write_check_result(error_writer, check_result)? {
                 package_names.extend(shard_package_names)