thodg/libgit2/tests/submodule/modify.c

• Show log

  Commit

• Hash : f0e693b1
  Author :
  Date : 2021-09-07T17:53:49
  

  str: introduce `git_str` for internal, `git_buf` is external libgit2 has two distinct requirements that were previously solved by `git_buf`. We require: 1. A general purpose string class that provides a number of utility APIs for manipulating data (eg, concatenating, truncating, etc). 2. A structure that we can use to return strings to callers that they can take ownership of. By using a single class (`git_buf`) for both of these purposes, we have confused the API to the point that refactorings are difficult and reasoning about correctness is also difficult. Move the utility class `git_buf` to be called `git_str`: this represents its general purpose, as an internal string buffer class. The name also is an homage to Junio Hamano ("gitstr"). The public API remains `git_buf`, and has a much smaller footprint. It is generally only used as an "out" param with strict requirements that follow the documentation. (Exceptions exist for some legacy APIs to avoid breaking callers unnecessarily.) Utility functions exist to convert a user-specified `git_buf` to a `git_str` so that we can call internal functions, then converting it back again.

Download

• tests/submodule/modify.c

• #include "clar_libgit2.h"
  #include "posix.h"
  #include "path.h"
  #include "submodule_helpers.h"
  #include "config/config_helpers.h"
  
  static git_repository *g_repo = NULL;
  
  #define SM_LIBGIT2_URL    "https://github.com/libgit2/libgit2.git"
  #define SM_LIBGIT2_BRANCH "github-branch"
  #define SM_LIBGIT2        "sm_libgit2"
  
  void test_submodule_modify__initialize(void)
  {
  	g_repo = setup_fixture_submod2();
  }
  
  static int delete_one_config(const git_config_entry *entry, void *payload)
  {
  	git_config *cfg = payload;
  	return git_config_delete_entry(cfg, entry->name);
  }
  
  static int init_one_submodule(
  	git_submodule *sm, const char *name, void *payload)
  {
  	GIT_UNUSED(name);
  	GIT_UNUSED(payload);
  	return git_submodule_init(sm, false);
  }
  
  void test_submodule_modify__init(void)
  {
  	git_config *cfg;
  	const char *str;
  
  	/* erase submodule data from .git/config */
  	cl_git_pass(git_repository_config(&cfg, g_repo));
  	cl_git_pass(
  		git_config_foreach_match(cfg, "submodule\\..*", delete_one_config, cfg));
  	git_config_free(cfg);
  
  	/* confirm no submodule data in config */
  	cl_git_pass(git_repository_config_snapshot(&cfg, g_repo));
  	cl_git_fail_with(GIT_ENOTFOUND, git_config_get_string(&str, cfg, "submodule.sm_unchanged.url"));
  	cl_git_fail_with(GIT_ENOTFOUND, git_config_get_string(&str, cfg, "submodule.sm_changed_head.url"));
  	cl_git_fail_with(GIT_ENOTFOUND, git_config_get_string(&str, cfg, "submodule.sm_added_and_uncommited.url"));
  	git_config_free(cfg);
  
  	/* call init and see that settings are copied */
  	cl_git_pass(git_submodule_foreach(g_repo, init_one_submodule, NULL));
  
  	/* confirm submodule data in config */
  	cl_git_pass(git_repository_config_snapshot(&cfg, g_repo));
  	cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_unchanged.url"));
  	cl_assert(git__suffixcmp(str, "/submod2_target") == 0);
  	cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_changed_head.url"));
  	cl_assert(git__suffixcmp(str, "/submod2_target") == 0);
  	cl_git_pass(git_config_get_string(&str, cfg, "submodule.sm_added_and_uncommited.url"));
  	cl_assert(git__suffixcmp(str, "/submod2_target") == 0);
  	git_config_free(cfg);
  }
  
  static int sync_one_submodule(
  	git_submodule *sm, const char *name, void *payload)
  {
  	GIT_UNUSED(name);
  	GIT_UNUSED(payload);
  	return git_submodule_sync(sm);
  }
  
  static void assert_submodule_url_is_synced(
  	git_submodule *sm, const char *parent_key, const char *child_key)
  {
  	git_repository *smrepo;
  
  	assert_config_entry_value(g_repo, parent_key, git_submodule_url(sm));
  
  	cl_git_pass(git_submodule_open(&smrepo, sm));
  	assert_config_entry_value(smrepo, child_key,  git_submodule_url(sm));
  	git_repository_free(smrepo);
  }
  
  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", "remote.origin.url");
  	assert_submodule_url_is_synced(
  		sm2, "submodule."SM2".url", "remote.origin.url");
  	assert_submodule_url_is_synced(
  		sm3, "submodule."SM3".url", "remote.origin.url");
  
  	git_submodule_free(sm1);
  	git_submodule_free(sm2);
  	git_submodule_free(sm3);
  }
  
  void assert_ignore_change(git_submodule_ignore_t ignore)
  {
  	git_submodule *sm;
  
  	cl_git_pass(git_submodule_set_ignore(g_repo, "sm_changed_head", ignore));
  
  	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
  	cl_assert_equal_i(ignore, git_submodule_ignore(sm));
  	git_submodule_free(sm);
  }
  
  void test_submodule_modify__set_ignore(void)
  {
  	assert_ignore_change(GIT_SUBMODULE_IGNORE_UNTRACKED);
  	assert_ignore_change(GIT_SUBMODULE_IGNORE_NONE);
  	assert_ignore_change(GIT_SUBMODULE_IGNORE_ALL);
  }
  
  void assert_update_change(git_submodule_update_t update)
  {
  	git_submodule *sm;
  
  	cl_git_pass(git_submodule_set_update(g_repo, "sm_changed_head", update));
  
  	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
  	cl_assert_equal_i(update, git_submodule_update_strategy(sm));
  	git_submodule_free(sm);
  }
  
  void test_submodule_modify__set_update(void)
  {
  	assert_update_change(GIT_SUBMODULE_UPDATE_REBASE);
  	assert_update_change(GIT_SUBMODULE_UPDATE_NONE);
  	assert_update_change(GIT_SUBMODULE_UPDATE_CHECKOUT);
  }
  
  void assert_recurse_change(git_submodule_recurse_t recurse)
  {
  	git_submodule *sm;
  
  	cl_git_pass(git_submodule_set_fetch_recurse_submodules(g_repo, "sm_changed_head", recurse));
  
  	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
  	cl_assert_equal_i(recurse, git_submodule_fetch_recurse_submodules(sm));
  	git_submodule_free(sm);
  }
  
  void test_submodule_modify__set_fetch_recurse_submodules(void)
  {
  	assert_recurse_change(GIT_SUBMODULE_RECURSE_YES);
  	assert_recurse_change(GIT_SUBMODULE_RECURSE_NO);
  	assert_recurse_change(GIT_SUBMODULE_RECURSE_ONDEMAND);
  }
  
  void test_submodule_modify__set_branch(void)
  {
  	git_submodule *sm;
  
  	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
  	cl_assert(git_submodule_branch(sm) == NULL);
  	git_submodule_free(sm);
  
  	cl_git_pass(git_submodule_set_branch(g_repo, "sm_changed_head", SM_LIBGIT2_BRANCH));
  	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
  	cl_assert_equal_s(SM_LIBGIT2_BRANCH, git_submodule_branch(sm));
  	git_submodule_free(sm);
  
  	cl_git_pass(git_submodule_set_branch(g_repo, "sm_changed_head", NULL));
  	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
  	cl_assert(git_submodule_branch(sm) == NULL);
  	git_submodule_free(sm);
  }
  
  void test_submodule_modify__set_url(void)
  {
  	git_submodule *sm;
  
  	cl_git_pass(git_submodule_set_url(g_repo, "sm_changed_head", SM_LIBGIT2_URL));
  	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
  	cl_assert_equal_s(SM_LIBGIT2_URL, git_submodule_url(sm));
  	git_submodule_free(sm);
  }
  
  void test_submodule_modify__set_relative_url(void)
  {
  	git_str path = GIT_STR_INIT;
  	git_repository *repo;
  	git_submodule *sm;
  
  	cl_git_pass(git_submodule_set_url(g_repo, SM1, "../relative-url"));
  	cl_git_pass(git_submodule_lookup(&sm, g_repo, SM1));
  	cl_git_pass(git_submodule_sync(sm));
  	cl_git_pass(git_submodule_open(&repo, sm));
  
  	cl_git_pass(git_str_joinpath(&path, clar_sandbox_path(), "relative-url"));
  
  	assert_config_entry_value(g_repo, "submodule."SM1".url", path.ptr);
  	assert_config_entry_value(repo, "remote.origin.url", path.ptr);
  
  	git_repository_free(repo);
  	git_submodule_free(sm);
  	git_str_dispose(&path);
  }
  

Download