Create merge-base feature

Signed-off-by: David Pordomingo <David.Pordomingo.F@gmail.com>

1 files changed, 262 insertions, 0 deletions

diff --git a/plumbing/object/commit_walker_bfs_filtered_test.go b/plumbing/object/commit_walker_bfs_filtered_test.go
new file mode 100644
index 0000000..d31bdf0
--- /dev/null
+++ b/plumbing/object/commit_walker_bfs_filtered_test.go
@@ -0,0 +1,262 @@
+package object
+
+import (
+	"fmt"
+	"strings"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/storer"
+
+	. "gopkg.in/check.v1"
+)
+
+var _ = Suite(&filterCommitIterSuite{})
+
+type filterCommitIterSuite struct {
+	BaseObjectsSuite
+}
+
+func commitsFromIter(iter CommitIter) ([]*Commit, error) {
+	var commits []*Commit
+	err := iter.ForEach(func(c *Commit) error {
+		commits = append(commits, c)
+		return nil
+	})
+
+	return commits, err
+}
+
+func assertHashes(c *C, commits []*Commit, hashes []string) {
+	if len(commits) != len(hashes) {
+		var expected []string
+		for _, c := range hashes {
+			expected = append(expected, c)
+		}
+		fmt.Println("expected:", strings.Join(expected, ", "))
+		var got []string
+		for _, c := range commits {
+			got = append(got, c.Hash.String())
+		}
+		fmt.Println("     got:", strings.Join(got, ", "))
+	}
+
+	c.Assert(commits, HasLen, len(hashes))
+	for i, commit := range commits {
+		c.Assert(hashes[i], Equals, commit.Hash.String())
+	}
+}
+
+func validIfCommit(ignored plumbing.Hash) CommitFilter {
+	return func(c *Commit) bool {
+		if c.Hash == ignored {
+			return true
+		}
+
+		return false
+	}
+}
+
+func not(filter CommitFilter) CommitFilter {
+	return func(c *Commit) bool {
+		return !filter(c)
+	}
+}
+
+/*
+// TestCase history
+
+* 6ecf0ef2c2dffb796033e5a02219af86ec6584e5 <- HEAD
+|
+| * e8d3ffab552895c19b9fcf7aa264d277cde33881
+|/
+* 918c48b83bd081e863dbe1b80f8998f058cd8294
+|
+* af2d6a6954d532f8ffb47615169c8fdf9d383a1a
+|
+* 1669dce138d9b841a518c64b10914d88f5e488ea
+|\
+| * a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69	// isLimit
+| |\
+| | * b8e471f58bcbca63b07bda20e428190409c2db47  // ignored if isLimit is passed
+| |/
+* | 35e85108805c84807bc66a02d91535e1e24b38b9	// isValid; ignored if passed as !isValid
+|/
+* b029517f6300c2da0f4b651b8642506cd6aaf45d
+*/
+
+// TestFilterCommitIter asserts that FilterCommitIter returns all commits from
+// history, but e8d3ffab552895c19b9fcf7aa264d277cde33881, that is not reachable
+// from HEAD
+func (s *filterCommitIterSuite) TestFilterCommitIter(c *C) {
+	from := s.commit(c, s.Fixture.Head)
+
+	commits, err := commitsFromIter(NewFilterCommitIter(from, nil, nil))
+	c.Assert(err, IsNil)
+
+	expected := []string{
+		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+		"918c48b83bd081e863dbe1b80f8998f058cd8294",
+		"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
+		"1669dce138d9b841a518c64b10914d88f5e488ea",
+		"35e85108805c84807bc66a02d91535e1e24b38b9",
+		"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
+		"b029517f6300c2da0f4b651b8642506cd6aaf45d",
+		"b8e471f58bcbca63b07bda20e428190409c2db47",
+	}
+
+	assertHashes(c, commits, expected)
+}
+
+// TestFilterCommitIterWithValid asserts that FilterCommitIter returns only commits
+// that matches the passed isValid filter; in this testcase, it was filtered out
+// all commits but one from history
+func (s *filterCommitIterSuite) TestFilterCommitIterWithValid(c *C) {
+	from := s.commit(c, s.Fixture.Head)
+
+	validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
+	commits, err := commitsFromIter(NewFilterCommitIter(from, &validIf, nil))
+	c.Assert(err, IsNil)
+
+	expected := []string{
+		"35e85108805c84807bc66a02d91535e1e24b38b9",
+	}
+
+	assertHashes(c, commits, expected)
+}
+
+// that matches the passed isValid filter; in this testcase, it was filtered out
+// only one commit from history
+func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalid(c *C) {
+	from := s.commit(c, s.Fixture.Head)
+
+	validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
+	validIfNot := not(validIf)
+	commits, err := commitsFromIter(NewFilterCommitIter(from, &validIfNot, nil))
+	c.Assert(err, IsNil)
+
+	expected := []string{
+		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+		"918c48b83bd081e863dbe1b80f8998f058cd8294",
+		"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
+		"1669dce138d9b841a518c64b10914d88f5e488ea",
+		"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
+		"b029517f6300c2da0f4b651b8642506cd6aaf45d",
+		"b8e471f58bcbca63b07bda20e428190409c2db47",
+	}
+
+	assertHashes(c, commits, expected)
+}
+
+// TestFilterCommitIterWithNoValidCommits asserts that FilterCommitIter returns
+// no commits if the passed isValid filter does not allow any commit
+func (s *filterCommitIterSuite) TestFilterCommitIterWithNoValidCommits(c *C) {
+	from := s.commit(c, s.Fixture.Head)
+
+	validIf := validIfCommit(plumbing.NewHash("THIS_COMMIT_DOES_NOT_EXIST"))
+	commits, err := commitsFromIter(NewFilterCommitIter(from, &validIf, nil))
+	c.Assert(err, IsNil)
+	c.Assert(commits, HasLen, 0)
+}
+
+// TestFilterCommitIterWithStopAt asserts that FilterCommitIter returns only commits
+// are not beyond a isLimit filter
+func (s *filterCommitIterSuite) TestFilterCommitIterWithStopAt(c *C) {
+	from := s.commit(c, s.Fixture.Head)
+
+	stopAtRule := validIfCommit(plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"))
+	commits, err := commitsFromIter(NewFilterCommitIter(from, nil, &stopAtRule))
+	c.Assert(err, IsNil)
+
+	expected := []string{
+		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+		"918c48b83bd081e863dbe1b80f8998f058cd8294",
+		"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
+		"1669dce138d9b841a518c64b10914d88f5e488ea",
+		"35e85108805c84807bc66a02d91535e1e24b38b9",
+		"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
+		"b029517f6300c2da0f4b651b8642506cd6aaf45d",
+	}
+
+	assertHashes(c, commits, expected)
+}
+
+// TestFilterCommitIterWithStopAt asserts that FilterCommitIter works properly
+// with isValid and isLimit filters
+func (s *filterCommitIterSuite) TestFilterCommitIterWithInvalidAndStopAt(c *C) {
+	from := s.commit(c, s.Fixture.Head)
+
+	stopAtRule := validIfCommit(plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"))
+	validIf := validIfCommit(plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"))
+	validIfNot := not(validIf)
+	commits, err := commitsFromIter(NewFilterCommitIter(from, &validIfNot, &stopAtRule))
+	c.Assert(err, IsNil)
+
+	expected := []string{
+		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+		"918c48b83bd081e863dbe1b80f8998f058cd8294",
+		"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
+		"1669dce138d9b841a518c64b10914d88f5e488ea",
+		"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
+		"b029517f6300c2da0f4b651b8642506cd6aaf45d",
+	}
+
+	assertHashes(c, commits, expected)
+}
+
+// TestIteratorForEachCallbackReturn that ForEach callback does not cause
+// the ForEach to return an error if it returned an ErrStop
+//
+//   - 6ecf0ef2c2dffb796033e5a02219af86ec6584e5
+//   - 918c48b83bd081e863dbe1b80f8998f058cd8294 //<- stop
+//   - af2d6a6954d532f8ffb47615169c8fdf9d383a1a
+//   - 1669dce138d9b841a518c64b10914d88f5e488ea //<- err
+//   - 35e85108805c84807bc66a02d91535e1e24b38b9
+//   - a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69
+//   - b029517f6300c2da0f4b651b8642506cd6aaf45d
+//   - b8e471f58bcbca63b07bda20e428190409c2db47
+func (s *filterCommitIterSuite) TestIteratorForEachCallbackReturn(c *C) {
+
+	var visited []*Commit
+	errUnexpected := fmt.Errorf("Could not continue")
+	cb := func(c *Commit) error {
+		switch c.Hash {
+		case plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"):
+			return storer.ErrStop
+		case plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"):
+			return errUnexpected
+		}
+
+		visited = append(visited, c)
+		return nil
+	}
+
+	from := s.commit(c, s.Fixture.Head)
+
+	iter := NewFilterCommitIter(from, nil, nil)
+	err := iter.ForEach(cb)
+	c.Assert(err, IsNil)
+	expected := []string{
+		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+	}
+	assertHashes(c, visited, expected)
+
+	err = iter.ForEach(cb)
+	c.Assert(err, Equals, errUnexpected)
+	expected = []string{
+		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+		"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
+	}
+	assertHashes(c, visited, expected)
+
+	err = iter.ForEach(cb)
+	c.Assert(err, IsNil)
+	expected = []string{
+		"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+		"af2d6a6954d532f8ffb47615169c8fdf9d383a1a",
+		"35e85108805c84807bc66a02d91535e1e24b38b9",
+		"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
+		"b029517f6300c2da0f4b651b8642506cd6aaf45d",
+		"b8e471f58bcbca63b07bda20e428190409c2db47",
+	}
+	assertHashes(c, visited, expected)
+}