t/helper/test-ref-store.c

   1 #include "test-tool.h"
   2 #include "cache.h"
   3 #include "refs.h"
   4 #include "worktree.h"
   5 #include "object-store.h"
   6 #include "repository.h"
   7
   8 static const char *notnull(const char *arg, const char *name)
   9 {
  10         if (!arg)
  11                 die("%s required", name);
  12         return arg;
  13 }
  14
  15 static unsigned int arg_flags(const char *arg, const char *name)
  16 {
  17         return atoi(notnull(arg, name));
  18 }
  19
  20 static const char **get_store(const char **argv, struct ref_store **refs)
  21 {
  22         const char *gitdir;
  23
  24         if (!argv[0]) {
  25                 die("ref store required");
  26         } else if (!strcmp(argv[0], "main")) {
  27                 *refs = get_main_ref_store(the_repository);
  28         } else if (skip_prefix(argv[0], "submodule:", &gitdir)) {
  29                 struct strbuf sb = STRBUF_INIT;
  30                 int ret;
  31
  32                 ret = strbuf_git_path_submodule(&sb, gitdir, "objects/");
  33                 if (ret)
  34                         die("strbuf_git_path_submodule failed: %d", ret);
  35                 add_to_alternates_memory(sb.buf);
  36                 strbuf_release(&sb);
  37
  38                 *refs = get_submodule_ref_store(gitdir);
  39         } else if (skip_prefix(argv[0], "worktree:", &gitdir)) {
  40                 struct worktree **p, **worktrees = get_worktrees();
  41
  42                 for (p = worktrees; *p; p++) {
  43                         struct worktree *wt = *p;
  44
  45                         if (!wt->id) {
  46                                 /* special case for main worktree */
  47                                 if (!strcmp(gitdir, "main"))
  48                                         break;
  49                         } else if (!strcmp(gitdir, wt->id))
  50                                 break;
  51                 }
  52                 if (!*p)
  53                         die("no such worktree: %s", gitdir);
  54
  55                 *refs = get_worktree_ref_store(*p);
  56         } else
  57                 die("unknown backend %s", argv[0]);
  58
  59         if (!*refs)
  60                 die("no ref store");
  61
  62         /* consume store-specific optional arguments if needed */
  63
  64         return argv + 1;
  65 }
  66
  67
  68 static int cmd_pack_refs(struct ref_store *refs, const char **argv)
  69 {
  70         unsigned int flags = arg_flags(*argv++, "flags");
  71
  72         return refs_pack_refs(refs, flags);
  73 }
  74
  75 static int cmd_peel_ref(struct ref_store *refs, const char **argv)
  76 {
  77         const char *refname = notnull(*argv++, "refname");
  78         struct object_id oid;
  79         int ret;
  80
  81         ret = refs_peel_ref(refs, refname, &oid);
  82         if (!ret)
  83                 puts(oid_to_hex(&oid));
  84         return ret;
  85 }
  86
  87 static int cmd_create_symref(struct ref_store *refs, const char **argv)
  88 {
  89         const char *refname = notnull(*argv++, "refname");
  90         const char *target = notnull(*argv++, "target");
  91         const char *logmsg = *argv++;
  92
  93         return refs_create_symref(refs, refname, target, logmsg);
  94 }
  95
  96 static int cmd_delete_refs(struct ref_store *refs, const char **argv)
  97 {
  98         unsigned int flags = arg_flags(*argv++, "flags");
  99         const char *msg = *argv++;
 100         struct string_list refnames = STRING_LIST_INIT_NODUP;
 101
 102         while (*argv)
 103                 string_list_append(&refnames, *argv++);
 104
 105         return refs_delete_refs(refs, msg, &refnames, flags);
 106 }
 107
 108 static int cmd_rename_ref(struct ref_store *refs, const char **argv)
 109 {
 110         const char *oldref = notnull(*argv++, "oldref");
 111         const char *newref = notnull(*argv++, "newref");
 112         const char *logmsg = *argv++;
 113
 114         return refs_rename_ref(refs, oldref, newref, logmsg);
 115 }
 116
 117 static int each_ref(const char *refname, const struct object_id *oid,
 118                     int flags, void *cb_data)
 119 {
 120         printf("%s %s 0x%x\n", oid_to_hex(oid), refname, flags);
 121         return 0;
 122 }
 123
 124 static int cmd_for_each_ref(struct ref_store *refs, const char **argv)
 125 {
 126         const char *prefix = notnull(*argv++, "prefix");
 127
 128         return refs_for_each_ref_in(refs, prefix, each_ref, NULL);
 129 }
 130
 131 static int cmd_resolve_ref(struct ref_store *refs, const char **argv)
 132 {
 133         struct object_id oid;
 134         const char *refname = notnull(*argv++, "refname");
 135         int resolve_flags = arg_flags(*argv++, "resolve-flags");
 136         int flags;
 137         const char *ref;
 138
 139         ref = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
 140                                       &oid, &flags);
 141         printf("%s %s 0x%x\n", oid_to_hex(&oid), ref ? ref : "(null)", flags);
 142         return ref ? 0 : 1;
 143 }
 144
 145 static int cmd_verify_ref(struct ref_store *refs, const char **argv)
 146 {
 147         const char *refname = notnull(*argv++, "refname");
 148         struct strbuf err = STRBUF_INIT;
 149         int ret;
 150
 151         ret = refs_verify_refname_available(refs, refname, NULL, NULL, &err);
 152         if (err.len)
 153                 puts(err.buf);
 154         return ret;
 155 }
 156
 157 static int cmd_for_each_reflog(struct ref_store *refs, const char **argv)
 158 {
 159         return refs_for_each_reflog(refs, each_ref, NULL);
 160 }
 161
 162 static int each_reflog(struct object_id *old_oid, struct object_id *new_oid,
 163                        const char *committer, timestamp_t timestamp,
 164                        int tz, const char *msg, void *cb_data)
 165 {
 166         printf("%s %s %s %"PRItime" %d %s\n",
 167                oid_to_hex(old_oid), oid_to_hex(new_oid),
 168                committer, timestamp, tz, msg);
 169         return 0;
 170 }
 171
 172 static int cmd_for_each_reflog_ent(struct ref_store *refs, const char **argv)
 173 {
 174         const char *refname = notnull(*argv++, "refname");
 175
 176         return refs_for_each_reflog_ent(refs, refname, each_reflog, refs);
 177 }
 178
 179 static int cmd_for_each_reflog_ent_reverse(struct ref_store *refs, const char **argv)
 180 {
 181         const char *refname = notnull(*argv++, "refname");
 182
 183         return refs_for_each_reflog_ent_reverse(refs, refname, each_reflog, refs);
 184 }
 185
 186 static int cmd_reflog_exists(struct ref_store *refs, const char **argv)
 187 {
 188         const char *refname = notnull(*argv++, "refname");
 189
 190         return !refs_reflog_exists(refs, refname);
 191 }
 192
 193 static int cmd_create_reflog(struct ref_store *refs, const char **argv)
 194 {
 195         const char *refname = notnull(*argv++, "refname");
 196         int force_create = arg_flags(*argv++, "force-create");
 197         struct strbuf err = STRBUF_INIT;
 198         int ret;
 199
 200         ret = refs_create_reflog(refs, refname, force_create, &err);
 201         if (err.len)
 202                 puts(err.buf);
 203         return ret;
 204 }
 205
 206 static int cmd_delete_reflog(struct ref_store *refs, const char **argv)
 207 {
 208         const char *refname = notnull(*argv++, "refname");
 209
 210         return refs_delete_reflog(refs, refname);
 211 }
 212
 213 static int cmd_reflog_expire(struct ref_store *refs, const char **argv)
 214 {
 215         die("not supported yet");
 216 }
 217
 218 static int cmd_delete_ref(struct ref_store *refs, const char **argv)
 219 {
 220         const char *msg = notnull(*argv++, "msg");
 221         const char *refname = notnull(*argv++, "refname");
 222         const char *sha1_buf = notnull(*argv++, "old-sha1");
 223         unsigned int flags = arg_flags(*argv++, "flags");
 224         struct object_id old_oid;
 225
 226         if (get_oid_hex(sha1_buf, &old_oid))
 227                 die("not sha-1");
 228
 229         return refs_delete_ref(refs, msg, refname, &old_oid, flags);
 230 }
 231
 232 static int cmd_update_ref(struct ref_store *refs, const char **argv)
 233 {
 234         const char *msg = notnull(*argv++, "msg");
 235         const char *refname = notnull(*argv++, "refname");
 236         const char *new_sha1_buf = notnull(*argv++, "new-sha1");
 237         const char *old_sha1_buf = notnull(*argv++, "old-sha1");
 238         unsigned int flags = arg_flags(*argv++, "flags");
 239         struct object_id old_oid;
 240         struct object_id new_oid;
 241
 242         if (get_oid_hex(old_sha1_buf, &old_oid) ||
 243             get_oid_hex(new_sha1_buf, &new_oid))
 244                 die("not sha-1");
 245
 246         return refs_update_ref(refs, msg, refname,
 247                                &new_oid, &old_oid,
 248                                flags, UPDATE_REFS_DIE_ON_ERR);
 249 }
 250
 251 struct command {
 252         const char *name;
 253         int (*func)(struct ref_store *refs, const char **argv);
 254 };
 255
 256 static struct command commands[] = {
 257         { "pack-refs", cmd_pack_refs },
 258         { "peel-ref", cmd_peel_ref },
 259         { "create-symref", cmd_create_symref },
 260         { "delete-refs", cmd_delete_refs },
 261         { "rename-ref", cmd_rename_ref },
 262         { "for-each-ref", cmd_for_each_ref },
 263         { "resolve-ref", cmd_resolve_ref },
 264         { "verify-ref", cmd_verify_ref },
 265         { "for-each-reflog", cmd_for_each_reflog },
 266         { "for-each-reflog-ent", cmd_for_each_reflog_ent },
 267         { "for-each-reflog-ent-reverse", cmd_for_each_reflog_ent_reverse },
 268         { "reflog-exists", cmd_reflog_exists },
 269         { "create-reflog", cmd_create_reflog },
 270         { "delete-reflog", cmd_delete_reflog },
 271         { "reflog-expire", cmd_reflog_expire },
 272         /*
 273          * backend transaction functions can't be tested separately
 274          */
 275         { "delete-ref", cmd_delete_ref },
 276         { "update-ref", cmd_update_ref },
 277         { NULL, NULL }
 278 };
 279
 280 int cmd__ref_store(int argc, const char **argv)
 281 {
 282         struct ref_store *refs;
 283         const char *func;
 284         struct command *cmd;
 285
 286         setup_git_directory();
 287
 288         argv = get_store(argv + 1, &refs);
 289
 290         func = *argv++;
 291         if (!func)
 292                 die("ref function required");
 293         for (cmd = commands; cmd->name; cmd++) {
 294                 if (!strcmp(func, cmd->name))
 295                         return cmd->func(refs, argv);
 296         }
 297         die("unknown function %s", func);
 298         return 0;
 299 }