func (s *RefSpecSuite) TestRefSpecMatch(c *C) {
spec := RefSpec("refs/heads/master:refs/remotes/origin/master")
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/foo")), Equals, false)
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/master")), Equals, true)
spec = RefSpec(":refs/heads/master")
c.Assert(spec.Match(plumbing.ReferenceName("")), Equals, true)
c.Assert(spec.Match(plumbing.ReferenceName("refs/heads/master")), Equals, false)
}
func (s *RefSpecSuite) TestMatchAny(c *C) {
specs := []RefSpec{
"refs/heads/bar:refs/remotes/origin/foo",
"refs/heads/foo:refs/remotes/origin/bar",
}
c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/foo")), Equals, true)
c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/bar")), Equals, true)
c.Assert(MatchAny(specs, plumbing.ReferenceName("refs/heads/master")), Equals, false)
}
func (s *RefSpecSuite) TestRefSpecDstBlob(c *C) {
spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
c.Assert(
spec.Dst(plumbing.ReferenceName("refs/heads/foo")).String(), Equals,
"refs/remotes/origin/foo",
)
}
func (s *RemoteSuite) TestDefaultBranch(c *C) {
r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: RepositoryFixture})
r.upSrv = &MockGitUploadPackService{}
c.Assert(r.Connect(), IsNil)
c.Assert(r.Head().Name(), Equals, plumbing.ReferenceName("refs/heads/master"))
}
func (s *RefSpecSuite) TestRefSpecDst(c *C) {
spec := RefSpec("refs/heads/master:refs/remotes/origin/master")
c.Assert(
spec.Dst(plumbing.ReferenceName("refs/heads/master")).String(), Equals,
"refs/remotes/origin/master",
)
}
// Dst returns the destination for the given remote reference
func (s RefSpec) Dst(n plumbing.ReferenceName) plumbing.ReferenceName {
spec := string(s)
start := strings.Index(spec, refSpecSeparator) + 1
dst := spec[start:]
src := s.Src()
if !s.IsWildcard() {
return plumbing.ReferenceName(dst)
}
name := n.String()
ws := strings.Index(src, refSpecWildcard)
wd := strings.Index(dst, refSpecWildcard)
match := name[ws : len(name)-(len(src)-(ws+1))]
return plumbing.ReferenceName(dst[0:wd] + match + dst[wd+1:])
}
func (s *ReportStatusSuite) TestDecodeErrorEmpty(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "unexpected EOF")
}
func findReference(refs []*plumbing.Reference, name string) *plumbing.Reference {
n := plumbing.ReferenceName(name)
for _, ref := range refs {
if ref.Name() == n {
return ref
}
}
return nil
}
func (i *GitUploadPackInfo) addSymbolicRefs(ar *advrefs.AdvRefs) error {
if !hasSymrefs(ar) {
return nil
}
for _, symref := range ar.Capabilities.Get("symref").Values {
chunks := strings.Split(symref, ":")
if len(chunks) != 2 {
err := fmt.Errorf("bad number of `:` in symref value (%q)", symref)
return plumbing.NewUnexpectedError(err)
}
name := plumbing.ReferenceName(chunks[0])
target := plumbing.ReferenceName(chunks[1])
ref := plumbing.NewSymbolicReference(name, target)
i.Refs.SetReference(ref)
}
return nil
}
func (s *SuiteCommon) TestGitUploadPackInfo(c *C) {
b, _ := base64.StdEncoding.DecodeString(GitUploadPackInfoFixture)
i := NewGitUploadPackInfo()
err := i.Decode(bytes.NewBuffer(b))
c.Assert(err, IsNil)
name := i.Capabilities.SymbolicReference("HEAD")
c.Assert(name, Equals, "refs/heads/master")
c.Assert(i.Refs, HasLen, 4)
ref := i.Refs[plumbing.ReferenceName(name)]
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
ref = i.Refs[plumbing.HEAD]
c.Assert(ref, NotNil)
c.Assert(ref.Target(), Equals, plumbing.ReferenceName(name))
}
func (s *UpdReqEncodeSuite) TestMultipleCommands(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
r := NewReferenceUpdateRequest()
r.Commands = []*Command{
{Name: plumbing.ReferenceName("myref1"), Old: hash1, New: hash2},
{Name: plumbing.ReferenceName("myref2"), Old: plumbing.ZeroHash, New: hash2},
{Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash},
}
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00",
"0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3",
pktline.FlushString,
)
s.testEncode(c, r, expected)
}
func (s *UpdReqDecodeSuite) TestMultipleCommands(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
expected := NewReferenceUpdateRequest()
expected.Commands = []*Command{
{Name: plumbing.ReferenceName("myref1"), Old: hash1, New: hash2},
{Name: plumbing.ReferenceName("myref2"), Old: plumbing.ZeroHash, New: hash2},
{Name: plumbing.ReferenceName("myref3"), Old: hash1, New: plumbing.ZeroHash},
}
expected.Packfile = ioutil.NopCloser(bytes.NewReader([]byte{}))
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref1\x00",
"0000000000000000000000000000000000000000 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref2",
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 0000000000000000000000000000000000000000 myref3",
pktline.FlushString,
}
s.testDecodeOkExpected(c, expected, payloads)
}
func addSymbolicRefs(s storer.ReferenceStorer, ar *AdvRefs) error {
if !hasSymrefs(ar) {
return nil
}
for _, symref := range ar.Capabilities.Get(capability.SymRef) {
chunks := strings.Split(symref, ":")
if len(chunks) != 2 {
err := fmt.Errorf("bad number of `:` in symref value (%q)", symref)
return plumbing.NewUnexpectedError(err)
}
name := plumbing.ReferenceName(chunks[0])
target := plumbing.ReferenceName(chunks[1])
ref := plumbing.NewSymbolicReference(name, target)
if err := s.SetReference(ref); err != nil {
return nil
}
}
return nil
}
func (s *ReportStatusSuite) TestDecodeErrorPrematureFlush(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "premature flush",
pktline.FlushString,
)
}
func (s *ReportStatusSuite) TestEncodeDecodeOkMoreReferences(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "ok"
rs.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}, {
ReferenceName: plumbing.ReferenceName("refs/heads/a"),
Status: "ok",
}, {
ReferenceName: plumbing.ReferenceName("refs/heads/b"),
Status: "ok",
}}
s.testEncodeDecodeOk(c, rs,
"unpack ok\n",
"ok refs/heads/master\n",
"ok refs/heads/a\n",
"ok refs/heads/b\n",
pktline.FlushString,
)
}
func (s *RepositorySuite) TestRef(c *C) {
r := NewMemoryRepository()
err := r.Clone(&CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
c.Assert(err, IsNil)
ref, err := r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(ref.Name(), Equals, plumbing.HEAD)
ref, err = r.Reference(plumbing.HEAD, true)
c.Assert(err, IsNil)
c.Assert(ref.Name(), Equals, plumbing.ReferenceName("refs/heads/master"))
}
func (s *ReportStatusSuite) TestDecodeErrorOneReferenceNoFlush(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "missing flush",
"unpack ok\n",
"ok refs/heads/master\n",
)
}
func (s *ReportStatusSuite) TestDecodeErrorMalformed2(c *C) {
expected := NewReportStatus()
expected.UnpackStatus = "ok"
expected.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "ok",
}}
s.testDecodeError(c, "malformed unpack status: UNPACK OK",
"UNPACK OK\n",
pktline.FlushString,
)
}
func (s *RepositorySuite) TestCloneDetachedHEAD(c *C) {
r := NewMemoryRepository()
err := r.Clone(&CloneOptions{
URL: s.GetBasicLocalRepositoryURL(),
ReferenceName: plumbing.ReferenceName("refs/tags/v1.0.0"),
})
head, err := r.Reference(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(head, NotNil)
c.Assert(head.Type(), Equals, plumbing.HashReference)
c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
}
func (s *ReportStatusSuite) TestEncodeDecodeOkOneReferenceFailed(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "my error"
rs.CommandStatuses = []*CommandStatus{{
ReferenceName: plumbing.ReferenceName("refs/heads/master"),
Status: "command error",
}}
s.testEncodeDecodeOk(c, rs,
"unpack my error\n",
"ng refs/heads/master command error\n",
pktline.FlushString,
)
}
func (s *BaseStorageSuite) TestSetReferenceAndGetReference(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
)
c.Assert(err, IsNil)
err = s.Storer.SetReference(
plumbing.NewReferenceFromStrings("bar", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, IsNil)
e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
}
func (s *RemoteSuite) TestRef(c *C) {
r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: RepositoryFixture})
r.upSrv = &MockGitUploadPackService{}
err := r.Connect()
c.Assert(err, IsNil)
ref, err := r.Ref(plumbing.HEAD, false)
c.Assert(err, IsNil)
c.Assert(ref.Name(), Equals, plumbing.HEAD)
ref, err = r.Ref(plumbing.HEAD, true)
c.Assert(err, IsNil)
c.Assert(ref.Name(), Equals, plumbing.ReferenceName("refs/heads/master"))
}
func (p *MockGitUploadPackService) Info() (*common.GitUploadPackInfo, error) {
if !p.connected {
return nil, errors.New("not connected")
}
h := fixtures.ByURL(p.endpoint.String()).One().Head
c := packp.NewCapabilities()
c.Decode("6ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEADmulti_ack thin-pack side-band side-band-64k ofs-delta shallow no-progress include-tag multi_ack_detailed no-done symref=HEAD:refs/heads/master agent=git/2:2.4.8~dbussink-fix-enterprise-tokens-compilation-1167-gc7006cf")
ref := plumbing.ReferenceName("refs/heads/master")
branch := plumbing.ReferenceName("refs/heads/branch")
tag := plumbing.ReferenceName("refs/tags/v1.0.0")
return &common.GitUploadPackInfo{
Capabilities: c,
Refs: map[plumbing.ReferenceName]*plumbing.Reference{
plumbing.HEAD: plumbing.NewSymbolicReference(plumbing.HEAD, ref),
ref: plumbing.NewHashReference(ref, h),
tag: plumbing.NewHashReference(tag, h),
branch: plumbing.NewHashReference(branch, plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881")),
},
}, nil
}
func (s *UpdReqEncodeSuite) TestOneUpdateCommand(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
r := NewReferenceUpdateRequest()
r.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
)
s.testEncode(c, r, expected)
}
func (s *SuiteCommon) TestGitUploadPackEncode(c *C) {
info := NewGitUploadPackInfo()
info.Capabilities.Add("symref", "HEAD:refs/heads/master")
ref := plumbing.ReferenceName("refs/heads/master")
hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
info.Refs = map[plumbing.ReferenceName]*plumbing.Reference{
plumbing.HEAD: plumbing.NewSymbolicReference(plumbing.HEAD, ref),
ref: plumbing.NewHashReference(ref, hash),
}
c.Assert(info.Head(), NotNil)
c.Assert(info.String(), Equals,
"001e# service=git-upload-pack\n"+
"000000506ecf0ef2c2dffb796033e5a02219af86ec6584e5 HEAD\x00symref=HEAD:refs/heads/master\n"+
"003f6ecf0ef2c2dffb796033e5a02219af86ec6584e5 refs/heads/master\n"+
"0000",
)
}
func (s *ReportStatus) decodeCommandStatus(b []byte) error {
b = bytes.TrimSuffix(b, eol)
line := string(b)
fields := strings.SplitN(line, " ", 3)
status := ok
if len(fields) == 3 && fields[0] == "ng" {
status = fields[2]
} else if len(fields) != 2 || fields[0] != "ok" {
return fmt.Errorf("malformed command status: %s", line)
}
cs := &CommandStatus{
ReferenceName: plumbing.ReferenceName(fields[1]),
Status: status,
}
s.CommandStatuses = append(s.CommandStatuses, cs)
return nil
}
func (s *ReportStatusSuite) TestError(c *C) {
rs := NewReportStatus()
rs.UnpackStatus = "ok"
c.Assert(rs.Error(), IsNil)
rs.UnpackStatus = "OK"
c.Assert(rs.Error(), ErrorMatches, "unpack error: OK")
rs.UnpackStatus = ""
c.Assert(rs.Error(), ErrorMatches, "unpack error: ")
cs := &CommandStatus{ReferenceName: plumbing.ReferenceName("ref")}
rs.UnpackStatus = "ok"
rs.CommandStatuses = append(rs.CommandStatuses, cs)
cs.Status = "ok"
c.Assert(rs.Error(), IsNil)
cs.Status = "OK"
c.Assert(rs.Error(), ErrorMatches, "command error on ref: OK")
cs.Status = ""
c.Assert(rs.Error(), ErrorMatches, "command error on ref: ")
}
func (s *SendPackSuite) TestSendPackOnNonEmptyWithReportStatusWithError(c *C) {
endpoint := s.Endpoint
full := false
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{"refs/heads/master", plumbing.ZeroHash, fixture.Head},
}
req.Capabilities.Set(capability.ReportStatus)
report, err := s.sendPackNoCheck(c, endpoint, req, fixture, full)
//XXX: Recent git versions return "failed to update ref", while older
// (>=1.9) return "failed to lock".
c.Assert(err, ErrorMatches, ".*(failed to update ref|failed to lock).*")
c.Assert(report.UnpackStatus, Equals, "ok")
c.Assert(len(report.CommandStatuses), Equals, 1)
c.Assert(report.CommandStatuses[0].ReferenceName, Equals, plumbing.ReferenceName("refs/heads/master"))
c.Assert(report.CommandStatuses[0].Status, Matches, "(failed to update ref|failed to lock)")
s.checkRemoteHead(c, endpoint, fixture.Head)
}
func (s *UpdReqDecodeSuite) TestWithPackfile(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
expected := NewReferenceUpdateRequest()
expected.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
packfileContent := []byte("PACKabc")
expected.Packfile = ioutil.NopCloser(bytes.NewReader(packfileContent))
payloads := []string{
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
}
var buf bytes.Buffer
e := pktline.NewEncoder(&buf)
c.Assert(e.EncodeString(payloads...), IsNil)
buf.Write(packfileContent)
s.testDecodeOkRaw(c, expected, buf.Bytes())
}
func (s *UpdReqEncodeSuite) TestWithPackfile(c *C) {
hash1 := plumbing.NewHash("1ecf0ef2c2dffb796033e5a02219af86ec6584e5")
hash2 := plumbing.NewHash("2ecf0ef2c2dffb796033e5a02219af86ec6584e5")
name := plumbing.ReferenceName("myref")
packfileContent := []byte("PACKabc")
packfileReader := bytes.NewReader(packfileContent)
packfileReadCloser := ioutil.NopCloser(packfileReader)
r := NewReferenceUpdateRequest()
r.Commands = []*Command{
{Name: name, Old: hash1, New: hash2},
}
r.Packfile = packfileReadCloser
expected := pktlines(c,
"1ecf0ef2c2dffb796033e5a02219af86ec6584e5 2ecf0ef2c2dffb796033e5a02219af86ec6584e5 myref\x00",
pktline.FlushString,
)
expected = append(expected, packfileContent...)
s.testEncode(c, r, expected)
}
