package test import ( "encoding/hex" "errors" "fmt" "io" "io/ioutil" "srcd.works/go-git.v4/config" "srcd.works/go-git.v4/plumbing" "srcd.works/go-git.v4/plumbing/format/index" "srcd.works/go-git.v4/plumbing/storer" "srcd.works/go-git.v4/storage" . "gopkg.in/check.v1" ) type Storer interface { storer.EncodedObjectStorer storer.ReferenceStorer storer.ShallowStorer storer.IndexStorer config.ConfigStorer storage.ModuleStorer } type TestObject struct { Object plumbing.EncodedObject Hash string Type plumbing.ObjectType } type BaseStorageSuite struct { Storer Storer validTypes []plumbing.ObjectType testObjects map[plumbing.ObjectType]TestObject } func NewBaseStorageSuite(s Storer) BaseStorageSuite { commit := &plumbing.MemoryObject{} commit.SetType(plumbing.CommitObject) tree := &plumbing.MemoryObject{} tree.SetType(plumbing.TreeObject) blob := &plumbing.MemoryObject{} blob.SetType(plumbing.BlobObject) tag := &plumbing.MemoryObject{} tag.SetType(plumbing.TagObject) return BaseStorageSuite{ Storer: s, validTypes: []plumbing.ObjectType{ plumbing.CommitObject, plumbing.BlobObject, plumbing.TagObject, plumbing.TreeObject, }, testObjects: map[plumbing.ObjectType]TestObject{ plumbing.CommitObject: {commit, "dcf5b16e76cce7425d0beaef62d79a7d10fce1f5", plumbing.CommitObject}, plumbing.TreeObject: {tree, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", plumbing.TreeObject}, plumbing.BlobObject: {blob, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", plumbing.BlobObject}, plumbing.TagObject: {tag, "d994c6bb648123a17e8f70a966857c546b2a6f94", plumbing.TagObject}, }} } func (s *BaseStorageSuite) TestSetEncodedObjectAndEncodedObject(c *C) { for _, to := range s.testObjects { comment := Commentf("failed for type %s", to.Type.String()) h, err := s.Storer.SetEncodedObject(to.Object) c.Assert(err, IsNil) c.Assert(h.String(), Equals, to.Hash, comment) o, err := s.Storer.EncodedObject(to.Type, h) c.Assert(err, IsNil) c.Assert(objectEquals(o, to.Object), IsNil) o, err = s.Storer.EncodedObject(plumbing.AnyObject, h) c.Assert(err, IsNil) c.Assert(objectEquals(o, to.Object), IsNil) for _, t := range s.validTypes { if t == to.Type { continue } o, err = s.Storer.EncodedObject(t, h) c.Assert(o, IsNil) c.Assert(err, Equals, plumbing.ErrObjectNotFound) } } } func (s *BaseStorageSuite) TestSetEncodedObjectInvalid(c *C) { o := s.Storer.NewEncodedObject() o.SetType(plumbing.REFDeltaObject) _, err := s.Storer.SetEncodedObject(o) c.Assert(err, NotNil) } func (s *BaseStorageSuite) TestIterEncodedObjects(c *C) { for _, o := range s.testObjects { h, err := s.Storer.SetEncodedObject(o.Object) c.Assert(err, IsNil) c.Assert(h, Equals, o.Object.Hash()) } for _, t := range s.validTypes { comment := Commentf("failed for type %s)", t.String()) i, err := s.Storer.IterEncodedObjects(t) c.Assert(err, IsNil, comment) o, err := i.Next() c.Assert(err, IsNil) c.Assert(objectEquals(o, s.testObjects[t].Object), IsNil) o, err = i.Next() c.Assert(o, IsNil) c.Assert(err, Equals, io.EOF, comment) } i, err := s.Storer.IterEncodedObjects(plumbing.AnyObject) c.Assert(err, IsNil) foundObjects := []plumbing.EncodedObject{} i.ForEach(func(o plumbing.EncodedObject) error { foundObjects = append(foundObjects, o) return nil }) c.Assert(foundObjects, HasLen, len(s.testObjects)) for _, to := range s.testObjects { found := false for _, o := range foundObjects { if to.Object.Hash() == o.Hash() { found = true break } } c.Assert(found, Equals, true, Commentf("Object of type %s not found", to.Type.String())) } } func (s *BaseStorageSuite) TestObjectStorerTxSetEncodedObjectAndCommit(c *C) { storer, ok := s.Storer.(storer.Transactioner) if !ok { c.Skip("not a plumbing.ObjectStorerTx") } tx := storer.Begin() for _, o := range s.testObjects { h, err := tx.SetEncodedObject(o.Object) c.Assert(err, IsNil) c.Assert(h.String(), Equals, o.Hash) } iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject) c.Assert(err, IsNil) _, err = iter.Next() c.Assert(err, Equals, io.EOF) err = tx.Commit() c.Assert(err, IsNil) iter, err = s.Storer.IterEncodedObjects(plumbing.AnyObject) c.Assert(err, IsNil) var count int iter.ForEach(func(o plumbing.EncodedObject) error { count++ return nil }) c.Assert(count, Equals, 4) } func (s *BaseStorageSuite) TestObjectStorerTxSetObjectAndGetObject(c *C) { storer, ok := s.Storer.(storer.Transactioner) if !ok { c.Skip("not a plumbing.ObjectStorerTx") } tx := storer.Begin() for _, expected := range s.testObjects { h, err := tx.SetEncodedObject(expected.Object) c.Assert(err, IsNil) c.Assert(h.String(), Equals, expected.Hash) o, err := tx.EncodedObject(expected.Type, plumbing.NewHash(expected.Hash)) c.Assert(err, IsNil) c.Assert(o.Hash().String(), DeepEquals, expected.Hash) } } func (s *BaseStorageSuite) TestObjectStorerTxGetObjectNotFound(c *C) { storer, ok := s.Storer.(storer.Transactioner) if !ok { c.Skip("not a plumbing.ObjectStorerTx") } tx := storer.Begin() o, err := tx.EncodedObject(plumbing.AnyObject, plumbing.ZeroHash) c.Assert(o, IsNil) c.Assert(err, Equals, plumbing.ErrObjectNotFound) } func (s *BaseStorageSuite) TestObjectStorerTxSetObjectAndRollback(c *C) { storer, ok := s.Storer.(storer.Transactioner) if !ok { c.Skip("not a plumbing.ObjectStorerTx") } tx := storer.Begin() for _, o := range s.testObjects { h, err := tx.SetEncodedObject(o.Object) c.Assert(err, IsNil) c.Assert(h.String(), Equals, o.Hash) } err := tx.Rollback() c.Assert(err, IsNil) iter, err := s.Storer.IterEncodedObjects(plumbing.AnyObject) c.Assert(err, IsNil) _, err = iter.Next() c.Assert(err, Equals, io.EOF) } 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 *BaseStorageSuite) TestGetReferenceNotFound(c *C) { r, err := s.Storer.Reference(plumbing.ReferenceName("bar")) c.Assert(err, Equals, plumbing.ErrReferenceNotFound) c.Assert(r, IsNil) } func (s *BaseStorageSuite) TestIterReferences(c *C) { err := s.Storer.SetReference( plumbing.NewReferenceFromStrings("refs/foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"), ) c.Assert(err, IsNil) i, err := s.Storer.IterReferences() c.Assert(err, IsNil) e, err := i.Next() c.Assert(err, IsNil) c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52") e, err = i.Next() c.Assert(e, IsNil) c.Assert(err, Equals, io.EOF) } 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) } func (s *BaseStorageSuite) TestSetConfigAndConfig(c *C) { expected := config.NewConfig() expected.Core.IsBare = true expected.Remotes["foo"] = &config.RemoteConfig{ Name: "foo", URL: "http://foo/bar.git", } err := s.Storer.SetConfig(expected) c.Assert(err, IsNil) cfg, err := s.Storer.Config() c.Assert(err, IsNil) c.Assert(cfg, DeepEquals, expected) } func (s *BaseStorageSuite) TestIndex(c *C) { expected := &index.Index{} expected.Version = 2 idx, err := s.Storer.Index() c.Assert(err, IsNil) c.Assert(idx, DeepEquals, expected) } func (s *BaseStorageSuite) TestSetIndexAndIndex(c *C) { expected := &index.Index{} expected.Version = 2 err := s.Storer.SetIndex(expected) c.Assert(err, IsNil) idx, err := s.Storer.Index() c.Assert(err, IsNil) c.Assert(idx, DeepEquals, expected) } func (s *BaseStorageSuite) TestSetConfigInvalid(c *C) { cfg := config.NewConfig() cfg.Remotes["foo"] = &config.RemoteConfig{} err := s.Storer.SetConfig(cfg) c.Assert(err, NotNil) } func (s *BaseStorageSuite) TestModule(c *C) { storer, err := s.Storer.Module("foo") c.Assert(err, IsNil) c.Assert(storer, NotNil) storer, err = s.Storer.Module("foo") c.Assert(err, IsNil) c.Assert(storer, NotNil) } func objectEquals(a plumbing.EncodedObject, b plumbing.EncodedObject) error { ha := a.Hash() hb := b.Hash() if ha != hb { return fmt.Errorf("hashes do not match: %s != %s", ha.String(), hb.String()) } ra, err := a.Reader() if err != nil { return fmt.Errorf("can't get reader on b: %q", err) } rb, err := b.Reader() if err != nil { return fmt.Errorf("can't get reader on a: %q", err) } ca, err := ioutil.ReadAll(ra) if err != nil { return fmt.Errorf("error reading a: %q", err) } cb, err := ioutil.ReadAll(rb) if err != nil { return fmt.Errorf("error reading b: %q", err) } if hex.EncodeToString(ca) != hex.EncodeToString(cb) { return errors.New("content does not match") } return nil }