Function TestApplyToTree

diff_test.go:466–595

(t *testing.T)

}

func TestApplyToTree(t *testing.T) {
	repo := createTestRepo(t)
	defer cleanupTestRepo(t, repo)

	seedTestRepo(t, repo)

	commitA, treeA := addAndGetTree(t, repo, "file", "a")
	defer commitA.Free()
	defer treeA.Free()
	commitB, treeB := addAndGetTree(t, repo, "file", "b")
	defer commitB.Free()
	defer treeB.Free()
	commitC, treeC := addAndGetTree(t, repo, "file", "c")
	defer commitC.Free()
	defer treeC.Free()

	diffAB, err := repo.DiffTreeToTree(treeA, treeB, nil)
	checkFatal(t, err)

	diffAC, err := repo.DiffTreeToTree(treeA, treeC, nil)
	checkFatal(t, err)

	errMessageDropped := errors.New("message dropped")

	for _, tc := range []struct {
		name               string
		tree               *Tree
		diff               *Diff
		applyHunkCallback  ApplyHunkCallback
		applyDeltaCallback ApplyDeltaCallback
		err                error
		expectedDiff       *Diff
	}{
		{
			name:         "applying patch produces the same diff",
			tree:         treeA,
			diff:         diffAB,
			expectedDiff: diffAB,
		},
		{
			name: "applying a conflicting patch errors",
			tree: treeB,
			diff: diffAC,
			err: &GitError{
				Message: "hunk at line 1 did not apply",
				Code:    ErrorCodeApplyFail,
				Class:   ErrorClassPatch,
			},
		},
		{
			name:               "callbacks succeeding apply the diff",
			tree:               treeA,
			diff:               diffAB,
			applyHunkCallback:  func(*DiffHunk) (bool, error) { return true, nil },
			applyDeltaCallback: func(*DiffDelta) (bool, error) { return true, nil },
			expectedDiff:       diffAB,
		},
		{