github.com/fredmanre/go-rabbitmq-client@v1.0.7/go-rabbitmq/client_test.go (about) 1 package rabbit 2 3 import ( 4 "fmt" 5 "log" 6 "os" 7 "testing" 8 "time" 9 10 amqp "github.com/rabbitmq/amqp091-go" 11 ) 12 13 var ( 14 username = os.Getenv("RABBIT_USER") 15 password = os.Getenv("RABBIT_PWD") 16 host = os.Getenv("RABBIT_HOST") 17 port = 5672 18 ) 19 20 // HELPERS FOR TESTING PURPOSES 21 func getConn() (*RabbitMQClient, error) { 22 client := &RabbitMQClient{} 23 log.Println(username, password, host, port) 24 err := client.StartConnection(username, password, host, port) 25 if err != nil { 26 return client, err 27 } 28 err = client.CreateChannel() 29 return client, err 30 } 31 32 func getQueues( 33 client *RabbitMQClient, 34 queueName string, 35 isDurable, 36 autoDelete bool, 37 routingKeys []string, 38 exchange string, 39 ) (<-chan amqp.Delivery, error) { 40 41 err := client.SetupQueues( 42 queueName, 43 isDurable, 44 autoDelete, 45 routingKeys, 46 exchange, 47 ) 48 if err != nil { 49 return make(chan amqp.Delivery), err 50 } 51 messages, err := client.Channel.Consume( 52 client.Reception.Queue.Name, // queue 53 exchange, // consumer 54 true, // auto-ack 55 false, // exclusive 56 false, // no-local 57 false, // no-wait 58 nil, // args 59 ) 60 61 return messages, err 62 } 63 64 func runDispatching() { 65 // Regular testing, should work just fine 66 client, err := getConn() 67 if err != nil { 68 log.Fatalf("Failure getting client to connect: %s", err) 69 } 70 err = client.SetupDispatcher( 71 "test", 72 "fanout", 73 false, 74 false, 75 ) 76 if err != nil { 77 log.Fatalf("dispatcher: %s", err) 78 } 79 80 for { 81 err = client.SendMessage( 82 "test", 83 "", 84 map[string]interface{}{ 85 "hola": "bye", 86 "num": 21231, 87 }, 88 ) 89 time.Sleep(1 * time.Second) 90 } 91 } 92 93 func TestRabbitMQClient_GetQueueName(t *testing.T) { 94 t.Parallel() 95 client := &RabbitMQClient{} 96 client.Reception.Queue.Name = "test" 97 if client.GetQueueName() != "test" { 98 t.Error("Error getting or setting queue name") 99 } 100 } 101 102 // The dial that connects to RabbitMQ server 103 func TestRabbitMQClient_StartConnection(t *testing.T) { 104 t.Parallel() 105 _, err := getConn() 106 if err != nil { 107 t.Errorf("Connection failed, error: %s", err) 108 } 109 110 client := &RabbitMQClient{} 111 112 err = client.StartConnection( 113 "aasd", 114 "asdasd", 115 "12312123.123", 116 5672, 117 ) 118 if err == nil { 119 t.Error("Error should arise in starting connection") 120 } 121 } 122 123 // Test the channel creation 124 func TestRabbitMQClient_StartChannel(t *testing.T) { 125 t.Parallel() 126 client, err := getConn() 127 if err != nil { 128 t.Errorf("Connection failed, error: %s", err) 129 } 130 errConn := client.Connection.Close() 131 if errConn != nil { 132 t.Errorf("Error closing the connection, err: %s", errConn) 133 } 134 err = client.CreateChannel() 135 if err == nil { 136 t.Errorf("%s", err) 137 } 138 } 139 140 // Test the setup and consume methods that creates a queue and consumes from it 141 func TestRabbitMQClient_SetupQueues(t *testing.T) { 142 t.Parallel() 143 client, err := getConn() 144 if err != nil { 145 t.Errorf("Connection failed, error: %s", err) 146 } 147 148 err = client.SetupDispatcher( 149 "test", 150 "fanout", 151 false, 152 false, 153 ) 154 if err != nil { 155 t.Errorf("Connection failed, error: %s", err) 156 } 157 _, err = getQueues( 158 client, 159 "client_test", 160 false, 161 false, 162 []string{""}, 163 "test", 164 ) 165 166 if err != nil { 167 t.Errorf("Error setting up Queue declaring and consume channel") 168 } 169 _, err = getQueues( 170 client, 171 "client_test", 172 false, 173 true, 174 []string{""}, 175 "test", 176 ) 177 if err == nil { 178 t.Errorf("Should throw error because of arguments difference") 179 } 180 181 _, err = getQueues( 182 client, 183 "client_test", 184 false, 185 false, 186 []string{"1231asda"}, 187 "test_&./~??=+~!", 188 ) 189 if err == nil { 190 t.Errorf("Should say that the queue doesn't exist") 191 } 192 } 193 194 // Test the full receiver component 195 func TestRabbitMQClient_StartReceiver(t *testing.T) { 196 t.Parallel() 197 client, err := getConn() 198 if err != nil { 199 t.Errorf("Failure getting client to connect: %s", err) 200 } 201 _, err = client.StartReceiver( 202 "client_test", 203 false, 204 false, 205 []string{""}, 206 "test", 207 "", 208 ) 209 if err != nil { 210 t.Errorf("Failure starting receiver: %s", err) 211 } 212 _, err = client.StartReceiver( 213 "client_test", 214 false, 215 true, 216 []string{""}, 217 "test", 218 "", 219 ) 220 if err == nil { 221 t.Errorf("failure should arise in receiver: %s", err) 222 } 223 _, err = client.StartReceiver( 224 "client_test", 225 false, 226 false, 227 []string{""}, 228 "test_1", 229 "", 230 ) 231 if err == nil { 232 t.Errorf("failure should arise in receiver: %s", err) 233 } 234 235 } 236 237 // Test a full dispatch operation, from exchange declaring to message delivery 238 func TestRabbitMQClient_SetupDispatcher(t *testing.T) { 239 t.Parallel() 240 // Regular testing, should work just fine 241 client, err := getConn() 242 if err != nil { 243 t.Errorf("Failure getting client to connect: %s", err) 244 } 245 err = client.SetupDispatcher( 246 "test", 247 "fanout", 248 false, 249 false, 250 ) 251 if err != nil { 252 t.Errorf("dispatcher: %s", err) 253 } 254 err = client.SendMessage( 255 "test", 256 "", 257 map[string]interface{}{ 258 "hola": "bye", 259 "num": 21231, 260 }, 261 ) 262 if err != nil { 263 t.Errorf("sending message: %s", err) 264 } 265 266 // Setting up existing exchange with different configuration 267 err = client.SetupDispatcher( 268 "amq.match", 269 "topic", 270 false, 271 true, 272 ) 273 if err == nil { 274 t.Errorf("dispatcher should fail: %s", err) 275 } 276 277 // Sending message to wrong exchange 278 t.Log("Sending message...") 279 err = client.SendMessage( 280 "amq.match", 281 "adas", 282 map[string]interface{}{ 283 "hola": "bye", 284 "num": 21231, 285 }, 286 ) 287 if err == nil { 288 t.Errorf("Sending message to wrong destiny: %s", err) 289 } 290 291 // Sending wrong message content 292 t.Log("Sending message...") 293 err = client.SendMessage( 294 "amq.match", 295 "", 296 map[string]interface{}{ 297 "hola": "bye", 298 "num": func(x, y float64) float64 { 299 return x + y 300 }, 301 }, 302 ) 303 if err == nil { 304 t.Errorf("Sending wrong message to destiny: %s", err) 305 } 306 307 } 308 309 // Checks the exchange used actually exist on a server 310 func ExampleRabbitMQClient_StartReceiver() { 311 312 go runDispatching() 313 client, err := getConn() 314 if err != nil { 315 log.Fatalf("Failure getting client to connect: %s", err) 316 } 317 messageChannel, err := client.StartReceiver( 318 "client_test", 319 false, 320 false, 321 []string{""}, 322 "test", 323 "", 324 ) 325 if err != nil { 326 log.Fatalf("Failure starting receive: %s", err) 327 } 328 c := <-messageChannel 329 fmt.Println(c.Exchange) 330 // Output: 331 // test 332 } 333 334 // Test how much starting the receiver and receiving a message takes 335 func BenchmarkRabbitMQClient_StartReceiver(b *testing.B) { 336 337 // Starts dispatch for testing purposes 338 go runDispatching() 339 340 client, err := getConn() 341 if err != nil { 342 log.Fatalf("Failure getting client to connect: %s", err) 343 } 344 messageChannel, err := client.StartReceiver( 345 "client_test", 346 false, 347 false, 348 []string{""}, 349 "test", 350 "", 351 ) 352 if err != nil { 353 log.Fatalf("Failure starting receive: %s", err) 354 } 355 c := <-messageChannel 356 fmt.Println(c.Exchange) 357 } 358 359 func TestRecconnectingRabbitMQClient_Reconnect(t *testing.T) { 360 t.Parallel() 361 // Starts dispatch for testing purposes 362 go runDispatching() 363 364 client, err := getConn() 365 if err != nil { 366 log.Fatalf("Failure getting client to connect: %s", err) 367 } 368 Err := client.Reconnect() 369 if Err != nil { 370 log.Fatalf("Failure to reconnect: %s", err) 371 } 372 fmt.Println(Err) 373 }