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)) }