Skip to content

G
git2
Commit 1b934689 by Russell Belfer
Options

Merge pull request #925 from nulltoken/topic/moving-branch-updates-config 

Updates config upon moving and deletion of branches
parents 505f37b4 fcccf304
Showing with 971 additions and 35 deletions
include/git2/remote.h
......@@ -347,6 +347,24 @@ GIT_EXTERN(int) git_remote_autotag(git_remote *remote);
*/
GIT_EXTERN(void) git_remote_set_autotag(git_remote *remote, int value);
/**
* Give the remote a new name
*
* All remote-tracking branches and configuration settings
* for the remote are updated.
*
* @param remote the remote to rename
* @param new_name the new name the remote should bear
* @param callback Optional callback to notify the consumer of fetch refspecs
* that haven't been automatically updated and need potential manual tweaking.
* @param payload Additional data to pass to the callback
* @return 0 or an error code
*/
GIT_EXTERN(int) git_remote_rename(
git_remote *remote,
const char *new_name,
int (*callback)(const char *problematic_refspec, void *payload),
void *payload);
/** @} */
GIT_END_DECL
......
src/branch.c
......@@ -92,6 +92,8 @@ cleanup:
int git_branch_delete(git_reference *branch)
{
int is_head;
git_buf config_section = GIT_BUF_INIT;
int error = -1;
assert(branch);
......@@ -110,7 +112,23 @@ int git_branch_delete(git_reference *branch)
return -1;
}
return git_reference_delete(branch);
if (git_buf_printf(&config_section, "branch.%s", git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)) < 0)
goto on_error;
if (git_config_rename_section(
git_reference_owner(branch),
git_buf_cstr(&config_section),
NULL) < 0)
goto on_error;
if (git_reference_delete(branch) < 0)
goto on_error;
error = 0;
on_error:
git_buf_free(&config_section);
return error;
}
typedef struct {
......@@ -161,7 +179,9 @@ int git_branch_move(
const char *new_branch_name,
int force)
{
git_buf new_reference_name = GIT_BUF_INIT;
git_buf new_reference_name = GIT_BUF_INIT,
old_config_section = GIT_BUF_INIT,
new_config_section = GIT_BUF_INIT;
int error;
assert(branch && new_branch_name);
......@@ -172,10 +192,28 @@ int git_branch_move(
if ((error = git_buf_joinpath(&new_reference_name, GIT_REFS_HEADS_DIR, new_branch_name)) < 0)
goto cleanup;
error = git_reference_rename(branch, git_buf_cstr(&new_reference_name), force);
if (git_buf_printf(
&old_config_section,
"branch.%s",
git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)) < 0)
goto cleanup;
if ((error = git_reference_rename(branch, git_buf_cstr(&new_reference_name), force)) < 0)
goto cleanup;
if (git_buf_printf(&new_config_section, "branch.%s", new_branch_name) < 0)
goto cleanup;
if ((error = git_config_rename_section(
git_reference_owner(branch),
git_buf_cstr(&old_config_section),
git_buf_cstr(&new_config_section))) < 0)
goto cleanup;
cleanup:
git_buf_free(&new_reference_name);
git_buf_free(&old_config_section);
git_buf_free(&new_config_section);
return error;
}
......
src/buffer.c
......@@ -549,3 +549,31 @@ void git_buf_unescape(git_buf *buf)
{
buf->size = git__unescape(buf->ptr);
}
int git_buf_splice(
git_buf *buf,
size_t where,
size_t nb_to_remove,
const char *data,
size_t nb_to_insert)
{
assert(buf &&
where <= git_buf_len(buf) &&
where + nb_to_remove <= git_buf_len(buf));
/* Ported from git.git
* https://github.com/git/git/blob/16eed7c/strbuf.c#L159-176
*/
if (git_buf_grow(buf, git_buf_len(buf) + nb_to_insert - nb_to_remove) < 0)
return -1;
memmove(buf->ptr + where + nb_to_insert,
buf->ptr + where + nb_to_remove,
buf->size - where - nb_to_remove);
memcpy(buf->ptr + where, data, nb_to_insert);
buf->size = buf->size + nb_to_insert - nb_to_remove;
buf->ptr[buf->size] = '\0';
return 0;
}
src/buffer.h
......@@ -158,4 +158,29 @@ void git_buf_unescape(git_buf *buf);
/* Write data as base64 encoded in buffer */
int git_buf_put_base64(git_buf *buf, const char *data, size_t len);
/*
* Insert, remove or replace a portion of the buffer.
*
* @param buf The buffer to work with
*
* @param where The location in the buffer where the transformation
* should be applied.
*
* @param nb_to_remove The number of chars to be removed. 0 to not
* remove any character in the buffer.
*
* @param data A pointer to the data which should be inserted.
*
* @param nb_to_insert The number of chars to be inserted. 0 to not
* insert any character from the buffer.
*
* @return 0 or an error code.
*/
int git_buf_splice(
git_buf *buf,
size_t where,
size_t nb_to_remove,
const char *data,
size_t nb_to_insert);
#endif
src/config.c
......@@ -720,3 +720,81 @@ fail_parse:
giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a 32-bit integer", value);
return -1;
}
struct rename_data
{
git_config *config;
const char *old_name;
const char *new_name;
};
static int rename_config_entries_cb(
const git_config_entry *entry,
void *payload)
{
struct rename_data *data = (struct rename_data *)payload;
if (data->new_name != NULL) {
git_buf name = GIT_BUF_INIT;
int error;
if (git_buf_printf(
&name,
"%s.%s",
data->new_name,
entry->name + strlen(data->old_name) + 1) < 0)
return -1;
error = git_config_set_string(
data->config,
git_buf_cstr(&name),
entry->value);
git_buf_free(&name);
if (error)
return error;
}
return git_config_delete(data->config, entry->name);
}
int git_config_rename_section(
git_repository *repo,
const char *old_section_name,
const char *new_section_name)
{
git_config *config;
git_buf pattern = GIT_BUF_INIT;
int error = -1;
struct rename_data data;
git_buf_puts_escape_regex(&pattern, old_section_name);
git_buf_puts(&pattern, "\\..+");
if (git_buf_oom(&pattern))
goto cleanup;
if (git_repository_config__weakptr(&config, repo) < 0)
goto cleanup;
data.config = config;
data.old_name = old_section_name;
data.new_name = new_section_name;
if ((error = git_config_foreach_match(
config,
git_buf_cstr(&pattern),
rename_config_entries_cb, &data)) < 0) {
giterr_set(GITERR_CONFIG,
"Cannot rename config section '%s' to '%s'",
old_section_name,
new_section_name);
goto cleanup;
}
error = 0;
cleanup:
git_buf_free(&pattern);
return error;
}
src/config.h
......@@ -27,4 +27,9 @@ extern int git_config_find_global_r(git_buf *global_config_path);
extern int git_config_find_xdg_r(git_buf *system_config_path);
extern int git_config_find_system_r(git_buf *system_config_path);
extern int git_config_rename_section(
git_repository *repo,
const char *old_section_name, /* eg "branch.dummy" */
const char *new_section_name); /* NULL to drop the old section */
#endif
src/refspec.c
......@@ -225,3 +225,14 @@ int git_refspec_transform_l(git_buf *out, const git_refspec *spec, const char *n
return refspec_transform(out, spec->dst, spec->src, name);
}
int git_refspec__serialize(git_buf *out, const git_refspec *refspec)
{
if (refspec->force)
git_buf_putc(out, '+');
git_buf_printf(out, "%s:%s",
refspec->src != NULL ? refspec->src : "",
refspec->dst != NULL ? refspec->dst : "");
return git_buf_oom(out) == false;
}
src/refspec.h
......@@ -51,4 +51,6 @@ int git_refspec_transform_r(git_buf *out, const git_refspec *spec, const char *n
*/
int git_refspec_transform_l(git_buf *out, const git_refspec *spec, const char *name);
int git_refspec__serialize(git_buf *out, const git_refspec *refspec);
#endif
src/remote.c
......@@ -201,12 +201,75 @@ cleanup:
return error;
}
static int ensure_remote_name_is_valid(const char *name)
{
git_buf buf = GIT_BUF_INIT;
git_refspec refspec;
int error = -1;
if (!name || *name == '\0')
goto cleanup;
git_buf_printf(&buf, "refs/heads/test:refs/remotes/%s/test", name);
error = git_refspec__parse(&refspec, git_buf_cstr(&buf), true);
git_buf_free(&buf);
git_refspec__free(&refspec);
cleanup:
if (error)
giterr_set(
GITERR_CONFIG,
"'%s' is not a valid remote name.", name);
return error;
}
static int update_config_refspec(
git_config *config,
const char *remote_name,
const git_refspec *refspec,
int git_direction)
{
git_buf name = GIT_BUF_INIT, value = GIT_BUF_INIT;
int error = -1;
if (refspec->src == NULL || refspec->dst == NULL)
return 0;
if (git_buf_printf(
&name,
"remote.%s.%s",
remote_name,
git_direction == GIT_DIR_FETCH ? "fetch" : "push") < 0)
goto cleanup;
if (git_refspec__serialize(&value, refspec) < 0)
goto cleanup;
error = git_config_set_string(
config,
git_buf_cstr(&name),
git_buf_cstr(&value));
cleanup:
git_buf_free(&name);
git_buf_free(&value);
return error;
}
int git_remote_save(const git_remote *remote)
{
int error;
git_config *config;
const char *tagopt = NULL;
git_buf buf = GIT_BUF_INIT, value = GIT_BUF_INIT;
git_buf buf = GIT_BUF_INIT;
assert(remote);
if (ensure_remote_name_is_valid(remote->name) < 0)
return -1;
if (git_repository_config__weakptr(&config, remote->repo) < 0)
return -1;
......@@ -239,33 +302,19 @@ int git_remote_save(const git_remote *remote)
}
}
if (remote->fetch.src != NULL && remote->fetch.dst != NULL) {
git_buf_clear(&buf);
git_buf_clear(&value);
git_buf_printf(&buf, "remote.%s.fetch", remote->name);
if (remote->fetch.force)
git_buf_putc(&value, '+');
git_buf_printf(&value, "%s:%s", remote->fetch.src, remote->fetch.dst);
if (git_buf_oom(&buf) || git_buf_oom(&value))
return -1;
if (git_config_set_string(config, git_buf_cstr(&buf), git_buf_cstr(&value)) < 0)
if (update_config_refspec(
config,
remote->name,
&remote->fetch,
GIT_DIR_FETCH) < 0)
goto on_error;
}
if (remote->push.src != NULL && remote->push.dst != NULL) {
git_buf_clear(&buf);
git_buf_clear(&value);
git_buf_printf(&buf, "remote.%s.push", remote->name);
if (remote->push.force)
git_buf_putc(&value, '+');
git_buf_printf(&value, "%s:%s", remote->push.src, remote->push.dst);
if (git_buf_oom(&buf) || git_buf_oom(&value))
return -1;
if (git_config_set_string(config, git_buf_cstr(&buf), git_buf_cstr(&value)) < 0)
if (update_config_refspec(
config,
remote->name,
&remote->push,
GIT_DIR_PUSH) < 0)
goto on_error;
}
/*
* What action to take depends on the old and new values. This
......@@ -300,13 +349,11 @@ int git_remote_save(const git_remote *remote)
}
git_buf_free(&buf);
git_buf_free(&value);
return 0;
on_error:
git_buf_free(&buf);
git_buf_free(&value);
return -1;
}
......@@ -760,3 +807,288 @@ void git_remote_set_autotag(git_remote *remote, int value)
{
remote->download_tags = value;
}
static int ensure_remote_doesnot_exist(git_repository *repo, const char *name)
{
int error;
git_remote *remote;
error = git_remote_load(&remote, repo, name);
if (error == GIT_ENOTFOUND)
return 0;
if (error < 0)
return error;
git_remote_free(remote);
giterr_set(
GITERR_CONFIG,
"Remote '%s' already exists.", name);
return GIT_EEXISTS;
}
static int rename_remote_config_section(
git_repository *repo,
const char *old_name,
const char *new_name)
{
git_buf old_section_name = GIT_BUF_INIT,
new_section_name = GIT_BUF_INIT;
int error = -1;
if (git_buf_printf(&old_section_name, "remote.%s", old_name) < 0)
goto cleanup;
if (git_buf_printf(&new_section_name, "remote.%s", new_name) < 0)
goto cleanup;
error = git_config_rename_section(
repo,
git_buf_cstr(&old_section_name),
git_buf_cstr(&new_section_name));
cleanup:
git_buf_free(&old_section_name);
git_buf_free(&new_section_name);
return error;
}
struct update_data
{
git_config *config;
const char *old_remote_name;
const char *new_remote_name;
};
static int update_config_entries_cb(
const git_config_entry *entry,
void *payload)
{
struct update_data *data = (struct update_data *)payload;
if (strcmp(entry->value, data->old_remote_name))
return 0;
return git_config_set_string(
data->config,
entry->name,
data->new_remote_name);
}
static int update_branch_remote_config_entry(
git_repository *repo,
const char *old_name,
const char *new_name)
{
git_config *config;
struct update_data data;
if (git_repository_config__weakptr(&config, repo) < 0)
return -1;
data.config = config;
data.old_remote_name = old_name;
data.new_remote_name = new_name;
return git_config_foreach_match(
config,
"branch\\..+\\.remote",
update_config_entries_cb, &data);
}
static int rename_cb(const char *ref, void *data)
{
if (git__prefixcmp(ref, GIT_REFS_REMOTES_DIR))
return 0;
return git_vector_insert((git_vector *)data, git__strdup(ref));
}
static int rename_one_remote_reference(
git_repository *repo,
const char *reference_name,
const char *old_remote_name,
const char *new_remote_name)
{
int error;
git_buf new_name = GIT_BUF_INIT;
git_reference *reference = NULL;
if (git_buf_printf(
&new_name,
GIT_REFS_REMOTES_DIR "%s%s",
new_remote_name,
reference_name + strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name)) < 0)
return -1;
if (git_reference_lookup(&reference, repo, reference_name) < 0)
goto cleanup;
error = git_reference_rename(reference, git_buf_cstr(&new_name), 0);
cleanup:
git_reference_free(reference);
git_buf_free(&new_name);
return error;
}
static int rename_remote_references(
git_repository *repo,
const char *old_name,
const char *new_name)
{
git_vector refnames;
int error = -1;
unsigned int i;
char *name;
if (git_vector_init(&refnames, 8, NULL) < 0)
goto cleanup;
if (git_reference_foreach(
repo,
GIT_REF_LISTALL,
rename_cb,
&refnames) < 0)
goto cleanup;
git_vector_foreach(&refnames, i, name) {
if ((error = rename_one_remote_reference(repo, name, old_name, new_name)) < 0)
goto cleanup;
}
error = 0;
cleanup:
git_vector_foreach(&refnames, i, name) {
git__free(name);
}
git_vector_free(&refnames);
return error;
}
static int rename_fetch_refspecs(
git_remote *remote,
const char *new_name,
int (*callback)(const char *problematic_refspec, void *payload),
void *payload)
{
git_config *config;
const git_refspec *fetch_refspec;
git_buf dst_prefix = GIT_BUF_INIT, serialized = GIT_BUF_INIT;
const char* pos;
int error = -1;
fetch_refspec = git_remote_fetchspec(remote);
/* Is there a refspec to deal with? */
if (fetch_refspec->src == NULL &&
fetch_refspec->dst == NULL)
return 0;
if (git_refspec__serialize(&serialized, fetch_refspec) < 0)
goto cleanup;
/* Is it an in-memory remote? */
if (remote->name == '\0') {
error = (callback(git_buf_cstr(&serialized), payload) < 0) ? GIT_EUSER : 0;
goto cleanup;
}
if (git_buf_printf(&dst_prefix, ":refs/remotes/%s/", remote->name) < 0)
goto cleanup;
pos = strstr(git_buf_cstr(&serialized), git_buf_cstr(&dst_prefix));
/* Does the dst part of the refspec follow the extected standard format? */
if (!pos) {
error = (callback(git_buf_cstr(&serialized), payload) < 0) ? GIT_EUSER : 0;
goto cleanup;
}
if (git_buf_splice(
&serialized,
pos - git_buf_cstr(&serialized) + strlen(":refs/remotes/"),
strlen(remote->name), new_name,
strlen(new_name)) < 0)
goto cleanup;
git_refspec__free(&remote->fetch);
if (git_refspec__parse(&remote->fetch, git_buf_cstr(&serialized), true) < 0)
goto cleanup;
if (git_repository_config__weakptr(&config, remote->repo) < 0)
goto cleanup;
error = update_config_refspec(config, new_name, &remote->fetch, GIT_DIR_FETCH);
cleanup:
git_buf_free(&serialized);
git_buf_free(&dst_prefix);
return error;
}
int git_remote_rename(
git_remote *remote,
const char *new_name,
int (*callback)(const char *problematic_refspec, void *payload),
void *payload)
{
int error;
assert(remote && new_name);
if ((error = ensure_remote_doesnot_exist(remote->repo, new_name)) < 0)
return error;
if ((error = ensure_remote_name_is_valid(new_name)) < 0)
return error;
if (!remote->name) {
if ((error = rename_fetch_refspecs(
remote,
new_name,
callback,
payload)) < 0)
return error;
remote->name = git__strdup(new_name);
return git_remote_save(remote);
}
if ((error = rename_remote_config_section(
remote->repo,
remote->name,
new_name)) < 0)
return error;
if ((error = update_branch_remote_config_entry(
remote->repo,
remote->name,
new_name)) < 0)
return error;
if ((error = rename_remote_references(
remote->repo,
remote->name,
new_name)) < 0)
return error;
if ((error = rename_fetch_refspecs(
remote,
new_name,
callback,
payload)) < 0)
return error;
git__free(remote->name);
remote->name = git__strdup(new_name);
return 0;
}
tests-clar/buf/splice.c 0 → 100644
#include "clar_libgit2.h"
#include "buffer.h"
static git_buf _buf;
void test_buf_splice__initialize(void) {
git_buf_init(&_buf, 16);
}
void test_buf_splice__cleanup(void) {
git_buf_free(&_buf);
}
void test_buf_splice__preprend(void)
{
git_buf_sets(&_buf, "world!");
cl_git_pass(git_buf_splice(&_buf, 0, 0, "Hello Dolly", strlen("Hello ")));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
void test_buf_splice__append(void)
{
git_buf_sets(&_buf, "Hello");
cl_git_pass(git_buf_splice(&_buf, git_buf_len(&_buf), 0, " world!", strlen(" world!")));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
void test_buf_splice__insert_at(void)
{
git_buf_sets(&_buf, "Hell world!");
cl_git_pass(git_buf_splice(&_buf, strlen("Hell"), 0, "o", strlen("o")));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
void test_buf_splice__remove_at(void)
{
git_buf_sets(&_buf, "Hello world of warcraft!");
cl_git_pass(git_buf_splice(&_buf, strlen("Hello world"), strlen(" of warcraft"), "", 0));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
void test_buf_splice__replace(void)
{
git_buf_sets(&_buf, "Hell0 w0rld!");
cl_git_pass(git_buf_splice(&_buf, strlen("Hell"), strlen("0 w0"), "o wo", strlen("o wo")));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
void test_buf_splice__replace_with_longer(void)
{
git_buf_sets(&_buf, "Hello you!");
cl_git_pass(git_buf_splice(&_buf, strlen("Hello "), strlen("you"), "world", strlen("world")));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
void test_buf_splice__replace_with_shorter(void)
{
git_buf_sets(&_buf, "Brave new world!");
cl_git_pass(git_buf_splice(&_buf, 0, strlen("Brave new"), "Hello", strlen("Hello")));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
void test_buf_splice__truncate(void)
{
git_buf_sets(&_buf, "Hello world!!");
cl_git_pass(git_buf_splice(&_buf, strlen("Hello world!"), strlen("!"), "", 0));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
void test_buf_splice__dont_do_anything(void)
{
git_buf_sets(&_buf, "Hello world!");
cl_git_pass(git_buf_splice(&_buf, 3, 0, "Hello", 0));
cl_assert_equal_s("Hello world!", git_buf_cstr(&_buf));
}
tests-clar/config/config_helpers.c 0 → 100644
#include "clar_libgit2.h"
#include "config_helpers.h"
#include "repository.h"
void assert_config_entry_existence(
git_repository *repo,
const char *name,
bool is_supposed_to_exist)
{
git_config *config;
const char *out;
int result;
cl_git_pass(git_repository_config__weakptr(&config, repo));
result = git_config_get_string(&out, config, name);
if (is_supposed_to_exist)
cl_git_pass(result);
else
cl_assert_equal_i(GIT_ENOTFOUND, result);
}
void assert_config_entry_value(
git_repository *repo,
const char *name,
const char *expected_value)
{
git_config *config;
const char *out;
cl_git_pass(git_repository_config__weakptr(&config, repo));
cl_git_pass(git_config_get_string(&out, config, name));
cl_assert_equal_s(expected_value, out);
}
tests-clar/config/config_helpers.h 0 → 100644
extern void assert_config_entry_existence(
git_repository *repo,
const char *name,
bool is_supposed_to_exist);
extern void assert_config_entry_value(
git_repository *repo,
const char *name,
const char *expected_value);
tests-clar/network/remoterename.c 0 → 100644
#include "clar_libgit2.h"
#include "config/config_helpers.h"
#include "repository.h"
static git_remote *_remote;
static git_repository *_repo;
void test_network_remoterename__initialize(void)
{
_repo = cl_git_sandbox_init("testrepo.git");
cl_git_pass(git_remote_load(&_remote, _repo, "test"));
}
void test_network_remoterename__cleanup(void)
{
git_remote_free(_remote);
cl_git_sandbox_cleanup();
}
static int dont_call_me_cb(const char *fetch_refspec, void *payload)
{
GIT_UNUSED(fetch_refspec);
GIT_UNUSED(payload);
cl_assert(false);
return -1;
}
void test_network_remoterename__renaming_a_remote_moves_related_configuration_section(void)
{
assert_config_entry_existence(_repo, "remote.test.fetch", true);
assert_config_entry_existence(_repo, "remote.just/renamed.fetch", false);
cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
assert_config_entry_existence(_repo, "remote.test.fetch", false);
assert_config_entry_existence(_repo, "remote.just/renamed.fetch", true);
}
void test_network_remoterename__renaming_a_remote_updates_branch_related_configuration_entries(void)
{
assert_config_entry_value(_repo, "branch.master.remote", "test");
cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
assert_config_entry_value(_repo, "branch.master.remote", "just/renamed");
}
void test_network_remoterename__renaming_a_remote_updates_default_fetchrefspec(void)
{
cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
assert_config_entry_value(_repo, "remote.just/renamed.fetch", "+refs/heads/*:refs/remotes/just/renamed/*");
}
void test_network_remoterename__renaming_a_remote_without_a_fetchrefspec_doesnt_create_one(void)
{
git_config *config;
git_remote_free(_remote);
cl_git_pass(git_repository_config__weakptr(&config, _repo));
cl_git_pass(git_config_delete(config, "remote.test.fetch"));
cl_git_pass(git_remote_load(&_remote, _repo, "test"));
assert_config_entry_existence(_repo, "remote.test.fetch", false);
cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
assert_config_entry_existence(_repo, "remote.just/renamed.fetch", false);
}
static int ensure_refspecs(const char* refspec_name, void *payload)
{
int i = 0;
bool found = false;
const char ** exp = (const char **)payload;
while (exp[i]) {
if (strcmp(exp[i++], refspec_name))
continue;
found = true;
break;
}
cl_assert(found);
return 0;
}
void test_network_remoterename__renaming_a_remote_notifies_of_non_default_fetchrefspec(void)
{
git_config *config;
char *expected_refspecs[] = {
"+refs/*:refs/*",
NULL
};
git_remote_free(_remote);
cl_git_pass(git_repository_config__weakptr(&config, _repo));
cl_git_pass(git_config_set_string(config, "remote.test.fetch", "+refs/*:refs/*"));
cl_git_pass(git_remote_load(&_remote, _repo, "test"));
cl_git_pass(git_remote_rename(_remote, "just/renamed", ensure_refspecs, &expected_refspecs));
assert_config_entry_value(_repo, "remote.just/renamed.fetch", "+refs/*:refs/*");
}
void test_network_remoterename__new_name_can_contain_dots(void)
{
cl_git_pass(git_remote_rename(_remote, "just.renamed", dont_call_me_cb, NULL));
cl_assert_equal_s("just.renamed", git_remote_name(_remote));
}
void test_network_remoterename__new_name_must_conform_to_reference_naming_conventions(void)
{
cl_git_fail(git_remote_rename(_remote, "new@{name", dont_call_me_cb, NULL));
}
void test_network_remoterename__renamed_name_is_persisted(void)
{
git_remote *renamed;
git_repository *another_repo;
cl_git_fail(git_remote_load(&renamed, _repo, "just/renamed"));
cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
cl_git_pass(git_repository_open(&another_repo, "testrepo.git"));
cl_git_pass(git_remote_load(&renamed, _repo, "just/renamed"));
git_remote_free(renamed);
git_repository_free(another_repo);
}
void test_network_remoterename__cannot_overwrite_an_existing_remote(void)
{
cl_assert_equal_i(GIT_EEXISTS, git_remote_rename(_remote, "test", dont_call_me_cb, NULL));
cl_assert_equal_i(GIT_EEXISTS, git_remote_rename(_remote, "test_with_pushurl", dont_call_me_cb, NULL));
}
void test_network_remoterename__renaming_an_inmemory_remote_persists_it(void)
{
git_remote *remote;
assert_config_entry_existence(_repo, "remote.durable.url", false);
cl_git_pass(git_remote_new(&remote, _repo, NULL, "git://github.com/libgit2/durable.git", NULL));
assert_config_entry_existence(_repo, "remote.durable.url", false);
cl_git_pass(git_remote_rename(remote, "durable", dont_call_me_cb, NULL));
assert_config_entry_value(_repo, "remote.durable.url", "git://github.com/libgit2/durable.git");
git_remote_free(remote);
}
void test_network_remoterename__renaming_an_inmemory_nameless_remote_notifies_the_inability_to_update_the_fetch_refspec(void)
{
git_remote *remote;
char *expected_refspecs[] = {
"+refs/heads/*:refs/remotes/volatile/*",
NULL
};
assert_config_entry_existence(_repo, "remote.volatile.url", false);
cl_git_pass(git_remote_new(
&remote,
_repo,
NULL,
"git://github.com/libgit2/volatile.git",
"+refs/heads/*:refs/remotes/volatile/*"));
cl_git_pass(git_remote_rename(remote, "durable", ensure_refspecs, &expected_refspecs));
git_remote_free(remote);
}
void test_network_remoterename__renaming_a_remote_moves_the_underlying_reference(void)
{
git_reference *underlying;
cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&underlying, _repo, "refs/remotes/just/renamed"));
cl_git_pass(git_reference_lookup(&underlying, _repo, "refs/remotes/test/master"));
git_reference_free(underlying);
cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&underlying, _repo, "refs/remotes/test/master"));
cl_git_pass(git_reference_lookup(&underlying, _repo, "refs/remotes/just/renamed/master"));
git_reference_free(underlying);
}
tests-clar/network/remotes.c
......@@ -10,9 +10,8 @@ static const git_refspec *_refspec;
void test_network_remotes__initialize(void)
{
cl_fixture_sandbox("testrepo.git");
_repo = cl_git_sandbox_init("testrepo.git");
cl_git_pass(git_repository_open(&_repo, "testrepo.git"));
cl_git_pass(git_remote_load(&_remote, _repo, "test"));
_refspec = git_remote_fetchspec(_remote);
......@@ -22,8 +21,7 @@ void test_network_remotes__initialize(void)
void test_network_remotes__cleanup(void)
{
git_remote_free(_remote);
git_repository_free(_repo);
cl_fixture_cleanup("testrepo.git");
cl_git_sandbox_cleanup();
}
void test_network_remotes__parsing(void)
......@@ -73,7 +71,7 @@ void test_network_remotes__parsing_local_path_fails_if_path_not_found(void)
void test_network_remotes__supported_transport_methods_are_supported(void)
{
cl_assert( git_remote_supported_url("git://github.com/libgit2/libgit2") );
cl_assert( git_remote_supported_url("git://github.com/libgit2/libgit2") );
}
void test_network_remotes__unsupported_transport_methods_are_unsupported(void)
......@@ -226,6 +224,29 @@ void test_network_remotes__add(void)
cl_assert_equal_s(git_remote_url(_remote), "http://github.com/libgit2/libgit2");
}
void test_network_remotes__cannot_add_a_nameless_remote(void)
{
git_remote *remote;
cl_git_fail(git_remote_add(&remote, _repo, NULL, "git://github.com/libgit2/libgit2"));
cl_git_fail(git_remote_add(&remote, _repo, "", "git://github.com/libgit2/libgit2"));
}
void test_network_remotes__cannot_save_a_nameless_remote(void)
{
git_remote *remote;
cl_git_pass(git_remote_new(&remote, _repo, NULL, "git://github.com/libgit2/libgit2", NULL));
cl_git_fail(git_remote_save(remote));
git_remote_free(remote);
cl_git_pass(git_remote_new(&remote, _repo, "", "git://github.com/libgit2/libgit2", NULL));
cl_git_fail(git_remote_save(remote));
git_remote_free(remote);
}
void test_network_remotes__tagopt(void)
{
const char *opt;
......
tests-clar/refs/branches/delete.c
#include "clar_libgit2.h"
#include "refs.h"
#include "repo/repo_helpers.h"
#include "config/config_helpers.h"
static git_repository *repo;
static git_reference *fake_remote;
......@@ -90,3 +91,17 @@ void test_refs_branches_delete__can_delete_a_remote_branch(void)
cl_git_pass(git_branch_lookup(&branch, repo, "nulltoken/master", GIT_BRANCH_REMOTE));
cl_git_pass(git_branch_delete(branch));
}
void test_refs_branches_delete__deleting_a_branch_removes_related_configuration_data(void)
{
git_reference *branch;
assert_config_entry_existence(repo, "branch.track-local.remote", true);
assert_config_entry_existence(repo, "branch.track-local.merge", true);
cl_git_pass(git_branch_lookup(&branch, repo, "track-local", GIT_BRANCH_LOCAL));
cl_git_pass(git_branch_delete(branch));
assert_config_entry_existence(repo, "branch.track-local.remote", false);
assert_config_entry_existence(repo, "branch.track-local.merge", false);
}
\ No newline at end of file
tests-clar/refs/branches/move.c
#include "clar_libgit2.h"
#include "refs.h"
#include "config/config_helpers.h"
static git_repository *repo;
static git_reference *ref;
......@@ -63,6 +64,27 @@ void test_refs_branches_move__can_force_move_over_an_existing_branch(void)
cl_git_pass(git_branch_move(ref, "master", 1));
}
void test_refs_branches_move__moving_a_branch_moves_related_configuration_data(void)
{
git_reference *branch;
cl_git_pass(git_branch_lookup(&branch, repo, "track-local", GIT_BRANCH_LOCAL));
assert_config_entry_existence(repo, "branch.track-local.remote", true);
assert_config_entry_existence(repo, "branch.track-local.merge", true);
assert_config_entry_existence(repo, "branch.moved.remote", false);
assert_config_entry_existence(repo, "branch.moved.merge", false);
cl_git_pass(git_branch_move(branch, "moved", 0));
assert_config_entry_existence(repo, "branch.track-local.remote", false);
assert_config_entry_existence(repo, "branch.track-local.merge", false);
assert_config_entry_existence(repo, "branch.moved.remote", true);
assert_config_entry_existence(repo, "branch.moved.merge", true);
git_reference_free(branch);
}
void test_refs_branches_move__moving_the_branch_pointed_at_by_HEAD_updates_HEAD(void)
{
git_reference *branch;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment