feat: Recognize GIX_TEST_CREATE_ARCHIVES_EVEN_ON_CI

When `gix-testtools` runs fixtures, it now recognizes a new
environment variable, `GIX_TEST_CREATE_ARCHIVES_EVEN_ON_CI`,
specifying that archives should be generated even when on CI.

By default, they are still not generated when on CI. It may make
sense to enable this:

- If automatically testing archive creation, or

- As a way to check that all intended generated arhives are committed
  (which is the motivating use case for this feature), or

- If actually using CI to generate archives that will be uploaded
  as artifacts, or

- In unusual non-CI environments that are mis-detected as CI
  (though that should usually be investigated and fixed, since some
  software performs destructive operations more readily without
  interactive checks when CI is detected).

The usual reason for not generating archives on CI is that they
would not typically be preserved. Thus refraining from generating
them on CI remains the default behavior.

Like the `GIX_TEST_IGNORE_ARCHIVES` environment variable, the new
variable `GIX_TEST_CREATE_ARCHIVES_EVEN_ON_CI` is currently
interpreted as "true" based solely on its presence. This is to say
that is actual value is currently not examined.

Author: EliahKagan

tests/tools/src/lib.rs

@@ -10,6 +10,7 @@
 
 use std::{
     collections::BTreeMap,
+    env,
     ffi::OsString,
     io::Read,
     path::{Path, PathBuf},
@@ -150,8 +151,8 @@ fn git_version_from_bytes(bytes: &[u8]) -> Result<(u8, u8, u8)> {
 
 /// Set the current working dir to `new_cwd` and return a type that returns to the previous working dir on drop.
 pub fn set_current_dir(new_cwd: impl AsRef<Path>) -> std::io::Result<AutoRevertToPreviousCWD> {
-    let cwd = std::env::current_dir()?;
-    std::env::set_current_dir(new_cwd)?;
+    let cwd = env::current_dir()?;
+    env::set_current_dir(new_cwd)?;
     Ok(AutoRevertToPreviousCWD(cwd))
 }
 
@@ -166,7 +167,7 @@ pub struct AutoRevertToPreviousCWD(PathBuf);
 
 impl Drop for AutoRevertToPreviousCWD {
     fn drop(&mut self) {
-        std::env::set_current_dir(&self.0).unwrap();
+        env::set_current_dir(&self.0).unwrap();
     }
 }
 
@@ -461,7 +462,7 @@ fn scripted_fixture_read_only_with_args_inner(
                 crc_digest.update(&std::fs::read(&script_path).unwrap_or_else(|err| {
                     panic!(
                         "file {script_path:?} in CWD {:?} could not be read: {err}",
-                        std::env::current_dir().expect("valid cwd"),
+                        env::current_dir().expect("valid cwd"),
                     )
                 }));
                 for arg in &args {
@@ -548,7 +549,7 @@ fn scripted_fixture_read_only_with_args_inner(
                         script_location.display()
                     );
                 }
-                let script_absolute_path = std::env::current_dir()?.join(script_path);
+                let script_absolute_path = env::current_dir()?.join(script_path);
                 let mut cmd = std::process::Command::new(&script_absolute_path);
                 let output = match configure_command(&mut cmd, &args, &script_result_directory).output() {
                     Ok(out) => out,
@@ -593,7 +594,7 @@ fn configure_command<'a>(
     args: &[String],
     script_result_directory: &Path,
 ) -> &'a mut std::process::Command {
-    let mut msys_for_git_bash_on_windows = std::env::var_os("MSYS").unwrap_or_default();
+    let mut msys_for_git_bash_on_windows = env::var_os("MSYS").unwrap_or_default();
     msys_for_git_bash_on_windows.push(" winsymlinks:nativestrict");
     cmd.args(args)
         .stdout(std::process::Stdio::piped())
@@ -632,6 +633,14 @@ fn write_failure_marker(failure_marker: &Path) {
     std::fs::write(failure_marker, []).ok();
 }
 
+fn should_skip_all_archive_creation() -> bool {
+    // On Windows, we fail to remove the meta_dir and can't do anything about it, which means tests will see more
+    // in the directory than they should which makes them fail. It's probably a bad idea to generate archives on Windows
+    // anyway. Either Unix is portable OR no archive is created anywhere. This also means that Windows users can't create
+    // archives, but that's not a deal-breaker.
+    cfg!(windows) || (is_ci::cached() && !env::var_os("GIX_TEST_CREATE_ARCHIVES_EVEN_ON_CI").is_some())
+}
+
 fn is_lfs_pointer_file(path: &Path) -> bool {
     const PREFIX: &[u8] = b"version https://gix-lfs";
     let mut buf = [0_u8; PREFIX.len()];
@@ -645,11 +654,7 @@ fn is_lfs_pointer_file(path: &Path) -> bool {
 /// The `script_identity` will be baked into the soon to be created `archive` as it identifies the script
 /// that created the contents of `source_dir`.
 fn create_archive_if_we_should(source_dir: &Path, archive: &Path, script_identity: u32) -> std::io::Result<()> {
-    // On Windows, we fail to remove the meta_dir and can't do anything about it, which means tests will see more
-    // in the directory than they should which makes them fail. It's probably a bad idea to generate archives on Windows
-    // anyway. Either Unix is portable OR no archive is created anywhere. This also means that Windows users can't create
-    // archives, but that's not a deal-breaker.
-    if cfg!(windows) || is_ci::cached() || is_excluded(archive) {
+    if should_skip_all_archive_creation() || is_excluded(archive) {
         return Ok(());
     }
     if is_lfs_pointer_file(archive) {
@@ -702,7 +707,7 @@ fn is_excluded(archive: &Path) -> bool {
     let mut lut = EXCLUDE_LUT.lock();
     lut.as_mut()
         .and_then(|cache| {
-            let archive = std::env::current_dir().ok()?.join(archive);
+            let archive = env::current_dir().ok()?.join(archive);
             let relative_path = archive.strip_prefix(cache.base()).ok()?;
             cache
                 .at_path(
@@ -746,7 +751,7 @@ fn extract_archive(
         let mut buf = Vec::new();
         #[cfg_attr(feature = "xz", allow(unused_mut))]
         let mut input_archive = std::fs::File::open(archive)?;
-        if std::env::var_os("GIX_TEST_IGNORE_ARCHIVES").is_some() {
+        if env::var_os("GIX_TEST_IGNORE_ARCHIVES").is_some() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::Other,
                 format!(
@@ -848,16 +853,16 @@ impl<'a> Env<'a> {
 
     /// Set `var` to `value`.
     pub fn set(mut self, var: &'a str, value: impl Into<String>) -> Self {
-        let prev = std::env::var_os(var);
-        std::env::set_var(var, value.into());
+        let prev = env::var_os(var);
+        env::set_var(var, value.into());
         self.altered_vars.push((var, prev));
         self
     }
 
     /// Unset `var`.
     pub fn unset(mut self, var: &'a str) -> Self {
-        let prev = std::env::var_os(var);
-        std::env::remove_var(var);
+        let prev = env::var_os(var);
+        env::remove_var(var);
         self.altered_vars.push((var, prev));
         self
     }
@@ -867,8 +872,8 @@ impl<'a> Drop for Env<'a> {
     fn drop(&mut self) {
         for (var, prev_value) in self.altered_vars.iter().rev() {
             match prev_value {
-                Some(value) => std::env::set_var(var, value),
-                None => std::env::remove_var(var),
+                Some(value) => env::set_var(var, value),
+                None => env::remove_var(var),
             }
         }
     }