JSON-RPC-M1/RpcError_test.go at main · vault-thirteen/JSON-RPC-M1 · 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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package jrm1

import (
	"fmt"
	"testing"

	"github.com/vault-thirteen/auxie/tester"
)

func Test_NewRpcError(t *testing.T) {
	aTest := tester.New(t)
	var re, reExpected *RpcError
	var err error

	// Test #1. Invalid error code.
	initErrorMessages()
	re, err = NewRpcError(0, nil)
	aTest.MustBeAnError(err)
	aTest.MustBeEqual(err.Error(), "unsupported error code")

	// Test #2. Error code for user-generated errors.
	initErrorMessages()
	re, err = NewRpcError(1, nil)
	aTest.MustBeAnError(err)
	aTest.MustBeEqual(err.Error(), "user-generated errors use another constructor")

	// Test #3. Error message is not found.
	// It is not possible in practice, but we will emulate such an error.
	initErrorMessages()
	delete(errorMessages, -64)
	re, err = NewRpcError(-64, nil)
	aTest.MustBeAnError(err)
	aTest.MustBeEqual(err.Error(), "unknown error code: -64")

	// Test #4. Empty error message.
	// It is not possible in practice, but we will emulate such an error.
	initErrorMessages()
	errorMessages[RpcErrorCode(-64)] = RpcErrorMessage("")
	re, err = NewRpcError(-64, nil)
	aTest.MustBeAnError(err)
	aTest.MustBeEqual(err.Error(), "error message is not set")

	// Test #5. All clear.
	initErrorMessages()
	re, err = NewRpcError(-64, nil)
	aTest.MustBeNoError(err)
	reExpected = &RpcError{
		Code:    RpcErrorCode_ReservedForFuture_1,
		Message: RpcErrorMsg_ReservedForFuture_1,
	}
	aTest.MustBeEqual(re, reExpected)
}

func Test_NewRpcErrorFast(t *testing.T) {
	aTest := tester.New(t)
	var re, reExpected *RpcError
	var hasException bool

	// Test #1. No panic.
	initErrorMessages()
	re, hasException = _newRpcErrorFastWrapper(NewRpcErrorFast, -1)
	aTest.MustBeEqual(hasException, false)
	reExpected = &RpcError{
		Code:    RpcErrorCode_RequestIsNotReadable,
		Message: RpcErrorMsg_RequestIsNotReadable,
	}
	aTest.MustBeEqual(re, reExpected)

	// Test #2. Panic.
	initErrorMessages()
	re, hasException = _newRpcErrorFastWrapper(NewRpcErrorFast, 1)
	aTest.MustBeEqual(hasException, true)
	reExpected = (*RpcError)(nil)
	aTest.MustBeEqual(re, reExpected)
}

// _newRpcErrorFastWrapper runs the 'NewRpcErrorFast' and stops panic.
func _newRpcErrorFastWrapper(f func(code int) (re *RpcError), code int) (re *RpcError, hasException bool) {
	defer func() {
		x := recover()
		if x != nil {
			hasException = true
			fmt.Println(fmt.Sprintf("An exception was captured: %v", x))
		}
	}()

	re = f(code)

	return re, false
}

func Test_NewRpcErrorByUser(t *testing.T) {
	aTest := tester.New(t)
	var re, reExpected *RpcError
	var hasException bool

	// Test #1. No panic.
	initErrorMessages()
	re, hasException = _newRpcErrorByUserWrapper(NewRpcErrorByUser, 1, "Custom error message", 42)
	aTest.MustBeEqual(hasException, false)
	reExpected = &RpcError{
		Code:    1,
		Message: "Custom error message",
		Data:    42,
	}
	aTest.MustBeEqual(re, reExpected)

	// Test #2. Panic.
	initErrorMessages()
	re, hasException = _newRpcErrorByUserWrapper(NewRpcErrorByUser, -1, "x", nil)
	aTest.MustBeEqual(hasException, true)
	reExpected = (*RpcError)(nil)
	aTest.MustBeEqual(re, reExpected)
}

// _newRpcErrorByUserWrapper  runs the 'NewRpcErrorByUser' and stops panic.
func _newRpcErrorByUserWrapper(f func(code int, message string, data any) (re *RpcError), code int, message string, data any) (re *RpcError, hasException bool) {
	defer func() {
		x := recover()
		if x != nil {
			hasException = true
			fmt.Println(fmt.Sprintf("An exception was captured: %v", x))
		}
	}()

	re = f(code, message, data)

	return re, false
}

func Test_RpcError_AsError(t *testing.T) {
	aTest := tester.New(t)
	var re *RpcError
	var res *RpcErrorStd

	// Test #1. Not null.
	re = &RpcError{
		Code:    1,
		Message: "One",
		Data:    true,
	}
	res = re.AsError()
	aTest.MustBeDifferent(res, (*RpcErrorStd)(nil))
	aTest.MustBeEqual(res.Code, re.Code)
	aTest.MustBeEqual(res.Message, re.Message)
	aTest.MustBeEqual(res.Data, re.Data)

	// Test #2. Null.
	re = nil
	res = re.AsError()
	aTest.MustBeEqual(res, (*RpcErrorStd)(nil))
}