1 files changed, 322 insertions, 0 deletions
diff --git a/plumbing/transport/test/receive_pack.go b/plumbing/transport/test/receive_pack.go
new file mode 100644
index 0000000..e798154
--- /dev/null
+++ b/plumbing/transport/test/receive_pack.go
@@ -0,0 +1,322 @@
+// Package test implements common test suite for different transport
+// implementations.
+//
+package test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+
+	"gopkg.in/src-d/go-git.v4/fixtures"
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/format/packfile"
+	"gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
+	"gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
+	"gopkg.in/src-d/go-git.v4/plumbing/transport"
+	"gopkg.in/src-d/go-git.v4/storage/memory"
+
+	. "gopkg.in/check.v1"
+)
+
+type ReceivePackSuite struct {
+	Endpoint            transport.Endpoint
+	EmptyEndpoint       transport.Endpoint
+	NonExistentEndpoint transport.Endpoint
+	Client              transport.Transport
+}
+
+func (s *ReceivePackSuite) TestAdvertisedReferencesEmpty(c *C) {
+	r, err := s.Client.NewReceivePackSession(s.EmptyEndpoint)
+	c.Assert(err, IsNil)
+	defer func() { c.Assert(r.Close(), IsNil) }()
+	ar, err := r.AdvertisedReferences()
+	c.Assert(err, IsNil)
+	c.Assert(ar.Head, IsNil)
+}
+
+func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists(c *C) {
+	r, err := s.Client.NewReceivePackSession(s.NonExistentEndpoint)
+	c.Assert(err, IsNil)
+	defer func() { c.Assert(r.Close(), IsNil) }()
+	ar, err := r.AdvertisedReferences()
+	c.Assert(err, Equals, transport.ErrRepositoryNotFound)
+	c.Assert(ar, IsNil)
+
+	r, err = s.Client.NewReceivePackSession(s.NonExistentEndpoint)
+	c.Assert(err, IsNil)
+	req := packp.NewReferenceUpdateRequest()
+	req.Commands = []*packp.Command{
+		{"master", plumbing.ZeroHash, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")},
+	}
+
+	writer, err := r.ReceivePack(req)
+	c.Assert(err, Equals, transport.ErrRepositoryNotFound)
+	c.Assert(writer, IsNil)
+}
+
+func (s *ReceivePackSuite) TestCallAdvertisedReferenceTwice(c *C) {
+	r, err := s.Client.NewReceivePackSession(s.Endpoint)
+	c.Assert(err, IsNil)
+	ar1, err := r.AdvertisedReferences()
+	c.Assert(err, IsNil)
+	c.Assert(ar1, NotNil)
+	ar2, err := r.AdvertisedReferences()
+	c.Assert(err, IsNil)
+	c.Assert(ar2, DeepEquals, ar1)
+}
+
+func (s *ReceivePackSuite) TestDefaultBranch(c *C) {
+	r, err := s.Client.NewReceivePackSession(s.Endpoint)
+	c.Assert(err, IsNil)
+	defer func() { c.Assert(r.Close(), IsNil) }()
+
+	info, err := r.AdvertisedReferences()
+	c.Assert(err, IsNil)
+	ref, ok := info.References["refs/heads/master"]
+	c.Assert(ok, Equals, true)
+	c.Assert(ref, Equals, fixtures.Basic().One().Head)
+}
+
+func (s *ReceivePackSuite) TestCapabilities(c *C) {
+	r, err := s.Client.NewReceivePackSession(s.Endpoint)
+	c.Assert(err, IsNil)
+	defer func() { c.Assert(r.Close(), IsNil) }()
+
+	info, err := r.AdvertisedReferences()
+	c.Assert(err, IsNil)
+	c.Assert(info.Capabilities.Get("agent"), HasLen, 1)
+}
+
+func (s *ReceivePackSuite) TestFullSendPackOnEmpty(c *C) {
+	endpoint := s.EmptyEndpoint
+	full := true
+	fixture := fixtures.Basic().ByTag("packfile").One()
+	req := packp.NewReferenceUpdateRequest()
+	req.Commands = []*packp.Command{
+		{"refs/heads/master", plumbing.ZeroHash, fixture.Head},
+	}
+	s.receivePack(c, endpoint, req, fixture, full)
+	s.checkRemoteHead(c, endpoint, fixture.Head)
+}
+
+func (s *ReceivePackSuite) TestSendPackOnEmpty(c *C) {
+	endpoint := s.EmptyEndpoint
+	full := false
+	fixture := fixtures.Basic().ByTag("packfile").One()
+	req := packp.NewReferenceUpdateRequest()
+	req.Commands = []*packp.Command{
+		{"refs/heads/master", plumbing.ZeroHash, fixture.Head},
+	}
+	s.receivePack(c, endpoint, req, fixture, full)
+	s.checkRemoteHead(c, endpoint, fixture.Head)
+}
+
+func (s *ReceivePackSuite) TestSendPackOnEmptyWithReportStatus(c *C) {
+	endpoint := s.EmptyEndpoint
+	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)
+	s.receivePack(c, endpoint, req, fixture, full)
+	s.checkRemoteHead(c, endpoint, fixture.Head)
+}
+
+func (s *ReceivePackSuite) TestFullSendPackOnNonEmpty(c *C) {
+	endpoint := s.Endpoint
+	full := true
+	fixture := fixtures.Basic().ByTag("packfile").One()
+	req := packp.NewReferenceUpdateRequest()
+	req.Commands = []*packp.Command{
+		{"refs/heads/master", fixture.Head, fixture.Head},
+	}
+	s.receivePack(c, endpoint, req, fixture, full)
+	s.checkRemoteHead(c, endpoint, fixture.Head)
+}
+
+func (s *ReceivePackSuite) TestSendPackOnNonEmpty(c *C) {
+	endpoint := s.Endpoint
+	full := false
+	fixture := fixtures.Basic().ByTag("packfile").One()
+	req := packp.NewReferenceUpdateRequest()
+	req.Commands = []*packp.Command{
+		{"refs/heads/master", fixture.Head, fixture.Head},
+	}
+	s.receivePack(c, endpoint, req, fixture, full)
+	s.checkRemoteHead(c, endpoint, fixture.Head)
+}
+
+func (s *ReceivePackSuite) TestSendPackOnNonEmptyWithReportStatus(c *C) {
+	endpoint := s.Endpoint
+	full := false
+	fixture := fixtures.Basic().ByTag("packfile").One()
+	req := packp.NewReferenceUpdateRequest()
+	req.Commands = []*packp.Command{
+		{"refs/heads/master", fixture.Head, fixture.Head},
+	}
+	req.Capabilities.Set(capability.ReportStatus)
+
+	s.receivePack(c, endpoint, req, fixture, full)
+	s.checkRemoteHead(c, endpoint, fixture.Head)
+}
+
+func (s *ReceivePackSuite) 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.receivePackNoCheck(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 *ReceivePackSuite) receivePackNoCheck(c *C, ep transport.Endpoint,
+	req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture,
+	callAdvertisedReferences bool) (*packp.ReportStatus, error) {
+	url := ""
+	if fixture != nil {
+		url = fixture.URL
+	}
+	comment := Commentf(
+		"failed with ep=%s fixture=%s callAdvertisedReferences=%s",
+		ep.String(), url, callAdvertisedReferences,
+	)
+
+	r, err := s.Client.NewReceivePackSession(ep)
+	c.Assert(err, IsNil, comment)
+	defer func() { c.Assert(r.Close(), IsNil, comment) }()
+
+	if callAdvertisedReferences {
+		info, err := r.AdvertisedReferences()
+		c.Assert(err, IsNil, comment)
+		c.Assert(info, NotNil, comment)
+	}
+
+	if fixture != nil {
+		c.Assert(fixture.Packfile(), NotNil)
+		req.Packfile = fixture.Packfile()
+	} else {
+		req.Packfile = s.emptyPackfile()
+	}
+
+	return r.ReceivePack(req)
+}
+
+func (s *ReceivePackSuite) receivePack(c *C, ep transport.Endpoint,
+	req *packp.ReferenceUpdateRequest, fixture *fixtures.Fixture,
+	callAdvertisedReferences bool) {
+
+	url := ""
+	if fixture != nil {
+		url = fixture.URL
+	}
+
+	comment := Commentf(
+		"failed with ep=%s fixture=%s callAdvertisedReferences=%s",
+		ep.String(), url, callAdvertisedReferences,
+	)
+	report, err := s.receivePackNoCheck(c, ep, req, fixture, callAdvertisedReferences)
+
+	c.Assert(err, IsNil, comment)
+	if req.Capabilities.Supports(capability.ReportStatus) {
+		c.Assert(report, NotNil, comment)
+		c.Assert(report.Error(), IsNil, comment)
+	} else {
+		c.Assert(report, IsNil, comment)
+	}
+}
+
+func (s *ReceivePackSuite) checkRemoteHead(c *C, ep transport.Endpoint, head plumbing.Hash) {
+	s.checkRemoteReference(c, ep, "refs/heads/master", head)
+}
+
+func (s *ReceivePackSuite) checkRemoteReference(c *C, ep transport.Endpoint,
+	refName string, head plumbing.Hash) {
+
+	r, err := s.Client.NewUploadPackSession(ep)
+	c.Assert(err, IsNil)
+	defer func() { c.Assert(r.Close(), IsNil) }()
+	ar, err := r.AdvertisedReferences()
+	c.Assert(err, IsNil, Commentf("endpoint: %s", ep.String()))
+	ref, ok := ar.References[refName]
+	if head == plumbing.ZeroHash {
+		c.Assert(ok, Equals, false)
+	} else {
+		c.Assert(ok, Equals, true)
+		c.Assert(ref, DeepEquals, head)
+	}
+}
+
+func (s *ReceivePackSuite) TestSendPackAddDeleteReference(c *C) {
+	s.testSendPackAddReference(c)
+	s.testSendPackDeleteReference(c)
+}
+
+func (s *ReceivePackSuite) testSendPackAddReference(c *C) {
+	r, err := s.Client.NewReceivePackSession(s.Endpoint)
+	c.Assert(err, IsNil)
+	defer func() { c.Assert(r.Close(), IsNil) }()
+
+	fixture := fixtures.Basic().ByTag("packfile").One()
+
+	ar, err := r.AdvertisedReferences()
+	c.Assert(err, IsNil)
+
+	req := packp.NewReferenceUpdateRequest()
+	req.Commands = []*packp.Command{
+		{"refs/heads/newbranch", plumbing.ZeroHash, fixture.Head},
+	}
+	if ar.Capabilities.Supports(capability.ReportStatus) {
+		req.Capabilities.Set(capability.ReportStatus)
+	}
+
+	s.receivePack(c, s.Endpoint, req, nil, false)
+	s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", fixture.Head)
+}
+
+func (s *ReceivePackSuite) testSendPackDeleteReference(c *C) {
+	r, err := s.Client.NewReceivePackSession(s.Endpoint)
+	c.Assert(err, IsNil)
+	defer func() { c.Assert(r.Close(), IsNil) }()
+
+	fixture := fixtures.Basic().ByTag("packfile").One()
+
+	ar, err := r.AdvertisedReferences()
+	c.Assert(err, IsNil)
+
+	req := packp.NewReferenceUpdateRequest()
+	req.Commands = []*packp.Command{
+		{"refs/heads/newbranch", fixture.Head, plumbing.ZeroHash},
+	}
+	if ar.Capabilities.Supports(capability.ReportStatus) {
+		req.Capabilities.Set(capability.ReportStatus)
+	}
+
+	s.receivePack(c, s.Endpoint, req, nil, false)
+	s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", plumbing.ZeroHash)
+}
+
+func (s *ReceivePackSuite) emptyPackfile() io.ReadCloser {
+	var buf bytes.Buffer
+	e := packfile.NewEncoder(&buf, memory.NewStorage(), false)
+	_, err := e.Encode(nil)
+	if err != nil {
+		panic(err)
+	}
+
+	return ioutil.NopCloser(&buf)
+}