forked from googollee/go-socket.io
-
Notifications
You must be signed in to change notification settings - Fork 0
/
namespace_test.go
125 lines (102 loc) · 2.68 KB
/
namespace_test.go
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
package socketio
import (
"reflect"
"testing"
"github.com/googollee/go-socket.io/parser"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestNamespaceHandler(t *testing.T) {
should := assert.New(t)
must := require.New(t)
h := newHandler()
onConnectCalled := false
h.OnConnect(func(c Conn) error {
onConnectCalled = true
return nil
})
disconnectMsg := ""
h.OnDisconnect(func(c Conn, reason string) {
disconnectMsg = reason
})
var onerror error
h.OnError(func(conn Conn, err error) {
onerror = err
})
header := parser.Header{}
header.Type = parser.Connect
args := h.getTypes(header, "")
should.Nil(args)
h.dispatch(&namespaceConn{}, header, "", nil)
should.True(onConnectCalled)
header.Type = parser.Disconnect
args = h.getTypes(header, "")
should.Equal([]reflect.Type{reflect.TypeOf("")}, args)
h.dispatch(&namespaceConn{}, header, "", []reflect.Value{reflect.ValueOf("disconn")})
should.Equal("disconn", disconnectMsg)
header.Type = parser.Error
args = h.getTypes(header, "")
should.Equal([]reflect.Type{reflect.TypeOf("")}, args)
h.dispatch(&namespaceConn{}, header, "", []reflect.Value{reflect.ValueOf("failed")})
should.Equal(onerror.Error(), "failed")
header.Type = parser.Event
args = h.getTypes(header, "nonexist")
should.Nil(args)
ret, err := h.dispatch(&namespaceConn{}, header, "nonexist", nil)
must.Nil(err)
should.Nil(ret)
}
func TestNamespaceHandlerEvent(t *testing.T) {
tests := []struct {
name string
events []string
handlers []interface{}
event string
args []interface{}
ok bool
ret []interface{}
}{
{
name: "string handler",
events: []string{"e", "n"},
handlers: []interface{}{
func(c Conn, str string) string {
return "handled " + str
},
func(c Conn) {},
},
event: "e",
args: []interface{}{"str"},
ok: true,
ret: []interface{}{"handled str"},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
should := assert.New(t)
must := require.New(t)
h := newHandler()
for i, e := range test.events {
h.OnEvent(e, test.handlers[i])
}
header := parser.Header{
Type: parser.Event,
}
target := make([]reflect.Type, len(test.args))
args := make([]reflect.Value, len(test.args))
for i := range test.args {
target[i] = reflect.TypeOf(test.args[i])
args[i] = reflect.ValueOf(test.args[i])
}
types := h.getTypes(header, test.event)
should.Equal(target, types)
ret, err := h.dispatch(&namespaceConn{}, header, test.event, args)
must.Nil(err)
rets := make([]interface{}, len(ret))
for i := range ret {
rets[i] = ret[i].Interface()
}
should.Equal(test.ret, rets)
})
}
}