tests/index/racy.c

   1 #include "clar_libgit2.h"
   2 #include "../checkout/checkout_helpers.h"
   3
   4 #include "buffer.h"
   5 #include "index.h"
   6 #include "repository.h"
   7
   8 static git_repository *g_repo;
   9
  10 void test_index_racy__initialize(void)
  11 {
  12         cl_git_pass(git_repository_init(&g_repo, "diff_racy", false));
  13 }
  14
  15 void test_index_racy__cleanup(void)
  16 {
  17         git_repository_free(g_repo);
  18         g_repo = NULL;
  19
  20         cl_fixture_cleanup("diff_racy");
  21 }
  22
  23 void test_index_racy__diff(void)
  24 {
  25         git_index *index;
  26         git_diff *diff;
  27         git_buf path = GIT_BUF_INIT;
  28
  29         cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "A"));
  30         cl_git_mkfile(path.ptr, "A");
  31
  32         /* Put 'A' into the index */
  33         cl_git_pass(git_repository_index(&index, g_repo));
  34         cl_git_pass(git_index_add_bypath(index, "A"));
  35         cl_git_pass(git_index_write(index));
  36
  37         cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, NULL));
  38         cl_assert_equal_i(0, git_diff_num_deltas(diff));
  39         git_diff_free(diff);
  40
  41         /* Change its contents quickly, so we get the same timestamp */
  42         cl_git_mkfile(path.ptr, "B");
  43
  44         cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, NULL));
  45         cl_assert_equal_i(1, git_diff_num_deltas(diff));
  46
  47         git_index_free(index);
  48         git_diff_free(diff);
  49         git_buf_dispose(&path);
  50 }
  51
  52 void test_index_racy__write_index_just_after_file(void)
  53 {
  54         git_index *index;
  55         git_diff *diff;
  56         git_buf path = GIT_BUF_INIT;
  57         struct p_timeval times[2];
  58
  59         /* Make sure we do have a timestamp */
  60         cl_git_pass(git_repository_index(&index, g_repo));
  61         cl_git_pass(git_index_write(index));
  62
  63         cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "A"));
  64         cl_git_mkfile(path.ptr, "A");
  65         /* Force the file's timestamp to be a second after we wrote the index */
  66         times[0].tv_sec = index->stamp.mtime.tv_sec + 1;
  67         times[0].tv_usec = index->stamp.mtime.tv_nsec / 1000;
  68         times[1].tv_sec = index->stamp.mtime.tv_sec + 1;
  69         times[1].tv_usec = index->stamp.mtime.tv_nsec / 1000;
  70         cl_git_pass(p_utimes(path.ptr, times));
  71
  72         /*
  73          * Put 'A' into the index, the size field will be filled,
  74          * because the index' on-disk timestamp does not match the
  75          * file's timestamp.
  76          */
  77         cl_git_pass(git_index_add_bypath(index, "A"));
  78         cl_git_pass(git_index_write(index));
  79
  80         cl_git_mkfile(path.ptr, "B");
  81         /*
  82          * Pretend this index' modification happened a second after the
  83          * file update, and rewrite the file in that same second.
  84          */
  85         times[0].tv_sec = index->stamp.mtime.tv_sec + 2;
  86         times[0].tv_usec = index->stamp.mtime.tv_nsec / 1000;
  87         times[1].tv_sec = index->stamp.mtime.tv_sec + 2;
  88         times[0].tv_usec = index->stamp.mtime.tv_nsec / 1000;
  89
  90         cl_git_pass(p_utimes(git_index_path(index), times));
  91         cl_git_pass(p_utimes(path.ptr, times));
  92
  93         cl_git_pass(git_index_read(index, true));
  94
  95         cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, NULL));
  96         cl_assert_equal_i(1, git_diff_num_deltas(diff));
  97
  98         git_buf_dispose(&path);
  99         git_diff_free(diff);
 100         git_index_free(index);
 101 }
 102
 103
 104 static void setup_race(void)
 105 {
 106         git_buf path = GIT_BUF_INIT;
 107         git_index *index;
 108         git_index_entry *entry;
 109         struct stat st;
 110
 111         /* Make sure we do have a timestamp */
 112         cl_git_pass(git_repository_index__weakptr(&index, g_repo));
 113         cl_git_pass(git_index_write(index));
 114
 115         cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "A"));
 116
 117         cl_git_mkfile(path.ptr, "A");
 118         cl_git_pass(git_index_add_bypath(index, "A"));
 119
 120         cl_git_mkfile(path.ptr, "B");
 121         cl_git_pass(git_index_write(index));
 122
 123         cl_git_mkfile(path.ptr, "");
 124
 125         cl_git_pass(p_stat(path.ptr, &st));
 126         cl_assert(entry = (git_index_entry *)git_index_get_bypath(index, "A", 0));
 127
 128         /* force a race */
 129         entry->mtime.seconds = (int32_t)st.st_mtime;
 130         entry->mtime.nanoseconds = (int32_t)st.st_mtime_nsec;
 131
 132         git_buf_dispose(&path);
 133 }
 134
 135 void test_index_racy__smudges_index_entry_on_save(void)
 136 {
 137         git_index *index;
 138         const git_index_entry *entry;
 139
 140         setup_race();
 141
 142         /* write the index, which will smudge anything that had the same timestamp
 143          * as the index when the index was loaded.  that way future loads of the
 144          * index (with the new timestamp) will know that these files were not
 145          * clean.
 146          */
 147
 148         cl_git_pass(git_repository_index__weakptr(&index, g_repo));
 149         cl_git_pass(git_index_write(index));
 150
 151         cl_assert(entry = git_index_get_bypath(index, "A", 0));
 152         cl_assert_equal_i(0, entry->file_size);
 153 }
 154
 155 void test_index_racy__detects_diff_of_change_in_identical_timestamp(void)
 156 {
 157         git_index *index;
 158         git_diff *diff;
 159
 160         cl_git_pass(git_repository_index__weakptr(&index, g_repo));
 161
 162         setup_race();
 163
 164         cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, index, NULL));
 165         cl_assert_equal_i(1, git_diff_num_deltas(diff));
 166
 167         git_diff_free(diff);
 168 }
 169
 170 static void setup_uptodate_files(void)
 171 {
 172         git_buf path = GIT_BUF_INIT;
 173         git_index *index;
 174         const git_index_entry *a_entry;
 175         git_index_entry new_entry = {{0}};
 176
 177         cl_git_pass(git_repository_index(&index, g_repo));
 178
 179         cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "A"));
 180         cl_git_mkfile(path.ptr, "A");
 181
 182         /* Put 'A' into the index */
 183         cl_git_pass(git_index_add_bypath(index, "A"));
 184
 185         cl_assert((a_entry = git_index_get_bypath(index, "A", 0)));
 186
 187         /* Put 'B' into the index */
 188         new_entry.path = "B";
 189         new_entry.mode = GIT_FILEMODE_BLOB;
 190         git_oid_cpy(&new_entry.id, &a_entry->id);
 191         cl_git_pass(git_index_add(index, &new_entry));
 192
 193         /* Put 'C' into the index */
 194         new_entry.path = "C";
 195         new_entry.mode = GIT_FILEMODE_BLOB;
 196         cl_git_pass(git_index_add_from_buffer(index, &new_entry, "hello!\n", 7));
 197
 198         git_index_free(index);
 199         git_buf_dispose(&path);
 200 }
 201
 202 void test_index_racy__adding_to_index_is_uptodate(void)
 203 {
 204         git_index *index;
 205         const git_index_entry *entry;
 206
 207         setup_uptodate_files();
 208
 209         cl_git_pass(git_repository_index(&index, g_repo));
 210
 211         /* ensure that they're all uptodate */
 212         cl_assert((entry = git_index_get_bypath(index, "A", 0)));
 213         cl_assert_equal_i(GIT_INDEX_ENTRY_UPTODATE, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 214
 215         cl_assert((entry = git_index_get_bypath(index, "B", 0)));
 216         cl_assert_equal_i(GIT_INDEX_ENTRY_UPTODATE, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 217
 218         cl_assert((entry = git_index_get_bypath(index, "C", 0)));
 219         cl_assert_equal_i(GIT_INDEX_ENTRY_UPTODATE, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 220
 221         cl_git_pass(git_index_write(index));
 222
 223         git_index_free(index);
 224 }
 225
 226 void test_index_racy__reading_clears_uptodate_bit(void)
 227 {
 228         git_index *index;
 229         const git_index_entry *entry;
 230
 231         setup_uptodate_files();
 232
 233         cl_git_pass(git_repository_index(&index, g_repo));
 234         cl_git_pass(git_index_write(index));
 235
 236         cl_git_pass(git_index_read(index, true));
 237
 238         /* ensure that no files are uptodate */
 239         cl_assert((entry = git_index_get_bypath(index, "A", 0)));
 240         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 241
 242         cl_assert((entry = git_index_get_bypath(index, "B", 0)));
 243         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 244
 245         cl_assert((entry = git_index_get_bypath(index, "C", 0)));
 246         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 247
 248         git_index_free(index);
 249 }
 250
 251 void test_index_racy__read_tree_clears_uptodate_bit(void)
 252 {
 253         git_index *index;
 254         git_tree *tree;
 255         const git_index_entry *entry;
 256         git_oid id;
 257
 258         setup_uptodate_files();
 259
 260         cl_git_pass(git_repository_index(&index, g_repo));
 261         cl_git_pass(git_index_write_tree_to(&id, index, g_repo));
 262         cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
 263         cl_git_pass(git_index_read_tree(index, tree));
 264
 265         /* ensure that no files are uptodate */
 266         cl_assert((entry = git_index_get_bypath(index, "A", 0)));
 267         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 268
 269         cl_assert((entry = git_index_get_bypath(index, "B", 0)));
 270         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 271
 272         cl_assert((entry = git_index_get_bypath(index, "C", 0)));
 273         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 274
 275         git_tree_free(tree);
 276         git_index_free(index);
 277 }
 278
 279 void test_index_racy__read_index_smudges(void)
 280 {
 281         git_index *index, *newindex;
 282         const git_index_entry *entry;
 283
 284         /* if we are reading an index into our new index, ensure that any
 285          * racy entries in the index that we're reading are smudged so that
 286          * we don't propagate their timestamps without further investigation.
 287          */
 288         setup_race();
 289
 290         cl_git_pass(git_repository_index(&index, g_repo));
 291         cl_git_pass(git_index_new(&newindex));
 292         cl_git_pass(git_index_read_index(newindex, index));
 293
 294         cl_assert(entry = git_index_get_bypath(newindex, "A", 0));
 295         cl_assert_equal_i(0, entry->file_size);
 296
 297         git_index_free(index);
 298         git_index_free(newindex);
 299 }
 300
 301 void test_index_racy__read_index_clears_uptodate_bit(void)
 302 {
 303         git_index *index, *newindex;
 304         const git_index_entry *entry;
 305
 306         setup_uptodate_files();
 307
 308         cl_git_pass(git_repository_index(&index, g_repo));
 309         cl_git_pass(git_index_new(&newindex));
 310         cl_git_pass(git_index_read_index(newindex, index));
 311
 312         /* ensure that files brought in from the other index are not uptodate */
 313         cl_assert((entry = git_index_get_bypath(newindex, "A", 0)));
 314         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 315
 316         cl_assert((entry = git_index_get_bypath(newindex, "B", 0)));
 317         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 318
 319         cl_assert((entry = git_index_get_bypath(newindex, "C", 0)));
 320         cl_assert_equal_i(0, (entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE));
 321
 322         git_index_free(index);
 323         git_index_free(newindex);
 324 }