1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
package git
import (
"io"
"time"
"gopkg.in/src-d/go-git.v4/core"
. "gopkg.in/check.v1"
)
type SuiteCommit struct {
BaseSuite
Commit *Commit
}
var _ = Suite(&SuiteCommit{})
func (s *SuiteCommit) SetUpSuite(c *C) {
s.BaseSuite.SetUpSuite(c)
hash := core.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")
var err error
s.Commit, err = s.Repository.Commit(hash)
c.Assert(err, IsNil)
}
func (s *SuiteCommit) TestDecodeNonCommit(c *C) {
hash := core.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")
blob, err := s.Repository.s.ObjectStorage().Get(hash)
c.Assert(err, IsNil)
commit := &Commit{}
err = commit.Decode(blob)
c.Assert(err, Equals, ErrUnsupportedObject)
}
func (s *SuiteCommit) TestType(c *C) {
c.Assert(s.Commit.Type(), Equals, core.CommitObject)
}
func (s *SuiteCommit) TestTree(c *C) {
tree, err := s.Commit.Tree()
c.Assert(err, IsNil)
c.Assert(tree.ID().String(), Equals, "eba74343e2f15d62adedfd8c883ee0262b5c8021")
}
func (s *SuiteCommit) TestParents(c *C) {
expected := []string{
"35e85108805c84807bc66a02d91535e1e24b38b9",
"a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
}
var output []string
i := s.Commit.Parents()
err := i.ForEach(func(commit *Commit) error {
output = append(output, commit.ID().String())
return nil
})
c.Assert(err, IsNil)
c.Assert(output, DeepEquals, expected)
}
func (s *SuiteCommit) TestCommitEncodeDecodeIdempotent(c *C) {
ts, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05-07:00")
c.Assert(err, IsNil)
commits := []*Commit{
&Commit{
Author: Signature{Name: "Foo", Email: "foo@example.local", When: ts},
Committer: Signature{Name: "Bar", Email: "bar@example.local", When: ts},
Message: "Message\n\nFoo\nBar\nWith trailing blank lines\n\n",
tree: core.NewHash("f000000000000000000000000000000000000001"),
parents: []core.Hash{core.NewHash("f000000000000000000000000000000000000002")},
},
&Commit{
Author: Signature{Name: "Foo", Email: "foo@example.local", When: ts},
Committer: Signature{Name: "Bar", Email: "bar@example.local", When: ts},
Message: "Message\n\nFoo\nBar\nWith no trailing blank lines",
tree: core.NewHash("0000000000000000000000000000000000000003"),
parents: []core.Hash{
core.NewHash("f000000000000000000000000000000000000004"),
core.NewHash("f000000000000000000000000000000000000005"),
core.NewHash("f000000000000000000000000000000000000006"),
core.NewHash("f000000000000000000000000000000000000007"),
},
},
}
for _, commit := range commits {
obj := &core.MemoryObject{}
err = commit.Encode(obj)
c.Assert(err, IsNil)
newCommit := &Commit{}
err = newCommit.Decode(obj)
c.Assert(err, IsNil)
commit.Hash = obj.Hash()
c.Assert(newCommit, DeepEquals, commit)
}
}
func (s *SuiteCommit) TestFile(c *C) {
file, err := s.Commit.File("CHANGELOG")
c.Assert(err, IsNil)
c.Assert(file.Name, Equals, "CHANGELOG")
}
func (s *SuiteCommit) TestNumParents(c *C) {
c.Assert(s.Commit.NumParents(), Equals, 2)
}
func (s *SuiteCommit) TestHistory(c *C) {
commits, err := s.Commit.History()
c.Assert(err, IsNil)
c.Assert(commits, HasLen, 5)
c.Assert(commits[0].Hash.String(), Equals, s.Commit.Hash.String())
c.Assert(commits[len(commits)-1].Hash.String(), Equals, "b029517f6300c2da0f4b651b8642506cd6aaf45d")
}
func (s *SuiteCommit) TestString(c *C) {
c.Assert(s.Commit.String(), Equals, ""+
"commit 1669dce138d9b841a518c64b10914d88f5e488ea\n"+
"Author: Máximo Cuadros Ortiz <mcuadros@gmail.com>\n"+
"Date: 2015-03-31 13:48:14 +0200 +0200\n",
)
}
func (s *SuiteCommit) TestCommitIterNext(c *C) {
i := s.Commit.Parents()
commit, err := i.Next()
c.Assert(err, IsNil)
c.Assert(commit.ID().String(), Equals, "35e85108805c84807bc66a02d91535e1e24b38b9")
commit, err = i.Next()
c.Assert(err, IsNil)
c.Assert(commit.ID().String(), Equals, "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69")
commit, err = i.Next()
c.Assert(err, Equals, io.EOF)
c.Assert(commit, IsNil)
}
|
