rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/tests-clar/refs/branches/listall.c

@@ -0,0 +1,78 @@
+#include "clar_libgit2.h"
+#include "refs.h"
+#include "branch.h"
+
+static git_repository *repo;
+static git_strarray branch_list;
+static git_reference *fake_remote;
+
+void test_refs_branches_listall__initialize(void)
+{
+	git_oid id;
+
+	cl_fixture_sandbox("testrepo.git");
+	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
+
+	cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"));
+	cl_git_pass(git_reference_create_oid(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0));
+}
+
+void test_refs_branches_listall__cleanup(void)
+{
+	git_strarray_free(&branch_list);
+	git_reference_free(fake_remote);
+	git_repository_free(repo);
+
+	cl_fixture_cleanup("testrepo.git");
+}
+
+static void assert_retrieval(unsigned int flags, unsigned int expected_count)
+{
+	cl_git_pass(git_branch_list(&branch_list, repo, flags));
+
+	cl_assert_equal_i(branch_list.count, expected_count);
+}
+
+void test_refs_branches_listall__retrieve_all_branches(void)
+{
+	assert_retrieval(GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE, 9);
+}
+
+void test_refs_branches_listall__retrieve_remote_branches(void)
+{
+	assert_retrieval(GIT_BRANCH_REMOTE, 2);
+}
+
+void test_refs_branches_listall__retrieve_local_branches(void)
+{
+	assert_retrieval(GIT_BRANCH_LOCAL, 7);
+}
+
+static void assert_branch_list_contains(git_strarray *branches, const char* expected_branch_name)
+{
+	unsigned int i;
+
+	for (i = 0; i < branches->count; i++) {
+		if (strcmp(expected_branch_name, branches->strings[i]) == 0)
+			return;
+	}
+
+	cl_fail("expected branch not found in list.");
+}
+
+/*
+ * $ git branch -r
+ *  nulltoken/HEAD -> nulltoken/master
+ *  nulltoken/master
+ */
+void test_refs_branches_listall__retrieve_remote_symbolic_HEAD_when_present(void)
+{
+	git_reference_free(fake_remote);
+	cl_git_pass(git_reference_create_symbolic(&fake_remote, repo, "refs/remotes/nulltoken/HEAD", "refs/remotes/nulltoken/master", 0));
+
+	cl_git_pass(git_branch_list(&branch_list, repo, GIT_BRANCH_REMOTE));
+	
+	cl_assert_equal_i(3, branch_list.count);
+	assert_branch_list_contains(&branch_list, "refs/remotes/nulltoken/HEAD");
+	assert_branch_list_contains(&branch_list, "refs/remotes/nulltoken/master");
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/refs/branches/move.c

@@ -0,0 +1,72 @@
+#include "clar_libgit2.h"
+#include "branch.h"
+
+static git_repository *repo;
+
+void test_refs_branches_move__initialize(void)
+{
+	cl_fixture_sandbox("testrepo.git");
+	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
+}
+
+void test_refs_branches_move__cleanup(void)
+{
+	git_repository_free(repo);
+
+	cl_fixture_cleanup("testrepo.git");
+}
+
+#define NEW_BRANCH_NAME "new-branch-on-the-block"
+
+void test_refs_branches_move__can_move_a_local_branch(void)
+{
+	cl_git_pass(git_branch_move(repo, "br2", NEW_BRANCH_NAME, 0));
+}
+
+void test_refs_branches_move__can_move_a_local_branch_to_a_different_namespace(void)
+{
+	/* Downward */
+	cl_git_pass(git_branch_move(repo, "br2", "somewhere/" NEW_BRANCH_NAME, 0));
+
+	/* Upward */
+	cl_git_pass(git_branch_move(repo, "somewhere/" NEW_BRANCH_NAME, "br2", 0));
+}
+
+void test_refs_branches_move__can_move_a_local_branch_to_a_partially_colliding_namespace(void)
+{
+	/* Downward */
+	cl_git_pass(git_branch_move(repo, "br2", "br2/" NEW_BRANCH_NAME, 0));
+
+	/* Upward */
+	cl_git_pass(git_branch_move(repo, "br2/" NEW_BRANCH_NAME, "br2", 0));
+}
+
+void test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_collide_with_an_existing_one(void)
+{
+	cl_git_fail(git_branch_move(repo, "br2", "master", 0));
+}
+
+void test_refs_branches_move__can_not_move_a_non_existing_branch(void)
+{
+	cl_git_fail(git_branch_move(repo, "i-am-no-branch", NEW_BRANCH_NAME, 0));
+}
+
+void test_refs_branches_move__can_force_move_over_an_existing_branch(void)
+{
+	cl_git_pass(git_branch_move(repo, "br2", "master", 1));
+}
+
+void test_refs_branches_move__can_not_move_a_branch_through_its_canonical_name(void)
+{
+	cl_git_fail(git_branch_move(repo, "refs/heads/br2", NEW_BRANCH_NAME, 1));
+}
+
+void test_refs_branches_move__moving_a_non_exisiting_branch_returns_ENOTFOUND(void)
+{
+	int error;
+
+	error = git_branch_move(repo, "where/am/I", NEW_BRANCH_NAME, 0);
+	cl_git_fail(error);
+
+	cl_assert_equal_i(GIT_ENOTFOUND, error);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/refs/crashes.c

@@ -0,0 +1,17 @@
+#include "clar_libgit2.h"
+
+void test_refs_crashes__double_free(void)
+{
+	git_repository *repo;
+	git_reference *ref, *ref2;
+	const char *REFNAME = "refs/heads/xxx";
+
+	cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
+	cl_git_pass(git_reference_create_symbolic(&ref, repo, REFNAME, "refs/heads/master", 0));
+	cl_git_pass(git_reference_lookup(&ref2, repo, REFNAME));
+	cl_git_pass(git_reference_delete(ref));
+	/* reference is gone from disk, so reloading it will fail */
+	cl_git_fail(git_reference_reload(ref2));
+
+	git_repository_free(repo);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/refs/create.c

@@ -0,0 +1,149 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+
+static const char *current_master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
+static const char *current_head_target = "refs/heads/master";
+
+static git_repository *g_repo;
+
+void test_refs_create__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_refs_create__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+void test_refs_create__symbolic(void)
+{
+   // create a new symbolic reference
+	git_reference *new_reference, *looked_up_ref, *resolved_ref;
+	git_repository *repo2;
+	git_oid id;
+	git_buf ref_path = GIT_BUF_INIT;
+
+	const char *new_head_tracker = "another-head-tracker";
+
+	git_oid_fromstr(&id, current_master_tip);
+
+	/* Retrieve the physical path to the symbolic ref for further cleaning */
+	cl_git_pass(git_buf_joinpath(&ref_path, g_repo->path_repository, new_head_tracker));
+	git_buf_free(&ref_path);
+
+	/* Create and write the new symbolic reference */
+	cl_git_pass(git_reference_create_symbolic(&new_reference, g_repo, new_head_tracker, current_head_target, 0));
+
+	/* Ensure the reference can be looked-up... */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head_tracker));
+	cl_assert(git_reference_type(looked_up_ref) & GIT_REF_SYMBOLIC);
+	cl_assert(git_reference_is_packed(looked_up_ref) == 0);
+	cl_assert_equal_s(looked_up_ref->name, new_head_tracker);
+
+	/* ...peeled.. */
+	cl_git_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
+	cl_assert(git_reference_type(resolved_ref) == GIT_REF_OID);
+
+	/* ...and that it points to the current master tip */
+	cl_assert(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0);
+	git_reference_free(looked_up_ref);
+	git_reference_free(resolved_ref);
+
+	/* Similar test with a fresh new repository */
+	cl_git_pass(git_repository_open(&repo2, "testrepo"));
+
+	cl_git_pass(git_reference_lookup(&looked_up_ref, repo2, new_head_tracker));
+	cl_git_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
+	cl_assert(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0);
+
+	git_repository_free(repo2);
+
+	git_reference_free(new_reference);
+	git_reference_free(looked_up_ref);
+	git_reference_free(resolved_ref);
+}
+
+void test_refs_create__deep_symbolic(void)
+{
+   // create a deep symbolic reference
+	git_reference *new_reference, *looked_up_ref, *resolved_ref;
+	git_oid id;
+	git_buf ref_path = GIT_BUF_INIT;
+
+	const char *new_head_tracker = "deep/rooted/tracker";
+
+	git_oid_fromstr(&id, current_master_tip);
+
+	cl_git_pass(git_buf_joinpath(&ref_path, g_repo->path_repository, new_head_tracker));
+	cl_git_pass(git_reference_create_symbolic(&new_reference, g_repo, new_head_tracker, current_head_target, 0));
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head_tracker));
+	cl_git_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
+	cl_assert(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0);
+
+	git_reference_free(new_reference);
+	git_reference_free(looked_up_ref);
+	git_reference_free(resolved_ref);
+	git_buf_free(&ref_path);
+}
+
+void test_refs_create__oid(void)
+{
+   // create a new OID reference
+	git_reference *new_reference, *looked_up_ref;
+	git_repository *repo2;
+	git_oid id;
+	git_buf ref_path = GIT_BUF_INIT;
+
+	const char *new_head = "refs/heads/new-head";
+
+	git_oid_fromstr(&id, current_master_tip);
+
+	/* Retrieve the physical path to the symbolic ref for further cleaning */
+	cl_git_pass(git_buf_joinpath(&ref_path, g_repo->path_repository, new_head));
+
+	/* Create and write the new object id reference */
+	cl_git_pass(git_reference_create_oid(&new_reference, g_repo, new_head, &id, 0));
+
+	/* Ensure the reference can be looked-up... */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head));
+	cl_assert(git_reference_type(looked_up_ref) & GIT_REF_OID);
+	cl_assert(git_reference_is_packed(looked_up_ref) == 0);
+	cl_assert_equal_s(looked_up_ref->name, new_head);
+
+	/* ...and that it points to the current master tip */
+	cl_assert(git_oid_cmp(&id, git_reference_oid(looked_up_ref)) == 0);
+	git_reference_free(looked_up_ref);
+
+	/* Similar test with a fresh new repository */
+	cl_git_pass(git_repository_open(&repo2, "testrepo"));
+
+	cl_git_pass(git_reference_lookup(&looked_up_ref, repo2, new_head));
+	cl_assert(git_oid_cmp(&id, git_reference_oid(looked_up_ref)) == 0);
+
+	git_repository_free(repo2);
+
+	git_reference_free(new_reference);
+	git_reference_free(looked_up_ref);
+	git_buf_free(&ref_path);
+}
+
+void test_refs_create__oid_unknown(void)
+{
+   // Can not create a new OID reference which targets at an unknown id
+	git_reference *new_reference, *looked_up_ref;
+	git_oid id;
+
+	const char *new_head = "refs/heads/new-head";
+
+	git_oid_fromstr(&id, "deadbeef3f795b2b4353bcce3a527ad0a4f7f644");
+
+	/* Create and write the new object id reference */
+	cl_git_fail(git_reference_create_oid(&new_reference, g_repo, new_head, &id, 0));
+
+	/* Ensure the reference can't be looked-up... */
+	cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, new_head));
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/refs/delete.c

@@ -0,0 +1,85 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+
+static const char *packed_test_head_name = "refs/heads/packed-test";
+static const char *current_master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
+
+static git_repository *g_repo;
+
+
+
+void test_refs_delete__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_refs_delete__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+
+
+void test_refs_delete__packed_loose(void)
+{
+   // deleting a ref which is both packed and loose should remove both tracks in the filesystem
+	git_reference *looked_up_ref, *another_looked_up_ref;
+	git_buf temp_path = GIT_BUF_INIT;
+
+	/* Ensure the loose reference exists on the file system */
+	cl_git_pass(git_buf_joinpath(&temp_path, g_repo->path_repository, packed_test_head_name));
+	cl_assert(git_path_exists(temp_path.ptr));
+
+	/* Lookup the reference */
+	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_test_head_name));
+
+	/* Ensure it's the loose version that has been found */
+	cl_assert(git_reference_is_packed(looked_up_ref) == 0);
+
+	/* Now that the reference is deleted... */
+	cl_git_pass(git_reference_delete(looked_up_ref));
+
+	/* Looking up the reference once again should not retrieve it */
+	cl_git_fail(git_reference_lookup(&another_looked_up_ref, g_repo, packed_test_head_name));
+
+	/* Ensure the loose reference doesn't exist any longer on the file system */
+	cl_assert(!git_path_exists(temp_path.ptr));
+
+	git_reference_free(another_looked_up_ref);
+	git_buf_free(&temp_path);
+}
+
+void test_refs_delete__packed_only(void)
+{
+   // can delete a just packed reference
+	git_reference *ref;
+	git_oid id;
+	const char *new_ref = "refs/heads/new_ref";
+
+	git_oid_fromstr(&id, current_master_tip);
+
+	/* Create and write the new object id reference */
+	cl_git_pass(git_reference_create_oid(&ref, g_repo, new_ref, &id, 0));
+	git_reference_free(ref);
+
+	/* Lookup the reference */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, new_ref));
+
+	/* Ensure it's a loose reference */
+	cl_assert(git_reference_is_packed(ref) == 0);
+
+	/* Pack all existing references */
+	cl_git_pass(git_reference_packall(g_repo));
+
+	/* Reload the reference from disk */
+	cl_git_pass(git_reference_reload(ref));
+
+	/* Ensure it's a packed reference */
+	cl_assert(git_reference_is_packed(ref) == 1);
+
+	/* This should pass */
+	cl_git_pass(git_reference_delete(ref));
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/refs/list.c

@@ -0,0 +1,53 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+
+static git_repository *g_repo;
+
+
+
+void test_refs_list__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_refs_list__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+
+
+void test_refs_list__all(void)
+{
+   // try to list all the references in our test repo
+	git_strarray ref_list;
+
+	cl_git_pass(git_reference_list(&ref_list, g_repo, GIT_REF_LISTALL));
+
+	/*{
+		unsigned short i;
+		for (i = 0; i < ref_list.count; ++i)
+			printf("# %s\n", ref_list.strings[i]);
+	}*/
+
+	/* We have exactly 9 refs in total if we include the packed ones:
+	 * there is a reference that exists both in the packfile and as
+	 * loose, but we only list it once */
+	cl_assert(ref_list.count == 9);
+
+	git_strarray_free(&ref_list);
+}
+
+void test_refs_list__symbolic_only(void)
+{
+   // try to list only the symbolic references
+	git_strarray ref_list;
+
+	cl_git_pass(git_reference_list(&ref_list, g_repo, GIT_REF_SYMBOLIC));
+	cl_assert(ref_list.count == 0); /* no symrefs in the test repo */
+
+	git_strarray_free(&ref_list);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/refs/listall.c

@@ -0,0 +1,36 @@
+#include "clar_libgit2.h"
+#include "posix.h"
+
+static git_repository *repo;
+static git_strarray ref_list;
+
+static void ensure_no_refname_starts_with_a_forward_slash(const char *path)
+{
+	size_t i;
+
+	cl_git_pass(git_repository_open(&repo, path));
+	cl_git_pass(git_reference_list(&ref_list, repo, GIT_REF_LISTALL));
+
+	cl_assert(ref_list.count > 0);
+
+	for (i = 0; i < ref_list.count; i++)
+		cl_assert(git__prefixcmp(ref_list.strings[i], "/") != 0);
+
+	git_strarray_free(&ref_list);
+	git_repository_free(repo);
+}
+
+void test_refs_listall__from_repository_opened_through_workdir_path(void)
+{
+	cl_fixture_sandbox("status");
+	cl_git_pass(p_rename("status/.gitted", "status/.git"));
+
+	ensure_no_refname_starts_with_a_forward_slash("status");
+
+	cl_fixture_cleanup("status");
+}
+
+void test_refs_listall__from_repository_opened_through_gitdir_path(void)
+{
+	ensure_no_refname_starts_with_a_forward_slash(cl_fixture("testrepo.git"));
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/refs/lookup.c

@@ -0,0 +1,42 @@
+#include "clar_libgit2.h"
+#include "refs.h"
+
+static git_repository *g_repo;
+
+void test_refs_lookup__initialize(void)
+{
+	g_repo = cl_git_sandbox_init("testrepo.git");
+}
+
+void test_refs_lookup__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_refs_lookup__with_resolve(void)
+{
+	git_reference *a, *b, *temp;
+
+	cl_git_pass(git_reference_lookup(&temp, g_repo, "HEAD"));
+	cl_git_pass(git_reference_resolve(&a, temp));
+	git_reference_free(temp);
+
+	cl_git_pass(git_reference_lookup_resolved(&b, g_repo, "HEAD", 5));
+	cl_assert(git_reference_cmp(a, b) == 0);
+	git_reference_free(b);
+
+	cl_git_pass(git_reference_lookup_resolved(&b, g_repo, "head-tracker", 5));
+	cl_assert(git_reference_cmp(a, b) == 0);
+	git_reference_free(b);
+
+	git_reference_free(a);
+}
+
+void test_refs_lookup__oid(void)
+{
+	git_oid tag, expected;
+
+	cl_git_pass(git_reference_name_to_oid(&tag, g_repo, "refs/tags/point_to_blob"));
+	cl_git_pass(git_oid_fromstr(&expected, "1385f264afb75a56a5bec74243be9b367ba4ca08"));
+	cl_assert(git_oid_cmp(&tag, &expected) == 0);
+}