delete old noder, create a new one in utils (#241)

1 files changed, 364 insertions, 0 deletions

diff --git a/utils/merkletrie/internal/fsnoder/dir_test.go b/utils/merkletrie/internal/fsnoder/dir_test.go
new file mode 100644
index 0000000..df5aacc
--- /dev/null
+++ b/utils/merkletrie/internal/fsnoder/dir_test.go
@@ -0,0 +1,364 @@
+package fsnoder
+
+import (
+	"reflect"
+	"sort"
+
+	"gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
+
+	. "gopkg.in/check.v1"
+)
+
+type DirSuite struct{}
+
+var _ = Suite(&DirSuite{})
+
+func (s *DirSuite) TestIsDir(c *C) {
+	noName, err := newDir("", nil)
+	c.Assert(err, IsNil)
+	c.Assert(noName.IsDir(), Equals, true)
+
+	empty, err := newDir("empty", nil)
+	c.Assert(err, IsNil)
+	c.Assert(empty.IsDir(), Equals, true)
+
+	root, err := newDir("foo", []noder.Noder{empty})
+	c.Assert(err, IsNil)
+	c.Assert(root.IsDir(), Equals, true)
+}
+
+func assertChildren(c *C, n noder.Noder, expected []noder.Noder) {
+	numChildren, err := n.NumChildren()
+	c.Assert(err, IsNil)
+	c.Assert(numChildren, Equals, len(expected))
+
+	children, err := n.Children()
+	c.Assert(err, IsNil)
+	c.Assert(children, sortedSliceEquals, expected)
+}
+
+type sortedSliceEqualsChecker struct {
+	*CheckerInfo
+}
+
+var sortedSliceEquals Checker = &sortedSliceEqualsChecker{
+	&CheckerInfo{
+		Name:   "sortedSliceEquals",
+		Params: []string{"obtained", "expected"},
+	},
+}
+
+func (checker *sortedSliceEqualsChecker) Check(
+	params []interface{}, names []string) (result bool, error string) {
+	a, ok := params[0].([]noder.Noder)
+	if !ok {
+		return false, "first parameter must be a []noder.Noder"
+	}
+	b, ok := params[1].([]noder.Noder)
+	if !ok {
+		return false, "second parameter must be a []noder.Noder"
+	}
+	sort.Sort(byName(a))
+	sort.Sort(byName(b))
+
+	return reflect.DeepEqual(a, b), ""
+}
+
+func (s *DirSuite) TestNewDirectoryNoNameAndEmpty(c *C) {
+	root, err := newDir("", nil)
+	c.Assert(err, IsNil)
+
+	c.Assert(root.Hash(), DeepEquals,
+		[]byte{0xca, 0x40, 0xf8, 0x67, 0x57, 0x8c, 0x32, 0x1c})
+	c.Assert(root.Name(), Equals, "")
+	assertChildren(c, root, noder.NoChildren)
+	c.Assert(root.String(), Equals, "()")
+}
+
+func (s *DirSuite) TestNewDirectoryEmpty(c *C) {
+	root, err := newDir("root", nil)
+	c.Assert(err, IsNil)
+
+	c.Assert(root.Hash(), DeepEquals,
+		[]byte{0xca, 0x40, 0xf8, 0x67, 0x57, 0x8c, 0x32, 0x1c})
+	c.Assert(root.Name(), Equals, "root")
+	assertChildren(c, root, noder.NoChildren)
+	c.Assert(root.String(), Equals, "root()")
+}
+
+func (s *DirSuite) TestEmptyDirsHaveSameHash(c *C) {
+	d1, err := newDir("foo", nil)
+	c.Assert(err, IsNil)
+
+	d2, err := newDir("bar", nil)
+	c.Assert(err, IsNil)
+
+	c.Assert(d1.Hash(), DeepEquals, d2.Hash())
+}
+
+func (s *DirSuite) TestNewDirWithEmptyDir(c *C) {
+	empty, err := newDir("empty", nil)
+	c.Assert(err, IsNil)
+
+	root, err := newDir("", []noder.Noder{empty})
+	c.Assert(err, IsNil)
+
+	c.Assert(root.Hash(), DeepEquals,
+		[]byte{0x39, 0x25, 0xa8, 0x99, 0x16, 0x47, 0x6a, 0x75})
+	c.Assert(root.Name(), Equals, "")
+	assertChildren(c, root, []noder.Noder{empty})
+	c.Assert(root.String(), Equals, "(empty())")
+}
+
+func (s *DirSuite) TestNewDirWithOneEmptyFile(c *C) {
+	empty, err := newFile("name", "")
+	c.Assert(err, IsNil)
+
+	root, err := newDir("", []noder.Noder{empty})
+	c.Assert(err, IsNil)
+	c.Assert(root.Hash(), DeepEquals,
+		[]byte{0xd, 0x4e, 0x23, 0x1d, 0xf5, 0x2e, 0xfa, 0xc2})
+	c.Assert(root.Name(), Equals, "")
+	assertChildren(c, root, []noder.Noder{empty})
+	c.Assert(root.String(), Equals, "(name<>)")
+}
+
+func (s *DirSuite) TestNewDirWithOneFile(c *C) {
+	a, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+
+	root, err := newDir("", []noder.Noder{a})
+	c.Assert(err, IsNil)
+	c.Assert(root.Hash(), DeepEquals,
+		[]byte{0x96, 0xab, 0x29, 0x54, 0x2, 0x9e, 0x89, 0x28})
+	c.Assert(root.Name(), Equals, "")
+	assertChildren(c, root, []noder.Noder{a})
+	c.Assert(root.String(), Equals, "(a<1>)")
+}
+
+func (s *DirSuite) TestDirsWithSameFileHaveSameHash(c *C) {
+	f1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+	r1, err := newDir("", []noder.Noder{f1})
+	c.Assert(err, IsNil)
+
+	f2, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+	r2, err := newDir("", []noder.Noder{f2})
+	c.Assert(err, IsNil)
+
+	c.Assert(r1.Hash(), DeepEquals, r2.Hash())
+}
+
+func (s *DirSuite) TestDirsWithDifferentFileContentHaveDifferentHash(c *C) {
+	f1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+	r1, err := newDir("", []noder.Noder{f1})
+	c.Assert(err, IsNil)
+
+	f2, err := newFile("a", "2")
+	c.Assert(err, IsNil)
+	r2, err := newDir("", []noder.Noder{f2})
+	c.Assert(err, IsNil)
+
+	c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash())
+}
+
+func (s *DirSuite) TestDirsWithDifferentFileNameHaveDifferentHash(c *C) {
+	f1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+	r1, err := newDir("", []noder.Noder{f1})
+	c.Assert(err, IsNil)
+
+	f2, err := newFile("b", "1")
+	c.Assert(err, IsNil)
+	r2, err := newDir("", []noder.Noder{f2})
+	c.Assert(err, IsNil)
+
+	c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash())
+}
+
+func (s *DirSuite) TestDirsWithDifferentFileHaveDifferentHash(c *C) {
+	f1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+	r1, err := newDir("", []noder.Noder{f1})
+	c.Assert(err, IsNil)
+
+	f2, err := newFile("b", "2")
+	c.Assert(err, IsNil)
+	r2, err := newDir("", []noder.Noder{f2})
+	c.Assert(err, IsNil)
+
+	c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash())
+}
+
+func (s *DirSuite) TestDirWithEmptyDirHasDifferentHashThanEmptyDir(c *C) {
+	f, err := newFile("a", "")
+	c.Assert(err, IsNil)
+	r1, err := newDir("", []noder.Noder{f})
+	c.Assert(err, IsNil)
+
+	d, err := newDir("a", nil)
+	c.Assert(err, IsNil)
+	r2, err := newDir("", []noder.Noder{d})
+	c.Assert(err, IsNil)
+
+	c.Assert(r1.Hash(), Not(DeepEquals), r2.Hash())
+}
+
+func (s *DirSuite) TestNewDirWithTwoFilesSameContent(c *C) {
+	a1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+	b1, err := newFile("b", "1")
+	c.Assert(err, IsNil)
+
+	root, err := newDir("", []noder.Noder{a1, b1})
+	c.Assert(err, IsNil)
+
+	c.Assert(root.Hash(), DeepEquals,
+		[]byte{0xc7, 0xc4, 0xbf, 0x70, 0x33, 0xb9, 0x57, 0xdb})
+	c.Assert(root.Name(), Equals, "")
+	assertChildren(c, root, []noder.Noder{b1, a1})
+	c.Assert(root.String(), Equals, "(a<1> b<1>)")
+}
+
+func (s *DirSuite) TestNewDirWithTwoFilesDifferentContent(c *C) {
+	a1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+	b2, err := newFile("b", "2")
+	c.Assert(err, IsNil)
+
+	root, err := newDir("", []noder.Noder{a1, b2})
+	c.Assert(err, IsNil)
+
+	c.Assert(root.Hash(), DeepEquals,
+		[]byte{0x94, 0x8a, 0x9d, 0x8f, 0x6d, 0x98, 0x34, 0x55})
+	c.Assert(root.Name(), Equals, "")
+	assertChildren(c, root, []noder.Noder{b2, a1})
+}
+
+func (s *DirSuite) TestCrazy(c *C) {
+	//           ""
+	//            |
+	//   -------------------------
+	//   |    |      |      |    |
+	//  a1    B     c1     d2    E
+	//        |                  |
+	//   -------------           E
+	//   |   |   |   |           |
+	//   A   B   X   c1          E
+	//           |               |
+	//          a1               e1
+	e1, err := newFile("e", "1")
+	c.Assert(err, IsNil)
+	E, err := newDir("e", []noder.Noder{e1})
+	c.Assert(err, IsNil)
+	E, err = newDir("e", []noder.Noder{E})
+	c.Assert(err, IsNil)
+	E, err = newDir("e", []noder.Noder{E})
+	c.Assert(err, IsNil)
+
+	A, err := newDir("a", nil)
+	c.Assert(err, IsNil)
+	B, err := newDir("b", nil)
+	c.Assert(err, IsNil)
+	a1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+	X, err := newDir("x", []noder.Noder{a1})
+	c.Assert(err, IsNil)
+	c1, err := newFile("c", "1")
+	c.Assert(err, IsNil)
+	B, err = newDir("b", []noder.Noder{c1, B, X, A})
+	c.Assert(err, IsNil)
+
+	a1, err = newFile("a", "1")
+	c.Assert(err, IsNil)
+	c1, err = newFile("c", "1")
+	c.Assert(err, IsNil)
+	d2, err := newFile("d", "2")
+	c.Assert(err, IsNil)
+
+	root, err := newDir("", []noder.Noder{a1, d2, E, B, c1})
+	c.Assert(err, IsNil)
+
+	c.Assert(root.Hash(), DeepEquals,
+		[]byte{0xc3, 0x72, 0x9d, 0xf1, 0xcc, 0xec, 0x6d, 0xbb})
+	c.Assert(root.Name(), Equals, "")
+	assertChildren(c, root, []noder.Noder{E, c1, B, a1, d2})
+	c.Assert(root.String(), Equals,
+		"(a<1> b(a() b() c<1> x(a<1>)) c<1> d<2> e(e(e(e<1>))))")
+}
+
+func (s *DirSuite) TestDirCannotHaveDirWithNoName(c *C) {
+	noName, err := newDir("", nil)
+	c.Assert(err, IsNil)
+
+	_, err = newDir("", []noder.Noder{noName})
+	c.Assert(err, Not(IsNil))
+}
+
+func (s *DirSuite) TestDirCannotHaveDuplicatedFiles(c *C) {
+	f1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+
+	f2, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+
+	_, err = newDir("", []noder.Noder{f1, f2})
+	c.Assert(err, Not(IsNil))
+}
+
+func (s *DirSuite) TestDirCannotHaveDuplicatedFileNames(c *C) {
+	a1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+
+	a2, err := newFile("a", "2")
+	c.Assert(err, IsNil)
+
+	_, err = newDir("", []noder.Noder{a1, a2})
+	c.Assert(err, Not(IsNil))
+}
+
+func (s *DirSuite) TestDirCannotHaveDuplicatedDirNames(c *C) {
+	d1, err := newDir("a", nil)
+	c.Assert(err, IsNil)
+
+	d2, err := newDir("a", nil)
+	c.Assert(err, IsNil)
+
+	_, err = newDir("", []noder.Noder{d1, d2})
+	c.Assert(err, Not(IsNil))
+}
+
+func (s *DirSuite) TestDirCannotHaveDirAndFileWithSameName(c *C) {
+	f, err := newFile("a", "")
+	c.Assert(err, IsNil)
+
+	d, err := newDir("a", nil)
+	c.Assert(err, IsNil)
+
+	_, err = newDir("", []noder.Noder{f, d})
+	c.Assert(err, Not(IsNil))
+}
+
+func (s *DirSuite) TestUnsortedString(c *C) {
+	b, err := newDir("b", nil)
+	c.Assert(err, IsNil)
+
+	z, err := newDir("z", nil)
+	c.Assert(err, IsNil)
+
+	a1, err := newFile("a", "1")
+	c.Assert(err, IsNil)
+
+	c2, err := newFile("c", "2")
+	c.Assert(err, IsNil)
+
+	d3, err := newFile("d", "3")
+	c.Assert(err, IsNil)
+
+	d, err := newDir("d", []noder.Noder{c2, z, d3, a1, b})
+	c.Assert(err, IsNil)
+
+	c.Assert(d.String(), Equals, "d(a<1> b() c<2> d<3> z())")
+}