reftable/stack_test.c

   1 /*
   2 Copyright 2020 Google LLC
   3
   4 Use of this source code is governed by a BSD-style
   5 license that can be found in the LICENSE file or at
   6 https://developers.google.com/open-source/licenses/bsd
   7 */
   8
   9 #include "stack.h"
  10
  11 #include "system.h"
  12
  13 #include "reftable-reader.h"
  14 #include "merged.h"
  15 #include "basics.h"
  16 #include "record.h"
  17 #include "test_framework.h"
  18 #include "reftable-tests.h"
  19 #include "reader.h"
  20
  21 #include <sys/types.h>
  22 #include <dirent.h>
  23
  24 static void clear_dir(const char *dirname)
  25 {
  26         struct strbuf path = STRBUF_INIT;
  27         strbuf_addstr(&path, dirname);
  28         remove_dir_recursively(&path, 0);
  29         strbuf_release(&path);
  30 }
  31
  32 static int count_dir_entries(const char *dirname)
  33 {
  34         DIR *dir = opendir(dirname);
  35         int len = 0;
  36         struct dirent *d;
  37         if (!dir)
  38                 return 0;
  39
  40         while ((d = readdir(dir))) {
  41                 if (!strcmp(d->d_name, "..") || !strcmp(d->d_name, "."))
  42                         continue;
  43                 len++;
  44         }
  45         closedir(dir);
  46         return len;
  47 }
  48
  49 /*
  50  * Work linenumber into the tempdir, so we can see which tests forget to
  51  * cleanup.
  52  */
  53 static char *get_tmp_template(int linenumber)
  54 {
  55         const char *tmp = getenv("TMPDIR");
  56         static char template[1024];
  57         snprintf(template, sizeof(template) - 1, "%s/stack_test-%d.XXXXXX",
  58                  tmp ? tmp : "/tmp", linenumber);
  59         return template;
  60 }
  61
  62 static char *get_tmp_dir(int linenumber)
  63 {
  64         char *dir = get_tmp_template(linenumber);
  65         EXPECT(mkdtemp(dir));
  66         return dir;
  67 }
  68
  69 static void test_read_file(void)
  70 {
  71         char *fn = get_tmp_template(__LINE__);
  72         int fd = mkstemp(fn);
  73         char out[1024] = "line1\n\nline2\nline3";
  74         int n, err;
  75         char **names = NULL;
  76         char *want[] = { "line1", "line2", "line3" };
  77         int i = 0;
  78
  79         EXPECT(fd > 0);
  80         n = write_in_full(fd, out, strlen(out));
  81         EXPECT(n == strlen(out));
  82         err = close(fd);
  83         EXPECT(err >= 0);
  84
  85         err = read_lines(fn, &names);
  86         EXPECT_ERR(err);
  87
  88         for (i = 0; names[i]; i++) {
  89                 EXPECT(0 == strcmp(want[i], names[i]));
  90         }
  91         free_names(names);
  92         (void) remove(fn);
  93 }
  94
  95 static void test_parse_names(void)
  96 {
  97         char buf[] = "line\n";
  98         char **names = NULL;
  99         parse_names(buf, strlen(buf), &names);
 100
 101         EXPECT(NULL != names[0]);
 102         EXPECT(0 == strcmp(names[0], "line"));
 103         EXPECT(NULL == names[1]);
 104         free_names(names);
 105 }
 106
 107 static void test_names_equal(void)
 108 {
 109         char *a[] = { "a", "b", "c", NULL };
 110         char *b[] = { "a", "b", "d", NULL };
 111         char *c[] = { "a", "b", NULL };
 112
 113         EXPECT(names_equal(a, a));
 114         EXPECT(!names_equal(a, b));
 115         EXPECT(!names_equal(a, c));
 116 }
 117
 118 static int write_test_ref(struct reftable_writer *wr, void *arg)
 119 {
 120         struct reftable_ref_record *ref = arg;
 121         reftable_writer_set_limits(wr, ref->update_index, ref->update_index);
 122         return reftable_writer_add_ref(wr, ref);
 123 }
 124
 125 struct write_log_arg {
 126         struct reftable_log_record *log;
 127         uint64_t update_index;
 128 };
 129
 130 static int write_test_log(struct reftable_writer *wr, void *arg)
 131 {
 132         struct write_log_arg *wla = arg;
 133
 134         reftable_writer_set_limits(wr, wla->update_index, wla->update_index);
 135         return reftable_writer_add_log(wr, wla->log);
 136 }
 137
 138 static void test_reftable_stack_add_one(void)
 139 {
 140         char *dir = get_tmp_dir(__LINE__);
 141         struct strbuf scratch = STRBUF_INIT;
 142         int mask = umask(002);
 143         struct reftable_write_options cfg = {
 144                 .default_permissions = 0660,
 145         };
 146         struct reftable_stack *st = NULL;
 147         int err;
 148         struct reftable_ref_record ref = {
 149                 .refname = "HEAD",
 150                 .update_index = 1,
 151                 .value_type = REFTABLE_REF_SYMREF,
 152                 .value.symref = "master",
 153         };
 154         struct reftable_ref_record dest = { NULL };
 155         struct stat stat_result = { 0 };
 156         err = reftable_new_stack(&st, dir, cfg);
 157         EXPECT_ERR(err);
 158
 159         err = reftable_stack_add(st, &write_test_ref, &ref);
 160         EXPECT_ERR(err);
 161
 162         err = reftable_stack_read_ref(st, ref.refname, &dest);
 163         EXPECT_ERR(err);
 164         EXPECT(0 == strcmp("master", dest.value.symref));
 165         EXPECT(st->readers_len > 0);
 166
 167         printf("testing print functionality:\n");
 168         err = reftable_stack_print_directory(dir, GIT_SHA1_FORMAT_ID);
 169         EXPECT_ERR(err);
 170
 171         err = reftable_stack_print_directory(dir, GIT_SHA256_FORMAT_ID);
 172         EXPECT(err == REFTABLE_FORMAT_ERROR);
 173
 174 #ifndef GIT_WINDOWS_NATIVE
 175         strbuf_addstr(&scratch, dir);
 176         strbuf_addstr(&scratch, "/tables.list");
 177         err = stat(scratch.buf, &stat_result);
 178         EXPECT(!err);
 179         EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
 180
 181         strbuf_reset(&scratch);
 182         strbuf_addstr(&scratch, dir);
 183         strbuf_addstr(&scratch, "/");
 184         /* do not try at home; not an external API for reftable. */
 185         strbuf_addstr(&scratch, st->readers[0]->name);
 186         err = stat(scratch.buf, &stat_result);
 187         EXPECT(!err);
 188         EXPECT((stat_result.st_mode & 0777) == cfg.default_permissions);
 189 #else
 190         (void) stat_result;
 191 #endif
 192
 193         reftable_ref_record_release(&dest);
 194         reftable_stack_destroy(st);
 195         strbuf_release(&scratch);
 196         clear_dir(dir);
 197         umask(mask);
 198 }
 199
 200 static void test_reftable_stack_uptodate(void)
 201 {
 202         struct reftable_write_options cfg = { 0 };
 203         struct reftable_stack *st1 = NULL;
 204         struct reftable_stack *st2 = NULL;
 205         char *dir = get_tmp_dir(__LINE__);
 206
 207         int err;
 208         struct reftable_ref_record ref1 = {
 209                 .refname = "HEAD",
 210                 .update_index = 1,
 211                 .value_type = REFTABLE_REF_SYMREF,
 212                 .value.symref = "master",
 213         };
 214         struct reftable_ref_record ref2 = {
 215                 .refname = "branch2",
 216                 .update_index = 2,
 217                 .value_type = REFTABLE_REF_SYMREF,
 218                 .value.symref = "master",
 219         };
 220
 221
 222         /* simulate multi-process access to the same stack
 223            by creating two stacks for the same directory.
 224          */
 225         err = reftable_new_stack(&st1, dir, cfg);
 226         EXPECT_ERR(err);
 227
 228         err = reftable_new_stack(&st2, dir, cfg);
 229         EXPECT_ERR(err);
 230
 231         err = reftable_stack_add(st1, &write_test_ref, &ref1);
 232         EXPECT_ERR(err);
 233
 234         err = reftable_stack_add(st2, &write_test_ref, &ref2);
 235         EXPECT(err == REFTABLE_LOCK_ERROR);
 236
 237         err = reftable_stack_reload(st2);
 238         EXPECT_ERR(err);
 239
 240         err = reftable_stack_add(st2, &write_test_ref, &ref2);
 241         EXPECT_ERR(err);
 242         reftable_stack_destroy(st1);
 243         reftable_stack_destroy(st2);
 244         clear_dir(dir);
 245 }
 246
 247 static void test_reftable_stack_transaction_api(void)
 248 {
 249         char *dir = get_tmp_dir(__LINE__);
 250
 251         struct reftable_write_options cfg = { 0 };
 252         struct reftable_stack *st = NULL;
 253         int err;
 254         struct reftable_addition *add = NULL;
 255
 256         struct reftable_ref_record ref = {
 257                 .refname = "HEAD",
 258                 .update_index = 1,
 259                 .value_type = REFTABLE_REF_SYMREF,
 260                 .value.symref = "master",
 261         };
 262         struct reftable_ref_record dest = { NULL };
 263
 264
 265         err = reftable_new_stack(&st, dir, cfg);
 266         EXPECT_ERR(err);
 267
 268         reftable_addition_destroy(add);
 269
 270         err = reftable_stack_new_addition(&add, st);
 271         EXPECT_ERR(err);
 272
 273         err = reftable_addition_add(add, &write_test_ref, &ref);
 274         EXPECT_ERR(err);
 275
 276         err = reftable_addition_commit(add);
 277         EXPECT_ERR(err);
 278
 279         reftable_addition_destroy(add);
 280
 281         err = reftable_stack_read_ref(st, ref.refname, &dest);
 282         EXPECT_ERR(err);
 283         EXPECT(REFTABLE_REF_SYMREF == dest.value_type);
 284         EXPECT(0 == strcmp("master", dest.value.symref));
 285
 286         reftable_ref_record_release(&dest);
 287         reftable_stack_destroy(st);
 288         clear_dir(dir);
 289 }
 290
 291 static void test_reftable_stack_transaction_api_performs_auto_compaction(void)
 292 {
 293         char *dir = get_tmp_dir(__LINE__);
 294         struct reftable_write_options cfg = {0};
 295         struct reftable_addition *add = NULL;
 296         struct reftable_stack *st = NULL;
 297         int i, n = 20, err;
 298
 299         err = reftable_new_stack(&st, dir, cfg);
 300         EXPECT_ERR(err);
 301
 302         for (i = 0; i <= n; i++) {
 303                 struct reftable_ref_record ref = {
 304                         .update_index = reftable_stack_next_update_index(st),
 305                         .value_type = REFTABLE_REF_SYMREF,
 306                         .value.symref = "master",
 307                 };
 308                 char name[100];
 309
 310                 snprintf(name, sizeof(name), "branch%04d", i);
 311                 ref.refname = name;
 312
 313                 /*
 314                  * Disable auto-compaction for all but the last runs. Like this
 315                  * we can ensure that we indeed honor this setting and have
 316                  * better control over when exactly auto compaction runs.
 317                  */
 318                 st->disable_auto_compact = i != n;
 319
 320                 err = reftable_stack_new_addition(&add, st);
 321                 EXPECT_ERR(err);
 322
 323                 err = reftable_addition_add(add, &write_test_ref, &ref);
 324                 EXPECT_ERR(err);
 325
 326                 err = reftable_addition_commit(add);
 327                 EXPECT_ERR(err);
 328
 329                 reftable_addition_destroy(add);
 330
 331                 /*
 332                  * The stack length should grow continuously for all runs where
 333                  * auto compaction is disabled. When enabled, we should merge
 334                  * all tables in the stack.
 335                  */
 336                 if (i != n)
 337                         EXPECT(st->merged->stack_len == i + 1);
 338                 else
 339                         EXPECT(st->merged->stack_len == 1);
 340         }
 341
 342         reftable_stack_destroy(st);
 343         clear_dir(dir);
 344 }
 345
 346 static void test_reftable_stack_validate_refname(void)
 347 {
 348         struct reftable_write_options cfg = { 0 };
 349         struct reftable_stack *st = NULL;
 350         int err;
 351         char *dir = get_tmp_dir(__LINE__);
 352
 353         int i;
 354         struct reftable_ref_record ref = {
 355                 .refname = "a/b",
 356                 .update_index = 1,
 357                 .value_type = REFTABLE_REF_SYMREF,
 358                 .value.symref = "master",
 359         };
 360         char *additions[] = { "a", "a/b/c" };
 361
 362         err = reftable_new_stack(&st, dir, cfg);
 363         EXPECT_ERR(err);
 364
 365         err = reftable_stack_add(st, &write_test_ref, &ref);
 366         EXPECT_ERR(err);
 367
 368         for (i = 0; i < ARRAY_SIZE(additions); i++) {
 369                 struct reftable_ref_record ref = {
 370                         .refname = additions[i],
 371                         .update_index = 1,
 372                         .value_type = REFTABLE_REF_SYMREF,
 373                         .value.symref = "master",
 374                 };
 375
 376                 err = reftable_stack_add(st, &write_test_ref, &ref);
 377                 EXPECT(err == REFTABLE_NAME_CONFLICT);
 378         }
 379
 380         reftable_stack_destroy(st);
 381         clear_dir(dir);
 382 }
 383
 384 static int write_error(struct reftable_writer *wr, void *arg)
 385 {
 386         return *((int *)arg);
 387 }
 388
 389 static void test_reftable_stack_update_index_check(void)
 390 {
 391         char *dir = get_tmp_dir(__LINE__);
 392
 393         struct reftable_write_options cfg = { 0 };
 394         struct reftable_stack *st = NULL;
 395         int err;
 396         struct reftable_ref_record ref1 = {
 397                 .refname = "name1",
 398                 .update_index = 1,
 399                 .value_type = REFTABLE_REF_SYMREF,
 400                 .value.symref = "master",
 401         };
 402         struct reftable_ref_record ref2 = {
 403                 .refname = "name2",
 404                 .update_index = 1,
 405                 .value_type = REFTABLE_REF_SYMREF,
 406                 .value.symref = "master",
 407         };
 408
 409         err = reftable_new_stack(&st, dir, cfg);
 410         EXPECT_ERR(err);
 411
 412         err = reftable_stack_add(st, &write_test_ref, &ref1);
 413         EXPECT_ERR(err);
 414
 415         err = reftable_stack_add(st, &write_test_ref, &ref2);
 416         EXPECT(err == REFTABLE_API_ERROR);
 417         reftable_stack_destroy(st);
 418         clear_dir(dir);
 419 }
 420
 421 static void test_reftable_stack_lock_failure(void)
 422 {
 423         char *dir = get_tmp_dir(__LINE__);
 424
 425         struct reftable_write_options cfg = { 0 };
 426         struct reftable_stack *st = NULL;
 427         int err, i;
 428
 429         err = reftable_new_stack(&st, dir, cfg);
 430         EXPECT_ERR(err);
 431         for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
 432                 err = reftable_stack_add(st, &write_error, &i);
 433                 EXPECT(err == i);
 434         }
 435
 436         reftable_stack_destroy(st);
 437         clear_dir(dir);
 438 }
 439
 440 static void test_reftable_stack_add(void)
 441 {
 442         int i = 0;
 443         int err = 0;
 444         struct reftable_write_options cfg = {
 445                 .exact_log_message = 1,
 446         };
 447         struct reftable_stack *st = NULL;
 448         char *dir = get_tmp_dir(__LINE__);
 449
 450         struct reftable_ref_record refs[2] = { { NULL } };
 451         struct reftable_log_record logs[2] = { { NULL } };
 452         int N = ARRAY_SIZE(refs);
 453
 454
 455         err = reftable_new_stack(&st, dir, cfg);
 456         EXPECT_ERR(err);
 457         st->disable_auto_compact = 1;
 458
 459         for (i = 0; i < N; i++) {
 460                 char buf[256];
 461                 snprintf(buf, sizeof(buf), "branch%02d", i);
 462                 refs[i].refname = xstrdup(buf);
 463                 refs[i].update_index = i + 1;
 464                 refs[i].value_type = REFTABLE_REF_VAL1;
 465                 refs[i].value.val1 = reftable_malloc(GIT_SHA1_RAWSZ);
 466                 set_test_hash(refs[i].value.val1, i);
 467
 468                 logs[i].refname = xstrdup(buf);
 469                 logs[i].update_index = N + i + 1;
 470                 logs[i].value_type = REFTABLE_LOG_UPDATE;
 471
 472                 logs[i].value.update.new_hash = reftable_malloc(GIT_SHA1_RAWSZ);
 473                 logs[i].value.update.email = xstrdup("identity@invalid");
 474                 set_test_hash(logs[i].value.update.new_hash, i);
 475         }
 476
 477         for (i = 0; i < N; i++) {
 478                 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
 479                 EXPECT_ERR(err);
 480         }
 481
 482         for (i = 0; i < N; i++) {
 483                 struct write_log_arg arg = {
 484                         .log = &logs[i],
 485                         .update_index = reftable_stack_next_update_index(st),
 486                 };
 487                 int err = reftable_stack_add(st, &write_test_log, &arg);
 488                 EXPECT_ERR(err);
 489         }
 490
 491         err = reftable_stack_compact_all(st, NULL);
 492         EXPECT_ERR(err);
 493
 494         for (i = 0; i < N; i++) {
 495                 struct reftable_ref_record dest = { NULL };
 496
 497                 int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
 498                 EXPECT_ERR(err);
 499                 EXPECT(reftable_ref_record_equal(&dest, refs + i,
 500                                                  GIT_SHA1_RAWSZ));
 501                 reftable_ref_record_release(&dest);
 502         }
 503
 504         for (i = 0; i < N; i++) {
 505                 struct reftable_log_record dest = { NULL };
 506                 int err = reftable_stack_read_log(st, refs[i].refname, &dest);
 507                 EXPECT_ERR(err);
 508                 EXPECT(reftable_log_record_equal(&dest, logs + i,
 509                                                  GIT_SHA1_RAWSZ));
 510                 reftable_log_record_release(&dest);
 511         }
 512
 513         /* cleanup */
 514         reftable_stack_destroy(st);
 515         for (i = 0; i < N; i++) {
 516                 reftable_ref_record_release(&refs[i]);
 517                 reftable_log_record_release(&logs[i]);
 518         }
 519         clear_dir(dir);
 520 }
 521
 522 static void test_reftable_stack_log_normalize(void)
 523 {
 524         int err = 0;
 525         struct reftable_write_options cfg = {
 526                 0,
 527         };
 528         struct reftable_stack *st = NULL;
 529         char *dir = get_tmp_dir(__LINE__);
 530
 531         uint8_t h1[GIT_SHA1_RAWSZ] = { 0x01 }, h2[GIT_SHA1_RAWSZ] = { 0x02 };
 532
 533         struct reftable_log_record input = { .refname = "branch",
 534                                              .update_index = 1,
 535                                              .value_type = REFTABLE_LOG_UPDATE,
 536                                              .value = { .update = {
 537                                                                 .new_hash = h1,
 538                                                                 .old_hash = h2,
 539                                                         } } };
 540         struct reftable_log_record dest = {
 541                 .update_index = 0,
 542         };
 543         struct write_log_arg arg = {
 544                 .log = &input,
 545                 .update_index = 1,
 546         };
 547
 548         err = reftable_new_stack(&st, dir, cfg);
 549         EXPECT_ERR(err);
 550
 551         input.value.update.message = "one\ntwo";
 552         err = reftable_stack_add(st, &write_test_log, &arg);
 553         EXPECT(err == REFTABLE_API_ERROR);
 554
 555         input.value.update.message = "one";
 556         err = reftable_stack_add(st, &write_test_log, &arg);
 557         EXPECT_ERR(err);
 558
 559         err = reftable_stack_read_log(st, input.refname, &dest);
 560         EXPECT_ERR(err);
 561         EXPECT(0 == strcmp(dest.value.update.message, "one\n"));
 562
 563         input.value.update.message = "two\n";
 564         arg.update_index = 2;
 565         err = reftable_stack_add(st, &write_test_log, &arg);
 566         EXPECT_ERR(err);
 567         err = reftable_stack_read_log(st, input.refname, &dest);
 568         EXPECT_ERR(err);
 569         EXPECT(0 == strcmp(dest.value.update.message, "two\n"));
 570
 571         /* cleanup */
 572         reftable_stack_destroy(st);
 573         reftable_log_record_release(&dest);
 574         clear_dir(dir);
 575 }
 576
 577 static void test_reftable_stack_tombstone(void)
 578 {
 579         int i = 0;
 580         char *dir = get_tmp_dir(__LINE__);
 581
 582         struct reftable_write_options cfg = { 0 };
 583         struct reftable_stack *st = NULL;
 584         int err;
 585         struct reftable_ref_record refs[2] = { { NULL } };
 586         struct reftable_log_record logs[2] = { { NULL } };
 587         int N = ARRAY_SIZE(refs);
 588         struct reftable_ref_record dest = { NULL };
 589         struct reftable_log_record log_dest = { NULL };
 590
 591
 592         err = reftable_new_stack(&st, dir, cfg);
 593         EXPECT_ERR(err);
 594
 595         /* even entries add the refs, odd entries delete them. */
 596         for (i = 0; i < N; i++) {
 597                 const char *buf = "branch";
 598                 refs[i].refname = xstrdup(buf);
 599                 refs[i].update_index = i + 1;
 600                 if (i % 2 == 0) {
 601                         refs[i].value_type = REFTABLE_REF_VAL1;
 602                         refs[i].value.val1 = reftable_malloc(GIT_SHA1_RAWSZ);
 603                         set_test_hash(refs[i].value.val1, i);
 604                 }
 605
 606                 logs[i].refname = xstrdup(buf);
 607                 /* update_index is part of the key. */
 608                 logs[i].update_index = 42;
 609                 if (i % 2 == 0) {
 610                         logs[i].value_type = REFTABLE_LOG_UPDATE;
 611                         logs[i].value.update.new_hash =
 612                                 reftable_malloc(GIT_SHA1_RAWSZ);
 613                         set_test_hash(logs[i].value.update.new_hash, i);
 614                         logs[i].value.update.email =
 615                                 xstrdup("identity@invalid");
 616                 }
 617         }
 618         for (i = 0; i < N; i++) {
 619                 int err = reftable_stack_add(st, &write_test_ref, &refs[i]);
 620                 EXPECT_ERR(err);
 621         }
 622
 623         for (i = 0; i < N; i++) {
 624                 struct write_log_arg arg = {
 625                         .log = &logs[i],
 626                         .update_index = reftable_stack_next_update_index(st),
 627                 };
 628                 int err = reftable_stack_add(st, &write_test_log, &arg);
 629                 EXPECT_ERR(err);
 630         }
 631
 632         err = reftable_stack_read_ref(st, "branch", &dest);
 633         EXPECT(err == 1);
 634         reftable_ref_record_release(&dest);
 635
 636         err = reftable_stack_read_log(st, "branch", &log_dest);
 637         EXPECT(err == 1);
 638         reftable_log_record_release(&log_dest);
 639
 640         err = reftable_stack_compact_all(st, NULL);
 641         EXPECT_ERR(err);
 642
 643         err = reftable_stack_read_ref(st, "branch", &dest);
 644         EXPECT(err == 1);
 645
 646         err = reftable_stack_read_log(st, "branch", &log_dest);
 647         EXPECT(err == 1);
 648         reftable_ref_record_release(&dest);
 649         reftable_log_record_release(&log_dest);
 650
 651         /* cleanup */
 652         reftable_stack_destroy(st);
 653         for (i = 0; i < N; i++) {
 654                 reftable_ref_record_release(&refs[i]);
 655                 reftable_log_record_release(&logs[i]);
 656         }
 657         clear_dir(dir);
 658 }
 659
 660 static void test_reftable_stack_hash_id(void)
 661 {
 662         char *dir = get_tmp_dir(__LINE__);
 663
 664         struct reftable_write_options cfg = { 0 };
 665         struct reftable_stack *st = NULL;
 666         int err;
 667
 668         struct reftable_ref_record ref = {
 669                 .refname = "master",
 670                 .value_type = REFTABLE_REF_SYMREF,
 671                 .value.symref = "target",
 672                 .update_index = 1,
 673         };
 674         struct reftable_write_options cfg32 = { .hash_id = GIT_SHA256_FORMAT_ID };
 675         struct reftable_stack *st32 = NULL;
 676         struct reftable_write_options cfg_default = { 0 };
 677         struct reftable_stack *st_default = NULL;
 678         struct reftable_ref_record dest = { NULL };
 679
 680         err = reftable_new_stack(&st, dir, cfg);
 681         EXPECT_ERR(err);
 682
 683         err = reftable_stack_add(st, &write_test_ref, &ref);
 684         EXPECT_ERR(err);
 685
 686         /* can't read it with the wrong hash ID. */
 687         err = reftable_new_stack(&st32, dir, cfg32);
 688         EXPECT(err == REFTABLE_FORMAT_ERROR);
 689
 690         /* check that we can read it back with default config too. */
 691         err = reftable_new_stack(&st_default, dir, cfg_default);
 692         EXPECT_ERR(err);
 693
 694         err = reftable_stack_read_ref(st_default, "master", &dest);
 695         EXPECT_ERR(err);
 696
 697         EXPECT(reftable_ref_record_equal(&ref, &dest, GIT_SHA1_RAWSZ));
 698         reftable_ref_record_release(&dest);
 699         reftable_stack_destroy(st);
 700         reftable_stack_destroy(st_default);
 701         clear_dir(dir);
 702 }
 703
 704 static void test_log2(void)
 705 {
 706         EXPECT(1 == fastlog2(3));
 707         EXPECT(2 == fastlog2(4));
 708         EXPECT(2 == fastlog2(5));
 709 }
 710
 711 static void test_sizes_to_segments(void)
 712 {
 713         uint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };
 714         /* .................0  1  2  3  4  5 */
 715
 716         int seglen = 0;
 717         struct segment *segs =
 718                 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
 719         EXPECT(segs[2].log == 3);
 720         EXPECT(segs[2].start == 5);
 721         EXPECT(segs[2].end == 6);
 722
 723         EXPECT(segs[1].log == 2);
 724         EXPECT(segs[1].start == 2);
 725         EXPECT(segs[1].end == 5);
 726         reftable_free(segs);
 727 }
 728
 729 static void test_sizes_to_segments_empty(void)
 730 {
 731         int seglen = 0;
 732         struct segment *segs = sizes_to_segments(&seglen, NULL, 0);
 733         EXPECT(seglen == 0);
 734         reftable_free(segs);
 735 }
 736
 737 static void test_sizes_to_segments_all_equal(void)
 738 {
 739         uint64_t sizes[] = { 5, 5 };
 740
 741         int seglen = 0;
 742         struct segment *segs =
 743                 sizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));
 744         EXPECT(seglen == 1);
 745         EXPECT(segs[0].start == 0);
 746         EXPECT(segs[0].end == 2);
 747         reftable_free(segs);
 748 }
 749
 750 static void test_suggest_compaction_segment(void)
 751 {
 752         uint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };
 753         /* .................0    1    2  3   4  5  6 */
 754         struct segment min =
 755                 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
 756         EXPECT(min.start == 2);
 757         EXPECT(min.end == 7);
 758 }
 759
 760 static void test_suggest_compaction_segment_nothing(void)
 761 {
 762         uint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };
 763         struct segment result =
 764                 suggest_compaction_segment(sizes, ARRAY_SIZE(sizes));
 765         EXPECT(result.start == result.end);
 766 }
 767
 768 static void test_reflog_expire(void)
 769 {
 770         char *dir = get_tmp_dir(__LINE__);
 771
 772         struct reftable_write_options cfg = { 0 };
 773         struct reftable_stack *st = NULL;
 774         struct reftable_log_record logs[20] = { { NULL } };
 775         int N = ARRAY_SIZE(logs) - 1;
 776         int i = 0;
 777         int err;
 778         struct reftable_log_expiry_config expiry = {
 779                 .time = 10,
 780         };
 781         struct reftable_log_record log = { NULL };
 782
 783
 784         err = reftable_new_stack(&st, dir, cfg);
 785         EXPECT_ERR(err);
 786
 787         for (i = 1; i <= N; i++) {
 788                 char buf[256];
 789                 snprintf(buf, sizeof(buf), "branch%02d", i);
 790
 791                 logs[i].refname = xstrdup(buf);
 792                 logs[i].update_index = i;
 793                 logs[i].value_type = REFTABLE_LOG_UPDATE;
 794                 logs[i].value.update.time = i;
 795                 logs[i].value.update.new_hash = reftable_malloc(GIT_SHA1_RAWSZ);
 796                 logs[i].value.update.email = xstrdup("identity@invalid");
 797                 set_test_hash(logs[i].value.update.new_hash, i);
 798         }
 799
 800         for (i = 1; i <= N; i++) {
 801                 struct write_log_arg arg = {
 802                         .log = &logs[i],
 803                         .update_index = reftable_stack_next_update_index(st),
 804                 };
 805                 int err = reftable_stack_add(st, &write_test_log, &arg);
 806                 EXPECT_ERR(err);
 807         }
 808
 809         err = reftable_stack_compact_all(st, NULL);
 810         EXPECT_ERR(err);
 811
 812         err = reftable_stack_compact_all(st, &expiry);
 813         EXPECT_ERR(err);
 814
 815         err = reftable_stack_read_log(st, logs[9].refname, &log);
 816         EXPECT(err == 1);
 817
 818         err = reftable_stack_read_log(st, logs[11].refname, &log);
 819         EXPECT_ERR(err);
 820
 821         expiry.min_update_index = 15;
 822         err = reftable_stack_compact_all(st, &expiry);
 823         EXPECT_ERR(err);
 824
 825         err = reftable_stack_read_log(st, logs[14].refname, &log);
 826         EXPECT(err == 1);
 827
 828         err = reftable_stack_read_log(st, logs[16].refname, &log);
 829         EXPECT_ERR(err);
 830
 831         /* cleanup */
 832         reftable_stack_destroy(st);
 833         for (i = 0; i <= N; i++) {
 834                 reftable_log_record_release(&logs[i]);
 835         }
 836         clear_dir(dir);
 837         reftable_log_record_release(&log);
 838 }
 839
 840 static int write_nothing(struct reftable_writer *wr, void *arg)
 841 {
 842         reftable_writer_set_limits(wr, 1, 1);
 843         return 0;
 844 }
 845
 846 static void test_empty_add(void)
 847 {
 848         struct reftable_write_options cfg = { 0 };
 849         struct reftable_stack *st = NULL;
 850         int err;
 851         char *dir = get_tmp_dir(__LINE__);
 852
 853         struct reftable_stack *st2 = NULL;
 854
 855
 856         err = reftable_new_stack(&st, dir, cfg);
 857         EXPECT_ERR(err);
 858
 859         err = reftable_stack_add(st, &write_nothing, NULL);
 860         EXPECT_ERR(err);
 861
 862         err = reftable_new_stack(&st2, dir, cfg);
 863         EXPECT_ERR(err);
 864         clear_dir(dir);
 865         reftable_stack_destroy(st);
 866         reftable_stack_destroy(st2);
 867 }
 868
 869 static void test_reftable_stack_auto_compaction(void)
 870 {
 871         struct reftable_write_options cfg = { 0 };
 872         struct reftable_stack *st = NULL;
 873         char *dir = get_tmp_dir(__LINE__);
 874
 875         int err, i;
 876         int N = 100;
 877
 878         err = reftable_new_stack(&st, dir, cfg);
 879         EXPECT_ERR(err);
 880
 881         st->disable_auto_compact = 1; /* call manually below for coverage. */
 882         for (i = 0; i < N; i++) {
 883                 char name[100];
 884                 struct reftable_ref_record ref = {
 885                         .refname = name,
 886                         .update_index = reftable_stack_next_update_index(st),
 887                         .value_type = REFTABLE_REF_SYMREF,
 888                         .value.symref = "master",
 889                 };
 890                 snprintf(name, sizeof(name), "branch%04d", i);
 891
 892                 err = reftable_stack_add(st, &write_test_ref, &ref);
 893                 EXPECT_ERR(err);
 894
 895                 err = reftable_stack_auto_compact(st);
 896                 EXPECT_ERR(err);
 897                 EXPECT(i < 3 || st->merged->stack_len < 2 * fastlog2(i));
 898         }
 899
 900         EXPECT(reftable_stack_compaction_stats(st)->entries_written <
 901                (uint64_t)(N * fastlog2(N)));
 902
 903         reftable_stack_destroy(st);
 904         clear_dir(dir);
 905 }
 906
 907 static void test_reftable_stack_add_performs_auto_compaction(void)
 908 {
 909         struct reftable_write_options cfg = { 0 };
 910         struct reftable_stack *st = NULL;
 911         struct strbuf refname = STRBUF_INIT;
 912         char *dir = get_tmp_dir(__LINE__);
 913         int err, i, n = 20;
 914
 915         err = reftable_new_stack(&st, dir, cfg);
 916         EXPECT_ERR(err);
 917
 918         for (i = 0; i <= n; i++) {
 919                 struct reftable_ref_record ref = {
 920                         .update_index = reftable_stack_next_update_index(st),
 921                         .value_type = REFTABLE_REF_SYMREF,
 922                         .value.symref = "master",
 923                 };
 924
 925                 /*
 926                  * Disable auto-compaction for all but the last runs. Like this
 927                  * we can ensure that we indeed honor this setting and have
 928                  * better control over when exactly auto compaction runs.
 929                  */
 930                 st->disable_auto_compact = i != n;
 931
 932                 strbuf_reset(&refname);
 933                 strbuf_addf(&refname, "branch-%04d", i);
 934                 ref.refname = refname.buf;
 935
 936                 err = reftable_stack_add(st, &write_test_ref, &ref);
 937                 EXPECT_ERR(err);
 938
 939                 /*
 940                  * The stack length should grow continuously for all runs where
 941                  * auto compaction is disabled. When enabled, we should merge
 942                  * all tables in the stack.
 943                  */
 944                 if (i != n)
 945                         EXPECT(st->merged->stack_len == i + 1);
 946                 else
 947                         EXPECT(st->merged->stack_len == 1);
 948         }
 949
 950         reftable_stack_destroy(st);
 951         strbuf_release(&refname);
 952         clear_dir(dir);
 953 }
 954
 955 static void test_reftable_stack_compaction_concurrent(void)
 956 {
 957         struct reftable_write_options cfg = { 0 };
 958         struct reftable_stack *st1 = NULL, *st2 = NULL;
 959         char *dir = get_tmp_dir(__LINE__);
 960
 961         int err, i;
 962         int N = 3;
 963
 964         err = reftable_new_stack(&st1, dir, cfg);
 965         EXPECT_ERR(err);
 966
 967         for (i = 0; i < N; i++) {
 968                 char name[100];
 969                 struct reftable_ref_record ref = {
 970                         .refname = name,
 971                         .update_index = reftable_stack_next_update_index(st1),
 972                         .value_type = REFTABLE_REF_SYMREF,
 973                         .value.symref = "master",
 974                 };
 975                 snprintf(name, sizeof(name), "branch%04d", i);
 976
 977                 err = reftable_stack_add(st1, &write_test_ref, &ref);
 978                 EXPECT_ERR(err);
 979         }
 980
 981         err = reftable_new_stack(&st2, dir, cfg);
 982         EXPECT_ERR(err);
 983
 984         err = reftable_stack_compact_all(st1, NULL);
 985         EXPECT_ERR(err);
 986
 987         reftable_stack_destroy(st1);
 988         reftable_stack_destroy(st2);
 989
 990         EXPECT(count_dir_entries(dir) == 2);
 991         clear_dir(dir);
 992 }
 993
 994 static void unclean_stack_close(struct reftable_stack *st)
 995 {
 996         /* break abstraction boundary to simulate unclean shutdown. */
 997         int i = 0;
 998         for (; i < st->readers_len; i++) {
 999                 reftable_reader_free(st->readers[i]);
1000         }
1001         st->readers_len = 0;
1002         FREE_AND_NULL(st->readers);
1003 }
1004
1005 static void test_reftable_stack_compaction_concurrent_clean(void)
1006 {
1007         struct reftable_write_options cfg = { 0 };
1008         struct reftable_stack *st1 = NULL, *st2 = NULL, *st3 = NULL;
1009         char *dir = get_tmp_dir(__LINE__);
1010
1011         int err, i;
1012         int N = 3;
1013
1014         err = reftable_new_stack(&st1, dir, cfg);
1015         EXPECT_ERR(err);
1016
1017         for (i = 0; i < N; i++) {
1018                 char name[100];
1019                 struct reftable_ref_record ref = {
1020                         .refname = name,
1021                         .update_index = reftable_stack_next_update_index(st1),
1022                         .value_type = REFTABLE_REF_SYMREF,
1023                         .value.symref = "master",
1024                 };
1025                 snprintf(name, sizeof(name), "branch%04d", i);
1026
1027                 err = reftable_stack_add(st1, &write_test_ref, &ref);
1028                 EXPECT_ERR(err);
1029         }
1030
1031         err = reftable_new_stack(&st2, dir, cfg);
1032         EXPECT_ERR(err);
1033
1034         err = reftable_stack_compact_all(st1, NULL);
1035         EXPECT_ERR(err);
1036
1037         unclean_stack_close(st1);
1038         unclean_stack_close(st2);
1039
1040         err = reftable_new_stack(&st3, dir, cfg);
1041         EXPECT_ERR(err);
1042
1043         err = reftable_stack_clean(st3);
1044         EXPECT_ERR(err);
1045         EXPECT(count_dir_entries(dir) == 2);
1046
1047         reftable_stack_destroy(st1);
1048         reftable_stack_destroy(st2);
1049         reftable_stack_destroy(st3);
1050
1051         clear_dir(dir);
1052 }
1053
1054 int stack_test_main(int argc, const char *argv[])
1055 {
1056         RUN_TEST(test_empty_add);
1057         RUN_TEST(test_log2);
1058         RUN_TEST(test_names_equal);
1059         RUN_TEST(test_parse_names);
1060         RUN_TEST(test_read_file);
1061         RUN_TEST(test_reflog_expire);
1062         RUN_TEST(test_reftable_stack_add);
1063         RUN_TEST(test_reftable_stack_add_one);
1064         RUN_TEST(test_reftable_stack_auto_compaction);
1065         RUN_TEST(test_reftable_stack_add_performs_auto_compaction);
1066         RUN_TEST(test_reftable_stack_compaction_concurrent);
1067         RUN_TEST(test_reftable_stack_compaction_concurrent_clean);
1068         RUN_TEST(test_reftable_stack_hash_id);
1069         RUN_TEST(test_reftable_stack_lock_failure);
1070         RUN_TEST(test_reftable_stack_log_normalize);
1071         RUN_TEST(test_reftable_stack_tombstone);
1072         RUN_TEST(test_reftable_stack_transaction_api);
1073         RUN_TEST(test_reftable_stack_transaction_api_performs_auto_compaction);
1074         RUN_TEST(test_reftable_stack_update_index_check);
1075         RUN_TEST(test_reftable_stack_uptodate);
1076         RUN_TEST(test_reftable_stack_validate_refname);
1077         RUN_TEST(test_sizes_to_segments);
1078         RUN_TEST(test_sizes_to_segments_all_equal);
1079         RUN_TEST(test_sizes_to_segments_empty);
1080         RUN_TEST(test_suggest_compaction_segment);
1081         RUN_TEST(test_suggest_compaction_segment_nothing);
1082         return 0;
1083 }