From 4b23312bc8b892aa8a346cd3fb64a07bee631c7e Mon Sep 17 00:00:00 2001 From: Ayman Bagabas Date: Sun, 29 Dec 2024 17:02:50 +0300 Subject: [PATCH] plumbing: server, remove package in favor of transport We no longer need a separate package for the server protocol, as it is now implemented in the transport package. --- plumbing/server/loader.go | 72 ----- plumbing/server/loader_test.go | 92 ------ plumbing/server/receive_pack_test.go | 64 ---- plumbing/server/serve.go | 73 ----- plumbing/server/server.go | 461 --------------------------- plumbing/server/server_test.go | 64 ---- plumbing/server/upload_pack_test.go | 50 --- 7 files changed, 876 deletions(-) delete mode 100644 plumbing/server/loader.go delete mode 100644 plumbing/server/loader_test.go delete mode 100644 plumbing/server/receive_pack_test.go delete mode 100644 plumbing/server/serve.go delete mode 100644 plumbing/server/server.go delete mode 100644 plumbing/server/server_test.go delete mode 100644 plumbing/server/upload_pack_test.go diff --git a/plumbing/server/loader.go b/plumbing/server/loader.go deleted file mode 100644 index f03a91c6d..000000000 --- a/plumbing/server/loader.go +++ /dev/null @@ -1,72 +0,0 @@ -package server - -import ( - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/storage/filesystem" - - "github.com/go-git/go-billy/v5" - "github.com/go-git/go-billy/v5/osfs" -) - -// DefaultLoader is a filesystem loader ignoring host and resolving paths to /. -var DefaultLoader = NewFilesystemLoader(osfs.New("")) - -// Loader loads repository's storer.Storer based on an optional host and a path. -type Loader interface { - // Load loads a storer.Storer given a transport.Endpoint. - // Returns transport.ErrRepositoryNotFound if the repository does not - // exist. - Load(ep *transport.Endpoint) (storer.Storer, error) -} - -type fsLoader struct { - base billy.Filesystem -} - -// NewFilesystemLoader creates a Loader that ignores host and resolves paths -// with a given base filesystem. -func NewFilesystemLoader(base billy.Filesystem) Loader { - return &fsLoader{base} -} - -// Load looks up the endpoint's path in the base file system and returns a -// storer for it. Returns transport.ErrRepositoryNotFound if a repository does -// not exist in the given path. -func (l *fsLoader) Load(ep *transport.Endpoint) (storer.Storer, error) { - fs, err := l.base.Chroot(ep.Path) - if err != nil { - return nil, err - } - - var bare bool - if _, err := fs.Stat("config"); err == nil { - bare = true - } - - if !bare { - // do not use git.GitDirName due to import cycle - if _, err := fs.Stat(".git"); err != nil { - return nil, transport.ErrRepositoryNotFound - } - } - - return filesystem.NewStorage(fs, cache.NewObjectLRUDefault()), nil -} - -// MapLoader is a Loader that uses a lookup map of storer.Storer by -// transport.Endpoint. -type MapLoader map[string]storer.Storer - -// Load returns a storer.Storer for given a transport.Endpoint by looking it up -// in the map. Returns transport.ErrRepositoryNotFound if the endpoint does not -// exist. -func (l MapLoader) Load(ep *transport.Endpoint) (storer.Storer, error) { - s, ok := l[ep.String()] - if !ok { - return nil, transport.ErrRepositoryNotFound - } - - return s, nil -} diff --git a/plumbing/server/loader_test.go b/plumbing/server/loader_test.go deleted file mode 100644 index d478e6521..000000000 --- a/plumbing/server/loader_test.go +++ /dev/null @@ -1,92 +0,0 @@ -package server - -import ( - "os/exec" - "path/filepath" - - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/storage/memory" - - . "gopkg.in/check.v1" -) - -type loaderSuiteRepo struct { - bare bool - - path string -} - -type LoaderSuite struct { - Repos map[string]loaderSuiteRepo -} - -var _ = Suite(&LoaderSuite{ - Repos: map[string]loaderSuiteRepo{ - "repo": {path: "repo.git"}, - "bare": {path: "bare.git", bare: true}, - }, -}) - -func (s *LoaderSuite) SetUpSuite(c *C) { - if err := exec.Command("git", "--version").Run(); err != nil { - c.Skip("git command not found") - } - - dir := c.MkDir() - - for key, repo := range s.Repos { - repo.path = filepath.Join(dir, repo.path) - if repo.bare { - c.Assert(exec.Command("git", "init", "--bare", repo.path).Run(), IsNil) - } else { - c.Assert(exec.Command("git", "init", repo.path).Run(), IsNil) - } - s.Repos[key] = repo - } - -} - -func (s *LoaderSuite) endpoint(c *C, url string) *transport.Endpoint { - ep, err := transport.NewEndpoint(url) - c.Assert(err, IsNil) - return ep -} - -func (s *LoaderSuite) TestLoadNonExistent(c *C) { - sto, err := DefaultLoader.Load(s.endpoint(c, "does-not-exist")) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(sto, IsNil) -} - -func (s *LoaderSuite) TestLoadNonExistentIgnoreHost(c *C) { - sto, err := DefaultLoader.Load(s.endpoint(c, "https://github.com/does-not-exist")) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(sto, IsNil) -} - -func (s *LoaderSuite) TestLoad(c *C) { - sto, err := DefaultLoader.Load(s.endpoint(c, s.Repos["repo"].path)) - c.Assert(err, IsNil) - c.Assert(sto, NotNil) -} - -func (s *LoaderSuite) TestLoadBare(c *C) { - sto, err := DefaultLoader.Load(s.endpoint(c, s.Repos["bare"].path)) - c.Assert(err, IsNil) - c.Assert(sto, NotNil) -} - -func (s *LoaderSuite) TestMapLoader(c *C) { - ep, err := transport.NewEndpoint("file://test") - sto := memory.NewStorage() - c.Assert(err, IsNil) - - loader := MapLoader{ep.String(): sto} - - ep, err = transport.NewEndpoint("file://test") - c.Assert(err, IsNil) - - loaderSto, err := loader.Load(ep) - c.Assert(err, IsNil) - c.Assert(sto, Equals, loaderSto) -} diff --git a/plumbing/server/receive_pack_test.go b/plumbing/server/receive_pack_test.go deleted file mode 100644 index 6c704bd76..000000000 --- a/plumbing/server/receive_pack_test.go +++ /dev/null @@ -1,64 +0,0 @@ -package server_test - -import ( - "context" - - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/transport" - - fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" -) - -type ReceivePackSuite struct { - BaseSuite -} - -var _ = Suite(&ReceivePackSuite{}) - -func (s *ReceivePackSuite) SetUpSuite(c *C) { - s.BaseSuite.SetUpSuite(c) - s.ReceivePackSuite.Client = s.client -} - -func (s *ReceivePackSuite) SetUpTest(c *C) { - s.prepareRepositories(c) -} - -func (s *ReceivePackSuite) TearDownTest(c *C) { - s.Suite.TearDownSuite(c) -} - -// Overwritten, server returns error earlier. -func (s *ReceivePackSuite) TestAdvertisedReferencesNotExists(c *C) { - r, err := s.Client.NewReceivePackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(r, IsNil) -} - -func (s *ReceivePackSuite) TestReceivePackWithNilPackfile(c *C) { - endpoint := s.Endpoint - auth := s.EmptyAuth - - fixture := fixtures.Basic().ByTag("packfile").One() - req := packp.NewReferenceUpdateRequest() - req.Commands = []*packp.Command{ - {Name: "refs/heads/newbranch", Old: plumbing.NewHash(fixture.Head), New: plumbing.ZeroHash}, - } - // default is already nil, but be explicit since this is what the test is for - req.Packfile = nil - - comment := Commentf( - "failed with ep=%s fixture=%s", - endpoint.String(), fixture.URL, - ) - - r, err := s.Client.NewReceivePackSession(endpoint, auth) - c.Assert(err, IsNil, comment) - defer func() { c.Assert(r.Close(), IsNil, comment) }() - - report, err := r.ReceivePack(context.Background(), req) - c.Assert(report, IsNil, comment) - c.Assert(err, NotNil, comment) -} diff --git a/plumbing/server/serve.go b/plumbing/server/serve.go deleted file mode 100644 index 336194108..000000000 --- a/plumbing/server/serve.go +++ /dev/null @@ -1,73 +0,0 @@ -package server - -import ( - "context" - "fmt" - "io" - - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/utils/ioutil" -) - -// ServerCommand is used for a single server command execution. -type ServerCommand struct { - Stderr io.Writer - Stdout io.WriteCloser - Stdin io.Reader -} - -func ServeUploadPack(cmd ServerCommand, s transport.UploadPackSession) (err error) { - ioutil.CheckClose(cmd.Stdout, &err) - - ar, err := s.AdvertisedReferences() - if err != nil { - return err - } - - if err := ar.Encode(cmd.Stdout); err != nil { - return err - } - - req := packp.NewUploadPackRequest() - if err := req.Decode(cmd.Stdin); err != nil { - return err - } - - var resp *packp.UploadPackResponse - resp, err = s.UploadPack(context.TODO(), req) - if err != nil { - return err - } - - return resp.Encode(cmd.Stdout) -} - -func ServeReceivePack(cmd ServerCommand, s transport.ReceivePackSession) error { - ar, err := s.AdvertisedReferences() - if err != nil { - return fmt.Errorf("internal error in advertised references: %s", err) - } - - if err := ar.Encode(cmd.Stdout); err != nil { - return fmt.Errorf("error in advertised references encoding: %s", err) - } - - req := packp.NewReferenceUpdateRequest() - if err := req.Decode(cmd.Stdin); err != nil { - return fmt.Errorf("error decoding: %s", err) - } - - rs, err := s.ReceivePack(context.TODO(), req) - if rs != nil { - if err := rs.Encode(cmd.Stdout); err != nil { - return fmt.Errorf("error in encoding report status %s", err) - } - } - - if err != nil { - return fmt.Errorf("error in receive pack: %s", err) - } - - return nil -} diff --git a/plumbing/server/server.go b/plumbing/server/server.go deleted file mode 100644 index 784c6a58e..000000000 --- a/plumbing/server/server.go +++ /dev/null @@ -1,461 +0,0 @@ -// Package server implements the git server protocol. For most use cases, the -// transport-specific implementations should be used. -package server - -import ( - "context" - "errors" - "fmt" - "io" - "time" - - "github.com/go-git/go-git/v5/plumbing" - "github.com/go-git/go-git/v5/plumbing/format/packfile" - "github.com/go-git/go-git/v5/plumbing/protocol/packp" - "github.com/go-git/go-git/v5/plumbing/protocol/packp/capability" - "github.com/go-git/go-git/v5/plumbing/revlist" - "github.com/go-git/go-git/v5/plumbing/storer" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/utils/ioutil" - "github.com/go-git/go-git/v5/utils/trace" -) - -var DefaultServer = NewServer(DefaultLoader) - -type server struct { - loader Loader - handler *handler -} - -// NewServer returns a transport.Transport implementing a git server, -// independent of transport. Each transport must wrap this. -func NewServer(loader Loader) transport.Transport { - return &server{ - loader, - &handler{asClient: false}, - } -} - -// NewClient returns a transport.Transport implementing a client with an -// embedded server. -func NewClient(loader Loader) transport.Transport { - return &server{ - loader, - &handler{asClient: true}, - } -} - -func (s *server) NewUploadPackSession(ep *transport.Endpoint, auth transport.AuthMethod) (transport.UploadPackSession, error) { - sto, err := s.loader.Load(ep) - if err != nil { - return nil, err - } - - return s.handler.NewUploadPackSession(sto) -} - -func (s *server) NewReceivePackSession(ep *transport.Endpoint, auth transport.AuthMethod) (transport.ReceivePackSession, error) { - sto, err := s.loader.Load(ep) - if err != nil { - return nil, err - } - - return s.handler.NewReceivePackSession(sto) -} - -type handler struct { - asClient bool -} - -func (h *handler) NewUploadPackSession(s storer.Storer) (transport.UploadPackSession, error) { - return &upSession{ - session: session{storer: s, asClient: h.asClient}, - }, nil -} - -func (h *handler) NewReceivePackSession(s storer.Storer) (transport.ReceivePackSession, error) { - return &rpSession{ - session: session{storer: s, asClient: h.asClient}, - cmdStatus: map[plumbing.ReferenceName]error{}, - }, nil -} - -type session struct { - storer storer.Storer - caps *capability.List - asClient bool -} - -func (s *session) Close() error { - return nil -} - -func (s *session) SetAuth(transport.AuthMethod) error { - //TODO: deprecate - return nil -} - -func (s *session) checkSupportedCapabilities(cl *capability.List) error { - for _, c := range cl.All() { - if !s.caps.Supports(c) { - return fmt.Errorf("unsupported capability: %s", c) - } - } - - return nil -} - -type upSession struct { - session -} - -func (s *upSession) AdvertisedReferences() (*packp.AdvRefs, error) { - return s.AdvertisedReferencesContext(context.TODO()) -} - -func (s *upSession) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) { - ar := packp.NewAdvRefs() - - if err := s.setSupportedCapabilities(ar.Capabilities); err != nil { - return nil, err - } - - s.caps = ar.Capabilities - - if err := setReferences(s.storer, ar); err != nil { - return nil, err - } - - if err := setHEAD(s.storer, ar); err != nil { - return nil, err - } - - if s.asClient && len(ar.References) == 0 { - return nil, transport.ErrEmptyRemoteRepository - } - - return ar, nil -} - -func (s *upSession) UploadPack(ctx context.Context, req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) { - start := time.Now() - defer func() { - trace.Performance.Printf("performance: %.9f s: upload_pack", time.Since(start).Seconds()) - }() - - if req.IsEmpty() { - return nil, transport.ErrEmptyUploadPackRequest - } - - if err := req.Validate(); err != nil { - return nil, err - } - - if s.caps == nil { - s.caps = capability.NewList() - if err := s.setSupportedCapabilities(s.caps); err != nil { - return nil, err - } - } - - if err := s.checkSupportedCapabilities(req.Capabilities); err != nil { - return nil, err - } - - s.caps = req.Capabilities - - if len(req.Shallows) > 0 { - return nil, fmt.Errorf("shallow not supported") - } - - havesWithRef, err := revlist.ObjectsWithRef(s.storer, req.Wants, nil) - if err != nil { - return nil, err - } - - pr, pw := io.Pipe() - e := packfile.NewEncoder(pw, s.storer, false) - go func() { - allHaves := []plumbing.Hash{} - foundWants := map[plumbing.Hash]bool{} - for haves := range req.HavesUR { - acks := []packp.UploadPackRequestAck{} - for _, hu := range haves.Haves { - refs, ok := havesWithRef[hu] - if ok { - for _, ref := range refs { - foundWants[ref] = true - } - } - acks = append(acks, packp.UploadPackRequestAck{Hash: hu, IsCommon: ok, IsReady: ok && (len(refs) >= len(req.Wants) || len(foundWants) >= len(req.Wants))}) - allHaves = append(allHaves, hu) - } - - req.UploadPackCommands <- packp.UploadPackCommand{Acks: acks, Done: haves.Done} - } - close(req.UploadPackCommands) - objs, err := s.objectsToUpload(req.Wants, allHaves) - if err != nil { - pw.CloseWithError(err) - return - } - _, err = e.Encode(objs, 10) - pw.CloseWithError(err) - }() - - return packp.NewUploadPackResponseWithPackfile(req, - ioutil.NewContextReadCloser(ctx, pr), - ), nil -} - -func (s *upSession) objectsToUpload(wants, haves []plumbing.Hash) ([]plumbing.Hash, error) { - return revlist.Objects(s.storer, wants, haves) -} - -func (*upSession) setSupportedCapabilities(c *capability.List) error { - if err := c.Set(capability.Agent, capability.DefaultAgent()); err != nil { - return err - } - - if err := c.Set(capability.OFSDelta); err != nil { - return err - } - - return nil -} - -type rpSession struct { - session - cmdStatus map[plumbing.ReferenceName]error - firstErr error - unpackErr error -} - -func (s *rpSession) AdvertisedReferences() (*packp.AdvRefs, error) { - return s.AdvertisedReferencesContext(context.TODO()) -} - -func (s *rpSession) AdvertisedReferencesContext(ctx context.Context) (*packp.AdvRefs, error) { - ar := packp.NewAdvRefs() - - if err := s.setSupportedCapabilities(ar.Capabilities); err != nil { - return nil, err - } - - s.caps = ar.Capabilities - - if err := setReferences(s.storer, ar); err != nil { - return nil, err - } - - if err := setHEAD(s.storer, ar); err != nil { - return nil, err - } - - return ar, nil -} - -var ( - ErrUpdateReference = errors.New("failed to update ref") -) - -func (s *rpSession) ReceivePack(ctx context.Context, req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) { - start := time.Now() - defer func() { - trace.Performance.Printf("performance: %.9f s: receive_pack", time.Since(start).Seconds()) - }() - - if s.caps == nil { - s.caps = capability.NewList() - if err := s.setSupportedCapabilities(s.caps); err != nil { - return nil, err - } - } - - if err := s.checkSupportedCapabilities(req.Capabilities); err != nil { - return nil, err - } - - s.caps = req.Capabilities - - //TODO: Implement 'atomic' update of references. - - if req.Packfile != nil { - r := ioutil.NewContextReadCloser(ctx, req.Packfile) - if err := s.writePackfile(r); err != nil { - s.unpackErr = err - s.firstErr = err - return s.reportStatus(), err - } - } - - s.updateReferences(req) - return s.reportStatus(), s.firstErr -} - -func (s *rpSession) updateReferences(req *packp.ReferenceUpdateRequest) { - for _, cmd := range req.Commands { - exists, err := referenceExists(s.storer, cmd.Name) - if err != nil { - s.setStatus(cmd.Name, err) - continue - } - - switch cmd.Action() { - case packp.Create: - if exists { - s.setStatus(cmd.Name, ErrUpdateReference) - continue - } - - ref := plumbing.NewHashReference(cmd.Name, cmd.New) - err := s.storer.SetReference(ref) - s.setStatus(cmd.Name, err) - case packp.Delete: - if !exists { - s.setStatus(cmd.Name, ErrUpdateReference) - continue - } - - err := s.storer.RemoveReference(cmd.Name) - s.setStatus(cmd.Name, err) - case packp.Update: - if !exists { - s.setStatus(cmd.Name, ErrUpdateReference) - continue - } - - ref := plumbing.NewHashReference(cmd.Name, cmd.New) - err := s.storer.SetReference(ref) - s.setStatus(cmd.Name, err) - } - } -} - -func (s *rpSession) writePackfile(r io.ReadCloser) error { - if r == nil { - return nil - } - - if err := packfile.UpdateObjectStorage(s.storer, r); err != nil { - _ = r.Close() - return err - } - - return r.Close() -} - -func (s *rpSession) setStatus(ref plumbing.ReferenceName, err error) { - s.cmdStatus[ref] = err - if s.firstErr == nil && err != nil { - s.firstErr = err - } -} - -func (s *rpSession) reportStatus() *packp.ReportStatus { - if !s.caps.Supports(capability.ReportStatus) { - return nil - } - - rs := packp.NewReportStatus() - rs.UnpackStatus = "ok" - - if s.unpackErr != nil { - rs.UnpackStatus = s.unpackErr.Error() - } - - if s.cmdStatus == nil { - return rs - } - - for ref, err := range s.cmdStatus { - msg := "ok" - if err != nil { - msg = err.Error() - } - status := &packp.CommandStatus{ - ReferenceName: ref, - Status: msg, - } - rs.CommandStatuses = append(rs.CommandStatuses, status) - } - - return rs -} - -func (*rpSession) setSupportedCapabilities(c *capability.List) error { - if err := c.Set(capability.Agent, capability.DefaultAgent()); err != nil { - return err - } - - if err := c.Set(capability.OFSDelta); err != nil { - return err - } - - if err := c.Set(capability.DeleteRefs); err != nil { - return err - } - - return c.Set(capability.ReportStatus) -} - -func setHEAD(s storer.Storer, ar *packp.AdvRefs) error { - ref, err := s.Reference(plumbing.HEAD) - if err == plumbing.ErrReferenceNotFound { - return nil - } - - if err != nil { - return err - } - - if ref.Type() == plumbing.SymbolicReference { - if err := ar.AddReference(ref); err != nil { - return nil - } - - ref, err = storer.ResolveReference(s, ref.Target()) - if err == plumbing.ErrReferenceNotFound { - return nil - } - - if err != nil { - return err - } - } - - if ref.Type() != plumbing.HashReference { - return plumbing.ErrInvalidType - } - - h := ref.Hash() - ar.Head = &h - - return nil -} - -func setReferences(s storer.Storer, ar *packp.AdvRefs) error { - //TODO: add peeled references. - iter, err := s.IterReferences() - if err != nil { - return err - } - - return iter.ForEach(func(ref *plumbing.Reference) error { - if ref.Type() != plumbing.HashReference { - return nil - } - - ar.References[ref.Name().String()] = ref.Hash() - return nil - }) -} - -func referenceExists(s storer.ReferenceStorer, n plumbing.ReferenceName) (bool, error) { - _, err := s.Reference(n) - if err == plumbing.ErrReferenceNotFound { - return false, nil - } - - return err == nil, err -} diff --git a/plumbing/server/server_test.go b/plumbing/server/server_test.go deleted file mode 100644 index 7e1b98d5d..000000000 --- a/plumbing/server/server_test.go +++ /dev/null @@ -1,64 +0,0 @@ -package server_test - -import ( - "testing" - - "github.com/go-git/go-git/v5/internal/transport/test" - "github.com/go-git/go-git/v5/plumbing/cache" - "github.com/go-git/go-git/v5/plumbing/server" - "github.com/go-git/go-git/v5/plumbing/transport" - "github.com/go-git/go-git/v5/plumbing/transport/file" - "github.com/go-git/go-git/v5/storage/filesystem" - "github.com/go-git/go-git/v5/storage/memory" - - fixtures "github.com/go-git/go-git-fixtures/v4" - . "gopkg.in/check.v1" -) - -func Test(t *testing.T) { TestingT(t) } - -type BaseSuite struct { - fixtures.Suite - test.ReceivePackSuite - - loader server.MapLoader - client transport.Transport - clientBackup transport.Transport - asClient bool -} - -func (s *BaseSuite) SetUpSuite(c *C) { - s.loader = server.MapLoader{} - if s.asClient { - s.client = server.NewClient(s.loader) - } else { - s.client = server.NewServer(s.loader) - } - - s.clientBackup = file.DefaultClient - transport.Register("file", s.client) -} - -func (s *BaseSuite) TearDownSuite(c *C) { - if s.clientBackup == nil { - transport.Unregister("file") - } else { - transport.Register("file", s.clientBackup) - } -} - -func (s *BaseSuite) prepareRepositories(c *C) { - var err error - - fs := fixtures.Basic().One().DotGit() - s.Endpoint, err = transport.NewEndpoint(fs.Root()) - c.Assert(err, IsNil) - s.loader[s.Endpoint.String()] = filesystem.NewStorage(fs, cache.NewObjectLRUDefault()) - - s.EmptyEndpoint, err = transport.NewEndpoint("/empty.git") - c.Assert(err, IsNil) - s.loader[s.EmptyEndpoint.String()] = memory.NewStorage() - - s.NonExistentEndpoint, err = transport.NewEndpoint("/non-existent.git") - c.Assert(err, IsNil) -} diff --git a/plumbing/server/upload_pack_test.go b/plumbing/server/upload_pack_test.go deleted file mode 100644 index b88b6b7ab..000000000 --- a/plumbing/server/upload_pack_test.go +++ /dev/null @@ -1,50 +0,0 @@ -package server_test - -import ( - "github.com/go-git/go-git/v5/plumbing/transport" - - . "gopkg.in/check.v1" -) - -type UploadPackSuite struct { - BaseSuite -} - -var _ = Suite(&UploadPackSuite{}) - -func (s *UploadPackSuite) SetUpSuite(c *C) { - s.BaseSuite.SetUpSuite(c) - s.Client = s.client -} - -func (s *UploadPackSuite) SetUpTest(c *C) { - s.prepareRepositories(c) -} - -// Overwritten, server returns error earlier. -func (s *UploadPackSuite) TestAdvertisedReferencesNotExists(c *C) { - r, err := s.Client.NewUploadPackSession(s.NonExistentEndpoint, s.EmptyAuth) - c.Assert(err, Equals, transport.ErrRepositoryNotFound) - c.Assert(r, IsNil) -} - -func (s *UploadPackSuite) TestUploadPackWithContext(c *C) { - c.Skip("UploadPack cannot be canceled on server") -} - -// Tests server with `asClient = true`. This is recommended when using a server -// registered directly with `transport.Register`. -type ClientLikeUploadPackSuite struct { - UploadPackSuite -} - -var _ = Suite(&ClientLikeUploadPackSuite{}) - -func (s *ClientLikeUploadPackSuite) SetUpSuite(c *C) { - s.asClient = true - s.UploadPackSuite.SetUpSuite(c) -} - -func (s *ClientLikeUploadPackSuite) TestAdvertisedReferencesEmpty(c *C) { - s.UploadPackSuite.TestAdvertisedReferencesEmpty(c) -}