tests/refs/read.c

   1 #include "clar_libgit2.h"
   2
   3 #include "repository.h"
   4 #include "git2/reflog.h"
   5 #include "reflog.h"
   6 #include "ref_helpers.h"
   7
   8 static const char *loose_tag_ref_name = "refs/tags/e90810b";
   9 static const char *non_existing_tag_ref_name = "refs/tags/i-do-not-exist";
  10 static const char *head_tracker_sym_ref_name = "HEAD_TRACKER";
  11 static const char *current_head_target = "refs/heads/master";
  12 static const char *current_master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
  13 static const char *packed_head_name = "refs/heads/packed";
  14 static const char *packed_test_head_name = "refs/heads/packed-test";
  15
  16 static git_repository *g_repo;
  17
  18 void test_refs_read__initialize(void)
  19 {
  20         cl_git_pass(git_repository_open(&g_repo, cl_fixture("testrepo.git")));
  21 }
  22
  23 void test_refs_read__cleanup(void)
  24 {
  25         git_repository_free(g_repo);
  26         g_repo = NULL;
  27 }
  28
  29 void test_refs_read__loose_tag(void)
  30 {
  31         /* lookup a loose tag reference */
  32         git_reference *reference;
  33         git_object *object;
  34         git_buf ref_name_from_tag_name = GIT_BUF_INIT;
  35
  36         cl_git_pass(git_reference_lookup(&reference, g_repo, loose_tag_ref_name));
  37         cl_assert(git_reference_type(reference) & GIT_REFERENCE_DIRECT);
  38         cl_assert(reference_is_packed(reference) == 0);
  39         cl_assert_equal_s(reference->name, loose_tag_ref_name);
  40
  41         cl_git_pass(git_object_lookup(&object, g_repo, git_reference_target(reference), GIT_OBJECT_ANY));
  42         cl_assert(object != NULL);
  43         cl_assert(git_object_type(object) == GIT_OBJECT_TAG);
  44
  45         /* Ensure the name of the tag matches the name of the reference */
  46         cl_git_pass(git_buf_joinpath(&ref_name_from_tag_name, GIT_REFS_TAGS_DIR, git_tag_name((git_tag *)object)));
  47         cl_assert_equal_s(ref_name_from_tag_name.ptr, loose_tag_ref_name);
  48         git_buf_dispose(&ref_name_from_tag_name);
  49
  50         git_object_free(object);
  51
  52         git_reference_free(reference);
  53 }
  54
  55 void test_refs_read__nonexisting_tag(void)
  56 {
  57         /* lookup a loose tag reference that doesn't exist */
  58         git_reference *reference;
  59
  60         cl_git_fail(git_reference_lookup(&reference, g_repo, non_existing_tag_ref_name));
  61
  62         git_reference_free(reference);
  63 }
  64
  65
  66 void test_refs_read__symbolic(void)
  67 {
  68         /* lookup a symbolic reference */
  69         git_reference *reference, *resolved_ref;
  70         git_object *object;
  71         git_oid id;
  72
  73         cl_git_pass(git_reference_lookup(&reference, g_repo, GIT_HEAD_FILE));
  74         cl_assert(git_reference_type(reference) & GIT_REFERENCE_SYMBOLIC);
  75         cl_assert(reference_is_packed(reference) == 0);
  76         cl_assert_equal_s(reference->name, GIT_HEAD_FILE);
  77
  78         cl_git_pass(git_reference_resolve(&resolved_ref, reference));
  79         cl_assert(git_reference_type(resolved_ref) == GIT_REFERENCE_DIRECT);
  80
  81         cl_git_pass(git_object_lookup(&object, g_repo, git_reference_target(resolved_ref), GIT_OBJECT_ANY));
  82         cl_assert(object != NULL);
  83         cl_assert(git_object_type(object) == GIT_OBJECT_COMMIT);
  84
  85         git_oid_fromstr(&id, current_master_tip);
  86         cl_assert_equal_oid(&id, git_object_id(object));
  87
  88         git_object_free(object);
  89
  90         git_reference_free(reference);
  91         git_reference_free(resolved_ref);
  92 }
  93
  94 void test_refs_read__nested_symbolic(void)
  95 {
  96         /* lookup a nested symbolic reference */
  97         git_reference *reference, *resolved_ref;
  98         git_object *object;
  99         git_oid id;
 100
 101         cl_git_pass(git_reference_lookup(&reference, g_repo, head_tracker_sym_ref_name));
 102         cl_assert(git_reference_type(reference) & GIT_REFERENCE_SYMBOLIC);
 103         cl_assert(reference_is_packed(reference) == 0);
 104         cl_assert_equal_s(reference->name, head_tracker_sym_ref_name);
 105
 106         cl_git_pass(git_reference_resolve(&resolved_ref, reference));
 107         cl_assert(git_reference_type(resolved_ref) == GIT_REFERENCE_DIRECT);
 108
 109         cl_git_pass(git_object_lookup(&object, g_repo, git_reference_target(resolved_ref), GIT_OBJECT_ANY));
 110         cl_assert(object != NULL);
 111         cl_assert(git_object_type(object) == GIT_OBJECT_COMMIT);
 112
 113         git_oid_fromstr(&id, current_master_tip);
 114         cl_assert_equal_oid(&id, git_object_id(object));
 115
 116         git_object_free(object);
 117
 118         git_reference_free(reference);
 119         git_reference_free(resolved_ref);
 120 }
 121
 122 void test_refs_read__head_then_master(void)
 123 {
 124         /* lookup the HEAD and resolve the master branch */
 125         git_reference *reference, *resolved_ref, *comp_base_ref;
 126
 127         cl_git_pass(git_reference_lookup(&reference, g_repo, head_tracker_sym_ref_name));
 128         cl_git_pass(git_reference_resolve(&comp_base_ref, reference));
 129         git_reference_free(reference);
 130
 131         cl_git_pass(git_reference_lookup(&reference, g_repo, GIT_HEAD_FILE));
 132         cl_git_pass(git_reference_resolve(&resolved_ref, reference));
 133         cl_assert_equal_oid(git_reference_target(comp_base_ref), git_reference_target(resolved_ref));
 134         git_reference_free(reference);
 135         git_reference_free(resolved_ref);
 136
 137         cl_git_pass(git_reference_lookup(&reference, g_repo, current_head_target));
 138         cl_git_pass(git_reference_resolve(&resolved_ref, reference));
 139         cl_assert_equal_oid(git_reference_target(comp_base_ref), git_reference_target(resolved_ref));
 140         git_reference_free(reference);
 141         git_reference_free(resolved_ref);
 142
 143         git_reference_free(comp_base_ref);
 144 }
 145
 146 void test_refs_read__master_then_head(void)
 147 {
 148         /* lookup the master branch and then the HEAD */
 149         git_reference *reference, *master_ref, *resolved_ref;
 150
 151         cl_git_pass(git_reference_lookup(&master_ref, g_repo, current_head_target));
 152         cl_git_pass(git_reference_lookup(&reference, g_repo, GIT_HEAD_FILE));
 153
 154         cl_git_pass(git_reference_resolve(&resolved_ref, reference));
 155         cl_assert_equal_oid(git_reference_target(master_ref), git_reference_target(resolved_ref));
 156
 157         git_reference_free(reference);
 158         git_reference_free(resolved_ref);
 159         git_reference_free(master_ref);
 160 }
 161
 162
 163 void test_refs_read__packed(void)
 164 {
 165         /* lookup a packed reference */
 166         git_reference *reference;
 167         git_object *object;
 168
 169         cl_git_pass(git_reference_lookup(&reference, g_repo, packed_head_name));
 170         cl_assert(git_reference_type(reference) & GIT_REFERENCE_DIRECT);
 171         cl_assert(reference_is_packed(reference));
 172         cl_assert_equal_s(reference->name, packed_head_name);
 173
 174         cl_git_pass(git_object_lookup(&object, g_repo, git_reference_target(reference), GIT_OBJECT_ANY));
 175         cl_assert(object != NULL);
 176         cl_assert(git_object_type(object) == GIT_OBJECT_COMMIT);
 177
 178         git_object_free(object);
 179
 180         git_reference_free(reference);
 181 }
 182
 183 void test_refs_read__loose_first(void)
 184 {
 185         /* assure that a loose reference is looked up before a packed reference */
 186         git_reference *reference;
 187
 188         cl_git_pass(git_reference_lookup(&reference, g_repo, packed_head_name));
 189         git_reference_free(reference);
 190         cl_git_pass(git_reference_lookup(&reference, g_repo, packed_test_head_name));
 191         cl_assert(git_reference_type(reference) & GIT_REFERENCE_DIRECT);
 192         cl_assert(reference_is_packed(reference) == 0);
 193         cl_assert_equal_s(reference->name, packed_test_head_name);
 194
 195         git_reference_free(reference);
 196 }
 197
 198 void test_refs_read__chomped(void)
 199 {
 200         git_reference *test, *chomped;
 201
 202         cl_git_pass(git_reference_lookup(&test, g_repo, "refs/heads/test"));
 203         cl_git_pass(git_reference_lookup(&chomped, g_repo, "refs/heads/chomped"));
 204         cl_assert_equal_oid(git_reference_target(test), git_reference_target(chomped));
 205
 206         git_reference_free(test);
 207         git_reference_free(chomped);
 208 }
 209
 210 void test_refs_read__trailing(void)
 211 {
 212         git_reference *test, *trailing;
 213
 214         cl_git_pass(git_reference_lookup(&test, g_repo, "refs/heads/test"));
 215         cl_git_pass(git_reference_lookup(&trailing, g_repo, "refs/heads/trailing"));
 216         cl_assert_equal_oid(git_reference_target(test), git_reference_target(trailing));
 217         git_reference_free(trailing);
 218         cl_git_pass(git_reference_lookup(&trailing, g_repo, "FETCH_HEAD"));
 219
 220         git_reference_free(test);
 221         git_reference_free(trailing);
 222 }
 223
 224 void test_refs_read__unfound_return_ENOTFOUND(void)
 225 {
 226         git_reference *reference;
 227         git_oid id;
 228
 229         cl_assert_equal_i(GIT_ENOTFOUND,
 230                 git_reference_lookup(&reference, g_repo, "TEST_MASTER"));
 231         cl_assert_equal_i(GIT_ENOTFOUND,
 232                 git_reference_lookup(&reference, g_repo, "refs/test/master"));
 233         cl_assert_equal_i(GIT_ENOTFOUND,
 234                 git_reference_lookup(&reference, g_repo, "refs/tags/test/master"));
 235         cl_assert_equal_i(GIT_ENOTFOUND,
 236                 git_reference_lookup(&reference, g_repo, "refs/tags/test/farther/master"));
 237
 238         cl_assert_equal_i(GIT_ENOTFOUND,
 239                 git_reference_name_to_id(&id, g_repo, "refs/tags/test/farther/master"));
 240 }
 241
 242 static void assert_is_branch(const char *name, bool expected_branchness)
 243 {
 244         git_reference *reference;
 245         cl_git_pass(git_reference_lookup(&reference, g_repo, name));
 246         cl_assert_equal_i(expected_branchness, git_reference_is_branch(reference));
 247         git_reference_free(reference);
 248 }
 249
 250 void test_refs_read__can_determine_if_a_reference_is_a_local_branch(void)
 251 {
 252         assert_is_branch("refs/heads/master", true);
 253         assert_is_branch("refs/heads/packed", true);
 254         assert_is_branch("refs/remotes/test/master", false);
 255         assert_is_branch("refs/tags/e90810b", false);
 256 }
 257
 258 static void assert_is_tag(const char *name, bool expected_tagness)
 259 {
 260         git_reference *reference;
 261         cl_git_pass(git_reference_lookup(&reference, g_repo, name));
 262         cl_assert_equal_i(expected_tagness, git_reference_is_tag(reference));
 263         git_reference_free(reference);
 264 }
 265
 266 void test_refs_read__can_determine_if_a_reference_is_a_tag(void)
 267 {
 268         assert_is_tag("refs/tags/e90810b", true);
 269         assert_is_tag("refs/tags/test", true);
 270         assert_is_tag("refs/heads/packed", false);
 271         assert_is_tag("refs/remotes/test/master", false);
 272 }
 273
 274 static void assert_is_note(const char *name, bool expected_noteness)
 275 {
 276         git_reference *reference;
 277         cl_git_pass(git_reference_lookup(&reference, g_repo, name));
 278         cl_assert_equal_i(expected_noteness, git_reference_is_note(reference));
 279         git_reference_free(reference);
 280 }
 281
 282 void test_refs_read__can_determine_if_a_reference_is_a_note(void)
 283 {
 284         assert_is_note("refs/notes/fanout", true);
 285         assert_is_note("refs/heads/packed", false);
 286         assert_is_note("refs/remotes/test/master", false);
 287 }
 288
 289 void test_refs_read__invalid_name_returns_EINVALIDSPEC(void)
 290 {
 291         git_reference *reference;
 292         git_oid id;
 293
 294         cl_assert_equal_i(GIT_EINVALIDSPEC,
 295                 git_reference_lookup(&reference, g_repo, "refs/heads/Inv@{id"));
 296
 297         cl_assert_equal_i(GIT_EINVALIDSPEC,
 298                 git_reference_name_to_id(&id, g_repo, "refs/heads/Inv@{id"));
 299 }