go-tarantool/boxerror_gen_test.go at master · tarantool/go-tarantool · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package tarantool

import (
	"bytes"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/vmihailenco/msgpack/v5"
)

func TestSomeOptionalBoxError(t *testing.T) {
	val := BoxError{Code: 1, Msg: "error"}
	opt := SomeOptionalBoxError(val)

	assert.True(t, opt.IsSome())
	assert.False(t, opt.IsZero())

	v, ok := opt.Get()
	assert.True(t, ok)
	assert.Equal(t, val, v)
}

func TestNoneOptionalBoxError(t *testing.T) {
	opt := NoneOptionalBoxError()

	assert.False(t, opt.IsSome())
	assert.True(t, opt.IsZero())

	_, ok := opt.Get()
	assert.False(t, ok)
}

func TestOptionalBoxError_MustGet(t *testing.T) {
	val := BoxError{Code: 1, Msg: "error"}
	optSome := SomeOptionalBoxError(val)
	optNone := NoneOptionalBoxError()

	assert.Equal(t, val, optSome.MustGet())
	assert.Panics(t, func() { optNone.MustGet() })
}

func TestOptionalBoxError_Unwrap(t *testing.T) {
	val := BoxError{Code: 1, Msg: "error"}
	optSome := SomeOptionalBoxError(val)
	optNone := NoneOptionalBoxError()

	assert.Equal(t, val, optSome.Unwrap())
	assert.Equal(t, BoxError{}, optNone.Unwrap())
}

func TestOptionalBoxError_UnwrapOr(t *testing.T) {
	val := BoxError{Code: 1, Msg: "error"}
	def := BoxError{Code: 2, Msg: "default"}
	optSome := SomeOptionalBoxError(val)
	optNone := NoneOptionalBoxError()

	assert.Equal(t, val, optSome.UnwrapOr(def))
	assert.Equal(t, def, optNone.UnwrapOr(def))
}

func TestOptionalBoxError_UnwrapOrElse(t *testing.T) {
	val := BoxError{Code: 1, Msg: "error"}
	def := BoxError{Code: 2, Msg: "default"}
	optSome := SomeOptionalBoxError(val)
	optNone := NoneOptionalBoxError()

	assert.Equal(t, val, optSome.UnwrapOrElse(func() BoxError { return def }))
	assert.Equal(t, def, optNone.UnwrapOrElse(func() BoxError { return def }))
}

func TestOptionalBoxError_EncodeDecodeMsgpack_Some(t *testing.T) {
	val := BoxError{Code: 1, Msg: "error"}
	some := SomeOptionalBoxError(val)

	var buf bytes.Buffer
	enc := msgpack.NewEncoder(&buf)
	dec := msgpack.NewDecoder(&buf)

	err := enc.Encode(some)
	require.NoError(t, err)

	var decodedSome OptionalBoxError
	err = dec.Decode(&decodedSome)
	require.NoError(t, err)
	assert.True(t, decodedSome.IsSome())
	assert.Equal(t, val, decodedSome.Unwrap())
}

func TestOptionalBoxError_EncodeDecodeMsgpack_None(t *testing.T) {
	none := NoneOptionalBoxError()

	var buf bytes.Buffer
	enc := msgpack.NewEncoder(&buf)
	dec := msgpack.NewDecoder(&buf)

	err := enc.Encode(none)
	require.NoError(t, err)

	var decodedNone OptionalBoxError
	err = dec.Decode(&decodedNone)
	require.NoError(t, err)
	assert.True(t, decodedNone.IsZero())
}

func TestOptionalBoxError_EncodeDecodeMsgpack_InvalidType(t *testing.T) {
	var buf bytes.Buffer
	enc := msgpack.NewEncoder(&buf)
	dec := msgpack.NewDecoder(&buf)

	err := enc.Encode(123)
	require.NoError(t, err)

	var decodedInvalid OptionalBoxError
	err = dec.Decode(&decodedInvalid)
	assert.Error(t, err)
}