storage: transactional, gocheck to testify migration. Fixes #1313

storage/transactional/config_test.go

···
 package transactional
 
 import (
+	"testing"
+
 	"github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/storage/memory"
-
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/suite"
 )
 
-var _ = Suite(&ConfigSuite{})
+func TestConfigSuite(t *testing.T) {
+	suite.Run(t, new(ConfigSuite))
+}
 
-type ConfigSuite struct{}
+type ConfigSuite struct {
+	suite.Suite
+}
 
-func (s *ConfigSuite) TestSetConfigBase(c *C) {
+func (s *ConfigSuite) TestSetConfigBase() {
 	cfg := config.NewConfig()
 	cfg.Core.Worktree = "foo"
 
 	base := memory.NewStorage()
 	err := base.SetConfig(cfg)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	temporal := memory.NewStorage()
 	cs := NewConfigStorage(base, temporal)
 
 	cfg, err = cs.Config()
-	c.Assert(err, IsNil)
-	c.Assert(cfg.Core.Worktree, Equals, "foo")
+	s.NoError(err)
+	s.Equal("foo", cfg.Core.Worktree)
 }
 
-func (s *ConfigSuite) TestSetConfigTemporal(c *C) {
+func (s *ConfigSuite) TestSetConfigTemporal() {
 	cfg := config.NewConfig()
 	cfg.Core.Worktree = "foo"
 
 	base := memory.NewStorage()
 	err := base.SetConfig(cfg)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	temporal := memory.NewStorage()
 
···
 
 	cs := NewConfigStorage(base, temporal)
 	err = cs.SetConfig(cfg)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	baseCfg, err := base.Config()
-	c.Assert(err, IsNil)
-	c.Assert(baseCfg.Core.Worktree, Equals, "foo")
+	s.NoError(err)
+	s.Equal("foo", baseCfg.Core.Worktree)
 
 	temporalCfg, err := temporal.Config()
-	c.Assert(err, IsNil)
-	c.Assert(temporalCfg.Core.Worktree, Equals, "bar")
+	s.NoError(err)
+	s.Equal("bar", temporalCfg.Core.Worktree)
 
 	cfg, err = cs.Config()
-	c.Assert(err, IsNil)
-	c.Assert(cfg.Core.Worktree, Equals, "bar")
+	s.NoError(err)
+	s.Equal("bar", cfg.Core.Worktree)
 }
 
-func (s *ConfigSuite) TestCommit(c *C) {
+func (s *ConfigSuite) TestCommit() {
 	cfg := config.NewConfig()
 	cfg.Core.Worktree = "foo"
 
 	base := memory.NewStorage()
 	err := base.SetConfig(cfg)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	temporal := memory.NewStorage()
 
···
 
 	cs := NewConfigStorage(base, temporal)
 	err = cs.SetConfig(cfg)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = cs.Commit()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	baseCfg, err := base.Config()
-	c.Assert(err, IsNil)
-	c.Assert(baseCfg.Core.Worktree, Equals, "bar")
+	s.NoError(err)
+	s.Equal("bar", baseCfg.Core.Worktree)
 }

storage/transactional/index_test.go

···
 package transactional
 
 import (
+	"testing"
+
 	"github.com/go-git/go-git/v5/plumbing/format/index"
 	"github.com/go-git/go-git/v5/storage/memory"
-
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/suite"
 )
 
-var _ = Suite(&IndexSuite{})
+func TestIndexSuite(t *testing.T) {
+	suite.Run(t, new(IndexSuite))
+}
 
-type IndexSuite struct{}
+type IndexSuite struct {
+	suite.Suite
+}
 
-func (s *IndexSuite) TestSetIndexBase(c *C) {
+func (s *IndexSuite) TestSetIndexBase() {
 	idx := &index.Index{}
 	idx.Version = 2
 
 	base := memory.NewStorage()
 	err := base.SetIndex(idx)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	temporal := memory.NewStorage()
 	cs := NewIndexStorage(base, temporal)
 
 	idx, err = cs.Index()
-	c.Assert(err, IsNil)
-	c.Assert(idx.Version, Equals, uint32(2))
+	s.NoError(err)
+	s.Equal(uint32(2), idx.Version)
 }
 
-func (s *IndexSuite) TestCommit(c *C) {
+func (s *IndexSuite) TestCommit() {
 	idx := &index.Index{}
 	idx.Version = 2
 
 	base := memory.NewStorage()
 	err := base.SetIndex(idx)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	temporal := memory.NewStorage()
 
···
 
 	is := NewIndexStorage(base, temporal)
 	err = is.SetIndex(idx)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = is.Commit()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	baseIndex, err := base.Index()
-	c.Assert(err, IsNil)
-	c.Assert(baseIndex.Version, Equals, uint32(3))
+	s.NoError(err)
+	s.Equal(uint32(3), baseIndex.Version)
 }

storage/transactional/object_test.go

···
 package transactional
 
 import (
+	"testing"
+
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/storage/memory"
-
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/suite"
 )
 
-var _ = Suite(&ObjectSuite{})
+func TestObjectSuite(t *testing.T) {
+	suite.Run(t, new(ObjectSuite))
+}
 
-type ObjectSuite struct{}
+type ObjectSuite struct {
+	suite.Suite
+}
 
-func (s *ObjectSuite) TestHasEncodedObject(c *C) {
+func (s *ObjectSuite) TestHasEncodedObject() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	commit.SetType(plumbing.CommitObject)
 
 	ch, err := base.SetEncodedObject(commit)
-	c.Assert(ch.IsZero(), Equals, false)
-	c.Assert(err, IsNil)
+	s.False(ch.IsZero())
+	s.NoError(err)
 
 	tree := base.NewEncodedObject()
 	tree.SetType(plumbing.TreeObject)
 
 	th, err := os.SetEncodedObject(tree)
-	c.Assert(th.IsZero(), Equals, false)
-	c.Assert(err, IsNil)
+	s.False(th.IsZero())
+	s.NoError(err)
 
 	err = os.HasEncodedObject(th)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = os.HasEncodedObject(ch)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = base.HasEncodedObject(th)
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
+	s.ErrorIs(err, plumbing.ErrObjectNotFound)
 }
 
-func (s *ObjectSuite) TestEncodedObjectAndEncodedObjectSize(c *C) {
+func (s *ObjectSuite) TestEncodedObjectAndEncodedObjectSize() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	commit.SetType(plumbing.CommitObject)
 
 	ch, err := base.SetEncodedObject(commit)
-	c.Assert(ch.IsZero(), Equals, false)
-	c.Assert(err, IsNil)
+	s.False(ch.IsZero())
+	s.NoError(err)
 
 	tree := base.NewEncodedObject()
 	tree.SetType(plumbing.TreeObject)
 
 	th, err := os.SetEncodedObject(tree)
-	c.Assert(th.IsZero(), Equals, false)
-	c.Assert(err, IsNil)
+	s.False(th.IsZero())
+	s.NoError(err)
 
 	otree, err := os.EncodedObject(plumbing.TreeObject, th)
-	c.Assert(err, IsNil)
-	c.Assert(otree.Hash(), Equals, tree.Hash())
+	s.NoError(err)
+	s.Equal(tree.Hash(), otree.Hash())
 
 	treeSz, err := os.EncodedObjectSize(th)
-	c.Assert(err, IsNil)
-	c.Assert(treeSz, Equals, int64(0))
+	s.NoError(err)
+	s.Equal(int64(0), treeSz)
 
 	ocommit, err := os.EncodedObject(plumbing.CommitObject, ch)
-	c.Assert(err, IsNil)
-	c.Assert(ocommit.Hash(), Equals, commit.Hash())
+	s.NoError(err)
+	s.Equal(commit.Hash(), ocommit.Hash())
 
 	commitSz, err := os.EncodedObjectSize(ch)
-	c.Assert(err, IsNil)
-	c.Assert(commitSz, Equals, int64(0))
+	s.NoError(err)
+	s.Equal(int64(0), commitSz)
 
 	_, err = base.EncodedObject(plumbing.TreeObject, th)
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
+	s.ErrorIs(err, plumbing.ErrObjectNotFound)
 
 	_, err = base.EncodedObjectSize(th)
-	c.Assert(err, Equals, plumbing.ErrObjectNotFound)
+	s.ErrorIs(err, plumbing.ErrObjectNotFound)
 }
 
-func (s *ObjectSuite) TestIterEncodedObjects(c *C) {
+func (s *ObjectSuite) TestIterEncodedObjects() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	commit.SetType(plumbing.CommitObject)
 
 	ch, err := base.SetEncodedObject(commit)
-	c.Assert(ch.IsZero(), Equals, false)
-	c.Assert(err, IsNil)
+	s.False(ch.IsZero())
+	s.NoError(err)
 
 	tree := base.NewEncodedObject()
 	tree.SetType(plumbing.TreeObject)
 
 	th, err := os.SetEncodedObject(tree)
-	c.Assert(th.IsZero(), Equals, false)
-	c.Assert(err, IsNil)
+	s.False(th.IsZero())
+	s.NoError(err)
 
 	iter, err := os.IterEncodedObjects(plumbing.AnyObject)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	var hashes []plumbing.Hash
 	err = iter.ForEach(func(obj plumbing.EncodedObject) error {
···
 		return nil
 	})
 
-	c.Assert(err, IsNil)
-	c.Assert(hashes, HasLen, 2)
-	c.Assert(hashes[0], Equals, ch)
-	c.Assert(hashes[1], Equals, th)
+	s.NoError(err)
+	s.Len(hashes, 2)
+	s.Equal(ch, hashes[0])
+	s.Equal(th, hashes[1])
 }
 
-func (s *ObjectSuite) TestCommit(c *C) {
+func (s *ObjectSuite) TestCommit() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	commit.SetType(plumbing.CommitObject)
 
 	_, err := os.SetEncodedObject(commit)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	tree := base.NewEncodedObject()
 	tree.SetType(plumbing.TreeObject)
 
 	_, err = os.SetEncodedObject(tree)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = os.Commit()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	iter, err := base.IterEncodedObjects(plumbing.AnyObject)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	var hashes []plumbing.Hash
 	err = iter.ForEach(func(obj plumbing.EncodedObject) error {
···
 		return nil
 	})
 
-	c.Assert(err, IsNil)
-	c.Assert(hashes, HasLen, 2)
+	s.NoError(err)
+	s.Len(hashes, 2)
 }

storage/transactional/reference_test.go

···
 package transactional
 
 import (
+	"testing"
+
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/storage/memory"
-
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/suite"
 )
 
-var _ = Suite(&ReferenceSuite{})
+func TestReferenceSuite(t *testing.T) {
+	suite.Run(t, new(ReferenceSuite))
+}
 
-type ReferenceSuite struct{}
+type ReferenceSuite struct {
+	suite.Suite
+}
 
-func (s *ReferenceSuite) TestReference(c *C) {
+func (s *ReferenceSuite) TestReference() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	refB := plumbing.NewReferenceFromStrings("refs/b", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
 
 	err := base.SetReference(refA)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = rs.SetReference(refB)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = rs.Reference("refs/a")
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = rs.Reference("refs/b")
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = base.Reference("refs/b")
-	c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
+	s.ErrorIs(err, plumbing.ErrReferenceNotFound)
 }
 
-func (s *ReferenceSuite) TestRemoveReferenceTemporal(c *C) {
+func (s *ReferenceSuite) TestRemoveReferenceTemporal() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 
 	rs := NewReferenceStorage(base, temporal)
 	err := rs.SetReference(ref)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = rs.RemoveReference("refs/a")
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = rs.Reference("refs/a")
-	c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
+	s.ErrorIs(err, plumbing.ErrReferenceNotFound)
 }
 
-func (s *ReferenceSuite) TestRemoveReferenceBase(c *C) {
+func (s *ReferenceSuite) TestRemoveReferenceBase() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 
 	rs := NewReferenceStorage(base, temporal)
 	err := base.SetReference(ref)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = rs.RemoveReference("refs/a")
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	_, err = rs.Reference("refs/a")
-	c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
+	s.ErrorIs(err, plumbing.ErrReferenceNotFound)
 }
 
-func (s *ReferenceSuite) TestCheckAndSetReferenceInBase(c *C) {
+func (s *ReferenceSuite) TestCheckAndSetReferenceInBase() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 	rs := NewReferenceStorage(base, temporal)
···
 	err := base.SetReference(
 		plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
 	)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = rs.CheckAndSetReference(
 		plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
 		plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
 	)
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	e, err := rs.Reference(plumbing.ReferenceName("foo"))
-	c.Assert(err, IsNil)
-	c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
+	s.NoError(err)
+	s.Equal("bc9968d75e48de59f0870ffb71f5e160bbbdcf52", e.Hash().String())
 }
 
-func (s *ReferenceSuite) TestCommit(c *C) {
+func (s *ReferenceSuite) TestCommit() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	refC := plumbing.NewReferenceFromStrings("refs/c", "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
 
 	rs := NewReferenceStorage(base, temporal)
-	c.Assert(rs.SetReference(refA), IsNil)
-	c.Assert(rs.SetReference(refB), IsNil)
-	c.Assert(rs.SetReference(refC), IsNil)
+	s.Nil(rs.SetReference(refA))
+	s.Nil(rs.SetReference(refB))
+	s.Nil(rs.SetReference(refC))
 
 	err := rs.Commit()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	iter, err := base.IterReferences()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	var count int
 	iter.ForEach(func(ref *plumbing.Reference) error {
···
 		return nil
 	})
 
-	c.Assert(count, Equals, 3)
+	s.Equal(3, count)
 }
 
-func (s *ReferenceSuite) TestCommitDelete(c *C) {
+func (s *ReferenceSuite) TestCommitDelete() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	refC := plumbing.NewReferenceFromStrings("refs/c", "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
 
 	rs := NewReferenceStorage(base, temporal)
-	c.Assert(base.SetReference(refA), IsNil)
-	c.Assert(base.SetReference(refB), IsNil)
-	c.Assert(base.SetReference(refC), IsNil)
+	s.Nil(base.SetReference(refA))
+	s.Nil(base.SetReference(refB))
+	s.Nil(base.SetReference(refC))
 
-	c.Assert(rs.RemoveReference(refA.Name()), IsNil)
-	c.Assert(rs.RemoveReference(refB.Name()), IsNil)
-	c.Assert(rs.RemoveReference(refC.Name()), IsNil)
-	c.Assert(rs.SetReference(refC), IsNil)
+	s.Nil(rs.RemoveReference(refA.Name()))
+	s.Nil(rs.RemoveReference(refB.Name()))
+	s.Nil(rs.RemoveReference(refC.Name()))
+	s.Nil(rs.SetReference(refC))
 
 	err := rs.Commit()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	iter, err := base.IterReferences()
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	var count int
 	iter.ForEach(func(ref *plumbing.Reference) error {
···
 		return nil
 	})
 
-	c.Assert(count, Equals, 1)
+	s.Equal(1, count)
 
 	ref, err := rs.Reference(refC.Name())
-	c.Assert(err, IsNil)
-	c.Assert(ref.Hash().String(), Equals, "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
+	s.NoError(err)
+	s.Equal("c3f4688a08fd86f1bf8e055724c84b7a40a09733", ref.Hash().String())
 
 }

storage/transactional/shallow_test.go

···
 package transactional
 
 import (
+	"testing"
+
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/storage/memory"
-
-	. "gopkg.in/check.v1"
+	"github.com/stretchr/testify/suite"
 )
 
-var _ = Suite(&ShallowSuite{})
+func TestShallowSuite(t *testing.T) {
+	suite.Run(t, new(ShallowSuite))
+}
 
-type ShallowSuite struct{}
+type ShallowSuite struct {
+	suite.Suite
+}
 
-func (s *ShallowSuite) TestShallow(c *C) {
+func (s *ShallowSuite) TestShallow() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	commitB := plumbing.NewHash("aa9968d75e48de59f0870ffb71f5e160bbbdcf52")
 
 	err := base.SetShallow([]plumbing.Hash{commitA})
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	err = rs.SetShallow([]plumbing.Hash{commitB})
-	c.Assert(err, IsNil)
+	s.NoError(err)
 
 	commits, err := rs.Shallow()
-	c.Assert(err, IsNil)
-	c.Assert(commits, HasLen, 1)
-	c.Assert(commits[0], Equals, commitB)
+	s.NoError(err)
+	s.Len(commits, 1)
+	s.Equal(commitB, commits[0])
 
 	commits, err = base.Shallow()
-	c.Assert(err, IsNil)
-	c.Assert(commits, HasLen, 1)
-	c.Assert(commits[0], Equals, commitA)
+	s.NoError(err)
+	s.Len(commits, 1)
+	s.Equal(commitA, commits[0])
 }
 
-func (s *ShallowSuite) TestCommit(c *C) {
+func (s *ShallowSuite) TestCommit() {
 	base := memory.NewStorage()
 	temporal := memory.NewStorage()
 
···
 	commitA := plumbing.NewHash("bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
 	commitB := plumbing.NewHash("aa9968d75e48de59f0870ffb71f5e160bbbdcf52")
 
-	c.Assert(base.SetShallow([]plumbing.Hash{commitA}), IsNil)
-	c.Assert(rs.SetShallow([]plumbing.Hash{commitB}), IsNil)
+	s.Nil(base.SetShallow([]plumbing.Hash{commitA}))
+	s.Nil(rs.SetShallow([]plumbing.Hash{commitB}))
 
-	c.Assert(rs.Commit(), IsNil)
+	s.Nil(rs.Commit())
 
 	commits, err := rs.Shallow()
-	c.Assert(err, IsNil)
-	c.Assert(commits, HasLen, 1)
-	c.Assert(commits[0], Equals, commitB)
+	s.NoError(err)
+	s.Len(commits, 1)
+	s.Equal(commitB, commits[0])
 
 	commits, err = base.Shallow()
-	c.Assert(err, IsNil)
-	c.Assert(commits, HasLen, 1)
-	c.Assert(commits[0], Equals, commitB)
+	s.NoError(err)
+	s.Len(commits, 1)
+	s.Equal(commitB, commits[0])
 }