Skip to content

Commit c9db158

Browse files
ymz-ncnkymz-ncnk
committed
Use testkit-go
1 parent 8ba570d commit c9db158

4 files changed

Lines changed: 83 additions & 80 deletions

File tree

‎codec_test.go‎

Lines changed: 73 additions & 73 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
1-
package codec
1+
package codec_test
22

33
import (
44
"errors"
55
"reflect"
66
"testing"
77

8-
"github.com/cmd-stream/codec-generic-go/testdata"
8+
"github.com/cmd-stream/codec-generic-go"
99
"github.com/cmd-stream/codec-generic-go/testdata/mock"
10-
tmock "github.com/cmd-stream/transport-go/testdata/mock"
10+
tmocks "github.com/cmd-stream/testkit-go/mocks/transport"
1111
com "github.com/mus-format/common-go"
1212
assertfatal "github.com/ymz-ncnk/assert/fatal"
1313
)
@@ -21,23 +21,23 @@ func TestCodec(t *testing.T) {
2121
wantN = 1 + 1 + wantLen
2222
)
2323

24-
ser := mock.NewSerializer[testdata.MyInterface, testdata.MyInterface]().RegisterMarshal(
25-
func(t testdata.MyInterface) ([]byte, error) {
24+
ser := mock.NewSerializer[MyInterface, MyInterface]().RegisterMarshal(
25+
func(t MyInterface) ([]byte, error) {
2626
return wantBs, nil
2727
})
28-
codec := NewCodec(
28+
c := codec.NewCodec(
2929
[]reflect.Type{
30-
reflect.TypeFor[testdata.MyStruct1](),
31-
reflect.TypeFor[testdata.MyStruct2](),
30+
reflect.TypeFor[MyStruct1](),
31+
reflect.TypeFor[MyStruct2](),
3232
},
3333
[]reflect.Type{
34-
reflect.TypeFor[testdata.MyStruct1](),
35-
reflect.TypeFor[testdata.MyStruct2](),
34+
reflect.TypeFor[MyStruct1](),
35+
reflect.TypeFor[MyStruct2](),
3636
},
3737
ser,
3838
)
3939

40-
w := tmock.NewWriter().RegisterWriteByte(func(b byte) error {
40+
w := tmocks.NewWriter().RegisterWriteByte(func(b byte) error {
4141
assertfatal.Equal(b, byte(wantDTM), t)
4242
return nil
4343
}).RegisterWriteByte(func(b byte) error {
@@ -48,44 +48,44 @@ func TestCodec(t *testing.T) {
4848
return len(p), nil
4949
})
5050

51-
n, err := codec.Encode(testdata.MyStruct1{}, w)
51+
n, err := c.Encode(MyStruct1{}, w)
5252
assertfatal.EqualError(err, nil, t)
5353
assertfatal.Equal(n, wantN, t)
5454
})
5555

5656
t.Run("Failed to marshal DTM", func(t *testing.T) {
57-
codec := NewCodec[testdata.MyInterface, testdata.MyInterface](
57+
c := codec.NewCodec[MyInterface, MyInterface](
5858
[]reflect.Type{
59-
reflect.TypeFor[testdata.MyStruct1](),
60-
reflect.TypeFor[testdata.MyStruct2](),
59+
reflect.TypeFor[MyStruct1](),
60+
reflect.TypeFor[MyStruct2](),
6161
},
6262
[]reflect.Type{
63-
reflect.TypeFor[testdata.MyStruct1](),
64-
reflect.TypeFor[testdata.MyStruct2](),
63+
reflect.TypeFor[MyStruct1](),
64+
reflect.TypeFor[MyStruct2](),
6565
},
6666
nil,
6767
)
6868

6969
writeErr := errors.New("failed to write DTM")
70-
wantErr := NewFailedToMarshalDTM(writeErr)
70+
wantErr := codec.NewFailedToMarshalDTM(writeErr)
7171

72-
w := tmock.NewWriter().RegisterWriteByte(func(b byte) error {
72+
w := tmocks.NewWriter().RegisterWriteByte(func(b byte) error {
7373
return writeErr
7474
})
75-
n, err := codec.Encode(testdata.MyStruct1{}, w)
75+
n, err := c.Encode(MyStruct1{}, w)
7676
assertfatal.EqualError(err, wantErr, t)
7777
assertfatal.Equal(n, 0, t)
7878
})
7979

8080
t.Run("Decoding should work", func(t *testing.T) {
8181
wantDTM := 1
82-
wantV := testdata.MyStruct2{Y: "hello"}
82+
wantV := MyStruct2{Y: "hello"}
8383
wantBs := []byte{1, 2, 3}
8484
wantLen := len(wantBs)
8585
wantN := 1 + 1 + wantLen
8686

87-
ser := mock.NewSerializer[testdata.MyInterface, testdata.MyInterface]().RegisterUnmarshal(
88-
func(bs []byte, v testdata.MyInterface) error {
87+
ser := mock.NewSerializer[MyInterface, MyInterface]().RegisterUnmarshal(
88+
func(bs []byte, v MyInterface) error {
8989
assertfatal.EqualDeep(bs, wantBs, t)
9090

9191
rv := reflect.ValueOf(v)
@@ -96,19 +96,19 @@ func TestCodec(t *testing.T) {
9696
return nil
9797
},
9898
)
99-
codec := NewCodec(
99+
c := codec.NewCodec(
100100
[]reflect.Type{
101-
reflect.TypeFor[testdata.MyStruct1](),
102-
reflect.TypeFor[testdata.MyStruct2](),
101+
reflect.TypeFor[MyStruct1](),
102+
reflect.TypeFor[MyStruct2](),
103103
},
104104
[]reflect.Type{
105-
reflect.TypeFor[testdata.MyStruct1](),
106-
reflect.TypeFor[testdata.MyStruct2](),
105+
reflect.TypeFor[MyStruct1](),
106+
reflect.TypeFor[MyStruct2](),
107107
},
108108
ser,
109109
)
110110

111-
r := tmock.NewReader().RegisterReadByte(func() (b byte, err error) {
111+
r := tmocks.NewReader().RegisterReadByte(func() (b byte, err error) {
112112
return byte(wantDTM), nil
113113
}).RegisterReadByte(func() (b byte, err error) {
114114
return byte(wantLen), nil
@@ -117,141 +117,141 @@ func TestCodec(t *testing.T) {
117117
return wantLen, nil
118118
})
119119

120-
v, n, err := codec.Decode(r)
120+
v, n, err := c.Decode(r)
121121
assertfatal.EqualError(err, nil, t)
122122
assertfatal.Equal(n, wantN, t)
123123
assertfatal.EqualDeep(v, wantV, t)
124124
})
125125

126126
t.Run("Unrecognized type", func(t *testing.T) {
127-
codec := NewCodec[testdata.MyInterface, testdata.MyInterface](
127+
c := codec.NewCodec[MyInterface, MyInterface](
128128
[]reflect.Type{
129-
reflect.TypeFor[testdata.MyStruct1](),
130-
reflect.TypeFor[testdata.MyStruct2](),
129+
reflect.TypeFor[MyStruct1](),
130+
reflect.TypeFor[MyStruct2](),
131131
},
132132
[]reflect.Type{
133-
reflect.TypeFor[testdata.MyStruct1](),
134-
reflect.TypeFor[testdata.MyStruct2](),
133+
reflect.TypeFor[MyStruct1](),
134+
reflect.TypeFor[MyStruct2](),
135135
},
136136
nil,
137137
)
138138

139-
v := testdata.MyStruct3{Z: 3.14}
139+
v := MyStruct3{Z: 3.14}
140140
wantType := reflect.TypeOf(v)
141-
wantErr := NewUnrecognizedType(wantType)
141+
wantErr := codec.NewUnrecognizedType(wantType)
142142

143-
w := tmock.NewWriter()
143+
w := tmocks.NewWriter()
144144

145-
n, err := codec.Encode(v, w)
145+
n, err := c.Encode(v, w)
146146
assertfatal.EqualError(err, wantErr, t)
147147
assertfatal.Equal(n, 0, t)
148148
})
149149

150150
t.Run("Failed to marshal byte slice", func(t *testing.T) {
151-
ser := mock.NewSerializer[testdata.MyInterface, testdata.MyInterface]().RegisterMarshal(
152-
func(t testdata.MyInterface) ([]byte, error) {
151+
ser := mock.NewSerializer[MyInterface, MyInterface]().RegisterMarshal(
152+
func(t MyInterface) ([]byte, error) {
153153
return []byte{}, nil
154154
},
155155
)
156-
codec := NewCodec(
156+
c := codec.NewCodec(
157157
[]reflect.Type{
158-
reflect.TypeFor[testdata.MyStruct1](),
159-
reflect.TypeFor[testdata.MyStruct2](),
158+
reflect.TypeFor[MyStruct1](),
159+
reflect.TypeFor[MyStruct2](),
160160
},
161161
[]reflect.Type{
162-
reflect.TypeFor[testdata.MyStruct1](),
163-
reflect.TypeFor[testdata.MyStruct2](),
162+
reflect.TypeFor[MyStruct1](),
163+
reflect.TypeFor[MyStruct2](),
164164
},
165165
ser,
166166
)
167167

168168
writeErr := errors.New("failed to write byte slice length")
169-
wantErr := NewFailedToMarshalByteSlice(writeErr)
169+
wantErr := codec.NewFailedToMarshalByteSlice(writeErr)
170170

171-
w := tmock.NewWriter().RegisterWriteByte(func(b byte) error {
171+
w := tmocks.NewWriter().RegisterWriteByte(func(b byte) error {
172172
return nil
173173
}).RegisterWriteByte(func(b byte) error {
174174
return writeErr
175175
})
176176

177-
n, err := codec.Encode(testdata.MyStruct1{}, w)
177+
n, err := c.Encode(MyStruct1{}, w)
178178
assertfatal.EqualError(err, wantErr, t)
179179
assertfatal.Equal(n, 1, t)
180180
})
181181

182182
t.Run("Failed to unmarshal DTM", func(t *testing.T) {
183-
codec := NewCodec[testdata.MyInterface, testdata.MyInterface](
183+
c := codec.NewCodec[MyInterface, MyInterface](
184184
[]reflect.Type{
185-
reflect.TypeFor[testdata.MyStruct1](),
186-
reflect.TypeFor[testdata.MyStruct2](),
185+
reflect.TypeFor[MyStruct1](),
186+
reflect.TypeFor[MyStruct2](),
187187
},
188188
[]reflect.Type{
189-
reflect.TypeFor[testdata.MyStruct1](),
190-
reflect.TypeFor[testdata.MyStruct2](),
189+
reflect.TypeFor[MyStruct1](),
190+
reflect.TypeFor[MyStruct2](),
191191
},
192192
nil,
193193
)
194194

195195
readErr := errors.New("failed to read DTM")
196-
wantErr := NewFailedToUnmarshalDTM(readErr)
196+
wantErr := codec.NewFailedToUnmarshalDTM(readErr)
197197

198-
r := tmock.NewReader().RegisterReadByte(func() (b byte, err error) {
198+
r := tmocks.NewReader().RegisterReadByte(func() (b byte, err error) {
199199
return 0, readErr
200200
})
201201

202-
_, n, err := codec.Decode(r)
202+
_, n, err := c.Decode(r)
203203
assertfatal.EqualError(err, wantErr, t)
204204
assertfatal.Equal(n, 0, t)
205205
})
206206

207207
t.Run("Unrecognized DTM", func(t *testing.T) {
208-
codec := NewCodec[testdata.MyInterface, testdata.MyInterface](
208+
c := codec.NewCodec[MyInterface, MyInterface](
209209
[]reflect.Type{
210-
reflect.TypeFor[testdata.MyStruct1](),
211-
reflect.TypeFor[testdata.MyStruct2](),
210+
reflect.TypeFor[MyStruct1](),
211+
reflect.TypeFor[MyStruct2](),
212212
},
213213
[]reflect.Type{
214-
reflect.TypeFor[testdata.MyStruct1](),
215-
reflect.TypeFor[testdata.MyStruct2](),
214+
reflect.TypeFor[MyStruct1](),
215+
reflect.TypeFor[MyStruct2](),
216216
},
217217
nil,
218218
)
219219

220220
const unrecognizedDTM com.DTM = 99
221-
wantErr := NewUnrecognizedDTM(unrecognizedDTM)
221+
wantErr := codec.NewUnrecognizedDTM(unrecognizedDTM)
222222

223-
r := tmock.NewReader().RegisterReadByte(func() (b byte, err error) {
223+
r := tmocks.NewReader().RegisterReadByte(func() (b byte, err error) {
224224
return byte(unrecognizedDTM), nil
225225
})
226226

227-
_, n, err := codec.Decode(r)
227+
_, n, err := c.Decode(r)
228228
assertfatal.EqualError(err, wantErr, t)
229229
assertfatal.Equal(n, 1, t)
230230
})
231231

232232
t.Run("Failed to unmarshal byte slice", func(t *testing.T) {
233-
codec := NewCodec[testdata.MyInterface, testdata.MyInterface](
233+
c := codec.NewCodec[MyInterface, MyInterface](
234234
[]reflect.Type{
235-
reflect.TypeFor[testdata.MyStruct1](),
236-
reflect.TypeFor[testdata.MyStruct2](),
235+
reflect.TypeFor[MyStruct1](),
236+
reflect.TypeFor[MyStruct2](),
237237
},
238238
[]reflect.Type{
239-
reflect.TypeFor[testdata.MyStruct1](),
240-
reflect.TypeFor[testdata.MyStruct2](),
239+
reflect.TypeFor[MyStruct1](),
240+
reflect.TypeFor[MyStruct2](),
241241
},
242242
nil,
243243
)
244244

245245
readErr := errors.New("failed to read byte slice")
246-
wantErr := NewFailedToUnmarshalByteSlice(readErr)
246+
wantErr := codec.NewFailedToUnmarshalByteSlice(readErr)
247247

248-
r := tmock.NewReader().RegisterReadByte(func() (b byte, err error) {
248+
r := tmocks.NewReader().RegisterReadByte(func() (b byte, err error) {
249249
return 0, nil
250250
}).RegisterReadByte(func() (b byte, err error) {
251251
return 0, readErr
252252
})
253253

254-
_, n, err := codec.Decode(r)
254+
_, n, err := c.Decode(r)
255255
assertfatal.EqualError(err, wantErr, t)
256256
assertfatal.Equal(n, 1, t)
257257
})

‎go.mod‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,8 @@ module github.com/cmd-stream/codec-generic-go
33
go 1.23.0
44

55
require (
6-
github.com/cmd-stream/transport-go v0.0.0-20251027205650-194496708c59
6+
github.com/cmd-stream/testkit-go v0.0.0-20251102032516-b7342d69dc9f
7+
github.com/cmd-stream/transport-go v0.0.0-20251102021115-2f2d348f4122
78
github.com/mus-format/common-go v0.0.0-20251026152644-9f5ac6728d8a
89
github.com/mus-format/dts-stream-go v0.9.1
910
github.com/mus-format/mus-stream-go v0.7.2
@@ -12,6 +13,6 @@ require (
1213
)
1314

1415
require (
15-
github.com/cmd-stream/core-go v0.0.0-20251027204658-b87de59c010f // indirect
16+
github.com/cmd-stream/core-go v0.0.0-20251102020427-f23e62426486 // indirect
1617
golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 // indirect
1718
)

‎go.sum‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,9 @@
1-
github.com/cmd-stream/core-go v0.0.0-20251027204658-b87de59c010f h1:iADLWy9Mms77uqwSzDQGdbmLhV3Cbe8vjxXZlwJbtkA=
2-
github.com/cmd-stream/core-go v0.0.0-20251027204658-b87de59c010f/go.mod h1:cDnp3kDEWudlKh2Qx4mziDvfpR4WJftjMe0aH14+cNo=
3-
github.com/cmd-stream/transport-go v0.0.0-20251027205650-194496708c59 h1:0IUJX8EFwW1gHwlcOJcMKRi1uequLA54X9jccua/tMA=
4-
github.com/cmd-stream/transport-go v0.0.0-20251027205650-194496708c59/go.mod h1:zhYpcQy7vhNSE6ZU5fZ/jRlqCc6i+oOm41DL8SUyyL4=
1+
github.com/cmd-stream/core-go v0.0.0-20251102020427-f23e62426486 h1:W2nkjUDYccnWf6wQnwM5UZGSGiKUbaxV2DPs0BQhprA=
2+
github.com/cmd-stream/core-go v0.0.0-20251102020427-f23e62426486/go.mod h1:UDKu4nEJWsUAebqQAzMvlhf87zPS5Kf57+SSXXOrl2c=
3+
github.com/cmd-stream/testkit-go v0.0.0-20251102032516-b7342d69dc9f h1:tHANclzJpiPlnIQUcJh8YkouQ2XCvbjiNmI5X9xIah8=
4+
github.com/cmd-stream/testkit-go v0.0.0-20251102032516-b7342d69dc9f/go.mod h1:lXvkEKawzV+ukHhSsNd30J1wDAtZ8uQZMasHpqxXZns=
5+
github.com/cmd-stream/transport-go v0.0.0-20251102021115-2f2d348f4122 h1:ZLp7/NHm7bp/QhIqgYg2bqguoYkFYE4oyYXA4b6dzUk=
6+
github.com/cmd-stream/transport-go v0.0.0-20251102021115-2f2d348f4122/go.mod h1:0/rIfxXHFLKW1GrMHKs8MtjMMo93KIZUkhUN5Ycg494=
57
github.com/mus-format/common-go v0.0.0-20251026152644-9f5ac6728d8a h1:tLF20eBk2jdZHOy3Kyv8Wh3KdhxnIDadmrmXYE7sprc=
68
github.com/mus-format/common-go v0.0.0-20251026152644-9f5ac6728d8a/go.mod h1:6Dv72knd/gHi0Scn4OEFPQbnl7RrQlQDfUOOkKP/nZc=
79
github.com/mus-format/dts-stream-go v0.9.1 h1:+BRsG76wAtLml6HOuhzgfgg7yC1cEcjTX31XkP16CE0=

testdata/testdata.go renamed to helpers_test.go

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
package testdata
1+
package codec_test
22

33
import "fmt"
44

0 commit comments

Comments
 (0)