Debian Codegraph @

amqp/dial_test.go

raw
1 //go:build integration
2 // +build integration
3
4 package amqp
5
6 import (
7 "crypto/tls"
8 "errors"
9 "fmt"
10 "os"
11 "testing"
12 "time"
13
14 "github.com/NeowayLabs/wabbit"
15 docker "github.com/fsouza/go-dockerclient"
16 amqp "github.com/rabbitmq/amqp091-go"
17 "github.com/tiago4orion/conjure"
18 )
19
20 var (
21 dockerClient *conjure.Client
22 rabbitmqCtn *docker.Container
23 rabbitmqCtnName1 = "test-rabbitmq1"
24 rabbitmqPort1 = "35672"
25 rabbitmqSpec1 = `{
26 "Name": "` + rabbitmqCtnName1 + `",
27 "Config": {
28 "Image": "rabbitmq",
29 "ExposedPorts": {
30 "5672/tcp": {}
31 }
32 },
33 "HostConfig": {
34 "PortBindings": {
35 "5672/tcp": [
36 {
37 "HostPort": "` + rabbitmqPort1 + `"
38 }
39 ]
40 },
41 "PublishAllPorts": true,
42 "Privileged": false
43 }
44 }`
45 rabbitmqCtnName2 = "test-rabbitmq1"
46 rabbitmqPort2 = "35673"
47 rabbitmqSpec2 = `{
48 "Name": "` + rabbitmqCtnName2 + `",
49 "Config": {
50 "Image": "rabbitmq",
51 "ExposedPorts": {
52 "5672/tcp": {}
53 }
54 },
55 "HostConfig": {
56 "PortBindings": {
57 "5672/tcp": [
58 {
59 "HostPort": "` + rabbitmqPort2 + `"
60 }
61 ]
62 },
63 "PublishAllPorts": true,
64 "Privileged": false
65 }
66 }`
67 )
68
69 func TestMain(m *testing.M) {
70 var err error
71
72 dockerClient, err = conjure.NewClient()
73
74 if err != nil || dockerClient == nil {
75 fmt.Printf("You need docker >= 1.6 installed to enable testing rabbitmq backend\n")
76 os.Exit(1)
77 }
78
79 dockerClient.Remove(rabbitmqCtnName1)
80 dockerClient.Remove(rabbitmqCtnName2)
81
82 // Execute the tests
83 status := m.Run()
84
85 // remove the backend container
86 dockerClient.Remove(rabbitmqCtnName1)
87 dockerClient.Remove(rabbitmqCtnName2)
88 os.Exit(status)
89 }
90
91 // WaitOK blocks until rabbitmq can accept connections on
92 // <ctn ip address>:5672
93 func waitRabbitOK(host string, port string) error {
94 var err error
95 var counter uint
96 dial:
97 _, err = Dial("amqp://guest:guest@" + host + ":" + port + "/%2f")
98 if err != nil {
99 if counter >= 120 {
100 panic("isn't possible to connect on rabbitmq")
101 }
102
103 counter++
104 time.Sleep(500 * time.Millisecond)
105 goto dial
106 }
107
108 return nil
109 }
110
111 func testDialGeneric(t *testing.T, dialFunc func() error) {
112 // Should fail
113 err := dialFunc()
114
115 if err == nil {
116 t.Error("No backend started... Should fail")
117 return
118 }
119
120 rabbitmqCtn, err = dockerClient.Run(rabbitmqSpec1)
121 if err != nil {
122 t.Error(err)
123 }
124
125 err = waitRabbitOK("localhost", rabbitmqPort1)
126
127 if err != nil {
128 t.Error(err)
129 return
130 }
131
132 err = dialFunc()
133
134 if err != nil {
135 t.Error(err)
136 return
137 }
138
139 dockerClient.Remove(rabbitmqCtnName1)
140 }
141
142 // TestDial test a simple connection to rabbitmq.
143 // If the rabbitmq disconnects will not be tested here!
144 func TestDial(t *testing.T) {
145 testDialGeneric(t, func() error {
146 _, err := Dial("amqp://guest:guest@localhost:35672/%2f")
147 return err
148 })
149 }
150
151 // TestDialTLS test a simple connection to rabbitmq, with TLS.
152 func TestDialTLS(t *testing.T) {
153 testDialGeneric(t, func() error {
154 _, err := DialTLS("amqp://guest:guest@localhost:35672/%2f", &tls.Config{})
155 return err
156 })
157 }
158
159 // TestDialConfig test a simple connection to rabbitmq, with custom config.
160 func TestDialConfig(t *testing.T) {
161 testDialGeneric(t, func() error {
162 _, err := DialConfig("amqp://guest:guest@localhost:35672/%2f", amqp.Config{
163 Properties: amqp.Table{
164 "foo": "bar",
165 },
166 })
167 return err
168 })
169 }
170
171 func TestAutoRedial(t *testing.T) {
172 var err error
173
174 dockerClient.Remove(rabbitmqCtnName2)
175 rabbitmqCtn, err = dockerClient.Run(rabbitmqSpec2)
176
177 if err != nil {
178 t.Errorf("Failed to start rabbitmq: %s", err.Error())
179 return
180 }
181
182 err = waitRabbitOK("localhost", rabbitmqPort2)
183
184 if err != nil {
185 t.Error(err)
186 return
187 }
188
189 conn, err := Dial("amqp://guest:guest@localhost:35673/%2f")
190
191 if err != nil {
192 t.Error(err)
193 return
194 }
195
196 redialErrors := make(chan wabbit.Error)
197 done := make(chan bool)
198 conn.AutoRedial(redialErrors, done)
199
200 // required goroutine to consume connection error messages
201 go func() {
202 for {
203 // discards the connection errors
204 <-redialErrors
205 }
206 }()
207
208 dockerClient.StopContainer(rabbitmqCtnName2, 3)
209
210 // concurrently starts the rabbitmq after 1 second
211 go func() {
212 time.Sleep(1 * time.Second)
213
214 err := dockerClient.StartContainer(rabbitmqCtnName2, nil)
215
216 if err != nil {
217 t.Error(err)
218 return
219 }
220 }()
221
222 select {
223 case <-time.After(10 * time.Second):
224 err = errors.New("Failed to reconnect. Timeout exceeded")
225 case <-done:
226 err = nil
227 }
228
229 if err != nil {
230 t.Errorf("Client doesn't reconnect in 10 seconds: %s", err.Error())
231 return
232 }
233
234 conn.Close()
235 dockerClient.Remove(rabbitmqCtnName2)
236 }
237
238 func TestChannelMock(t *testing.T) {
239 var channel wabbit.Channel
240
241 // rabbitmq.Channel satisfies wabbit.Channel interface
242 channel = new(Channel)
243
244 if channel == nil {
245 t.Error("Maybe wabbit.Channel interface does not mock amqp.Channel correctly")
246 }
247 }
248
249 func TestConnMock(t *testing.T) {
250 var conn wabbit.Conn
251
252 // rabbitmq.Conn satisfies wabbit.Conn interface
253 conn = &Conn{}
254
255 if conn == nil {
256 t.Error("Maybe wabbit.Conn interface does not mock amqp.Conn correctly")
257 }
258 }