void test_submodule_nosubs__reload_add_reload(void) { git_repository *repo = cl_git_sandbox_init("status"); git_submodule *sm; cl_git_pass(git_submodule_reload_all(repo, 0)); /* try one add with a reload (to make sure no errors happen) */ cl_git_pass(git_submodule_add_setup(&sm, repo, "https://github.com/libgit2/libgit2.git", "submodules/libgit2", 1)); cl_git_pass(git_submodule_reload_all(repo, 0)); cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm)); git_submodule_free(sm); cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2")); cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm)); git_submodule_free(sm); /* try one add without a reload (to make sure cache inval works, too) */ cl_git_pass(git_submodule_add_setup(&sm, repo, "https://github.com/libgit2/libgit2.git", "libgit2-again", 1)); cl_assert_equal_s("libgit2-again", git_submodule_name(sm)); git_submodule_free(sm); cl_git_pass(git_submodule_lookup(&sm, repo, "libgit2-again")); cl_assert_equal_s("libgit2-again", git_submodule_name(sm)); git_submodule_free(sm); }
void test_submodule_add__url_absolute(void) { git_submodule *sm; git_config *cfg; git_repository *repo; const char *worktree_path; git_buf dot_git_content = GIT_BUF_INIT; g_repo = setup_fixture_submod2(); /* re-add existing submodule */ cl_git_fail_with( GIT_EEXISTS, git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1)); /* add a submodule using a gitlink */ cl_git_pass( git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_libgit2", 1) ); git_submodule_free(sm); cl_assert(git_path_isfile("submod2/" "sm_libgit2" "/.git")); cl_assert(git_path_isdir("submod2/.git/modules")); cl_assert(git_path_isdir("submod2/.git/modules/" "sm_libgit2")); cl_assert(git_path_isfile("submod2/.git/modules/" "sm_libgit2" "/HEAD")); assert_submodule_url("sm_libgit2", "https://github.com/libgit2/libgit2.git"); cl_git_pass(git_repository_open(&repo, "submod2/" "sm_libgit2")); /* Verify worktree path is relative */ cl_git_pass(git_repository_config(&cfg, repo)); cl_git_pass(git_config_get_string(&worktree_path, cfg, "core.worktree")); cl_assert_equal_s("../../../sm_libgit2/", worktree_path); /* Verify gitdir path is relative */ cl_git_pass(git_futils_readbuffer(&dot_git_content, "submod2/" "sm_libgit2" "/.git")); cl_assert_equal_s("gitdir: ../.git/modules/sm_libgit2/", dot_git_content.ptr); git_config_free(cfg); git_repository_free(repo); git_buf_free(&dot_git_content); /* add a submodule not using a gitlink */ cl_git_pass( git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_libgit2b", 0) ); git_submodule_free(sm); cl_assert(git_path_isdir("submod2/" "sm_libgit2b" "/.git")); cl_assert(git_path_isfile("submod2/" "sm_libgit2b" "/.git/HEAD")); cl_assert(!git_path_exists("submod2/.git/modules/" "sm_libgit2b")); assert_submodule_url("sm_libgit2b", "https://github.com/libgit2/libgit2.git"); }
void test_submodule_lookup__accessors(void) { git_submodule *sm; const char *oid = "480095882d281ed676fe5b863569520e54a7d5c0"; cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged")); cl_assert(git_submodule_owner(sm) == g_repo); cl_assert_equal_s("sm_unchanged", git_submodule_name(sm)); cl_assert(git__suffixcmp(git_submodule_path(sm), "sm_unchanged") == 0); cl_assert(git__suffixcmp(git_submodule_url(sm), "/submod2_target") == 0); cl_assert(git_oid_streq(git_submodule_index_id(sm), oid) == 0); cl_assert(git_oid_streq(git_submodule_head_id(sm), oid) == 0); cl_assert(git_oid_streq(git_submodule_wd_id(sm), oid) == 0); cl_assert(git_submodule_ignore(sm) == GIT_SUBMODULE_IGNORE_NONE); cl_assert(git_submodule_update(sm) == GIT_SUBMODULE_UPDATE_CHECKOUT); git_submodule_free(sm); cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head")); cl_assert_equal_s("sm_changed_head", git_submodule_name(sm)); cl_assert(git_oid_streq(git_submodule_index_id(sm), oid) == 0); cl_assert(git_oid_streq(git_submodule_head_id(sm), oid) == 0); cl_assert(git_oid_streq(git_submodule_wd_id(sm), "3d9386c507f6b093471a3e324085657a3c2b4247") == 0); git_submodule_free(sm); cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited")); cl_assert_equal_s("sm_added_and_uncommited", git_submodule_name(sm)); cl_assert(git_oid_streq(git_submodule_index_id(sm), oid) == 0); cl_assert(git_submodule_head_id(sm) == NULL); cl_assert(git_oid_streq(git_submodule_wd_id(sm), oid) == 0); git_submodule_free(sm); cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_missing_commits")); cl_assert_equal_s("sm_missing_commits", git_submodule_name(sm)); cl_assert(git_oid_streq(git_submodule_index_id(sm), oid) == 0); cl_assert(git_oid_streq(git_submodule_head_id(sm), oid) == 0); cl_assert(git_oid_streq(git_submodule_wd_id(sm), "5e4963595a9774b90524d35a807169049de8ccad") == 0); git_submodule_free(sm); }
static int diff_file_content_commit_to_str( git_diff_file_content *fc, bool check_status) { char oid[GIT_OID_HEXSZ+1]; git_buf content = GIT_BUF_INIT; const char *status = ""; if (check_status) { int error = 0; git_submodule *sm = NULL; unsigned int sm_status = 0; const git_oid *sm_head; if ((error = git_submodule_lookup(&sm, fc->repo, fc->file->path)) < 0) { /* GIT_EEXISTS means a "submodule" that has not been git added */ if (error == GIT_EEXISTS) { giterr_clear(); error = 0; } return error; } if ((error = git_submodule_status(&sm_status, fc->repo, fc->file->path, GIT_SUBMODULE_IGNORE_UNSPECIFIED)) < 0) { git_submodule_free(sm); return error; } /* update OID if we didn't have it previously */ if ((fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0 && ((sm_head = git_submodule_wd_id(sm)) != NULL || (sm_head = git_submodule_head_id(sm)) != NULL)) { git_oid_cpy(&fc->file->id, sm_head); fc->file->flags |= GIT_DIFF_FLAG_VALID_ID; } if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status)) status = "-dirty"; git_submodule_free(sm); } git_oid_tostr(oid, sizeof(oid), &fc->file->id); if (git_buf_printf(&content, "Subproject commit %s%s\n", oid, status) < 0) return -1; fc->map.len = git_buf_len(&content); fc->map.data = git_buf_detach(&content); fc->flags |= GIT_DIFF_FLAG__FREE_DATA; return 0; }
void test_submodule_nosubs__add(void) { git_repository *repo = cl_git_sandbox_init("status"); git_submodule *sm, *sm2; cl_git_pass(git_submodule_add_setup(&sm, repo, "https://github.com/libgit2/libgit2.git", "submodules/libgit2", 1)); cl_git_pass(git_submodule_lookup(&sm2, repo, "submodules/libgit2")); git_submodule_free(sm2); cl_git_pass(git_submodule_foreach(repo, fake_submod_cb, NULL)); git_submodule_free(sm); }
static int submodules_from_index(git_strmap *map, git_index *idx) { int error; git_iterator *i; const git_index_entry *entry; if ((error = git_iterator_for_index(&i, idx, 0, NULL, NULL)) < 0) return error; while (!(error = git_iterator_advance(&entry, i))) { khiter_t pos = git_strmap_lookup_index(map, entry->path); git_submodule *sm; if (git_strmap_valid_index(map, pos)) { sm = git_strmap_value_at(map, pos); if (S_ISGITLINK(entry->mode)) submodule_update_from_index_entry(sm, entry); else sm->flags |= GIT_SUBMODULE_STATUS__INDEX_NOT_SUBMODULE; } else if (S_ISGITLINK(entry->mode)) { if (!submodule_get_or_create(&sm, git_index_owner(idx), map, entry->path)) { submodule_update_from_index_entry(sm, entry); git_submodule_free(sm); } } } if (error == GIT_ITEROVER) error = 0; git_iterator_free(i); return error; }
void test_submodule_update__update_and_init_submodule(void) { git_submodule *sm; git_submodule_update_options update_options = GIT_SUBMODULE_UPDATE_OPTIONS_INIT; unsigned int submodule_status = 0; g_repo = setup_fixture_submodule_simple(); /* get the submodule */ cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo")); cl_git_pass(git_submodule_status(&submodule_status, sm)); cl_assert_equal_i(submodule_status, GIT_SUBMODULE_STATUS_IN_HEAD | GIT_SUBMODULE_STATUS_IN_INDEX | GIT_SUBMODULE_STATUS_IN_CONFIG | GIT_SUBMODULE_STATUS_WD_UNINITIALIZED); /* update (with option to initialize sub repo) */ cl_git_pass(git_submodule_update(sm, 1, &update_options)); /* verify expected state */ cl_assert(git_oid_streq(git_submodule_head_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0); cl_assert(git_oid_streq(git_submodule_wd_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0); cl_assert(git_oid_streq(git_submodule_index_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0); git_submodule_free(sm); }
static void add_submodule_with_commit(const char *name) { git_submodule *sm; git_repository *smrepo; git_index *idx; git_buf p = GIT_BUF_INIT; cl_git_pass(git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", name, 1)); assert_submodule_exists(g_repo, name); cl_git_pass(git_submodule_open(&smrepo, sm)); cl_git_pass(git_repository_index(&idx, smrepo)); cl_git_pass(git_buf_joinpath(&p, git_repository_workdir(smrepo), "file")); cl_git_mkfile(p.ptr, "new file"); git_buf_free(&p); cl_git_pass(git_index_add_bypath(idx, "file")); cl_git_pass(git_index_write(idx)); git_index_free(idx); cl_repo_commit_from_index(NULL, smrepo, NULL, 0, "initial commit"); git_repository_free(smrepo); cl_git_pass(git_submodule_add_finalize(sm)); git_submodule_free(sm); }
void test_rebase_submodule__init_untracked(void) { git_rebase *rebase; git_reference *branch_ref, *upstream_ref; git_annotated_commit *branch_head, *upstream_head; git_buf untracked_path = GIT_BUF_INIT; FILE *fp; git_submodule *submodule; cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/asparagus")); cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/master")); cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref)); cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref)); cl_git_pass(git_submodule_lookup(&submodule, repo, "my-submodule")); cl_git_pass(git_submodule_update(submodule, 1, NULL)); git_buf_printf(&untracked_path, "%s/my-submodule/untracked", git_repository_workdir(repo)); fp = fopen(git_buf_cstr(&untracked_path), "w"); fprintf(fp, "An untracked file in a submodule should not block a rebase\n"); fclose(fp); git_buf_free(&untracked_path); cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); git_submodule_free(submodule); git_annotated_commit_free(branch_head); git_annotated_commit_free(upstream_head); git_reference_free(branch_ref); git_reference_free(upstream_ref); git_rebase_free(rebase); }
void test_submodule_init__relative_url(void) { git_submodule *sm; git_config *cfg; git_buf absolute_url = GIT_BUF_INIT; const char *config_url; g_repo = setup_fixture_submodule_simple(); cl_assert(git_path_dirname_r(&absolute_url, git_repository_workdir(g_repo)) > 0); cl_git_pass(git_buf_joinpath(&absolute_url, absolute_url.ptr, "testrepo.git")); cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo")); /* verify that the .gitmodules is set with an absolute path*/ cl_assert_equal_s("../testrepo.git", git_submodule_url(sm)); /* init and verify that absolute path is written to .git/config */ cl_git_pass(git_submodule_init(sm, false)); cl_git_pass(git_repository_config_snapshot(&cfg, g_repo)); cl_git_pass(git_config_get_string(&config_url, cfg, "submodule.testrepo.url")); cl_assert_equal_s(absolute_url.ptr, config_url); git_buf_free(&absolute_url); git_config_free(cfg); git_submodule_free(sm); }
/* When looking at the short name for a submodule, we need to prevent * people from overwriting the `.git` file in the submodule working * directory itself. We don't want to look at the actual repository * path, since it will be in the super's repository above us, and * typically named with the name of our subrepository. Consequently, * preventing access to the short name of the actual repository path * would prevent us from creating files with the same name as the * subrepo. (Eg, a submodule named "libgit2" could not contain a file * named "libgit2", which would be unfortunate.) */ void test_repo_reservedname__submodule_pointer(void) { #ifdef GIT_WIN32 git_repository *super_repo, *sub_repo; git_submodule *sub; git_buf *sub_reserved; size_t sub_reserved_len; if (!cl_sandbox_supports_8dot3()) clar__skip(); super_repo = setup_fixture_submod2(); assert_submodule_exists(super_repo, "sm_unchanged"); cl_git_pass(git_submodule_lookup(&sub, super_repo, "sm_unchanged")); cl_git_pass(git_submodule_open(&sub_repo, sub)); cl_assert(git_repository__reserved_names(&sub_reserved, &sub_reserved_len, sub_repo, true)); cl_assert_equal_i(2, sub_reserved_len); cl_assert_equal_s(".git", sub_reserved[0].ptr); cl_assert_equal_s("GIT~1", sub_reserved[1].ptr); git_submodule_free(sub); git_repository_free(sub_repo); #endif }
void test_submodule_repository_init__basic(void) { git_submodule *sm; git_repository *repo; git_buf dot_git_content = GIT_BUF_INIT; g_repo = setup_fixture_submod2(); cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_gitmodules_only")); cl_git_pass(git_submodule_init(sm, 0)); cl_git_pass(git_submodule_repo_init(&repo, sm, 1)); /* Verify worktree */ assert_config_entry_value(repo, "core.worktree", "../../../sm_gitmodules_only/"); /* Verify gitlink */ cl_git_pass(git_futils_readbuffer(&dot_git_content, "submod2/" "sm_gitmodules_only" "/.git")); cl_assert_equal_s("gitdir: ../.git/modules/sm_gitmodules_only/", dot_git_content.ptr); cl_assert(git_path_isfile("submod2/" "sm_gitmodules_only" "/.git")); cl_assert(git_path_isdir("submod2/.git/modules")); cl_assert(git_path_isdir("submod2/.git/modules/" "sm_gitmodules_only")); cl_assert(git_path_isfile("submod2/.git/modules/" "sm_gitmodules_only" "/HEAD")); git_submodule_free(sm); git_repository_free(repo); git_buf_free(&dot_git_content); }
static int submodule_get_or_create(git_submodule **out, git_repository *repo, git_strmap *map, const char *name) { int error = 0; khiter_t pos; git_submodule *sm = NULL; pos = git_strmap_lookup_index(map, name); if (git_strmap_valid_index(map, pos)) { sm = git_strmap_value_at(map, pos); goto done; } /* if the submodule doesn't exist yet in the map, create it */ if ((error = submodule_alloc(&sm, repo, name)) < 0) return error; pos = kh_put(str, map, sm->name, &error); /* nobody can beat us to adding it */ assert(error != 0); if (error < 0) { git_submodule_free(sm); return error; } git_strmap_set_value_at(map, pos, sm); done: GIT_REFCOUNT_INC(sm); *out = sm; return 0; }
void test_submodule_modify__sync(void) { git_submodule *sm1, *sm2, *sm3; git_config *cfg; const char *str; #define SM1 "sm_unchanged" #define SM2 "sm_changed_head" #define SM3 "sm_added_and_uncommited" /* look up some submodules */ cl_git_pass(git_submodule_lookup(&sm1, g_repo, SM1)); cl_git_pass(git_submodule_lookup(&sm2, g_repo, SM2)); cl_git_pass(git_submodule_lookup(&sm3, g_repo, SM3)); /* At this point, the .git/config URLs for the submodules have * not be rewritten with the absolute paths (although the * .gitmodules have. Let's confirm that they DO NOT match * yet, then we can do a sync to make them match... */ /* check submodule info does not match before sync */ cl_git_pass(git_repository_config_snapshot(&cfg, g_repo)); cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM1".url")); cl_assert(strcmp(git_submodule_url(sm1), str) != 0); cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM2".url")); cl_assert(strcmp(git_submodule_url(sm2), str) != 0); cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM3".url")); cl_assert(strcmp(git_submodule_url(sm3), str) != 0); git_config_free(cfg); /* sync all the submodules */ cl_git_pass(git_submodule_foreach(g_repo, sync_one_submodule, NULL)); /* check that submodule config is updated */ assert_submodule_url_is_synced( sm1, "submodule."SM1".url", "branch.origin.remote"); assert_submodule_url_is_synced( sm2, "submodule."SM2".url", "branch.origin.remote"); assert_submodule_url_is_synced( sm3, "submodule."SM3".url", "branch.origin.remote"); git_submodule_free(sm1); git_submodule_free(sm2); git_submodule_free(sm3); }
void test_submodule_open__cleanup(void) { git_submodule_free(g_module); git_repository_free(g_child); cl_git_sandbox_cleanup(); g_parent = NULL; g_child = NULL; g_module = NULL; }
void assert__submodule_exists( git_repository *repo, const char *name, const char *msg, const char *file, int line) { git_submodule *sm; int error = git_submodule_lookup(&sm, repo, name); if (error) cl_git_report_failure(error, file, line, msg); cl_assert_at_line(sm != NULL, file, line); git_submodule_free(sm); }
unsigned int get_submodule_status(git_repository *repo, const char *name) { git_submodule *sm = NULL; unsigned int status = 0; cl_git_pass(git_submodule_lookup(&sm, repo, name)); cl_assert(sm); cl_git_pass(git_submodule_status(&status, sm)); git_submodule_free(sm); return status; }
void test_submodule_add__url_relative_to_workdir(void) { git_submodule *sm; /* In this repo, HEAD (master) has no remote tracking branc h*/ g_repo = cl_git_sandbox_init("testrepo"); cl_git_pass( git_submodule_add_setup(&sm, g_repo, "./", "TestGitRepository", 1) ); git_submodule_free(sm); assert_submodule_url("TestGitRepository", git_repository_workdir(g_repo)); }
void test_submodule_add__url_relative_to_origin(void) { git_submodule *sm; /* default remote url is https://github.com/libgit2/false.git */ g_repo = cl_git_sandbox_init("testrepo2"); cl_git_pass( git_submodule_add_setup(&sm, g_repo, "../TestGitRepository", "TestGitRepository", 1) ); git_submodule_free(sm); assert_submodule_url("TestGitRepository", "https://github.com/libgit2/TestGitRepository"); }
void test_submodule_add__url_absolute(void) { git_submodule *sm; g_repo = setup_fixture_submod2(); /* re-add existing submodule */ cl_git_fail_with( GIT_EEXISTS, git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1)); /* add a submodule using a gitlink */ cl_git_pass( git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_libgit2", 1) ); git_submodule_free(sm); cl_assert(git_path_isfile("submod2/" "sm_libgit2" "/.git")); cl_assert(git_path_isdir("submod2/.git/modules")); cl_assert(git_path_isdir("submod2/.git/modules/" "sm_libgit2")); cl_assert(git_path_isfile("submod2/.git/modules/" "sm_libgit2" "/HEAD")); assert_submodule_url("sm_libgit2", "https://github.com/libgit2/libgit2.git"); /* add a submodule not using a gitlink */ cl_git_pass( git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_libgit2b", 0) ); git_submodule_free(sm); cl_assert(git_path_isdir("submod2/" "sm_libgit2b" "/.git")); cl_assert(git_path_isfile("submod2/" "sm_libgit2b" "/.git/HEAD")); cl_assert(!git_path_exists("submod2/.git/modules/" "sm_libgit2b")); assert_submodule_url("sm_libgit2b", "https://github.com/libgit2/libgit2.git"); }
void test_submodule_update__unitialized_submodule_no_init(void) { git_submodule *sm; git_submodule_update_options update_options = GIT_SUBMODULE_UPDATE_OPTIONS_INIT; g_repo = setup_fixture_submodule_simple(); /* get the submodule */ cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo")); /* updating an unitialized repository throws */ cl_git_fail_with( GIT_ERROR, git_submodule_update(sm, 0, &update_options)); git_submodule_free(sm); }
void test_submodule_update__update_submodule(void) { git_submodule *sm; git_submodule_update_options update_options = GIT_SUBMODULE_UPDATE_OPTIONS_INIT; unsigned int submodule_status = 0; struct update_submodule_cb_payload update_payload = { 0 }; g_repo = setup_fixture_submodule_simple(); update_options.checkout_opts.progress_cb = checkout_progress_cb; update_options.checkout_opts.progress_payload = &update_payload; update_options.remote_callbacks.update_tips = update_tips; update_options.remote_callbacks.payload = &update_payload; /* get the submodule */ cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo")); /* verify the initial state of the submodule */ cl_git_pass(git_submodule_status(&submodule_status, sm)); cl_assert_equal_i(submodule_status, GIT_SUBMODULE_STATUS_IN_HEAD | GIT_SUBMODULE_STATUS_IN_INDEX | GIT_SUBMODULE_STATUS_IN_CONFIG | GIT_SUBMODULE_STATUS_WD_UNINITIALIZED); /* initialize and update the submodule */ cl_git_pass(git_submodule_init(sm, 0)); cl_git_pass(git_submodule_update(sm, 0, &update_options)); /* verify state */ cl_git_pass(git_submodule_status(&submodule_status, sm)); cl_assert_equal_i(submodule_status, GIT_SUBMODULE_STATUS_IN_HEAD | GIT_SUBMODULE_STATUS_IN_INDEX | GIT_SUBMODULE_STATUS_IN_CONFIG | GIT_SUBMODULE_STATUS_IN_WD); cl_assert(git_oid_streq(git_submodule_head_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0); cl_assert(git_oid_streq(git_submodule_wd_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0); cl_assert(git_oid_streq(git_submodule_index_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0); /* verify that the expected callbacks have been called. */ cl_assert_equal_i(1, update_payload.checkout_progress_called); cl_assert_equal_i(1, update_payload.update_tips_called); git_submodule_free(sm); }
static int checksum_tree_callback (const char *root, const git_tree_entry *entry, void *data) { int iter_r = 1; int tmp_r; struct TreeWalkData *twdata = data; git_otype otype = git_tree_entry_type (entry); switch (otype) { case GIT_OBJ_TREE: case GIT_OBJ_BLOB: if (!checksum_object_id (twdata, git_tree_entry_id (entry), twdata->error)) { twdata->caught_error = TRUE; return -1; } break; case GIT_OBJ_COMMIT: { git_submodule *submod = NULL; tmp_r = git_submodule_lookup (&submod, twdata->repo, git_tree_entry_name (entry)); if (!handle_libgit_ret (tmp_r, twdata->error)) goto out; tmp_r = checksum_submodule (twdata, submod); if (tmp_r != 0) goto out; git_submodule_free (submod); } break; default: g_assert_not_reached (); } iter_r = 0; out: if (iter_r > 0) twdata->caught_error = TRUE; return iter_r; }
void test_submodule_add__url_relative(void) { git_submodule *sm; git_remote *remote; /* default remote url is https://github.com/libgit2/false.git */ g_repo = cl_git_sandbox_init("testrepo2"); /* make sure we don't default to origin - rename origin -> test_remote */ cl_git_pass(git_remote_load(&remote, g_repo, "origin")); cl_git_pass(git_remote_rename(remote, "test_remote", NULL, NULL)); cl_git_fail(git_remote_load(&remote, g_repo, "origin")); git_remote_free(remote); cl_git_pass( git_submodule_add_setup(&sm, g_repo, "../TestGitRepository", "TestGitRepository", 1) ); git_submodule_free(sm); assert_submodule_url("TestGitRepository", "https://github.com/libgit2/TestGitRepository"); }
void test_submodule_init__relative_url_detached_head(void) { git_submodule *sm; git_config *cfg; git_buf absolute_url = GIT_BUF_INIT; const char *config_url; git_reference *head_ref = NULL; git_object *head_commit = NULL; g_repo = setup_fixture_submodule_simple(); /* Put the parent repository into a detached head state. */ cl_git_pass(git_repository_head(&head_ref, g_repo)); cl_git_pass(git_reference_peel(&head_commit, head_ref, GIT_OBJ_COMMIT)); cl_git_pass(git_repository_set_head_detached(g_repo, git_commit_id((git_commit *)head_commit))); cl_assert(git_path_dirname_r(&absolute_url, git_repository_workdir(g_repo)) > 0); cl_git_pass(git_buf_joinpath(&absolute_url, absolute_url.ptr, "testrepo.git")); cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo")); /* verify that the .gitmodules is set with an absolute path*/ cl_assert_equal_s("../testrepo.git", git_submodule_url(sm)); /* init and verify that absolute path is written to .git/config */ cl_git_pass(git_submodule_init(sm, false)); cl_git_pass(git_repository_config_snapshot(&cfg, g_repo)); cl_git_pass(git_config_get_string(&config_url, cfg, "submodule.testrepo.url")); cl_assert_equal_s(absolute_url.ptr, config_url); git_buf_free(&absolute_url); git_config_free(cfg); git_object_free(head_commit); git_reference_free(head_ref); git_submodule_free(sm); }
void test_submodule_add__url_relative(void) { git_submodule *sm; git_remote *remote; git_strarray problems = {0}; /* default remote url is https://github.com/libgit2/false.git */ g_repo = cl_git_sandbox_init("testrepo2"); /* make sure we don't default to origin - rename origin -> test_remote */ cl_git_pass(git_remote_rename(&problems, g_repo, "origin", "test_remote")); cl_assert_equal_i(0, problems.count); git_strarray_free(&problems); cl_git_fail(git_remote_lookup(&remote, g_repo, "origin")); cl_git_pass( git_submodule_add_setup(&sm, g_repo, "../TestGitRepository", "TestGitRepository", 1) ); git_submodule_free(sm); assert_submodule_url("TestGitRepository", "https://github.com/libgit2/TestGitRepository"); }
void test_clone_nonetwork__clone_submodule(void) { git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT; git_index *index; git_oid tree_id, commit_id; git_submodule *sm; git_signature *sig; git_repository *sm_repo; cl_git_pass(git_repository_init(&g_repo, "willaddsubmodule", false)); /* Create the submodule structure, clone into it and finalize */ cl_git_pass(git_submodule_add_setup(&sm, g_repo, cl_fixture("testrepo.git"), "testrepo", true)); clone_opts.repository_cb = just_return_repo; clone_opts.repository_cb_payload = sm; clone_opts.remote_cb = just_return_origin; clone_opts.remote_cb_payload = sm; cl_git_pass(git_clone(&sm_repo, cl_fixture("testrepo.git"), "testrepo", &clone_opts)); cl_git_pass(git_submodule_add_finalize(sm)); git_repository_free(sm_repo); git_submodule_free(sm); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_write_tree(&tree_id, index)); git_index_free(index); cl_git_pass(git_signature_now(&sig, "Submoduler", "submoduler@local")); cl_git_pass(git_commit_create_from_ids(&commit_id, g_repo, "HEAD", sig, sig, NULL, "A submodule\n", &tree_id, 0, NULL)); git_signature_free(sig); assert_submodule_exists(g_repo, "testrepo"); }
void test_submodule_nosubs__add_and_delete(void) { git_repository *repo = cl_git_sandbox_init("status"); git_submodule *sm; git_buf buf = GIT_BUF_INIT; /* note lack of calls to git_submodule_reload_all - this *should* work */ cl_git_fail(git_submodule_lookup(NULL, repo, "libgit2")); cl_git_fail(git_submodule_lookup(NULL, repo, "submodules/libgit2")); /* create */ cl_git_pass(git_submodule_add_setup( &sm, repo, "https://github.com/libgit2/libgit2.git", "submodules/libgit2", 1)); cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm)); cl_assert_equal_s("submodules/libgit2", git_submodule_path(sm)); git_submodule_free(sm); cl_git_pass(git_futils_readbuffer(&buf, "status/.gitmodules")); cl_assert(strstr(buf.ptr, "[submodule \"submodules/libgit2\"]") != NULL); cl_assert(strstr(buf.ptr, "path = submodules/libgit2") != NULL); git_buf_free(&buf); /* lookup */ cl_git_fail(git_submodule_lookup(&sm, repo, "libgit2")); cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2")); cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm)); cl_assert_equal_s("submodules/libgit2", git_submodule_path(sm)); git_submodule_free(sm); /* update name */ cl_git_rewritefile( "status/.gitmodules", "[submodule \"libgit2\"]\n" " path = submodules/libgit2\n" " url = https://github.com/libgit2/libgit2.git\n"); cl_git_pass(git_submodule_lookup(&sm, repo, "libgit2")); cl_assert_equal_s("libgit2", git_submodule_name(sm)); cl_assert_equal_s("submodules/libgit2", git_submodule_path(sm)); git_submodule_free(sm); cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2")); git_submodule_free(sm); /* revert name update */ cl_git_rewritefile( "status/.gitmodules", "[submodule \"submodules/libgit2\"]\n" " path = submodules/libgit2\n" " url = https://github.com/libgit2/libgit2.git\n"); cl_git_fail(git_submodule_lookup(&sm, repo, "libgit2")); cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2")); git_submodule_free(sm); /* remove completely */ cl_must_pass(p_unlink("status/.gitmodules")); cl_git_fail(git_submodule_lookup(&sm, repo, "libgit2")); cl_git_fail(git_submodule_lookup(&sm, repo, "submodules/libgit2")); }
void test_submodule_lookup__just_added(void) { git_submodule *sm; git_buf snap1 = GIT_BUF_INIT, snap2 = GIT_BUF_INIT; git_reference *original_head = NULL; refute_submodule_exists(g_repo, "sm_just_added", GIT_ENOTFOUND); refute_submodule_exists(g_repo, "sm_just_added_2", GIT_ENOTFOUND); refute_submodule_exists(g_repo, "sm_just_added_idx", GIT_ENOTFOUND); refute_submodule_exists(g_repo, "sm_just_added_head", GIT_ENOTFOUND); refute_submodule_exists(g_repo, "mismatch_name", GIT_ENOTFOUND); refute_submodule_exists(g_repo, "mismatch_path", GIT_ENOTFOUND); baseline_tests(); cl_git_pass(git_futils_readbuffer(&snap1, "submod2/.gitmodules")); cl_git_pass(git_repository_head(&original_head, g_repo)); cl_git_pass(git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_just_added", 1)); git_submodule_free(sm); assert_submodule_exists(g_repo, "sm_just_added"); cl_git_pass(git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_just_added_2", 1)); assert_submodule_exists(g_repo, "sm_just_added_2"); cl_git_fail(git_submodule_add_finalize(sm)); /* fails if no HEAD */ git_submodule_free(sm); add_submodule_with_commit("sm_just_added_head"); cl_repo_commit_from_index(NULL, g_repo, NULL, 0, "commit new sm to head"); assert_submodule_exists(g_repo, "sm_just_added_head"); add_submodule_with_commit("sm_just_added_idx"); assert_submodule_exists(g_repo, "sm_just_added_idx"); cl_git_pass(git_futils_readbuffer(&snap2, "submod2/.gitmodules")); cl_git_append2file( "submod2/.gitmodules", "\n[submodule \"mismatch_name\"]\n" "\tpath = mismatch_path\n" "\turl = https://example.com/example.git\n\n"); assert_submodule_exists(g_repo, "mismatch_name"); assert_submodule_exists(g_repo, "mismatch_path"); assert_submodule_exists(g_repo, "sm_just_added"); assert_submodule_exists(g_repo, "sm_just_added_2"); assert_submodule_exists(g_repo, "sm_just_added_idx"); assert_submodule_exists(g_repo, "sm_just_added_head"); baseline_tests(); cl_git_rewritefile("submod2/.gitmodules", snap2.ptr); git_buf_free(&snap2); refute_submodule_exists(g_repo, "mismatch_name", GIT_ENOTFOUND); refute_submodule_exists(g_repo, "mismatch_path", GIT_ENOTFOUND); assert_submodule_exists(g_repo, "sm_just_added"); assert_submodule_exists(g_repo, "sm_just_added_2"); assert_submodule_exists(g_repo, "sm_just_added_idx"); assert_submodule_exists(g_repo, "sm_just_added_head"); baseline_tests(); cl_git_rewritefile("submod2/.gitmodules", snap1.ptr); git_buf_free(&snap1); refute_submodule_exists(g_repo, "mismatch_name", GIT_ENOTFOUND); refute_submodule_exists(g_repo, "mismatch_path", GIT_ENOTFOUND); /* note error code change, because add_setup made a repo in the workdir */ refute_submodule_exists(g_repo, "sm_just_added", GIT_EEXISTS); refute_submodule_exists(g_repo, "sm_just_added_2", GIT_EEXISTS); /* these still exist in index and head respectively */ assert_submodule_exists(g_repo, "sm_just_added_idx"); assert_submodule_exists(g_repo, "sm_just_added_head"); baseline_tests(); { git_index *idx; cl_git_pass(git_repository_index(&idx, g_repo)); cl_git_pass(git_index_remove_bypath(idx, "sm_just_added_idx")); cl_git_pass(git_index_remove_bypath(idx, "sm_just_added_head")); cl_git_pass(git_index_write(idx)); git_index_free(idx); } refute_submodule_exists(g_repo, "sm_just_added_idx", GIT_EEXISTS); assert_submodule_exists(g_repo, "sm_just_added_head"); { git_signature *sig; cl_git_pass(git_signature_now(&sig, "resetter", "*****@*****.**")); cl_git_pass(git_reference_create(NULL, g_repo, "refs/heads/master", git_reference_target(original_head), 1, sig, "move head back")); git_signature_free(sig); git_reference_free(original_head); } refute_submodule_exists(g_repo, "sm_just_added_head", GIT_EEXISTS); }
static void rb_git_submodule__free(git_submodule *submodule) { git_submodule_free(submodule); }