From 0e1a52757a3938e97cf7d31e0dff3c9949001763 Mon Sep 17 00:00:00 2001 From: "Santiago M. Mola" Date: Fri, 9 Dec 2016 14:44:03 +0100 Subject: transport: add git-send-pack support to local/ssh. (#163) * protocol/packp: add Packfile field to ReferenceUpdateRequest. * protocol/packp: add NewReferenceUpdateRequestFromCapabilities. * NewReferenceUpdateRequestFromCapabilities can be used to create a ReferenceUpdateRequest with initial capabilities compatible with the server. * protocol/packp: fix new line handling on report status. * transport/file: test error on unexisting command. --- plumbing/transport/test/common.go | 196 ----------------------- plumbing/transport/test/fetch_pack.go | 196 +++++++++++++++++++++++ plumbing/transport/test/send_pack.go | 285 ++++++++++++++++++++++++++++++++++ 3 files changed, 481 insertions(+), 196 deletions(-) delete mode 100644 plumbing/transport/test/common.go create mode 100644 plumbing/transport/test/fetch_pack.go create mode 100644 plumbing/transport/test/send_pack.go (limited to 'plumbing/transport/test') diff --git a/plumbing/transport/test/common.go b/plumbing/transport/test/common.go deleted file mode 100644 index 2984154..0000000 --- a/plumbing/transport/test/common.go +++ /dev/null @@ -1,196 +0,0 @@ -// Package test implements common test suite for different transport -// implementations. -// -package test - -import ( - "bytes" - "io" - "io/ioutil" - - "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/transport" - "gopkg.in/src-d/go-git.v4/storage/memory" - - . "gopkg.in/check.v1" - "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability" -) - -type FetchPackSuite struct { - Endpoint transport.Endpoint - EmptyEndpoint transport.Endpoint - NonExistentEndpoint transport.Endpoint - Client transport.Client -} - -func (s *FetchPackSuite) TestInfoEmpty(c *C) { - r, err := s.Client.NewFetchPackSession(s.EmptyEndpoint) - c.Assert(err, IsNil) - info, err := r.AdvertisedReferences() - c.Assert(err, Equals, transport.ErrEmptyRemoteRepository) - c.Assert(info, IsNil) -} - -func (s *FetchPackSuite) TestInfoNotExists(c *C) { - r, err := s.Client.NewFetchPackSession(s.NonExistentEndpoint) - c.Assert(err, IsNil) - info, err := r.AdvertisedReferences() - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(info, IsNil) - - r, err = s.Client.NewFetchPackSession(s.NonExistentEndpoint) - c.Assert(err, IsNil) - req := packp.NewUploadPackRequest() - req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - reader, err := r.FetchPack(req) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(reader, IsNil) -} - -func (s *FetchPackSuite) TestCallAdvertisedReferenceTwice(c *C) { - r, err := s.Client.NewFetchPackSession(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 *FetchPackSuite) TestDefaultBranch(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() - - info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - symrefs := info.Capabilities.Get(capability.SymRef) - c.Assert(symrefs, HasLen, 1) - c.Assert(symrefs[0], Equals, "HEAD:refs/heads/master") -} - -func (s *FetchPackSuite) TestAdvertisedReferencesFilterUnsupported(c *C) { - r, err := s.Client.NewFetchPackSession(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.Supports(capability.MultiACK), Equals, false) -} - -func (s *FetchPackSuite) TestCapabilities(c *C) { - r, err := s.Client.NewFetchPackSession(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(capability.Agent), HasLen, 1) -} - -func (s *FetchPackSuite) TestFullFetchPack(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) - c.Assert(err, IsNil) - defer func() { c.Assert(r.Close(), IsNil) }() - - info, err := r.AdvertisedReferences() - c.Assert(err, IsNil) - c.Assert(info, NotNil) - - req := packp.NewUploadPackRequest() - req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) - - reader, err := r.FetchPack(req) - c.Assert(err, IsNil) - - s.checkObjectNumber(c, reader, 28) -} - -func (s *FetchPackSuite) TestFetchPack(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")) - - reader, err := r.FetchPack(req) - c.Assert(err, IsNil) - - s.checkObjectNumber(c, reader, 28) -} - -func (s *FetchPackSuite) TestFetchPackInvalidReq(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.Capabilities.Set(capability.Sideband) - req.Capabilities.Set(capability.Sideband64k) - - _, err = r.FetchPack(req) - c.Assert(err, NotNil) -} - -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 *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 *FetchPackSuite) TestFetchError(c *C) { - r, err := s.Client.NewFetchPackSession(s.Endpoint) - c.Assert(err, IsNil) - - req := packp.NewUploadPackRequest() - req.Wants = append(req.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) - - reader, err := r.FetchPack(req) - c.Assert(err, Equals, transport.ErrEmptyUploadPackRequest) - c.Assert(reader, IsNil) - - //XXX: We do not test Close error, since implementations might return - // different errors if a previous error was found. -} - -func (s *FetchPackSuite) checkObjectNumber(c *C, r io.Reader, n int) { - b, err := ioutil.ReadAll(r) - c.Assert(err, IsNil) - buf := bytes.NewBuffer(b) - scanner := packfile.NewScanner(buf) - storage := memory.NewStorage() - d, err := packfile.NewDecoder(scanner, storage) - c.Assert(err, IsNil) - _, err = d.Decode() - c.Assert(err, IsNil) - c.Assert(len(storage.Objects), Equals, n) -} diff --git a/plumbing/transport/test/fetch_pack.go b/plumbing/transport/test/fetch_pack.go new file mode 100644 index 0000000..2984154 --- /dev/null +++ b/plumbing/transport/test/fetch_pack.go @@ -0,0 +1,196 @@ +// Package test implements common test suite for different transport +// implementations. +// +package test + +import ( + "bytes" + "io" + "io/ioutil" + + "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/transport" + "gopkg.in/src-d/go-git.v4/storage/memory" + + . "gopkg.in/check.v1" + "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability" +) + +type FetchPackSuite struct { + Endpoint transport.Endpoint + EmptyEndpoint transport.Endpoint + NonExistentEndpoint transport.Endpoint + Client transport.Client +} + +func (s *FetchPackSuite) TestInfoEmpty(c *C) { + r, err := s.Client.NewFetchPackSession(s.EmptyEndpoint) + c.Assert(err, IsNil) + info, err := r.AdvertisedReferences() + c.Assert(err, Equals, transport.ErrEmptyRemoteRepository) + c.Assert(info, IsNil) +} + +func (s *FetchPackSuite) TestInfoNotExists(c *C) { + r, err := s.Client.NewFetchPackSession(s.NonExistentEndpoint) + c.Assert(err, IsNil) + info, err := r.AdvertisedReferences() + c.Assert(err, Equals, transport.ErrRepositoryNotFound) + c.Assert(info, IsNil) + + r, err = s.Client.NewFetchPackSession(s.NonExistentEndpoint) + c.Assert(err, IsNil) + req := packp.NewUploadPackRequest() + req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + reader, err := r.FetchPack(req) + c.Assert(err, Equals, transport.ErrRepositoryNotFound) + c.Assert(reader, IsNil) +} + +func (s *FetchPackSuite) TestCallAdvertisedReferenceTwice(c *C) { + r, err := s.Client.NewFetchPackSession(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 *FetchPackSuite) TestDefaultBranch(c *C) { + r, err := s.Client.NewFetchPackSession(s.Endpoint) + c.Assert(err, IsNil) + defer func() { c.Assert(r.Close(), IsNil) }() + + info, err := r.AdvertisedReferences() + c.Assert(err, IsNil) + symrefs := info.Capabilities.Get(capability.SymRef) + c.Assert(symrefs, HasLen, 1) + c.Assert(symrefs[0], Equals, "HEAD:refs/heads/master") +} + +func (s *FetchPackSuite) TestAdvertisedReferencesFilterUnsupported(c *C) { + r, err := s.Client.NewFetchPackSession(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.Supports(capability.MultiACK), Equals, false) +} + +func (s *FetchPackSuite) TestCapabilities(c *C) { + r, err := s.Client.NewFetchPackSession(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(capability.Agent), HasLen, 1) +} + +func (s *FetchPackSuite) TestFullFetchPack(c *C) { + r, err := s.Client.NewFetchPackSession(s.Endpoint) + c.Assert(err, IsNil) + defer func() { c.Assert(r.Close(), IsNil) }() + + info, err := r.AdvertisedReferences() + c.Assert(err, IsNil) + c.Assert(info, NotNil) + + req := packp.NewUploadPackRequest() + req.Wants = append(req.Wants, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")) + + reader, err := r.FetchPack(req) + c.Assert(err, IsNil) + + s.checkObjectNumber(c, reader, 28) +} + +func (s *FetchPackSuite) TestFetchPack(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")) + + reader, err := r.FetchPack(req) + c.Assert(err, IsNil) + + s.checkObjectNumber(c, reader, 28) +} + +func (s *FetchPackSuite) TestFetchPackInvalidReq(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.Capabilities.Set(capability.Sideband) + req.Capabilities.Set(capability.Sideband64k) + + _, err = r.FetchPack(req) + c.Assert(err, NotNil) +} + +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 *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 *FetchPackSuite) TestFetchError(c *C) { + r, err := s.Client.NewFetchPackSession(s.Endpoint) + c.Assert(err, IsNil) + + req := packp.NewUploadPackRequest() + req.Wants = append(req.Wants, plumbing.NewHash("1111111111111111111111111111111111111111")) + + reader, err := r.FetchPack(req) + c.Assert(err, Equals, transport.ErrEmptyUploadPackRequest) + c.Assert(reader, IsNil) + + //XXX: We do not test Close error, since implementations might return + // different errors if a previous error was found. +} + +func (s *FetchPackSuite) checkObjectNumber(c *C, r io.Reader, n int) { + b, err := ioutil.ReadAll(r) + c.Assert(err, IsNil) + buf := bytes.NewBuffer(b) + scanner := packfile.NewScanner(buf) + storage := memory.NewStorage() + d, err := packfile.NewDecoder(scanner, storage) + c.Assert(err, IsNil) + _, err = d.Decode() + c.Assert(err, IsNil) + c.Assert(len(storage.Objects), Equals, n) +} diff --git a/plumbing/transport/test/send_pack.go b/plumbing/transport/test/send_pack.go new file mode 100644 index 0000000..94a1150 --- /dev/null +++ b/plumbing/transport/test/send_pack.go @@ -0,0 +1,285 @@ +// 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 SendPackSuite struct { + Endpoint transport.Endpoint + EmptyEndpoint transport.Endpoint + NonExistentEndpoint transport.Endpoint + Client transport.Client +} + +func (s *SendPackSuite) TestInfoEmpty(c *C) { + r, err := s.Client.NewSendPackSession(s.EmptyEndpoint) + c.Assert(err, IsNil) + defer func() { c.Assert(r.Close(), IsNil) }() + info, err := r.AdvertisedReferences() + c.Assert(err, IsNil) + c.Assert(info.Head, IsNil) +} + +func (s *SendPackSuite) TestInfoNotExists(c *C) { + r, err := s.Client.NewSendPackSession(s.NonExistentEndpoint) + c.Assert(err, IsNil) + defer func() { c.Assert(r.Close(), IsNil) }() + info, err := r.AdvertisedReferences() + c.Assert(err, Equals, transport.ErrRepositoryNotFound) + c.Assert(info, IsNil) + + r, err = s.Client.NewSendPackSession(s.NonExistentEndpoint) + c.Assert(err, IsNil) + req := packp.NewReferenceUpdateRequest() + req.Commands = []*packp.Command{ + {"master", plumbing.ZeroHash, plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")}, + } + + writer, err := r.SendPack(req) + c.Assert(err, Equals, transport.ErrRepositoryNotFound) + c.Assert(writer, IsNil) +} + +func (s *SendPackSuite) TestCallAdvertisedReferenceTwice(c *C) { + r, err := s.Client.NewSendPackSession(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 *SendPackSuite) TestDefaultBranch(c *C) { + r, err := s.Client.NewSendPackSession(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 *SendPackSuite) TestCapabilities(c *C) { + r, err := s.Client.NewSendPackSession(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 *SendPackSuite) 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.sendPack(c, endpoint, req, fixture, full) + s.checkRemoteHead(c, endpoint, fixture.Head) +} + +func (s *SendPackSuite) 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.sendPack(c, endpoint, req, fixture, full) + s.checkRemoteHead(c, endpoint, fixture.Head) +} + +func (s *SendPackSuite) 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.sendPack(c, endpoint, req, fixture, full) + s.checkRemoteHead(c, endpoint, fixture.Head) +} + +func (s *SendPackSuite) TestFullSendPackOnNonEmpty(c *C) { + endpoint := s.Endpoint + full := true + fixture := fixtures.Basic().ByTag("packfile").One() + req := packp.NewReferenceUpdateRequest() + req.Commands = []*packp.Command{ + {"refs/heads/master", plumbing.ZeroHash, fixture.Head}, + } + s.sendPack(c, endpoint, req, fixture, full) + s.checkRemoteHead(c, endpoint, fixture.Head) +} + +func (s *SendPackSuite) TestSendPackOnNonEmpty(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}, + } + s.sendPack(c, endpoint, req, fixture, full) + s.checkRemoteHead(c, endpoint, fixture.Head) +} + +func (s *SendPackSuite) TestSendPackOnNonEmptyWithReportStatus(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) + + s.sendPack(c, endpoint, req, fixture, full) + s.checkRemoteHead(c, endpoint, fixture.Head) +} + +func (s *SendPackSuite) sendPack(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, + ) + + r, err := s.Client.NewSendPackSession(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() + } + + report, err := r.SendPack(req) + c.Assert(err, IsNil, comment) + if req.Capabilities.Supports(capability.ReportStatus) { + c.Assert(report, NotNil, comment) + c.Assert(report.Ok(), Equals, true, comment) + } else { + c.Assert(report, IsNil, comment) + } +} + +func (s *SendPackSuite) checkRemoteHead(c *C, ep transport.Endpoint, head plumbing.Hash) { + s.checkRemoteReference(c, ep, "refs/heads/master", head) +} + +func (s *SendPackSuite) checkRemoteReference(c *C, ep transport.Endpoint, + refName string, head plumbing.Hash) { + + r, err := s.Client.NewFetchPackSession(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 *SendPackSuite) TestSendPackAddDeleteReference(c *C) { + s.testSendPackAddReference(c) + s.testSendPackDeleteReference(c) +} + +func (s *SendPackSuite) testSendPackAddReference(c *C) { + r, err := s.Client.NewSendPackSession(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.sendPack(c, s.Endpoint, req, nil, false) + s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", fixture.Head) +} + +func (s *SendPackSuite) testSendPackDeleteReference(c *C) { + r, err := s.Client.NewSendPackSession(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.sendPack(c, s.Endpoint, req, nil, false) + s.checkRemoteReference(c, s.Endpoint, "refs/heads/newbranch", plumbing.ZeroHash) +} + +func (s *SendPackSuite) emptyPackfile() io.ReadCloser { + var buf bytes.Buffer + e := packfile.NewEncoder(&buf, memory.NewStorage()) + _, err := e.Encode(nil) + if err != nil { + panic(err) + } + + return ioutil.NopCloser(&buf) +} -- cgit