| #include "clar_libgit2.h" |
| #include "git2/checkout.h" |
| #include "git2/rebase.h" |
| #include "posix.h" |
| #include "signature.h" |
| |
| #include <fcntl.h> |
| |
| static git_repository *repo; |
| static git_signature *signature; |
| |
| static void set_core_autocrlf_to(git_repository *repo, bool value) |
| { |
| git_config *cfg; |
| |
| cl_git_pass(git_repository_config(&cfg, repo)); |
| cl_git_pass(git_config_set_bool(cfg, "core.autocrlf", value)); |
| |
| git_config_free(cfg); |
| } |
| |
| // Fixture setup and teardown |
| void test_rebase_merge__initialize(void) |
| { |
| repo = cl_git_sandbox_init("rebase"); |
| cl_git_pass(git_signature_new(&signature, |
| "Rebaser", "rebaser@rebaser.rb", 1405694510, 0)); |
| |
| set_core_autocrlf_to(repo, false); |
| } |
| |
| void test_rebase_merge__cleanup(void) |
| { |
| git_signature_free(signature); |
| cl_git_sandbox_cleanup(); |
| } |
| |
| void test_rebase_merge__next(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_status_list *status_list; |
| const git_status_entry *status_entry; |
| git_oid pick_id, file1_id; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef")); |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| |
| git_oid_fromstr(&pick_id, "da9c51a23d02d931a486f45ad18cda05cf5d2b94"); |
| |
| cl_assert_equal_i(GIT_REBASE_OPERATION_PICK, rebase_operation->type); |
| cl_assert_equal_oid(&pick_id, &rebase_operation->id); |
| cl_assert_equal_file("da9c51a23d02d931a486f45ad18cda05cf5d2b94\n", 41, "rebase/.git/rebase-merge/current"); |
| cl_assert_equal_file("1\n", 2, "rebase/.git/rebase-merge/msgnum"); |
| |
| cl_git_pass(git_status_list_new(&status_list, repo, NULL)); |
| cl_assert_equal_i(1, git_status_list_entrycount(status_list)); |
| cl_assert(status_entry = git_status_byindex(status_list, 0)); |
| |
| cl_assert_equal_s("beef.txt", status_entry->head_to_index->new_file.path); |
| |
| git_oid_fromstr(&file1_id, "8d95ea62e621f1d38d230d9e7d206e41096d76af"); |
| cl_assert_equal_oid(&file1_id, &status_entry->head_to_index->new_file.id); |
| |
| git_status_list_free(status_list); |
| 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_rebase_merge__next_with_conflicts(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_status_list *status_list; |
| const git_status_entry *status_entry; |
| git_oid pick_id, commit_id; |
| |
| const char *expected_merge = |
| "ASPARAGUS SOUP.\n" |
| "\n" |
| "<<<<<<< master\n" |
| "TAKE FOUR LARGE BUNCHES of asparagus, scrape it nicely, cut off one inch\n" |
| "OF THE TOPS, and lay them in water, chop the stalks and put them on the\n" |
| "FIRE WITH A PIECE OF BACON, a large onion cut up, and pepper and salt;\n" |
| "ADD TWO QUARTS OF WATER, boil them till the stalks are quite soft, then\n" |
| "PULP THEM THROUGH A SIEVE, and strain the water to it, which must be put\n" |
| "=======\n" |
| "Take four large bunches of asparagus, scrape it nicely, CUT OFF ONE INCH\n" |
| "of the tops, and lay them in water, chop the stalks and PUT THEM ON THE\n" |
| "fire with a piece of bacon, a large onion cut up, and pepper and salt;\n" |
| "add two quarts of water, boil them till the stalks are quite soft, then\n" |
| "pulp them through a sieve, and strain the water to it, which must be put\n" |
| ">>>>>>> Conflicting modification 1 to asparagus\n" |
| "back in the pot; put into it a chicken cut up, with the tops of\n" |
| "asparagus which had been laid by, boil it until these last articles are\n" |
| "sufficiently done, thicken with flour, butter and milk, and serve it up.\n"; |
| |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| |
| git_oid_fromstr(&pick_id, "33f915f9e4dbd9f4b24430e48731a59b45b15500"); |
| |
| cl_assert_equal_i(GIT_REBASE_OPERATION_PICK, rebase_operation->type); |
| cl_assert_equal_oid(&pick_id, &rebase_operation->id); |
| cl_assert_equal_file("33f915f9e4dbd9f4b24430e48731a59b45b15500\n", 41, "rebase/.git/rebase-merge/current"); |
| cl_assert_equal_file("1\n", 2, "rebase/.git/rebase-merge/msgnum"); |
| |
| cl_git_pass(git_status_list_new(&status_list, repo, NULL)); |
| cl_assert_equal_i(1, git_status_list_entrycount(status_list)); |
| cl_assert(status_entry = git_status_byindex(status_list, 0)); |
| |
| cl_assert_equal_s("asparagus.txt", status_entry->head_to_index->new_file.path); |
| |
| cl_assert_equal_file(expected_merge, strlen(expected_merge), "rebase/asparagus.txt"); |
| |
| cl_git_fail_with(GIT_EUNMERGED, git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL)); |
| |
| git_status_list_free(status_list); |
| 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_rebase_merge__next_stops_with_iterover(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id; |
| int error; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef")); |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_fail(error = git_rebase_next(&rebase_operation, rebase)); |
| cl_assert_equal_i(GIT_ITEROVER, error); |
| |
| cl_assert_equal_file("5\n", 2, "rebase/.git/rebase-merge/end"); |
| cl_assert_equal_file("5\n", 2, "rebase/.git/rebase-merge/msgnum"); |
| |
| 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_rebase_merge__commit(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id, tree_id, parent_id; |
| git_signature *author; |
| git_commit *commit; |
| git_reflog *reflog; |
| const git_reflog_entry *reflog_entry; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef")); |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_commit_lookup(&commit, repo, &commit_id)); |
| |
| git_oid_fromstr(&parent_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00"); |
| cl_assert_equal_i(1, git_commit_parentcount(commit)); |
| cl_assert_equal_oid(&parent_id, git_commit_parent_id(commit, 0)); |
| |
| git_oid_fromstr(&tree_id, "4461379789c777d2a6c1f2ee0e9d6c86731b9992"); |
| cl_assert_equal_oid(&tree_id, git_commit_tree_id(commit)); |
| |
| cl_assert_equal_s(NULL, git_commit_message_encoding(commit)); |
| cl_assert_equal_s("Modification 1 to beef\n", git_commit_message(commit)); |
| |
| cl_git_pass(git_signature_new(&author, |
| "Edward Thomson", "ethomson@edwardthomson.com", 1405621769, 0-(4*60))); |
| cl_assert(git_signature__equal(author, git_commit_author(commit))); |
| |
| cl_assert(git_signature__equal(signature, git_commit_committer(commit))); |
| |
| /* Make sure the reflogs are updated appropriately */ |
| cl_git_pass(git_reflog_read(&reflog, repo, "HEAD")); |
| cl_assert(reflog_entry = git_reflog_entry_byindex(reflog, 0)); |
| cl_assert_equal_oid(&parent_id, git_reflog_entry_id_old(reflog_entry)); |
| cl_assert_equal_oid(&commit_id, git_reflog_entry_id_new(reflog_entry)); |
| cl_assert_equal_s("rebase: Modification 1 to beef", git_reflog_entry_message(reflog_entry)); |
| |
| git_reflog_free(reflog); |
| git_signature_free(author); |
| git_commit_free(commit); |
| 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_rebase_merge__commit_with_id(void) |
| { |
| git_rebase *rebase; |
| git_oid branch_id, upstream_id; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id, tree_id, parent_id; |
| git_signature *author; |
| git_commit *commit; |
| git_reflog *reflog; |
| const git_reflog_entry *reflog_entry; |
| |
| cl_git_pass(git_oid_fromstr(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64")); |
| cl_git_pass(git_oid_fromstr(&upstream_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00")); |
| |
| cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id)); |
| cl_git_pass(git_annotated_commit_lookup(&upstream_head, repo, &upstream_id)); |
| |
| cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_commit_lookup(&commit, repo, &commit_id)); |
| |
| git_oid_fromstr(&parent_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00"); |
| cl_assert_equal_i(1, git_commit_parentcount(commit)); |
| cl_assert_equal_oid(&parent_id, git_commit_parent_id(commit, 0)); |
| |
| git_oid_fromstr(&tree_id, "4461379789c777d2a6c1f2ee0e9d6c86731b9992"); |
| cl_assert_equal_oid(&tree_id, git_commit_tree_id(commit)); |
| |
| cl_assert_equal_s(NULL, git_commit_message_encoding(commit)); |
| cl_assert_equal_s("Modification 1 to beef\n", git_commit_message(commit)); |
| |
| cl_git_pass(git_signature_new(&author, |
| "Edward Thomson", "ethomson@edwardthomson.com", 1405621769, 0-(4*60))); |
| cl_assert(git_signature__equal(author, git_commit_author(commit))); |
| |
| cl_assert(git_signature__equal(signature, git_commit_committer(commit))); |
| |
| /* Make sure the reflogs are updated appropriately */ |
| cl_git_pass(git_reflog_read(&reflog, repo, "HEAD")); |
| cl_assert(reflog_entry = git_reflog_entry_byindex(reflog, 0)); |
| cl_assert_equal_oid(&parent_id, git_reflog_entry_id_old(reflog_entry)); |
| cl_assert_equal_oid(&commit_id, git_reflog_entry_id_new(reflog_entry)); |
| cl_assert_equal_s("rebase: Modification 1 to beef", git_reflog_entry_message(reflog_entry)); |
| |
| git_reflog_free(reflog); |
| git_signature_free(author); |
| git_commit_free(commit); |
| git_annotated_commit_free(branch_head); |
| git_annotated_commit_free(upstream_head); |
| git_rebase_free(rebase); |
| } |
| |
| void test_rebase_merge__blocked_when_dirty(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef")); |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| /* Allow untracked files */ |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_mkfile("rebase/untracked_file.txt", "This is untracked\n"); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| /* Do not allow unstaged */ |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_mkfile("rebase/veal.txt", "This is an unstaged change\n"); |
| cl_git_fail_with(GIT_EUNMERGED, git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| 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_rebase_merge__commit_updates_rewritten(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef")); |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_assert_equal_file( |
| "da9c51a23d02d931a486f45ad18cda05cf5d2b94 776e4c48922799f903f03f5f6e51da8b01e4cce0\n" |
| "8d1f13f93c4995760ac07d129246ac1ff64c0be9 ba1f9b4fd5cf8151f7818be2111cc0869f1eb95a\n", |
| 164, "rebase/.git/rebase-merge/rewritten"); |
| |
| 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_rebase_merge__commit_drops_already_applied(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id; |
| int error; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef")); |
| cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/green_pea")); |
| |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_fail(error = git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_assert_equal_i(GIT_EAPPLIED, error); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_assert_equal_file( |
| "8d1f13f93c4995760ac07d129246ac1ff64c0be9 2ac4fb7b74c1287f6c792acad759e1ec01e18dae\n", |
| 82, "rebase/.git/rebase-merge/rewritten"); |
| |
| 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_rebase_merge__finish(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref, *head_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id; |
| git_reflog *reflog; |
| const git_reflog_entry *reflog_entry; |
| int error; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/gravy")); |
| cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal")); |
| |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_fail(error = git_rebase_next(&rebase_operation, rebase)); |
| cl_assert_equal_i(GIT_ITEROVER, error); |
| |
| cl_git_pass(git_rebase_finish(rebase, signature)); |
| |
| cl_assert_equal_i(GIT_REPOSITORY_STATE_NONE, git_repository_state(repo)); |
| |
| cl_git_pass(git_reference_lookup(&head_ref, repo, "HEAD")); |
| cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head_ref)); |
| cl_assert_equal_s("refs/heads/gravy", git_reference_symbolic_target(head_ref)); |
| |
| /* Make sure the reflogs are updated appropriately */ |
| cl_git_pass(git_reflog_read(&reflog, repo, "HEAD")); |
| cl_assert(reflog_entry = git_reflog_entry_byindex(reflog, 0)); |
| cl_assert_equal_oid(&commit_id, git_reflog_entry_id_old(reflog_entry)); |
| cl_assert_equal_oid(&commit_id, git_reflog_entry_id_new(reflog_entry)); |
| cl_assert_equal_s("rebase finished: returning to refs/heads/gravy", git_reflog_entry_message(reflog_entry)); |
| git_reflog_free(reflog); |
| |
| cl_git_pass(git_reflog_read(&reflog, repo, "refs/heads/gravy")); |
| cl_assert(reflog_entry = git_reflog_entry_byindex(reflog, 0)); |
| cl_assert_equal_oid(git_annotated_commit_id(branch_head), git_reflog_entry_id_old(reflog_entry)); |
| cl_assert_equal_oid(&commit_id, git_reflog_entry_id_new(reflog_entry)); |
| cl_assert_equal_s("rebase finished: refs/heads/gravy onto f87d14a4a236582a0278a916340a793714256864", git_reflog_entry_message(reflog_entry)); |
| |
| git_reflog_free(reflog); |
| git_annotated_commit_free(branch_head); |
| git_annotated_commit_free(upstream_head); |
| git_reference_free(head_ref); |
| git_reference_free(branch_ref); |
| git_reference_free(upstream_ref); |
| git_rebase_free(rebase); |
| } |
| |
| void test_rebase_merge__detached_finish(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref, *head_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id; |
| git_reflog *reflog; |
| const git_reflog_entry *reflog_entry; |
| git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; |
| int error; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/gravy")); |
| cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal")); |
| |
| 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_repository_set_head_detached_from_annotated(repo, branch_head)); |
| opts.checkout_strategy = GIT_CHECKOUT_FORCE; |
| git_checkout_head(repo, &opts); |
| |
| cl_git_pass(git_rebase_init(&rebase, repo, NULL, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_fail(error = git_rebase_next(&rebase_operation, rebase)); |
| cl_assert_equal_i(GIT_ITEROVER, error); |
| |
| cl_git_pass(git_rebase_finish(rebase, signature)); |
| |
| cl_assert_equal_i(GIT_REPOSITORY_STATE_NONE, git_repository_state(repo)); |
| |
| cl_git_pass(git_reference_lookup(&head_ref, repo, "HEAD")); |
| cl_assert_equal_i(GIT_REF_OID, git_reference_type(head_ref)); |
| |
| /* Make sure the reflogs are updated appropriately */ |
| cl_git_pass(git_reflog_read(&reflog, repo, "HEAD")); |
| cl_assert(reflog_entry = git_reflog_entry_byindex(reflog, 0)); |
| cl_assert_equal_oid(git_annotated_commit_id(upstream_head), git_reflog_entry_id_old(reflog_entry)); |
| cl_assert_equal_oid(&commit_id, git_reflog_entry_id_new(reflog_entry)); |
| |
| git_reflog_free(reflog); |
| git_annotated_commit_free(branch_head); |
| git_annotated_commit_free(upstream_head); |
| git_reference_free(head_ref); |
| git_reference_free(branch_ref); |
| git_reference_free(upstream_ref); |
| git_rebase_free(rebase); |
| } |
| |
| void test_rebase_merge__finish_with_ids(void) |
| { |
| git_rebase *rebase; |
| git_reference *head_ref; |
| git_oid branch_id, upstream_id; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id; |
| git_reflog *reflog; |
| const git_reflog_entry *reflog_entry; |
| int error; |
| |
| cl_git_pass(git_oid_fromstr(&branch_id, "d616d97082eb7bb2dc6f180a7cca940993b7a56f")); |
| cl_git_pass(git_oid_fromstr(&upstream_id, "f87d14a4a236582a0278a916340a793714256864")); |
| |
| cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id)); |
| cl_git_pass(git_annotated_commit_lookup(&upstream_head, repo, &upstream_id)); |
| |
| cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_fail(error = git_rebase_next(&rebase_operation, rebase)); |
| cl_assert_equal_i(GIT_ITEROVER, error); |
| |
| cl_git_pass(git_rebase_finish(rebase, signature)); |
| |
| cl_assert_equal_i(GIT_REPOSITORY_STATE_NONE, git_repository_state(repo)); |
| |
| cl_git_pass(git_reference_lookup(&head_ref, repo, "HEAD")); |
| cl_assert_equal_i(GIT_REF_OID, git_reference_type(head_ref)); |
| cl_assert_equal_oid(&commit_id, git_reference_target(head_ref)); |
| |
| /* reflogs are not updated as if we were operating on proper |
| * branches. check that the last reflog entry is the rebase. |
| */ |
| cl_git_pass(git_reflog_read(&reflog, repo, "HEAD")); |
| cl_assert(reflog_entry = git_reflog_entry_byindex(reflog, 0)); |
| cl_assert_equal_oid(&commit_id, git_reflog_entry_id_new(reflog_entry)); |
| cl_assert_equal_s("rebase: Modification 3 to gravy", git_reflog_entry_message(reflog_entry)); |
| git_reflog_free(reflog); |
| |
| git_annotated_commit_free(branch_head); |
| git_annotated_commit_free(upstream_head); |
| git_reference_free(head_ref); |
| git_rebase_free(rebase); |
| } |
| |
| void test_rebase_merge__no_common_ancestor(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id, expected_final_id; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/barley")); |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_finish(rebase, signature)); |
| |
| git_oid_fromstr(&expected_final_id, "71e7ee8d4fe7d8bf0d107355197e0a953dfdb7f3"); |
| cl_assert_equal_oid(&expected_final_id, &commit_id); |
| |
| 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); |
| } |
| |
| static void test_copy_note( |
| const git_rebase_options *opts, |
| bool should_exist) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_commit *branch_commit; |
| git_rebase_operation *rebase_operation; |
| git_oid note_id, commit_id; |
| git_note *note = NULL; |
| int error; |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/gravy")); |
| cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal")); |
| |
| 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_reference_peel((git_object **)&branch_commit, |
| branch_ref, GIT_OBJ_COMMIT)); |
| |
| /* Add a note to a commit */ |
| cl_git_pass(git_note_create(¬e_id, repo, "refs/notes/test", |
| git_commit_author(branch_commit), git_commit_committer(branch_commit), |
| git_commit_id(branch_commit), |
| "This is a commit note.", 0)); |
| |
| cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, opts)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_finish(rebase, signature)); |
| |
| cl_assert_equal_i(GIT_REPOSITORY_STATE_NONE, git_repository_state(repo)); |
| |
| if (should_exist) { |
| cl_git_pass(git_note_read(¬e, repo, "refs/notes/test", &commit_id)); |
| cl_assert_equal_s("This is a commit note.", git_note_message(note)); |
| } else { |
| cl_git_fail(error = |
| git_note_read(¬e, repo, "refs/notes/test", &commit_id)); |
| cl_assert_equal_i(GIT_ENOTFOUND, error); |
| } |
| |
| git_note_free(note); |
| git_commit_free(branch_commit); |
| 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_rebase_merge__copy_notes_off_by_default(void) |
| { |
| test_copy_note(NULL, 0); |
| } |
| |
| void test_rebase_merge__copy_notes_specified_in_options(void) |
| { |
| git_rebase_options opts = GIT_REBASE_OPTIONS_INIT; |
| opts.rewrite_notes_ref = "refs/notes/test"; |
| |
| test_copy_note(&opts, 1); |
| } |
| |
| void test_rebase_merge__copy_notes_specified_in_config(void) |
| { |
| git_config *config; |
| |
| cl_git_pass(git_repository_config(&config, repo)); |
| cl_git_pass(git_config_set_string(config, |
| "notes.rewriteRef", "refs/notes/test")); |
| |
| test_copy_note(NULL, 1); |
| } |
| |
| void test_rebase_merge__copy_notes_disabled_in_config(void) |
| { |
| git_config *config; |
| |
| cl_git_pass(git_repository_config(&config, repo)); |
| cl_git_pass(git_config_set_bool(config, "notes.rewrite.rebase", 0)); |
| cl_git_pass(git_config_set_string(config, |
| "notes.rewriteRef", "refs/notes/test")); |
| |
| test_copy_note(NULL, 0); |
| } |
| |
| void rebase_checkout_progress_cb( |
| const char *path, |
| size_t completed_steps, |
| size_t total_steps, |
| void *payload) |
| { |
| int *called = payload; |
| |
| GIT_UNUSED(path); |
| GIT_UNUSED(completed_steps); |
| GIT_UNUSED(total_steps); |
| |
| *called = 1; |
| } |
| |
| void test_rebase_merge__custom_checkout_options(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_options rebase_options = GIT_REBASE_OPTIONS_INIT; |
| git_checkout_options checkout_options = GIT_CHECKOUT_OPTIONS_INIT; |
| git_rebase_operation *rebase_operation; |
| int called = 0; |
| |
| checkout_options.progress_cb = rebase_checkout_progress_cb; |
| checkout_options.progress_payload = &called; |
| |
| memcpy(&rebase_options.checkout_options, &checkout_options, |
| sizeof(git_checkout_options)); |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef")); |
| 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)); |
| |
| called = 0; |
| cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, &rebase_options)); |
| cl_assert_equal_i(1, called); |
| |
| called = 0; |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_assert_equal_i(1, called); |
| |
| called = 0; |
| cl_git_pass(git_rebase_abort(rebase)); |
| cl_assert_equal_i(1, called); |
| |
| 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_rebase_merge__custom_merge_options(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_options rebase_options = GIT_REBASE_OPTIONS_INIT; |
| git_rebase_operation *rebase_operation; |
| |
| rebase_options.merge_options.flags |= |
| GIT_MERGE_FAIL_ON_CONFLICT | |
| GIT_MERGE_SKIP_REUC; |
| |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, &rebase_options)); |
| |
| cl_git_fail_with(GIT_EMERGECONFLICT, git_rebase_next(&rebase_operation, rebase)); |
| |
| 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_rebase_merge__with_directories(void) |
| { |
| git_rebase *rebase; |
| git_reference *branch_ref, *upstream_ref; |
| git_annotated_commit *branch_head, *upstream_head; |
| git_rebase_operation *rebase_operation; |
| git_oid commit_id, tree_id; |
| git_commit *commit; |
| |
| git_oid_fromstr(&tree_id, "a4d6d9c3d57308fd8e320cf2525bae8f1adafa57"); |
| |
| cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/deep_gravy")); |
| cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal")); |
| |
| 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_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_pass(git_rebase_next(&rebase_operation, rebase)); |
| cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, |
| NULL, NULL)); |
| |
| cl_git_fail_with(GIT_ITEROVER, git_rebase_next(&rebase_operation, rebase)); |
| |
| cl_git_pass(git_commit_lookup(&commit, repo, &commit_id)); |
| cl_assert_equal_oid(&tree_id, git_commit_tree_id(commit)); |
| |
| git_commit_free(commit); |
| 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); |
| } |
