func TestServiceFutureSurvival(t *testing.T) {
connect := connectPacket()
connect.ClientID = "test"
connect.CleanSession = false
connack := connackPacket()
connack.SessionPresent = true
publish1 := packet.NewPublishPacket()
publish1.Message.Topic = "test"
publish1.Message.Payload = []byte("test")
publish1.Message.QOS = 1
publish1.PacketID = 1
publish2 := packet.NewPublishPacket()
publish2.Message.Topic = "test"
publish2.Message.Payload = []byte("test")
publish2.Message.QOS = 1
publish2.Dup = true
publish2.PacketID = 1
puback := packet.NewPubackPacket()
puback.PacketID = 1
broker1 := tools.NewFlow().
Receive(connect).
Send(connack).
Receive(publish1).
Close()
broker2 := tools.NewFlow().
Receive(connect).
Send(connack).
Receive(publish2).
Send(puback).
Receive(disconnectPacket()).
End()
done, port := fakeBroker(t, broker1, broker2)
config := NewConfigWithClientID("tcp://localhost:"+port, "test")
config.CleanSession = false
s := NewService()
s.Start(config)
err := s.Publish("test", []byte("test"), 1, false).Wait()
assert.NoError(t, err)
s.Stop(true)
<-done
}
func TestClientSessionResumption(t *testing.T) {
connect := connectPacket()
connect.ClientID = "test"
connect.CleanSession = false
publish1 := packet.NewPublishPacket()
publish1.Message.Topic = "test"
publish1.Message.Payload = []byte("test")
publish1.Message.QOS = 1
publish1.PacketID = 1
puback1 := packet.NewPubackPacket()
puback1.PacketID = 1
broker := tools.NewFlow().
Receive(connect).
Send(connackPacket()).
Receive(publish1).
Send(puback1).
Receive(disconnectPacket()).
End()
done, port := fakeBroker(t, broker)
c := New()
c.Session.SavePacket(outgoing, publish1)
c.Session.PacketID()
c.Callback = errorCallback(t)
config := NewConfig("tcp://localhost:" + port)
config.ClientID = "test"
config.CleanSession = false
connectFuture, err := c.Connect(config)
assert.NoError(t, err)
assert.NoError(t, connectFuture.Wait())
assert.False(t, connectFuture.SessionPresent)
assert.Equal(t, packet.ConnectionAccepted, connectFuture.ReturnCode)
time.Sleep(20 * time.Millisecond)
err = c.Disconnect()
assert.NoError(t, err)
<-done
pkts, err := c.Session.AllPackets(outgoing)
assert.NoError(t, err)
assert.Equal(t, 0, len(pkts))
}
func TestClientDisconnectWithTimeout(t *testing.T) {
publish := packet.NewPublishPacket()
publish.Message.Topic = "test"
publish.Message.Payload = []byte("test")
publish.Message.QOS = 1
publish.PacketID = 1
puback := packet.NewPubackPacket()
puback.PacketID = 1
wait := func() {
time.Sleep(100 * time.Millisecond)
}
broker := tools.NewFlow().
Receive(connectPacket()).
Send(connackPacket()).
Receive(publish).
Run(wait).
Send(puback).
Receive(disconnectPacket()).
End()
done, port := fakeBroker(t, broker)
c := New()
c.Callback = errorCallback(t)
connectFuture, err := c.Connect(NewConfig("tcp://localhost:" + port))
assert.NoError(t, err)
assert.NoError(t, connectFuture.Wait())
assert.False(t, connectFuture.SessionPresent)
assert.Equal(t, packet.ConnectionAccepted, connectFuture.ReturnCode)
publishFuture, err := c.Publish("test", []byte("test"), 1, false)
assert.NoError(t, err)
assert.NotNil(t, publishFuture)
err = c.Disconnect(10 * time.Second)
assert.NoError(t, err)
<-done
assert.NoError(t, publishFuture.Wait())
list, err := c.Session.AllPackets(outgoing)
assert.NoError(t, err)
assert.Equal(t, 0, len(list))
}
// handle an incoming PublishPacket
func (c *Client) processPublish(publish *packet.PublishPacket) error {
if publish.Message.QOS == 1 {
// prepare puback packet
puback := packet.NewPubackPacket()
puback.PacketID = publish.PacketID
// acknowledge qos 1 publish
err := c.send(puback, true)
if err != nil {
return c.die(err, false)
}
}
if publish.Message.QOS == 2 {
// store packet
err := c.Session.SavePacket(incoming, publish)
if err != nil {
return c.die(err, true)
}
// prepare pubrec packet
pubrec := packet.NewPubrecPacket()
pubrec.PacketID = publish.PacketID
// acknowledge qos 2 publish
err = c.send(pubrec, true)
if err != nil {
return c.die(err, false)
}
}
if publish.Message.QOS <= 1 {
// call callback
if c.Callback != nil {
c.Callback(&publish.Message, nil)
}
}
return nil
}
func TestClientPublishSubscribeQOS1(t *testing.T) {
subscribe := packet.NewSubscribePacket()
subscribe.Subscriptions = []packet.Subscription{{Topic: "test", QOS: 1}}
subscribe.PacketID = 1
suback := packet.NewSubackPacket()
suback.ReturnCodes = []uint8{1}
suback.PacketID = 1
publish := packet.NewPublishPacket()
publish.Message.Topic = "test"
publish.Message.Payload = []byte("test")
publish.Message.QOS = 1
publish.PacketID = 2
puback := packet.NewPubackPacket()
puback.PacketID = 2
broker := tools.NewFlow().
Receive(connectPacket()).
Send(connackPacket()).
Receive(subscribe).
Send(suback).
Receive(publish).
Send(puback).
Send(publish).
Receive(puback).
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(1), 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", 1)
assert.NoError(t, err)
assert.NoError(t, subscribeFuture.Wait())
assert.Equal(t, []uint8{1}, subscribeFuture.ReturnCodes)
publishFuture, err := c.Publish("test", []byte("test"), 1, 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))
}
