From fa75ab40f9d0447a8b670c991c3fcf8c1d5c3081 Mon Sep 17 00:00:00 2001
From: Antonio Jesus Navarro Perez <antonio@sourced.tech>
Date: Wed, 1 Mar 2017 17:51:11 +0100
Subject: git: Repository methods changes

To have a more consistent public API, we decided to rename some methods, and add others:

- Commit method renamed to CommitObject
- Commits method renamed to CommitObjects
- Tree method renamed to TreeObject
- Trees method renamed to TreeObjects
- Tags method renamed to TagObjects
- Tag method renamed to TagObject
- Added method Tags that returns tag references
- Added method Branches that returns branch references
- Added method Notes that returns note references
- Added BlobObject method
- Added BlobObjects method

Also, we added more functionality related to references:
- Added iterator to iterate References with a specific filter

Some notes:
- #298
---
 plumbing/storer/reference_test.go | 99 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)

(limited to 'plumbing/storer/reference_test.go')

diff --git a/plumbing/storer/reference_test.go b/plumbing/storer/reference_test.go
index ff7bd68..a6e301b 100644
--- a/plumbing/storer/reference_test.go
+++ b/plumbing/storer/reference_test.go
@@ -89,3 +89,102 @@ func (s *ReferenceSuite) TestReferenceSliceIterForEachStop(c *C) {
 
 	c.Assert(count, Equals, 1)
 }
+
+func (s *ReferenceSuite) TestReferenceFilteredIterNext(c *C) {
+	slice := []*plumbing.Reference{
+		plumbing.NewReferenceFromStrings("foo", "foo"),
+		plumbing.NewReferenceFromStrings("bar", "bar"),
+	}
+
+	i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
+		if r.Name() == "bar" {
+			return true
+		}
+
+		return false
+	}, NewReferenceSliceIter(slice))
+	foo, err := i.Next()
+	c.Assert(err, IsNil)
+	c.Assert(foo == slice[0], Equals, false)
+	c.Assert(foo == slice[1], Equals, true)
+
+	empty, err := i.Next()
+	c.Assert(err, Equals, io.EOF)
+	c.Assert(empty, IsNil)
+}
+
+func (s *ReferenceSuite) TestReferenceFilteredIterForEach(c *C) {
+	slice := []*plumbing.Reference{
+		plumbing.NewReferenceFromStrings("foo", "foo"),
+		plumbing.NewReferenceFromStrings("bar", "bar"),
+	}
+
+	i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
+		if r.Name() == "bar" {
+			return true
+		}
+
+		return false
+	}, NewReferenceSliceIter(slice))
+	var count int
+	i.ForEach(func(r *plumbing.Reference) error {
+		c.Assert(r == slice[1], Equals, true)
+		count++
+		return nil
+	})
+
+	c.Assert(count, Equals, 1)
+}
+
+func (s *ReferenceSuite) TestReferenceFilteredIterError(c *C) {
+	slice := []*plumbing.Reference{
+		plumbing.NewReferenceFromStrings("foo", "foo"),
+		plumbing.NewReferenceFromStrings("bar", "bar"),
+	}
+
+	i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
+		if r.Name() == "bar" {
+			return true
+		}
+
+		return false
+	}, NewReferenceSliceIter(slice))
+	var count int
+	exampleErr := errors.New("SOME ERROR")
+	err := i.ForEach(func(r *plumbing.Reference) error {
+		c.Assert(r == slice[1], Equals, true)
+		count++
+		if count == 1 {
+			return exampleErr
+		}
+
+		return nil
+	})
+
+	c.Assert(err, Equals, exampleErr)
+	c.Assert(count, Equals, 1)
+}
+
+func (s *ReferenceSuite) TestReferenceFilteredIterForEachStop(c *C) {
+	slice := []*plumbing.Reference{
+		plumbing.NewReferenceFromStrings("foo", "foo"),
+		plumbing.NewReferenceFromStrings("bar", "bar"),
+	}
+
+	i := NewReferenceFilteredIter(func(r *plumbing.Reference) bool {
+		if r.Name() == "bar" {
+			return true
+		}
+
+		return false
+	}, NewReferenceSliceIter(slice))
+
+	var count int
+	i.ForEach(func(r *plumbing.Reference) error {
+		c.Assert(r == slice[1], Equals, true)
+		count++
+		return ErrStop
+	})
+
+	c.Assert(count, Equals, 1)
+}
-- 
cgit