add test for racy git detection

Author: pascalkuthe

gix-worktree/src/index/status/worktree.rs

@@ -28,7 +28,7 @@ pub enum Error {
 /// Options that control how the index status of a worktree is computed
 pub struct Options {
     /// capabilities of the file system
-    pub fs: crate::fs::Capabilities,
+    pub fs: fs::Capabilities,
     /// If set, don't use more than this amount of threads.
     /// Otherwise, usually use as many threads as there are logical cores.
     /// A value of 0 is interpreted as no-limit

gix-worktree/tests/fixtures/generated-archives/racy_git.tar.xz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35b728a127f3b6170bac44469ff36d5ad0be2a4247a8926f1aaffb97b5973efc
+size 1596

gix-worktree/tests/fixtures/racy_git.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -eu -o pipefail
+
+git init -q
+
+echo -n "foo" > content
+
+git add -A
+git commit -m "Commit"
+
+# file size should not be changed by this
+echo -n "bar" > content

gix-worktree/tests/worktree/index/status.rs

@@ -1,11 +1,24 @@
 use bstr::BStr;
+use filetime::{set_file_mtime, FileTime};
+use gix_index as index;
 use gix_worktree::fs::Capabilities;
 use gix_worktree::index::status::content::FastEq;
 use gix_worktree::index::status::worktree::{self, Options};
 use gix_worktree::index::status::{Change, Recorder};
 
 use crate::fixture_path;
 
+// since tests are fixtures a bunch of stat information (like inode number)
+// changes when extracting the data so we need to disable all advanced stat
+// changes and only look at mtime seconds and file size to properly
+// test all code paths (and to trigger racy git)
+const TEST_OPTIONS: index::entry::stat::Options = index::entry::stat::Options {
+    trust_ctime: false,
+    check_stat: false,
+    use_nsec: false,
+    use_stdev: false,
+};
+
 fn fixture(name: &str, expected_status: &[(&BStr, Option<Change>, bool)]) {
     let worktree = fixture_path(name);
     let git_dir = worktree.join(".git");
@@ -18,6 +31,7 @@ fn fixture(name: &str, expected_status: &[(&BStr, Option<Change>, bool)]) {
         &FastEq,
         Options {
             fs: Capabilities::probe(git_dir),
+            stat: TEST_OPTIONS,
             ..Options::default()
         },
     )
@@ -43,6 +57,7 @@ fn removed() {
 fn unchanged() {
     fixture("status_unchanged", &[]);
 }
+
 #[test]
 fn modified() {
     // run the same status check twice to ensure that racy detection
@@ -108,3 +123,69 @@ fn modified() {
         ],
     );
 }
+
+#[test]
+fn racy_git() {
+    let timestamp = 940040400;
+    // we need a writable fixture because we have to mess with mtimes manually,
+    // because touch -d respects the locale so the test wouldn't work depending
+    // on the timesystem you run your test in
+    let dir = gix_testtools::scripted_fixture_writable("racy_git.sh").expect("script works");
+    let worktree = dir.path();
+    let git_dir = worktree.join(".git");
+    let fs = Capabilities::probe(&git_dir);
+    let mut index = gix_index::File::at(git_dir.join("index"), gix_hash::Kind::Sha1, Default::default()).unwrap();
+    // we artificially mess with mtime so that it's before the timestamp
+    // saved by git. This would usually mean an invalid fs/invalid index file
+    // and as a result the racy git mitigation doesn't work and the worktree
+    // shows up as unchanged even tough the file did change. This case
+    // doesn't happen in the realworld (except for file corruption) but
+    // makes sure we are actually hitting the right codepath
+    index.entries[0].stat.mtime.secs = timestamp;
+    set_file_mtime(worktree.join("content"), FileTime::from_unix_time(timestamp as i64, 0))
+        .expect("changing filetime works");
+    let mut recorder = Recorder::default();
+    worktree::changes_to_obtain(
+        &mut index,
+        &worktree,
+        &mut recorder,
+        &FastEq,
+        Options {
+            fs,
+            stat: TEST_OPTIONS,
+            ..Options::default()
+        },
+    )
+    .unwrap();
+    assert_eq!(recorder.records, &[]);
+
+    // now we also backdate the index timestamp to match the artificially created
+    // mtime above this is now a realistic realworld racecondition which
+    // should trigger racy git and cause proper output
+    index.set_timestamp(FileTime::from_unix_time(timestamp as i64, 0));
+    let mut recorder = Recorder::default();
+    worktree::changes_to_obtain(
+        &mut index,
+        &worktree,
+        &mut recorder,
+        &FastEq,
+        Options {
+            fs,
+            stat: TEST_OPTIONS,
+            ..Options::default()
+        },
+    )
+    .unwrap();
+    // be handled correctly by the racy git detection
+    assert_eq!(
+        recorder.records,
+        &[(
+            BStr::new(b"content"),
+            Some(Change::Modification {
+                executable_bit_changed: false,
+                content_change: Some(()),
+            }),
+            false
+        )]
+    );
+}