/
responder_queue_internal_test.go
112 lines (92 loc) · 2.46 KB
/
responder_queue_internal_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
package bot
import (
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
type testChat struct {
Name string
}
func (c testChat) Load(r *Robot) {}
func (c testChat) Username() string { return c.Name }
func (c testChat) Messages() <-chan Message { return make(chan Message) }
func (c testChat) Send(m Message) error { return nil }
func (c testChat) Reply(m Message) error { return nil }
func (c testChat) Topic(m Message) error { return nil }
func (c testChat) Direct(m Message) error { return nil }
func TestResponderQueueCallback(t *testing.T) {
rq := newResponderQueue(1)
msg := Message{Text: "hi"}
rq.On(DefaultMessage, func(rs *Responder) {
assert.Equal(t, msg, rs.Message)
})
rq.Emit(DefaultMessage, &Responder{Message: msg})
}
func TestResponderQueueChannel(t *testing.T) {
rq := newResponderQueue(2)
msg := Message{Text: "hi"}
pipe := rq.On(Leave)
rq.Emit(Leave, &Responder{Message: msg})
rs := <-pipe
assert.Equal(t, msg, rs.Message)
}
func TestResponderQueueForward(t *testing.T) {
rs := newResponderQueue(0)
msg1 := Message{Type: DefaultMessage, Text: "foo"}
msg2 := Message{Type: Leave, Text: "bar"}
var wg sync.WaitGroup
ch := make(chan Message, 3)
defer close(ch)
wg.Add(2)
ch <- msg1
ch <- msg2
rs.On(DefaultMessage, func(rs *Responder) {
assert.Equal(t, msg1, rs.Message)
wg.Done()
})
rs.On(Leave, func(rs *Responder) {
assert.Equal(t, msg2, rs.Message)
wg.Done()
})
// subject
go rs.Forward(&Robot{Chat: testChat{}}, ch)
wg.Wait()
}
func TestMessageIsForwardedToRespondListener(t *testing.T) {
botName := "testBot"
tests := []struct {
name string
text string
}{
{
name: "normal space in message",
text: "@testBot hello",
},
{
name: "no break space in message",
text: "@testBot\u00a0hello",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
rs := newResponderQueue(0)
ch := make(chan Message, 1)
defer close(ch)
ch <- Message{Type: DefaultMessage, Text: test.text}
// Channel to end the test if message fails to be received.
doneCh := make(chan struct{})
defer close(doneCh)
rs.On(Response, func(rs *Responder) {
assert.Equal(t, Message{Type: DefaultMessage, Text: test.text}, rs.Message)
doneCh <- struct{}{}
})
go rs.Forward(&Robot{Chat: testChat{Name: botName}}, ch)
select {
case <-time.NewTicker(time.Second).C:
assert.Fail(t, "Timeout waiting to receive message")
case <-doneCh:
}
})
}
}