func (s *RemoteSuite) TestFetchDepth(c *C) {
url := s.GetBasicLocalRepositoryURL()
sto := memory.NewStorage()
r := newRemote(sto, nil, &config.RemoteConfig{Name: "foo", URL: url})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{refspec},
Depth: 1,
})
c.Assert(err, IsNil)
c.Assert(sto.Objects, HasLen, 18)
expectedRefs := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewReferenceFromStrings("refs/remotes/origin/branch", "e8d3ffab552895c19b9fcf7aa264d277cde33881"),
}
for _, exp := range expectedRefs {
r, _ := sto.Reference(exp.Name())
c.Assert(exp.String(), Equals, r.String())
}
h, err := sto.Shallow()
c.Assert(err, IsNil)
c.Assert(h, HasLen, 2)
c.Assert(h, DeepEquals, []plumbing.Hash{
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
}
func ExampleUploadRequest_Encode() {
// Create an empty UlReq with the contents you want...
ur := NewUploadRequest()
// Add a couple of wants
ur.Wants = append(ur.Wants, plumbing.NewHash("3333333333333333333333333333333333333333"))
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Wants = append(ur.Wants, plumbing.NewHash("2222222222222222222222222222222222222222"))
// And some capabilities you will like the server to use
ur.Capabilities.Add(capability.OFSDelta)
ur.Capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")
// Add a couple of shallows
ur.Shallows = append(ur.Shallows, plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
ur.Shallows = append(ur.Shallows, plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
// And retrict the answer of the server to commits newer than "2015-01-02 03:04:05 UTC"
since := time.Date(2015, time.January, 2, 3, 4, 5, 0, time.UTC)
ur.Depth = DepthSince(since)
// Create a new Encode for the stdout...
e := newUlReqEncoder(os.Stdout)
// ...and encode the upload-request to it.
_ = e.Encode(ur) // ignoring errors for brevity
// Output:
// 005bwant 1111111111111111111111111111111111111111 ofs-delta symref=HEAD:/refs/heads/master
// 0032want 2222222222222222222222222222222222222222
// 0032want 3333333333333333333333333333333333333333
// 0035shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
// 0035shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
// 001cdeepen-since 1420167845
// 0000
}
func (s *UlReqEncodeSuite) TestWantsWithCapabilities(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants,
plumbing.NewHash("4444444444444444444444444444444444444444"),
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("5555555555555555555555555555555555555555"),
)
ur.Capabilities.Add(capability.MultiACK)
ur.Capabilities.Add(capability.OFSDelta)
ur.Capabilities.Add(capability.Sideband)
ur.Capabilities.Add(capability.SymRef, "HEAD:/refs/heads/master")
ur.Capabilities.Add(capability.ThinPack)
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack ofs-delta side-band symref=HEAD:/refs/heads/master thin-pack\n",
"want 2222222222222222222222222222222222222222\n",
"want 3333333333333333333333333333333333333333\n",
"want 4444444444444444444444444444444444444444\n",
"want 5555555555555555555555555555555555555555\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
// * 6ecf0ef vendor stuff
// | * e8d3ffa some code in a branch
// |/
// * 918c48b some code
// -----
func (s *RevListSuite) TestRevListObjectsNewBranch(c *C) {
someCommit := s.commit(c, plumbing.NewHash(someCommit))
someCommitBranch := s.commit(c, plumbing.NewHash(someCommitBranch))
someCommitOtherBranch := s.commit(c, plumbing.NewHash(someCommitOtherBranch))
localHist, err := Objects(s.Storer, []*object.Commit{someCommit}, nil)
c.Assert(err, IsNil)
remoteHist, err := Objects(
s.Storer, []*object.Commit{someCommitBranch, someCommitOtherBranch}, localHist)
c.Assert(err, IsNil)
revList := map[string]bool{
"a8d315b2b1c615d43042c3a62402b8a54288cf5c": true, // init tree
"cf4aa3b38974fb7d81f367c0830f7d78d65ab86b": true, // vendor folder
"9dea2395f5403188298c1dabe8bdafe562c491e3": true, // foo.go
"e8d3ffab552895c19b9fcf7aa264d277cde33881": true, // branch commit
"dbd3641b371024f44d0e469a9c8f5457b0660de1": true, // init tree
"7e59600739c96546163833214c36459e324bad0a": true, // README
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5": true, // otherBranch commit
}
for _, h := range remoteHist {
c.Assert(revList[h.String()], Equals, true)
}
c.Assert(len(remoteHist), Equals, len(revList))
}
func (s *SuiteEncoder) TestWantsWithCapabilities(c *C) {
ur := New()
ur.Wants = append(ur.Wants, plumbing.NewHash("4444444444444444444444444444444444444444"))
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Wants = append(ur.Wants, plumbing.NewHash("3333333333333333333333333333333333333333"))
ur.Wants = append(ur.Wants, plumbing.NewHash("2222222222222222222222222222222222222222"))
ur.Wants = append(ur.Wants, plumbing.NewHash("5555555555555555555555555555555555555555"))
ur.Capabilities.Add("sysref", "HEAD:/refs/heads/master")
ur.Capabilities.Add("multi_ack")
ur.Capabilities.Add("thin-pack")
ur.Capabilities.Add("side-band")
ur.Capabilities.Add("ofs-delta")
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack ofs-delta side-band sysref=HEAD:/refs/heads/master thin-pack\n",
"want 2222222222222222222222222222222222222222\n",
"want 3333333333333333333333333333333333333333\n",
"want 4444444444444444444444444444444444444444\n",
"want 5555555555555555555555555555555555555555\n",
pktline.FlushString,
}
testEncode(c, ur, expected)
}
func (s *TagSuite) TestTagEncodeDecodeIdempotent(c *C) {
ts, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05-07:00")
c.Assert(err, IsNil)
tags := []*Tag{
{
Name: "foo",
Tagger: Signature{Name: "Foo", Email: "*****@*****.**", When: ts},
Message: "Message\n\nFoo\nBar\nBaz\n\n",
TargetType: plumbing.BlobObject,
Target: plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
},
{
Name: "foo",
Tagger: Signature{Name: "Foo", Email: "*****@*****.**", When: ts},
TargetType: plumbing.BlobObject,
Target: plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
},
}
for _, tag := range tags {
obj := &plumbing.MemoryObject{}
err = tag.Encode(obj)
c.Assert(err, IsNil)
newTag := &Tag{}
err = newTag.Decode(obj)
c.Assert(err, IsNil)
tag.Hash = obj.Hash()
c.Assert(newTag, DeepEquals, tag)
}
}
func (s *BlameSuite) mockBlame(c *C, t blameTest, r *Repository) (blame *BlameResult) {
commit, err := r.Commit(plumbing.NewHash(t.rev))
c.Assert(err, IsNil, Commentf("%v: repo=%s, rev=%s", err, t.repo, t.rev))
f, err := commit.File(t.path)
c.Assert(err, IsNil)
lines, err := f.Lines()
c.Assert(err, IsNil)
c.Assert(len(t.blames), Equals, len(lines), Commentf(
"repo=%s, path=%s, rev=%s: the number of lines in the file and the number of expected blames differ (len(blames)=%d, len(lines)=%d)\nblames=%#q\nlines=%#q", t.repo, t.path, t.rev, len(t.blames), len(lines), t.blames, lines))
blamedLines := make([]*line, 0, len(t.blames))
for i := range t.blames {
commit, err := r.Commit(plumbing.NewHash(t.blames[i]))
c.Assert(err, IsNil)
l := &line{
author: commit.Author.Email,
text: lines[i],
}
blamedLines = append(blamedLines, l)
}
return &BlameResult{
Path: t.path,
Rev: plumbing.NewHash(t.rev),
Lines: blamedLines,
}
}
func (s *ReferencesSuite) TestRevList(c *C) {
for _, t := range referencesTests {
r := s.NewRepositoryFromPackfile(fixtures.ByURL(t.repo).One())
commit, err := r.Commit(plumbing.NewHash(t.commit))
c.Assert(err, IsNil)
revs, err := References(commit, t.path)
c.Assert(err, IsNil)
c.Assert(len(revs), Equals, len(t.revs))
for i := range revs {
if revs[i].Hash.String() != t.revs[i] {
commit, err := s.Repository.Commit(plumbing.NewHash(t.revs[i]))
c.Assert(err, IsNil)
equiv, err := equivalent(t.path, revs[i], commit)
c.Assert(err, IsNil)
if equiv {
fmt.Printf("cherry-pick detected: %s %s\n", revs[i].Hash.String(), t.revs[i])
} else {
c.Fatalf("\nrepo=%s, commit=%s, path=%s, \n%s",
t.repo, t.commit, t.path, compareSideBySide(t.revs, revs))
}
}
}
}
}
func (s *UlReqDecodeSuite) TestManyShallowSingleWant(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"shallow cccccccccccccccccccccccccccccccccccccccc",
"shallow dddddddddddddddddddddddddddddddddddddddd",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expectedWants := []plumbing.Hash{
plumbing.NewHash("3333333333333333333333333333333333333333"),
}
expectedShallows := []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"),
}
sort.Sort(byHash(expectedShallows))
c.Assert(ur.Wants, DeepEquals, expectedWants)
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
sort.Sort(byHash(ur.Shallows))
c.Assert(ur.Shallows, DeepEquals, expectedShallows)
}
func (s *UlReqDecodeSuite) TestSingleShallowManyWants(c *C) {
payloads := []string{
"want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
"want 4444444444444444444444444444444444444444",
"want 1111111111111111111111111111111111111111",
"want 2222222222222222222222222222222222222222",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
pktline.FlushString,
}
ur := s.testDecodeOK(c, payloads)
expectedWants := []plumbing.Hash{
plumbing.NewHash("1111111111111111111111111111111111111111"),
plumbing.NewHash("2222222222222222222222222222222222222222"),
plumbing.NewHash("3333333333333333333333333333333333333333"),
plumbing.NewHash("4444444444444444444444444444444444444444"),
}
sort.Sort(byHash(expectedWants))
expectedShallows := []plumbing.Hash{
plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
}
sort.Sort(byHash(ur.Wants))
c.Assert(ur.Wants, DeepEquals, expectedWants)
c.Assert(ur.Capabilities.Supports(capability.OFSDelta), Equals, true)
c.Assert(ur.Capabilities.Supports(capability.MultiACK), Equals, true)
c.Assert(ur.Shallows, DeepEquals, expectedShallows)
}
func (s *TagSuite) TestString(c *C) {
tag := s.tag(c, plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
c.Assert(tag.String(), Equals, ""+
"tag annotated-tag\n"+
"Tagger: Máximo Cuadros <*****@*****.**>\n"+
"Date: Wed Sep 21 21:13:35 2016 +0200\n"+
"\n"+
"example annotated tag\n"+
"\n"+
"commit f7b877701fbf855b44c0a9e86f3fdce2c298b07f\n"+
"Author: Máximo Cuadros <*****@*****.**>\n"+
"Date: Wed Sep 21 21:10:52 2016 +0200\n"+
"\n"+
" initial\n"+
"\n",
)
tag = s.tag(c, plumbing.NewHash("152175bf7e5580299fa1f0ba41ef6474cc043b70"))
c.Assert(tag.String(), Equals, ""+
"tag tree-tag\n"+
"Tagger: Máximo Cuadros <*****@*****.**>\n"+
"Date: Wed Sep 21 21:17:56 2016 +0200\n"+
"\n"+
"a tagged tree\n"+
"\n",
)
}
func (s *UlReqSuite) TestValidateShallows(c *C) {
r := NewUploadRequest()
r.Wants = append(r.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
r.Shallows = append(r.Shallows, plumbing.NewHash("2222222222222222222222222222222222222222"))
err := r.Validate()
c.Assert(err, NotNil)
r.Capabilities.Set(capability.Shallow)
err = r.Validate()
c.Assert(err, IsNil)
}
func (s *RevListSuite) TestRevListObjectsReverse(c *C) {
initCommit := s.commit(c, plumbing.NewHash(initialCommit))
secondCommit := s.commit(c, plumbing.NewHash(secondCommit))
localHist, err := Objects(s.Storer, []*object.Commit{secondCommit}, nil)
c.Assert(err, IsNil)
remoteHist, err := Objects(s.Storer, []*object.Commit{initCommit}, localHist)
c.Assert(err, IsNil)
c.Assert(len(remoteHist), Equals, 0)
}
func (s *RemoteSuite) TestFetchNoChanges(c *C) {
r := NewGitUploadPackService(s.Endpoint)
c.Assert(r.Connect(), IsNil)
req := &common.GitUploadPackRequest{}
req.Want(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
req.Have(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.Fetch(req)
c.Assert(err, Equals, common.ErrEmptyGitUploadPack)
c.Assert(reader, IsNil)
}
func (s *DiffTreeSuite) TestChangeFilesInsert(c *C) {
tree := s.tree(c, plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"))
change := &Change{Action: Insert}
change.To.Name = "json/long.json"
change.To.Tree = tree
change.To.TreeEntry.Hash = plumbing.NewHash("49c6bb89b17060d7b4deacb7b338fcc6ea2352a9")
from, to, err := change.Files()
c.Assert(err, IsNil)
c.Assert(from, IsNil)
c.Assert(to.ID(), Equals, change.To.TreeEntry.Hash)
}
func (s *SuiteCommon) TestGitUploadPackRequest(c *C) {
r := &GitUploadPackRequest{}
r.Want(plumbing.NewHash("d82f291cde9987322c8a0c81a325e1ba6159684c"))
r.Want(plumbing.NewHash("2b41ef280fdb67a9b250678686a0c3e03b0a9989"))
r.Have(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
c.Assert(r.String(), Equals,
"0032want d82f291cde9987322c8a0c81a325e1ba6159684c\n"+
"0032want 2b41ef280fdb67a9b250678686a0c3e03b0a9989\n"+
"0032have 6ecf0ef2c2dffb796033e5a02219af86ec6584e5\n0000"+
"0009done\n",
)
}
func (s *FetchPackSuite) TestFetchPackNoChanges(c *C) {
r, err := s.Client.NewFetchPackSession(s.Endpoint)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
req.Haves = append(req.Haves, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
reader, err := r.FetchPack(req)
c.Assert(err, Equals, transport.ErrEmptyUploadPackRequest)
c.Assert(reader, IsNil)
}
func (s *SuiteEncoder) TestShallow(c *C) {
ur := New()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Capabilities.Add("multi_ack")
ur.Shallows = append(ur.Shallows, plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack\n",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
pktline.FlushString,
}
testEncode(c, ur, expected)
}
func (s *SuiteCommon) TestNewVersions(c *C) {
refs := make(memory.ReferenceStorage, 0)
refs.SetReference(plumbing.NewHashReference("refs/heads/master", plumbing.NewHash("")))
refs.SetReference(plumbing.NewHashReference("refs/tags/v1.0.0", plumbing.NewHash("")))
refs.SetReference(plumbing.NewHashReference("refs/tags/1.1.2", plumbing.NewHash("")))
refs.SetReference(plumbing.NewHashReference("refs/tags/1.1.3", plumbing.NewHash("")))
refs.SetReference(plumbing.NewHashReference("refs/tags/v1.0.3", plumbing.NewHash("")))
refs.SetReference(plumbing.NewHashReference("refs/tags/v2.0.3", plumbing.NewHash("")))
refs.SetReference(plumbing.NewHashReference("refs/tags/v4.0.0-rc1", plumbing.NewHash("")))
v := NewVersions(refs)
c.Assert(v.BestMatch("v0").Name().String(), Equals, "refs/heads/master")
c.Assert(v.BestMatch("v1.1").Name().String(), Equals, "refs/tags/1.1.3")
c.Assert(v.BestMatch("1.1").Name().String(), Equals, "refs/tags/1.1.3")
c.Assert(v.BestMatch("1.1.2").Name().String(), Equals, "refs/tags/1.1.2")
c.Assert(v.BestMatch("2").Name().String(), Equals, "refs/tags/v2.0.3")
c.Assert(v.BestMatch("4").Name().String(), Equals, "refs/tags/v4.0.0-rc1")
c.Assert(v.BestMatch("master").Name().String(), Equals, "refs/heads/master")
c.Assert(v.BestMatch("foo"), IsNil)
refs.SetReference(plumbing.NewHashReference("refs/tags/v0.0.0", plumbing.NewHash("")))
v = NewVersions(refs)
c.Assert(v.BestMatch("v0").Name().String(), Equals, "refs/tags/v0.0.0")
}
func (s *UlReqEncodeSuite) TestShallow(c *C) {
ur := NewUploadRequest()
ur.Wants = append(ur.Wants, plumbing.NewHash("1111111111111111111111111111111111111111"))
ur.Capabilities.Add(capability.MultiACK)
ur.Shallows = append(ur.Shallows, plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
expected := []string{
"want 1111111111111111111111111111111111111111 multi_ack\n",
"shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n",
pktline.FlushString,
}
testUlReqEncode(c, ur, expected)
}
func (s *FetchPackSuite) TestFetchPackMulti(c *C) {
r, err := s.Client.NewFetchPackSession(s.Endpoint)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
req := packp.NewUploadPackRequest()
req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
req.Wants = append(req.Wants, plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"))
reader, err := r.FetchPack(req)
c.Assert(err, IsNil)
s.checkObjectNumber(c, reader, 31)
}
func (s *BaseStorageSuite) TestSetShallowAndShallow(c *C) {
expected := []plumbing.Hash{
plumbing.NewHash("b66c08ba28aa1f81eb06a1127aa3936ff77e5e2c"),
plumbing.NewHash("c3f4688a08fd86f1bf8e055724c84b7a40a09733"),
plumbing.NewHash("c78874f116be67ecf54df225a613162b84cc6ebf"),
}
err := s.Storer.SetShallow(expected)
c.Assert(err, IsNil)
result, err := s.Storer.Shallow()
c.Assert(err, IsNil)
c.Assert(result, DeepEquals, expected)
}
// Decode transforms a plumbing.EncodedObject into a Commit struct.
func (c *Commit) Decode(o plumbing.EncodedObject) (err error) {
if o.Type() != plumbing.CommitObject {
return ErrUnsupportedObject
}
c.Hash = o.Hash()
reader, err := o.Reader()
if err != nil {
return err
}
defer ioutil.CheckClose(reader, &err)
r := bufio.NewReader(reader)
var message bool
for {
line, err := r.ReadSlice('\n')
if err != nil && err != io.EOF {
return err
}
if !message {
line = bytes.TrimSpace(line)
if len(line) == 0 {
message = true
continue
}
split := bytes.SplitN(line, []byte{' '}, 2)
switch string(split[0]) {
case "tree":
c.tree = plumbing.NewHash(string(split[1]))
case "parent":
c.parents = append(c.parents, plumbing.NewHash(string(split[1])))
case "author":
c.Author.Decode(split[1])
case "committer":
c.Committer.Decode(split[1])
}
} else {
c.Message += string(line)
}
if err == io.EOF {
return nil
}
}
}
func (s *FsSuite) TestGetFromPackfileMultiplePackfiles(c *C) {
fs := fixtures.ByTag(".git").ByTag("multi-packfile").One().DotGit()
o, err := newObjectStorage(dotgit.New(fs))
c.Assert(err, IsNil)
expected := plumbing.NewHash("8d45a34641d73851e01d3754320b33bb5be3c4d3")
obj, err := o.getFromPackfile(expected)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
expected = plumbing.NewHash("e9cfa4c9ca160546efd7e8582ec77952a27b17db")
obj, err = o.getFromPackfile(expected)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
}
func (s *RemoteSuite) TestFetchMulti(c *C) {
r := NewGitUploadPackService(s.Endpoint)
c.Assert(r.Connect(), IsNil)
req := &common.GitUploadPackRequest{}
req.Want(plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"))
req.Want(plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"))
reader, err := r.Fetch(req)
c.Assert(err, IsNil)
b, err := ioutil.ReadAll(reader)
c.Assert(err, IsNil)
c.Assert(b, HasLen, 85585)
}
func (s *TagSuite) TestTagger(c *C) {
r := s.Repositories["https://github.com/git-fixtures/tags.git"]
tag, err := r.Tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
c.Assert(err, IsNil)
c.Assert(tag.Tagger.String(), Equals, "Máximo Cuadros <*****@*****.**>")
}
func (s *TagSuite) TestName(c *C) {
r := s.Repositories["https://github.com/git-fixtures/tags.git"]
tag, err := r.Tag(plumbing.NewHash("b742a2a9fa0afcfa9a6fad080980fbc26b007c69"))
c.Assert(err, IsNil)
c.Assert(tag.Name, Equals, "annotated-tag")
}
func (s *AdvRefSuite) TestAllReferences(c *C) {
hash := plumbing.NewHash("5dc01c595e6c6ec9ccda4f6f69c131c0dd945f8c")
a := NewAdvRefs()
err := a.AddReference(plumbing.NewSymbolicReference("foo", "bar"))
c.Assert(err, IsNil)
err = a.AddReference(plumbing.NewHashReference("bar", hash))
c.Assert(err, IsNil)
refs, err := a.AllReferences()
c.Assert(err, IsNil)
iter, err := refs.IterReferences()
c.Assert(err, IsNil)
var count int
iter.ForEach(func(ref *plumbing.Reference) error {
count++
switch ref.Name() {
case "bar":
c.Assert(ref.Hash(), Equals, hash)
case "foo":
c.Assert(ref.Target().String(), Equals, "bar")
}
return nil
})
c.Assert(count, Equals, 2)
}
func (s *ObjectsSuite) TestParseTree(c *C) {
hash := plumbing.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c")
tree, err := s.Repository.Tree(hash)
c.Assert(err, IsNil)
c.Assert(tree.Entries, HasLen, 8)
tree.buildMap()
c.Assert(tree.m, HasLen, 8)
c.Assert(tree.m[".gitignore"].Name, Equals, ".gitignore")
c.Assert(tree.m[".gitignore"].Mode.String(), Equals, "-rw-r--r--")
c.Assert(tree.m[".gitignore"].Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
count := 0
iter := tree.Files()
defer iter.Close()
for f, err := iter.Next(); err == nil; f, err = iter.Next() {
count++
if f.Name == "go/example.go" {
reader, err := f.Reader()
c.Assert(err, IsNil)
defer func() { c.Assert(reader.Close(), IsNil) }()
content, _ := ioutil.ReadAll(reader)
c.Assert(content, HasLen, 2780)
}
}
c.Assert(count, Equals, 9)
}
func (s *FileSuite) TestFileIter(c *C) {
hash := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")
commit, err := s.Repository.Commit(hash)
c.Assert(err, IsNil)
tree, err := commit.Tree()
expected := []string{
".gitignore",
"CHANGELOG",
"LICENSE",
"binary.jpg",
}
var count int
i := tree.Files()
i.ForEach(func(f *File) error {
c.Assert(f.Name, Equals, expected[count])
count++
return nil
})
c.Assert(count, Equals, 4)
count = 0
i = tree.Files()
i.ForEach(func(f *File) error {
count++
return storer.ErrStop
})
c.Assert(count, Equals, 1)
}
