func TestReceiveMessage(t *testing.T) {
subscribe := packet.NewSubscribePacket()
subscribe.PacketID = 1
subscribe.Subscriptions = []packet.Subscription{
{Topic: "test"},
}
suback := packet.NewSubackPacket()
suback.PacketID = 1
suback.ReturnCodes = []uint8{0}
publish := packet.NewPublishPacket()
publish.Message = packet.Message{
Topic: "test",
Payload: []byte("test"),
Retain: true,
}
broker := tools.NewFlow().
Receive(connectPacket()).
Send(connackPacket()).
Receive(subscribe).
Send(suback).
Send(publish).
Receive(disconnectPacket()).
End()
done, port := fakeBroker(t, broker)
msg, err := ReceiveMessage(NewConfig("tcp://localhost:"+port), "test", 0)
assert.NoError(t, err)
assert.Equal(t, publish.Message.String(), msg.String())
<-done
}
// SubscribeMultiple will send a SubscribePacket containing multiple topics to
// subscribe. It will return a SubscribeFuture that gets completed once a
// SubackPacket has been received.
func (c *Client) SubscribeMultiple(subscriptions []packet.Subscription) (*SubscribeFuture, error) {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if c.state.get() != clientConnected {
return nil, ErrClientNotConnected
}
// allocate packet
subscribe := packet.NewSubscribePacket()
subscribe.PacketID = c.Session.PacketID()
subscribe.Subscriptions = subscriptions
// create future
future := &SubscribeFuture{}
future.initialize()
// store future
c.futureStore.put(subscribe.PacketID, future)
// send packet
err := c.send(subscribe, true)
if err != nil {
return nil, c.cleanup(err, false, false)
}
return future, nil
}
func TestServiceCommandsInCallback(t *testing.T) {
subscribe := packet.NewSubscribePacket()
subscribe.Subscriptions = []packet.Subscription{{Topic: "test"}}
subscribe.PacketID = 1
suback := packet.NewSubackPacket()
suback.ReturnCodes = []uint8{0}
suback.PacketID = 1
publish := packet.NewPublishPacket()
publish.Message.Topic = "test"
publish.Message.Payload = []byte("test")
broker := tools.NewFlow().
Receive(connectPacket()).
Send(connackPacket()).
Receive(subscribe).
Send(suback).
Receive(publish).
Send(publish).
Receive(disconnectPacket()).
End()
done, port := fakeBroker(t, broker)
message := make(chan struct{})
offline := make(chan struct{})
s := NewService()
s.OnlineCallback = func(resumed bool) {
assert.False(t, resumed)
s.Subscribe("test", 0)
s.Publish("test", []byte("test"), 0, false)
}
s.OfflineCallback = func() {
close(offline)
}
s.MessageCallback = func(msg *packet.Message) {
assert.Equal(t, "test", msg.Topic)
assert.Equal(t, []byte("test"), msg.Payload)
assert.Equal(t, uint8(0), msg.QOS)
assert.False(t, msg.Retain)
close(message)
}
s.Start(NewConfig("tcp://localhost:" + port))
<-message
s.Stop(true)
<-offline
<-done
}
func TestClientLogger(t *testing.T) {
subscribe := packet.NewSubscribePacket()
subscribe.Subscriptions = []packet.Subscription{{Topic: "test"}}
subscribe.PacketID = 1
suback := packet.NewSubackPacket()
suback.ReturnCodes = []uint8{0}
suback.PacketID = 1
publish := packet.NewPublishPacket()
publish.Message.Topic = "test"
publish.Message.Payload = []byte("test")
broker := tools.NewFlow().
Receive(connectPacket()).
Send(connackPacket()).
Receive(subscribe).
Send(suback).
Receive(publish).
Send(publish).
Receive(disconnectPacket()).
End()
done, port := fakeBroker(t, broker)
wait := make(chan struct{})
c := New()
c.Callback = func(msg *packet.Message, err error) {
close(wait)
}
var counter uint32
c.Logger = func(msg string) {
atomic.AddUint32(&counter, 1)
}
future, _ := c.Connect(NewConfig("tcp://localhost:" + port))
future.Wait()
subscribeFuture, _ := c.Subscribe("test", 0)
subscribeFuture.Wait()
publishFuture, _ := c.Publish("test", []byte("test"), 0, false)
publishFuture.Wait()
<-wait
c.Disconnect()
<-done
assert.Equal(t, uint32(8), counter)
}
func TestClientPublishSubscribeQOS2(t *testing.T) {
subscribe := packet.NewSubscribePacket()
subscribe.Subscriptions = []packet.Subscription{{Topic: "test", QOS: 2}}
subscribe.PacketID = 1
suback := packet.NewSubackPacket()
suback.ReturnCodes = []uint8{2}
suback.PacketID = 1
publish := packet.NewPublishPacket()
publish.Message.Topic = "test"
publish.Message.Payload = []byte("test")
publish.Message.QOS = 2
publish.PacketID = 2
pubrec := packet.NewPubrecPacket()
pubrec.PacketID = 2
pubrel := packet.NewPubrelPacket()
pubrel.PacketID = 2
pubcomp := packet.NewPubcompPacket()
pubcomp.PacketID = 2
broker := tools.NewFlow().
Receive(connectPacket()).
Send(connackPacket()).
Receive(subscribe).
Send(suback).
Receive(publish).
Send(pubrec).
Receive(pubrel).
Send(pubcomp).
Send(publish).
Receive(pubrec).
Send(pubrel).
Receive(pubcomp).
Receive(disconnectPacket()).
End()
done, port := fakeBroker(t, broker)
wait := make(chan struct{})
c := New()
c.Callback = func(msg *packet.Message, err error) {
assert.NoError(t, err)
assert.Equal(t, "test", msg.Topic)
assert.Equal(t, []byte("test"), msg.Payload)
assert.Equal(t, uint8(2), msg.QOS)
assert.False(t, msg.Retain)
close(wait)
}
future, err := c.Connect(NewConfig("tcp://localhost:" + port))
assert.NoError(t, err)
assert.NoError(t, future.Wait())
assert.False(t, future.SessionPresent)
assert.Equal(t, packet.ConnectionAccepted, future.ReturnCode)
subscribeFuture, err := c.Subscribe("test", 2)
assert.NoError(t, err)
assert.NoError(t, subscribeFuture.Wait())
assert.Equal(t, []uint8{2}, subscribeFuture.ReturnCodes)
publishFuture, err := c.Publish("test", []byte("test"), 2, false)
assert.NoError(t, err)
assert.NoError(t, publishFuture.Wait())
<-wait
err = c.Disconnect()
assert.NoError(t, err)
<-done
in, err := c.Session.AllPackets(incoming)
assert.NoError(t, err)
assert.Equal(t, 0, len(in))
out, err := c.Session.AllPackets(outgoing)
assert.NoError(t, err)
assert.Equal(t, 0, len(out))
}