oppi.li
+28
-23
storage/transactional/config_test.go
+28
-23
storage/transactional/config_test.go
···
1
1
package transactional
2
2
3
3
import (
4
+
"testing"
5
+
4
6
"github.com/go-git/go-git/v5/config"
5
7
"github.com/go-git/go-git/v5/storage/memory"
6
-
7
-
. "gopkg.in/check.v1"
8
+
"github.com/stretchr/testify/suite"
8
9
)
9
10
10
-
var _ = Suite(&ConfigSuite{})
11
+
func TestConfigSuite(t *testing.T) {
12
+
suite.Run(t, new(ConfigSuite))
13
+
}
11
14
12
-
type ConfigSuite struct{}
15
+
type ConfigSuite struct {
16
+
suite.Suite
17
+
}
13
18
14
-
func (s *ConfigSuite) TestSetConfigBase(c *C) {
19
+
func (s *ConfigSuite) TestSetConfigBase() {
15
20
cfg := config.NewConfig()
16
21
cfg.Core.Worktree = "foo"
17
22
18
23
base := memory.NewStorage()
19
24
err := base.SetConfig(cfg)
20
-
c.Assert(err, IsNil)
25
+
s.NoError(err)
21
26
22
27
temporal := memory.NewStorage()
23
28
cs := NewConfigStorage(base, temporal)
24
29
25
30
cfg, err = cs.Config()
26
-
c.Assert(err, IsNil)
27
-
c.Assert(cfg.Core.Worktree, Equals, "foo")
31
+
s.NoError(err)
32
+
s.Equal("foo", cfg.Core.Worktree)
28
33
}
29
34
30
-
func (s *ConfigSuite) TestSetConfigTemporal(c *C) {
35
+
func (s *ConfigSuite) TestSetConfigTemporal() {
31
36
cfg := config.NewConfig()
32
37
cfg.Core.Worktree = "foo"
33
38
34
39
base := memory.NewStorage()
35
40
err := base.SetConfig(cfg)
36
-
c.Assert(err, IsNil)
41
+
s.NoError(err)
37
42
38
43
temporal := memory.NewStorage()
39
44
···
42
47
43
48
cs := NewConfigStorage(base, temporal)
44
49
err = cs.SetConfig(cfg)
45
-
c.Assert(err, IsNil)
50
+
s.NoError(err)
46
51
47
52
baseCfg, err := base.Config()
48
-
c.Assert(err, IsNil)
49
-
c.Assert(baseCfg.Core.Worktree, Equals, "foo")
53
+
s.NoError(err)
54
+
s.Equal("foo", baseCfg.Core.Worktree)
50
55
51
56
temporalCfg, err := temporal.Config()
52
-
c.Assert(err, IsNil)
53
-
c.Assert(temporalCfg.Core.Worktree, Equals, "bar")
57
+
s.NoError(err)
58
+
s.Equal("bar", temporalCfg.Core.Worktree)
54
59
55
60
cfg, err = cs.Config()
56
-
c.Assert(err, IsNil)
57
-
c.Assert(cfg.Core.Worktree, Equals, "bar")
61
+
s.NoError(err)
62
+
s.Equal("bar", cfg.Core.Worktree)
58
63
}
59
64
60
-
func (s *ConfigSuite) TestCommit(c *C) {
65
+
func (s *ConfigSuite) TestCommit() {
61
66
cfg := config.NewConfig()
62
67
cfg.Core.Worktree = "foo"
63
68
64
69
base := memory.NewStorage()
65
70
err := base.SetConfig(cfg)
66
-
c.Assert(err, IsNil)
71
+
s.NoError(err)
67
72
68
73
temporal := memory.NewStorage()
69
74
···
72
77
73
78
cs := NewConfigStorage(base, temporal)
74
79
err = cs.SetConfig(cfg)
75
-
c.Assert(err, IsNil)
80
+
s.NoError(err)
76
81
77
82
err = cs.Commit()
78
-
c.Assert(err, IsNil)
83
+
s.NoError(err)
79
84
80
85
baseCfg, err := base.Config()
81
-
c.Assert(err, IsNil)
82
-
c.Assert(baseCfg.Core.Worktree, Equals, "bar")
86
+
s.NoError(err)
87
+
s.Equal("bar", baseCfg.Core.Worktree)
83
88
}
+19
-14
storage/transactional/index_test.go
+19
-14
storage/transactional/index_test.go
···
1
1
package transactional
2
2
3
3
import (
4
+
"testing"
5
+
4
6
"github.com/go-git/go-git/v5/plumbing/format/index"
5
7
"github.com/go-git/go-git/v5/storage/memory"
6
-
7
-
. "gopkg.in/check.v1"
8
+
"github.com/stretchr/testify/suite"
8
9
)
9
10
10
-
var _ = Suite(&IndexSuite{})
11
+
func TestIndexSuite(t *testing.T) {
12
+
suite.Run(t, new(IndexSuite))
13
+
}
11
14
12
-
type IndexSuite struct{}
15
+
type IndexSuite struct {
16
+
suite.Suite
17
+
}
13
18
14
-
func (s *IndexSuite) TestSetIndexBase(c *C) {
19
+
func (s *IndexSuite) TestSetIndexBase() {
15
20
idx := &index.Index{}
16
21
idx.Version = 2
17
22
18
23
base := memory.NewStorage()
19
24
err := base.SetIndex(idx)
20
-
c.Assert(err, IsNil)
25
+
s.NoError(err)
21
26
22
27
temporal := memory.NewStorage()
23
28
cs := NewIndexStorage(base, temporal)
24
29
25
30
idx, err = cs.Index()
26
-
c.Assert(err, IsNil)
27
-
c.Assert(idx.Version, Equals, uint32(2))
31
+
s.NoError(err)
32
+
s.Equal(uint32(2), idx.Version)
28
33
}
29
34
30
-
func (s *IndexSuite) TestCommit(c *C) {
35
+
func (s *IndexSuite) TestCommit() {
31
36
idx := &index.Index{}
32
37
idx.Version = 2
33
38
34
39
base := memory.NewStorage()
35
40
err := base.SetIndex(idx)
36
-
c.Assert(err, IsNil)
41
+
s.NoError(err)
37
42
38
43
temporal := memory.NewStorage()
39
44
···
42
47
43
48
is := NewIndexStorage(base, temporal)
44
49
err = is.SetIndex(idx)
45
-
c.Assert(err, IsNil)
50
+
s.NoError(err)
46
51
47
52
err = is.Commit()
48
-
c.Assert(err, IsNil)
53
+
s.NoError(err)
49
54
50
55
baseIndex, err := base.Index()
51
-
c.Assert(err, IsNil)
52
-
c.Assert(baseIndex.Version, Equals, uint32(3))
56
+
s.NoError(err)
57
+
s.Equal(uint32(3), baseIndex.Version)
53
58
}
+49
-44
storage/transactional/object_test.go
+49
-44
storage/transactional/object_test.go
···
1
1
package transactional
2
2
3
3
import (
4
+
"testing"
5
+
4
6
"github.com/go-git/go-git/v5/plumbing"
5
7
"github.com/go-git/go-git/v5/storage/memory"
6
-
7
-
. "gopkg.in/check.v1"
8
+
"github.com/stretchr/testify/suite"
8
9
)
9
10
10
-
var _ = Suite(&ObjectSuite{})
11
+
func TestObjectSuite(t *testing.T) {
12
+
suite.Run(t, new(ObjectSuite))
13
+
}
11
14
12
-
type ObjectSuite struct{}
15
+
type ObjectSuite struct {
16
+
suite.Suite
17
+
}
13
18
14
-
func (s *ObjectSuite) TestHasEncodedObject(c *C) {
19
+
func (s *ObjectSuite) TestHasEncodedObject() {
15
20
base := memory.NewStorage()
16
21
temporal := memory.NewStorage()
17
22
···
21
26
commit.SetType(plumbing.CommitObject)
22
27
23
28
ch, err := base.SetEncodedObject(commit)
24
-
c.Assert(ch.IsZero(), Equals, false)
25
-
c.Assert(err, IsNil)
29
+
s.False(ch.IsZero())
30
+
s.NoError(err)
26
31
27
32
tree := base.NewEncodedObject()
28
33
tree.SetType(plumbing.TreeObject)
29
34
30
35
th, err := os.SetEncodedObject(tree)
31
-
c.Assert(th.IsZero(), Equals, false)
32
-
c.Assert(err, IsNil)
36
+
s.False(th.IsZero())
37
+
s.NoError(err)
33
38
34
39
err = os.HasEncodedObject(th)
35
-
c.Assert(err, IsNil)
40
+
s.NoError(err)
36
41
37
42
err = os.HasEncodedObject(ch)
38
-
c.Assert(err, IsNil)
43
+
s.NoError(err)
39
44
40
45
err = base.HasEncodedObject(th)
41
-
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
46
+
s.ErrorIs(err, plumbing.ErrObjectNotFound)
42
47
}
43
48
44
-
func (s *ObjectSuite) TestEncodedObjectAndEncodedObjectSize(c *C) {
49
+
func (s *ObjectSuite) TestEncodedObjectAndEncodedObjectSize() {
45
50
base := memory.NewStorage()
46
51
temporal := memory.NewStorage()
47
52
···
51
56
commit.SetType(plumbing.CommitObject)
52
57
53
58
ch, err := base.SetEncodedObject(commit)
54
-
c.Assert(ch.IsZero(), Equals, false)
55
-
c.Assert(err, IsNil)
59
+
s.False(ch.IsZero())
60
+
s.NoError(err)
56
61
57
62
tree := base.NewEncodedObject()
58
63
tree.SetType(plumbing.TreeObject)
59
64
60
65
th, err := os.SetEncodedObject(tree)
61
-
c.Assert(th.IsZero(), Equals, false)
62
-
c.Assert(err, IsNil)
66
+
s.False(th.IsZero())
67
+
s.NoError(err)
63
68
64
69
otree, err := os.EncodedObject(plumbing.TreeObject, th)
65
-
c.Assert(err, IsNil)
66
-
c.Assert(otree.Hash(), Equals, tree.Hash())
70
+
s.NoError(err)
71
+
s.Equal(tree.Hash(), otree.Hash())
67
72
68
73
treeSz, err := os.EncodedObjectSize(th)
69
-
c.Assert(err, IsNil)
70
-
c.Assert(treeSz, Equals, int64(0))
74
+
s.NoError(err)
75
+
s.Equal(int64(0), treeSz)
71
76
72
77
ocommit, err := os.EncodedObject(plumbing.CommitObject, ch)
73
-
c.Assert(err, IsNil)
74
-
c.Assert(ocommit.Hash(), Equals, commit.Hash())
78
+
s.NoError(err)
79
+
s.Equal(commit.Hash(), ocommit.Hash())
75
80
76
81
commitSz, err := os.EncodedObjectSize(ch)
77
-
c.Assert(err, IsNil)
78
-
c.Assert(commitSz, Equals, int64(0))
82
+
s.NoError(err)
83
+
s.Equal(int64(0), commitSz)
79
84
80
85
_, err = base.EncodedObject(plumbing.TreeObject, th)
81
-
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
86
+
s.ErrorIs(err, plumbing.ErrObjectNotFound)
82
87
83
88
_, err = base.EncodedObjectSize(th)
84
-
c.Assert(err, Equals, plumbing.ErrObjectNotFound)
89
+
s.ErrorIs(err, plumbing.ErrObjectNotFound)
85
90
}
86
91
87
-
func (s *ObjectSuite) TestIterEncodedObjects(c *C) {
92
+
func (s *ObjectSuite) TestIterEncodedObjects() {
88
93
base := memory.NewStorage()
89
94
temporal := memory.NewStorage()
90
95
···
94
99
commit.SetType(plumbing.CommitObject)
95
100
96
101
ch, err := base.SetEncodedObject(commit)
97
-
c.Assert(ch.IsZero(), Equals, false)
98
-
c.Assert(err, IsNil)
102
+
s.False(ch.IsZero())
103
+
s.NoError(err)
99
104
100
105
tree := base.NewEncodedObject()
101
106
tree.SetType(plumbing.TreeObject)
102
107
103
108
th, err := os.SetEncodedObject(tree)
104
-
c.Assert(th.IsZero(), Equals, false)
105
-
c.Assert(err, IsNil)
109
+
s.False(th.IsZero())
110
+
s.NoError(err)
106
111
107
112
iter, err := os.IterEncodedObjects(plumbing.AnyObject)
108
-
c.Assert(err, IsNil)
113
+
s.NoError(err)
109
114
110
115
var hashes []plumbing.Hash
111
116
err = iter.ForEach(func(obj plumbing.EncodedObject) error {
···
113
118
return nil
114
119
})
115
120
116
-
c.Assert(err, IsNil)
117
-
c.Assert(hashes, HasLen, 2)
118
-
c.Assert(hashes[0], Equals, ch)
119
-
c.Assert(hashes[1], Equals, th)
121
+
s.NoError(err)
122
+
s.Len(hashes, 2)
123
+
s.Equal(ch, hashes[0])
124
+
s.Equal(th, hashes[1])
120
125
}
121
126
122
-
func (s *ObjectSuite) TestCommit(c *C) {
127
+
func (s *ObjectSuite) TestCommit() {
123
128
base := memory.NewStorage()
124
129
temporal := memory.NewStorage()
125
130
···
129
134
commit.SetType(plumbing.CommitObject)
130
135
131
136
_, err := os.SetEncodedObject(commit)
132
-
c.Assert(err, IsNil)
137
+
s.NoError(err)
133
138
134
139
tree := base.NewEncodedObject()
135
140
tree.SetType(plumbing.TreeObject)
136
141
137
142
_, err = os.SetEncodedObject(tree)
138
-
c.Assert(err, IsNil)
143
+
s.NoError(err)
139
144
140
145
err = os.Commit()
141
-
c.Assert(err, IsNil)
146
+
s.NoError(err)
142
147
143
148
iter, err := base.IterEncodedObjects(plumbing.AnyObject)
144
-
c.Assert(err, IsNil)
149
+
s.NoError(err)
145
150
146
151
var hashes []plumbing.Hash
147
152
err = iter.ForEach(func(obj plumbing.EncodedObject) error {
···
149
154
return nil
150
155
})
151
156
152
-
c.Assert(err, IsNil)
153
-
c.Assert(hashes, HasLen, 2)
157
+
s.NoError(err)
158
+
s.Len(hashes, 2)
154
159
}
+48
-43
storage/transactional/reference_test.go
+48
-43
storage/transactional/reference_test.go
···
1
1
package transactional
2
2
3
3
import (
4
+
"testing"
5
+
4
6
"github.com/go-git/go-git/v5/plumbing"
5
7
"github.com/go-git/go-git/v5/storage/memory"
6
-
7
-
. "gopkg.in/check.v1"
8
+
"github.com/stretchr/testify/suite"
8
9
)
9
10
10
-
var _ = Suite(&ReferenceSuite{})
11
+
func TestReferenceSuite(t *testing.T) {
12
+
suite.Run(t, new(ReferenceSuite))
13
+
}
11
14
12
-
type ReferenceSuite struct{}
15
+
type ReferenceSuite struct {
16
+
suite.Suite
17
+
}
13
18
14
-
func (s *ReferenceSuite) TestReference(c *C) {
19
+
func (s *ReferenceSuite) TestReference() {
15
20
base := memory.NewStorage()
16
21
temporal := memory.NewStorage()
17
22
···
21
26
refB := plumbing.NewReferenceFromStrings("refs/b", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
22
27
23
28
err := base.SetReference(refA)
24
-
c.Assert(err, IsNil)
29
+
s.NoError(err)
25
30
26
31
err = rs.SetReference(refB)
27
-
c.Assert(err, IsNil)
32
+
s.NoError(err)
28
33
29
34
_, err = rs.Reference("refs/a")
30
-
c.Assert(err, IsNil)
35
+
s.NoError(err)
31
36
32
37
_, err = rs.Reference("refs/b")
33
-
c.Assert(err, IsNil)
38
+
s.NoError(err)
34
39
35
40
_, err = base.Reference("refs/b")
36
-
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
41
+
s.ErrorIs(err, plumbing.ErrReferenceNotFound)
37
42
}
38
43
39
-
func (s *ReferenceSuite) TestRemoveReferenceTemporal(c *C) {
44
+
func (s *ReferenceSuite) TestRemoveReferenceTemporal() {
40
45
base := memory.NewStorage()
41
46
temporal := memory.NewStorage()
42
47
···
44
49
45
50
rs := NewReferenceStorage(base, temporal)
46
51
err := rs.SetReference(ref)
47
-
c.Assert(err, IsNil)
52
+
s.NoError(err)
48
53
49
54
err = rs.RemoveReference("refs/a")
50
-
c.Assert(err, IsNil)
55
+
s.NoError(err)
51
56
52
57
_, err = rs.Reference("refs/a")
53
-
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
58
+
s.ErrorIs(err, plumbing.ErrReferenceNotFound)
54
59
}
55
60
56
-
func (s *ReferenceSuite) TestRemoveReferenceBase(c *C) {
61
+
func (s *ReferenceSuite) TestRemoveReferenceBase() {
57
62
base := memory.NewStorage()
58
63
temporal := memory.NewStorage()
59
64
···
61
66
62
67
rs := NewReferenceStorage(base, temporal)
63
68
err := base.SetReference(ref)
64
-
c.Assert(err, IsNil)
69
+
s.NoError(err)
65
70
66
71
err = rs.RemoveReference("refs/a")
67
-
c.Assert(err, IsNil)
72
+
s.NoError(err)
68
73
69
74
_, err = rs.Reference("refs/a")
70
-
c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
75
+
s.ErrorIs(err, plumbing.ErrReferenceNotFound)
71
76
}
72
77
73
-
func (s *ReferenceSuite) TestCheckAndSetReferenceInBase(c *C) {
78
+
func (s *ReferenceSuite) TestCheckAndSetReferenceInBase() {
74
79
base := memory.NewStorage()
75
80
temporal := memory.NewStorage()
76
81
rs := NewReferenceStorage(base, temporal)
···
78
83
err := base.SetReference(
79
84
plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
80
85
)
81
-
c.Assert(err, IsNil)
86
+
s.NoError(err)
82
87
83
88
err = rs.CheckAndSetReference(
84
89
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
85
90
plumbing.NewReferenceFromStrings("foo", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
86
91
)
87
-
c.Assert(err, IsNil)
92
+
s.NoError(err)
88
93
89
94
e, err := rs.Reference(plumbing.ReferenceName("foo"))
90
-
c.Assert(err, IsNil)
91
-
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
95
+
s.NoError(err)
96
+
s.Equal("bc9968d75e48de59f0870ffb71f5e160bbbdcf52", e.Hash().String())
92
97
}
93
98
94
-
func (s *ReferenceSuite) TestCommit(c *C) {
99
+
func (s *ReferenceSuite) TestCommit() {
95
100
base := memory.NewStorage()
96
101
temporal := memory.NewStorage()
97
102
···
100
105
refC := plumbing.NewReferenceFromStrings("refs/c", "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
101
106
102
107
rs := NewReferenceStorage(base, temporal)
103
-
c.Assert(rs.SetReference(refA), IsNil)
104
-
c.Assert(rs.SetReference(refB), IsNil)
105
-
c.Assert(rs.SetReference(refC), IsNil)
108
+
s.Nil(rs.SetReference(refA))
109
+
s.Nil(rs.SetReference(refB))
110
+
s.Nil(rs.SetReference(refC))
106
111
107
112
err := rs.Commit()
108
-
c.Assert(err, IsNil)
113
+
s.NoError(err)
109
114
110
115
iter, err := base.IterReferences()
111
-
c.Assert(err, IsNil)
116
+
s.NoError(err)
112
117
113
118
var count int
114
119
iter.ForEach(func(ref *plumbing.Reference) error {
···
116
121
return nil
117
122
})
118
123
119
-
c.Assert(count, Equals, 3)
124
+
s.Equal(3, count)
120
125
}
121
126
122
-
func (s *ReferenceSuite) TestCommitDelete(c *C) {
127
+
func (s *ReferenceSuite) TestCommitDelete() {
123
128
base := memory.NewStorage()
124
129
temporal := memory.NewStorage()
125
130
···
128
133
refC := plumbing.NewReferenceFromStrings("refs/c", "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
129
134
130
135
rs := NewReferenceStorage(base, temporal)
131
-
c.Assert(base.SetReference(refA), IsNil)
132
-
c.Assert(base.SetReference(refB), IsNil)
133
-
c.Assert(base.SetReference(refC), IsNil)
136
+
s.Nil(base.SetReference(refA))
137
+
s.Nil(base.SetReference(refB))
138
+
s.Nil(base.SetReference(refC))
134
139
135
-
c.Assert(rs.RemoveReference(refA.Name()), IsNil)
136
-
c.Assert(rs.RemoveReference(refB.Name()), IsNil)
137
-
c.Assert(rs.RemoveReference(refC.Name()), IsNil)
138
-
c.Assert(rs.SetReference(refC), IsNil)
140
+
s.Nil(rs.RemoveReference(refA.Name()))
141
+
s.Nil(rs.RemoveReference(refB.Name()))
142
+
s.Nil(rs.RemoveReference(refC.Name()))
143
+
s.Nil(rs.SetReference(refC))
139
144
140
145
err := rs.Commit()
141
-
c.Assert(err, IsNil)
146
+
s.NoError(err)
142
147
143
148
iter, err := base.IterReferences()
144
-
c.Assert(err, IsNil)
149
+
s.NoError(err)
145
150
146
151
var count int
147
152
iter.ForEach(func(ref *plumbing.Reference) error {
···
149
154
return nil
150
155
})
151
156
152
-
c.Assert(count, Equals, 1)
157
+
s.Equal(1, count)
153
158
154
159
ref, err := rs.Reference(refC.Name())
155
-
c.Assert(err, IsNil)
156
-
c.Assert(ref.Hash().String(), Equals, "c3f4688a08fd86f1bf8e055724c84b7a40a09733")
160
+
s.NoError(err)
161
+
s.Equal("c3f4688a08fd86f1bf8e055724c84b7a40a09733", ref.Hash().String())
157
162
158
163
}
+28
-23
storage/transactional/shallow_test.go
+28
-23
storage/transactional/shallow_test.go
···
1
1
package transactional
2
2
3
3
import (
4
+
"testing"
5
+
4
6
"github.com/go-git/go-git/v5/plumbing"
5
7
"github.com/go-git/go-git/v5/storage/memory"
6
-
7
-
. "gopkg.in/check.v1"
8
+
"github.com/stretchr/testify/suite"
8
9
)
9
10
10
-
var _ = Suite(&ShallowSuite{})
11
+
func TestShallowSuite(t *testing.T) {
12
+
suite.Run(t, new(ShallowSuite))
13
+
}
11
14
12
-
type ShallowSuite struct{}
15
+
type ShallowSuite struct {
16
+
suite.Suite
17
+
}
13
18
14
-
func (s *ShallowSuite) TestShallow(c *C) {
19
+
func (s *ShallowSuite) TestShallow() {
15
20
base := memory.NewStorage()
16
21
temporal := memory.NewStorage()
17
22
···
21
26
commitB := plumbing.NewHash("aa9968d75e48de59f0870ffb71f5e160bbbdcf52")
22
27
23
28
err := base.SetShallow([]plumbing.Hash{commitA})
24
-
c.Assert(err, IsNil)
29
+
s.NoError(err)
25
30
26
31
err = rs.SetShallow([]plumbing.Hash{commitB})
27
-
c.Assert(err, IsNil)
32
+
s.NoError(err)
28
33
29
34
commits, err := rs.Shallow()
30
-
c.Assert(err, IsNil)
31
-
c.Assert(commits, HasLen, 1)
32
-
c.Assert(commits[0], Equals, commitB)
35
+
s.NoError(err)
36
+
s.Len(commits, 1)
37
+
s.Equal(commitB, commits[0])
33
38
34
39
commits, err = base.Shallow()
35
-
c.Assert(err, IsNil)
36
-
c.Assert(commits, HasLen, 1)
37
-
c.Assert(commits[0], Equals, commitA)
40
+
s.NoError(err)
41
+
s.Len(commits, 1)
42
+
s.Equal(commitA, commits[0])
38
43
}
39
44
40
-
func (s *ShallowSuite) TestCommit(c *C) {
45
+
func (s *ShallowSuite) TestCommit() {
41
46
base := memory.NewStorage()
42
47
temporal := memory.NewStorage()
43
48
···
46
51
commitA := plumbing.NewHash("bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
47
52
commitB := plumbing.NewHash("aa9968d75e48de59f0870ffb71f5e160bbbdcf52")
48
53
49
-
c.Assert(base.SetShallow([]plumbing.Hash{commitA}), IsNil)
50
-
c.Assert(rs.SetShallow([]plumbing.Hash{commitB}), IsNil)
54
+
s.Nil(base.SetShallow([]plumbing.Hash{commitA}))
55
+
s.Nil(rs.SetShallow([]plumbing.Hash{commitB}))
51
56
52
-
c.Assert(rs.Commit(), IsNil)
57
+
s.Nil(rs.Commit())
53
58
54
59
commits, err := rs.Shallow()
55
-
c.Assert(err, IsNil)
56
-
c.Assert(commits, HasLen, 1)
57
-
c.Assert(commits[0], Equals, commitB)
60
+
s.NoError(err)
61
+
s.Len(commits, 1)
62
+
s.Equal(commitB, commits[0])
58
63
59
64
commits, err = base.Shallow()
60
-
c.Assert(err, IsNil)
61
-
c.Assert(commits, HasLen, 1)
62
-
c.Assert(commits[0], Equals, commitB)
65
+
s.NoError(err)
66
+
s.Len(commits, 1)
67
+
s.Equal(commitB, commits[0])
63
68
}