mini_mqtt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 998e32192be7c070e3c79ffc234c874ecf3962e7
+  data.tar.gz: 426b36b3850393562047e1a09f9c1cf9067fdfb9
+SHA512:
+  metadata.gz: 5e86d0852c429b21a11d035bbd0da3b1d8fc1c193ee7d106fe27787f75b931167a2ed7af46cec696b471c9e3bff09714c3a75f1d8d0617cc0f2717032a05093d
+  data.tar.gz: dbce45001fa0d8f7ef8b8a63c6a041c630722416f9cc67bd56add6641fbf54c34e24886000bea9e66f3ae852489540a8129b6c8987414d760390604522d0d0c0

data/README.md

@@ -0,0 +1,103 @@
+# MiniMqtt
+
+A full ruby implementation of the client side of MQTT protocol. 
+
+The philosophy behind this gem is to keep the code as minimal and tidy as possible, and to completely avoid dependencies.
+
+    cloc lib
+    
+    ---------------------------------------------------------------------
+    Language         files          blank        comment           code
+    ---------------------------------------------------------------------
+    Ruby                 6            103             14            449
+    ---------------------------------------------------------------------
+
+## Features
+
+* Supports all MQTT features up to QoS 1.
+* Doesn't support websockets.
+* Doesn't store messages once the connection has been closed.
+
+## Installation
+
+Clone this repo and include it to your load path. This project isn't published at rubygems yet.
+
+## How to test
+You need mosquitto server installed in order to run integration tests.
+
+    sudo apt-get install mosquitto
+    
+    rake test
+
+## Usage
+
+```ruby
+require 'mini_mqtt'
+```
+
+### Create client instance
+Possible params are host, port, user, password, keep_alive (seconds), client_id, and clean_session
+client_id defaults to random client id
+clean_session defaults to true
+keep_alive defaults to 10
+
+```ruby
+client = MiniMqtt::Client.new host: 'test.mosquitto.org'
+```
+
+### Establish connection
+Options are will_topic, will_message, will_retain(false) and will_qos(0)
+
+```ruby
+client.connect
+```
+
+You can check at any time if client is connected
+
+```ruby
+puts client.connected?
+```
+
+### Publish messages
+
+```ruby
+# Regular publish
+client.publish '/topic', 'hello'
+
+# Publish with retain
+client.publish '/other_topic', 'retained_message', retain: true
+
+# Publish with qos
+client.publish '/qos_topic', 'message', qos: 1
+```
+
+### Subscribe to topics
+
+```ruby
+# Single topic
+client.subscribe '/topic'
+
+# Multiple topics
+client.subscribe '/topic', '/other_topic'
+
+# Specifying max qos for topic (default 0)
+client.subscribe '/topic', '/qos_topic' => 1
+```
+
+### Get messages
+The caller of these methods are blocked until a message arrives, or the connection is lost.
+
+```ruby
+# Get a single message
+msg = client.get_message
+puts msg.message, msg.topic, msg.qos, msg.retain, msg.packet_id, msg.dup
+
+# Get messages in an infinite loop. Breaks if connection is lost.
+client.get_messages do |msg, topic|
+  puts "Received #{ msg } on topic #{ topic }"
+end
+```
+
+### Gracefully disconnect
+client.disconnect
+```

data/lib/mini_mqtt/bin_helper.rb

@@ -0,0 +1,32 @@
+module BinHelper
+  def uchar number
+    [number].pack 'C'
+  end
+
+  def ushort number
+    [number].pack 'n'
+  end
+
+  def flag_byte flags
+    raise "flags must have 8 elements" unless flags.size == 8
+    byte = 0
+    flags.reverse.each_with_index do |flag, index|
+      byte |= 1 << index if flag && flag != 0
+    end
+    byte
+  end
+
+  def mqtt_utf8_encode string
+    ushort(string.length) + string
+  end
+
+  def read_mqtt_encoded_string stream
+    length = read_ushort stream
+    stream.read length
+  end
+
+  def read_ushort stream
+    stream.read(2).unpack('n').first
+  end
+
+end

data/lib/mini_mqtt/client.rb

@@ -0,0 +1,135 @@
+require 'socket'
+
+module MiniMqtt
+  class Client
+    attr_accessor :host, :port, :user, :password, :clean_session, :client_id
+
+    def initialize params = {}
+      @host = params[:host] || 'localhost'
+      @port = params[:port] || 1883
+      @user = params[:user]
+      @password = params[:password]
+      @keep_alive = params[:keep_alive] || 10
+      @client_id = params[:client_id] || generate_client_id
+      @clean_session = params.fetch :clean_session, true
+    end
+
+    def connect options = {}
+      # Create socket and packet handler
+      @socket = TCPSocket.new @host, @port
+      @packet_handler = PacketHandler.new @socket
+
+      # Send ConnectPacket
+      send_packet ConnectPacket.new user: @user,
+        password: @password, keep_alive: @keep_alive, client_id: @client_id,
+        clean_session: @clean_session, will_topic: options[:will_topic],
+        will_message: options[:will_message], will_retain: options[:will_retain]
+
+      # Receive connack packet
+      connack = receive_packet
+
+      if connack.accepted?
+        @received_messages = Queue.new
+        @last_ping_response = Time.now
+        spawn_read_thread!
+        spawn_keepalive_thread!
+      else
+        raise StandardError.new(connack.error)
+      end
+    end
+
+    def subscribe *params
+      # Each param can be a topic or a topic with its max qos.
+      # Example: subscribe 'topic1', 'topic2' => 1
+      topics = params.map do |arg|
+        arg.is_a?(Hash) ? arg : { arg => 0 }
+      end
+      topics = topics.inject :merge
+      packet = SubscribePacket.new topics: topics
+      send_packet packet
+    end
+
+    def unsubscribe *topics
+      send_packet UnsubscribePacket.new topics: topics
+    end
+
+    def publish topic, message, options = {}
+      packet = PublishPacket.new topic: topic, message: message.to_s,
+        retain: options[:retain], qos: options[:qos]
+      send_packet packet
+    end
+
+    def disconnect
+      # Send DisconnectPacket, then kill threads and close socket
+      send_packet DisconnectPacket.new
+      @read_thread.kill
+      @keepalive_thread.kill
+      @socket.close
+    end
+
+    def get_message
+      @received_messages.pop
+    end
+
+    def get_messages
+      while message = get_message
+        yield message.message, message.topic
+      end
+    end
+
+    def connected?
+      @socket && !@socket.closed?
+    end
+
+    private
+
+      def send_packet packet
+        @packet_handler.write_packet packet
+      end
+
+      def receive_packet
+        @packet_handler.get_packet
+      end
+
+      def handle_received_packet packet
+        case packet
+        when PingrespPacket
+          @last_ping_response = Time.now
+
+        when PublishPacket
+          @received_messages << packet
+          if packet.qos > 0
+            send_packet PubackPacket.new packet_id: packet.packet_id
+          end
+
+        when PubackPacket
+        end
+      end
+
+      def generate_client_id
+        "client_#{ rand(10000000) }"
+      end
+
+      def spawn_read_thread!
+        @read_thread = Thread.new do
+          while connected? do
+            handle_received_packet receive_packet
+          end
+          @received_messages << nil
+        end
+      end
+
+      def spawn_keepalive_thread!
+        @keepalive_thread = Thread.new do
+          while connected? do
+            send_packet PingreqPacket.new
+            sleep @keep_alive
+            if Time.now - @last_ping_response > 2 * @keep_alive
+              puts "Error: MQTT Server not responding to ping. Disconnecting."
+              @socket.close
+            end
+          end
+        end
+      end
+  end
+end

data/lib/mini_mqtt/connect_packet.rb

@@ -0,0 +1,43 @@
+module MiniMqtt
+  class ConnectPacket < Packet
+    def initialize options = {}
+      @user = options[:user]
+      @password = options[:password]
+      @client_id = options[:client_id]
+      @will_message = options[:will_message]
+      @will_topic = options[:will_topic]
+      @will_retain = options[:will_retain]
+      @will_qos = options[:will_qos] || 0
+      @clean_session = options[:clean_session]
+      @keep_alive = options[:keep_alive]
+    end
+
+    def build_variable_header
+      # Protocol name
+      header = ushort(4) # length of name
+      header << 'MQTT' # name
+      # Protocol level
+      header << uchar(4)
+      # Flags
+      byte = flag_byte [ @user, @password, @will_retain, nil, nil,
+                            @will_message, @clean_session, nil]
+      byte |= @will_qos << 3
+      header << uchar(byte)
+      #Keepalive
+      header << ushort(@keep_alive)
+      header
+    end
+
+    def build_payload
+      payload = ""
+      payload << mqtt_utf8_encode(@client_id)
+      if @will_message
+        payload << mqtt_utf8_encode(@will_topic)
+        payload << mqtt_utf8_encode(@will_message)
+      end
+      payload << mqtt_utf8_encode(@user) if @user
+      payload << mqtt_utf8_encode(@password) if @password
+      payload
+    end
+  end
+end

data/lib/mini_mqtt/packet.rb

@@ -0,0 +1,239 @@
+class InvalidFlagsError < StandardError ; end
+
+module MiniMqtt
+  class Packet
+    include BinHelper
+
+    @@last_packet_id = 0
+
+    def decode stream, flags = 0
+      @stream = stream
+      handle_flags flags
+      read_variable_header
+      read_payload
+      self
+    end
+
+    def encode
+      build_variable_header + build_payload
+    end
+
+    def flags
+      0b000
+    end
+
+    private
+
+      def new_packet_id
+        @@last_packet_id += 1
+        @@last_packet_id %= 65535
+        1 + @@last_packet_id
+      end
+
+      def read_variable_header
+      end
+
+      def read_payload
+      end
+
+      def handle_flags flags
+      end
+
+      def build_variable_header
+        ""
+      end
+
+      def build_payload
+        ""
+      end
+
+  end
+
+  module AckPacket
+    attr_accessor :packet_id
+
+    def initialize params = {}
+      @packet_id = params[:packet_id]
+    end
+
+    def read_variable_header
+      @packet_id = read_ushort @stream
+    end
+
+    def build_variable_header
+      ushort @packet_id
+    end
+  end
+
+  class ConnackPacket < Packet
+    attr_reader :return_code
+
+    ERRORS = { 1 => "unacceptable protocol version",
+               2 => "identifier rejected",
+               3 => "server unavailable",
+               4 => "bad username or password",
+               5 => "not authorized" }
+
+
+    def read_variable_header
+      @session_present = @stream.readbyte & 0x01
+      @return_code = @stream.readbyte
+    end
+
+    def session_present?
+      @session_present == 1
+    end
+
+    def accepted?
+      @return_code == 0
+    end
+
+    def error_message
+      ERRORS[@return_code]
+    end
+
+  end
+
+  class PublishPacket < Packet
+    attr_accessor :dup, :qos, :retain, :packet_id, :topic, :message
+
+    def handle_flags flags
+      @dup = flags & 0b1000 != 0
+      @qos = (flags & 0b0110) >> 1
+      @retain = flags & 0b0001 != 0
+    end
+
+    def read_variable_header
+      @topic = read_mqtt_encoded_string @stream
+      if @qos > 0
+        @packet_id = read_ushort @stream
+      end
+    end
+
+    def read_payload
+      @message = @stream.read
+    end
+
+    def initialize params = {}
+      @topic = params[:topic] || ""
+      @message = params[:message] || ""
+      @qos = params[:qos] || 0
+      @dup = params[:dup] || false
+      @retain = params[:retain] || false
+      @packet_id = params[:packet_id]
+    end
+
+    def flags
+      flags = 0
+      flags |= 0b0001 if @retain
+      flags |= qos << 1
+      flags |= 0b1000 if @dup
+      flags
+    end
+
+    def build_variable_header
+      header = mqtt_utf8_encode @topic
+      if @qos > 0
+        @packet_id ||= new_packet_id
+        header << ushort(@packet_id)
+      end
+      header
+    end
+
+    def build_payload
+      @message
+    end
+
+  end
+
+  class PubackPacket < Packet
+    include AckPacket
+  end
+
+  class PubrecPacket < Packet
+    include AckPacket
+  end
+
+  class PubrelPacket < Packet
+    include AckPacket
+
+    def flags
+      0b0010
+    end
+  end
+
+  class PubcompPacket < Packet
+    include AckPacket
+  end
+
+  class SubscribePacket < Packet
+    attr_accessor :packet_id, :topics
+
+    def initialize params = {}
+      @topics = params[:topics]
+    end
+
+    def flags
+      0b0010
+    end
+
+    def build_variable_header
+      @packet_id ||= new_packet_id
+      ushort @packet_id
+    end
+
+    def build_payload
+      @topics.map do |topic, qos|
+        mqtt_utf8_encode(topic) + uchar(qos)
+      end.join
+    end
+  end
+
+  class SubackPacket < Packet
+    attr_accessor :packet_id, :max_qos_accepted
+
+    def read_variable_header
+      @packet_id = read_ushort @stream
+    end
+
+    def read_payload
+      @max_qos_accepted = @stream.read.unpack 'C*'
+    end
+  end
+
+  class UnsubscribePacket < Packet
+    attr_accessor :packet_id, :topics
+
+    def flags
+      0b0010
+    end
+
+    def initialize params = {}
+      @topics = params[:topics]
+    end
+
+    def build_variable_header
+      @packet_id ||= new_packet_id
+      ushort @packet_id
+    end
+
+    def build_payload
+      @topics.map do |topic|
+        mqtt_utf8_encode(topic)
+      end.join
+    end
+  end
+
+  class UnsubackPacket < Packet
+    include AckPacket
+  end
+
+  class PingreqPacket < Packet
+  end
+
+  class PingrespPacket < Packet
+  end
+
+  class DisconnectPacket < Packet
+  end
+end

data/lib/mini_mqtt/packet_handler.rb

@@ -0,0 +1,111 @@
+require 'stringio'
+
+module MiniMqtt
+  PACKET_CLASSES = { 1 => ConnectPacket,
+                     2 => ConnackPacket,
+                     3 => PublishPacket,
+                     4 => PubackPacket,
+                     5 => PubrecPacket,
+                     6 => PubrelPacket,
+                     7 => PubcompPacket,
+                     8 => SubscribePacket,
+                     9 => SubackPacket,
+                     10 => UnsubscribePacket,
+                     11 => UnsubackPacket,
+                     12 => PingreqPacket,
+                     13 => PingrespPacket,
+                     14 => DisconnectPacket }
+  PACKET_CODES = PACKET_CLASSES.invert
+
+  class PacketHandler
+    include BinHelper
+
+    MAX_LENGTH_MULTIPLIER = 128 ** 3
+
+    @@debug = false
+
+    def self.enable_debug
+      @@debug = true
+    end
+
+    def initialize stream
+      @stream = stream
+      @mutex = Mutex.new
+    end
+
+    def get_packet
+      # First byte contains packet type and flags. 4 bits each.
+      first_byte = @stream.readbyte
+      packet_class = PACKET_CLASSES[ first_byte >> 4 ]
+      flags = first_byte & 0xf
+
+      #Decode length using algorithm, and read packet body.
+      length = decode_length @stream
+      encoded_packet = @stream.read length
+      log_in_packet packet_class, encoded_packet
+
+      # Create appropiate packet instance and decode the packet body.
+      packet_class.new.decode StringIO.new(encoded_packet), flags
+
+    rescue StandardError => e
+      log "Exception while receiving: #{ e.inspect }"
+      @stream.close
+    end
+
+    def write_packet packet
+      # Write type and flags, then encoded packet length, then packet
+      @mutex.synchronize do
+        type_and_flags = PACKET_CODES[packet.class] << 4
+        type_and_flags += packet.flags
+        @stream.write uchar(type_and_flags)
+        encoded_packet = packet.encode
+        log_out_packet packet
+        @stream.write encode_length(encoded_packet.length)
+        @stream.write encoded_packet
+      end
+    rescue StandardError => e
+      log "Exception while receiving: #{ e.inspect }"
+      @stream.close
+    end
+
+    private
+
+    def encode_length length
+      encoded = ""
+      loop do
+        encoded_byte = length % 128
+        length = length / 128
+        encoded_byte |= 128 if length > 0
+        encoded << encoded_byte.chr
+        break if length == 0
+      end
+      encoded
+    end
+
+    def decode_length stream
+      length = 0
+      multiplier = 1
+      while encoded_byte = stream.readbyte
+        length += (encoded_byte & 0x7f) * multiplier
+        break if encoded_byte & 0x80 == 0
+        multiplier *= 128
+        raise "Malformed remaining length" if multiplier > MAX_LENGTH_MULTIPLIER
+      end
+      length
+    end
+
+    def log_in_packet type, message
+      log "\nIN - #{ type } - #{ message.inspect }\n"
+    end
+
+    def log_out_packet packet
+      log "\nOUT - #{ packet.class } - #{ packet.instance_variable_get :@packet_id } - #{ packet.encode.inspect }\n"
+    end
+
+    def log text
+      if @@debug
+        puts text
+      end
+    end
+  end
+end

data/lib/mini_mqtt.rb

@@ -0,0 +1,8 @@
+require 'mini_mqtt/bin_helper'
+require 'mini_mqtt/packet'
+require 'mini_mqtt/connect_packet'
+require 'mini_mqtt/packet_handler'
+require 'mini_mqtt/client'
+
+module MiniMqtt
+end

data/test/client_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+require 'socket'
+require 'timeout'
+
+class ClientTest < MiniTest::Test
+  TEST_SERVER = 'test.mosquitto.org'
+
+  def setup
+    @client = Client.new host: TEST_SERVER
+  end
+
+  def test_mosquitto_server_is_running
+    begin
+      socket = TCPSocket.new TEST_SERVER, 1883
+      socket.close
+    rescue
+      puts "There should be a mosquitto server running to run tests."
+    end
+  end
+
+  def test_connect_and_disconnect
+    @client.connect
+    assert @client.connected?
+    @client.disconnect
+    refute @client.connected?
+  end
+
+  def test_subscribe_and_publish
+    @client.connect
+    @client.subscribe '/mini_mqtt/test'
+    @client.publish '/mini_mqtt/test', 'hi'
+    msg = @client.get_message
+    assert_equal '/mini_mqtt/test', msg.topic
+    assert_equal 'hi', msg.message
+    @client.disconnect
+  end
+
+  def test_subscribe_multiple_topics
+    @client.connect
+    @client.subscribe '/mini_mqtt/test1', '/mini_mqtt/test2'
+    @client.publish '/mini_mqtt/test1', 'message_1'
+    @client.publish '/mini_mqtt/test2', 'message_2'
+    expected = ['message_1', 'message_2']
+    @client.get_messages do |message|
+      assert_equal expected.shift, message
+      break if expected.empty?
+    end
+    @client.disconnect
+  end
+
+  def test_unsubscribe
+    @client.connect
+    @client.subscribe '/mini_mqtt/test'
+    @client.unsubscribe '/mini_mqtt/test'
+    @client.publish '/mini_mqtt/test', 'hi'
+    assert_raises(Timeout::Error) do
+      Timeout::timeout(1) do
+        @client.get_message
+      end
+    end
+    @client.disconnect
+  end
+
+  def test_retain_message
+    @client.connect
+    message_to_retain = rand.to_s
+    @client.publish '/mini_mqtt/retain', message_to_retain, retain: true
+    @client.subscribe '/mini_mqtt/retain'
+    assert_equal message_to_retain, @client.get_message.message
+    @client.disconnect
+  end
+
+  def test_clean_session
+    @client = MiniMqtt::Client.new host: TEST_SERVER, clean_session: false
+    @client.connect
+    @client.subscribe '/mini_mqtt/test'
+    @client.disconnect
+    @client.connect
+    @client.publish '/mini_mqtt/test', 'hello'
+    assert_equal 'hello', @client.get_message.message
+    @client.disconnect
+  end
+
+  def test_last_will
+    @client2 = MiniMqtt::Client.new host: TEST_SERVER
+    @client2.connect
+    @client2.subscribe 'mini_mqtt/last_will'
+    sleep 3 # wait for suback to come back
+    @client.connect will_topic: 'mini_mqtt/last_will', will_message: 'help!!'
+    # abruptly close connection by closing socket.
+    @client.instance_variable_get(:@socket).close
+    assert_equal 'help!!', @client2.get_message.message
+    @client2.disconnect
+  end
+
+  def test_last_will_with_retain
+    will_msg = rand.to_s
+    @client.connect will_topic: 'mini_mqtt/last_will_retain', will_message: will_msg,
+      will_retain: true
+    assert @client.connected?
+    @client.instance_variable_get(:@socket).close
+    @client.connect
+    @client.subscribe 'mini_mqtt/last_will_retain'
+    assert_equal will_msg, @client.get_message.message
+    @client.disconnect
+  end
+
+  def test_qos_1
+    @client.connect
+    @client.subscribe '/mini_mqtt/topic_qos' => 1
+    @client.publish '/mini_mqtt/topic_qos', 'msg', qos: 1
+    msg = @client.get_message
+    assert_equal '/mini_mqtt/topic_qos', msg.topic
+    assert_equal 'msg', msg.message
+    assert_equal 1, msg.qos
+    @client.disconnect
+  end
+end
+

data/test/connack_packet_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class ConnackPacketTest < MiniTest::Test
+  def test_decode_accepted_connection
+    packet = ConnackPacket.new
+    packet.decode "\x01\x00".to_stream
+    assert packet.session_present?
+    assert packet.accepted?
+  end
+
+  def test_decode_refused_connection
+    packet = ConnackPacket.new
+    packet.decode "\x00\x04".to_stream
+    assert_equal false, packet.session_present?
+    assert_equal false, packet.accepted?
+    assert_match(/bad username or password/, packet.error_message)
+  end
+end

data/test/connect_packet_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class ConnectPacketTest < MiniTest::Test
+  def test_encode_with_all_params
+    packet = ConnectPacket.new user: 'arman',
+                               password: 'secret',
+                               client_id: 'abc',
+                               will_message: 'I am dead',
+                               will_topic: 'last_will',
+                               will_retain: false,
+                               will_qos: 0,
+                               clean_session: true,
+                               keep_alive: 20
+    encoded = packet.encode
+    assert_equal "\x00\x04MQTT", encoded[0..5]
+    assert_equal "\x04", encoded[6]
+    assert_equal [0xc6], encoded[7].bytes
+    assert_equal "\x00\x14", encoded[8..9]
+    assert_equal "\x00\x03abc", encoded[10..14]
+    assert_equal "\x00\x09last_will", encoded[15..25]
+    assert_equal "\x00\x09I am dead", encoded[26..36]
+    assert_equal "\x00\x05arman", encoded[37..43]
+    assert_equal "\x00\x06secret", encoded[44..-1]
+  end
+end

data/test/disconnect_packet_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class DisconnectPacketTest < MiniTest::Test
+  def test_encode
+    packet = DisconnectPacket.new
+    assert_equal "", packet.encode
+  end
+
+  def test_flags
+    packet = DisconnectPacket.new
+    assert_equal 0, packet.flags
+  end
+end

data/test/packet_handler_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class TestPacketHandler < Minitest::Test
+  def setup
+    @socket = StringIO.new
+    @handler = PacketHandler.new @socket
+  end
+
+  def test_get_packet
+    @socket.write "\xd0\x00"
+    @socket.write "\xa2\x05topic"
+    @socket.rewind
+    packet = @handler.get_packet
+    assert_equal PingrespPacket, packet.class
+
+    packet = @handler.get_packet
+    assert_equal UnsubscribePacket, packet.class
+  end
+
+  def test_write_pingreq_packet
+    packet = PingreqPacket.new
+    @handler.write_packet packet
+    @socket.rewind
+    assert_equal 0xc0, @socket.readbyte # packet type and flags
+    assert_equal 0x00, @socket.readbyte # encoded length
+  end
+
+  def test_write_connect_packet
+    packet = ConnectPacket.new client_id: 'abc', keep_alive: 15
+    @handler.write_packet packet
+    @socket.rewind
+    assert_equal 0x10, @socket.readbyte # packet type and flags
+    assert_equal 0x0F, @socket.readbyte # encoded length
+    assert_equal @socket.read, packet.encode
+  end
+
+  def test_length_encoding
+    assert_equal [0x00], @handler.send(:encode_length, 0).bytes
+    assert_equal [0xc1,0x02], @handler.send(:encode_length, 321).bytes
+    assert_equal [0x80,0x80,0x01], @handler.send(:encode_length, 16384).bytes
+    assert_equal [0xff,0xff,0xff,0x7f], @handler.send(:encode_length, 268_435_455).bytes
+  end
+
+  def test_length_decoding
+    assert_equal 0, @handler.send(:decode_length, "\x00".to_stream)
+    assert_equal 321, @handler.send(:decode_length, "\xC1\x02".to_stream)
+    assert_equal 16384, @handler.send(:decode_length, "\x80\x80\x01".to_stream)
+    assert_equal 268_435_455, @handler.send(:decode_length, "\xFF\xFF\xFF\x7F".to_stream)
+    assert_raises StandardError do
+      @handler.send(:decode_length, "\xFF\xFF\xFF\xFF".to_stream)
+    end
+  end
+end

data/test/ping_packets_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class PingPacketTest < MiniTest::Test
+  def test_pingreq_packet
+    packet = PingreqPacket.new
+    assert_equal "", packet.encode
+  end
+
+  def test_pingresp_packet
+    packet = PingrespPacket.new.decode ""
+    assert packet
+  end
+end

data/test/puback_packet_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class PubackPacketTest < MiniTest::Test
+  def test_decode
+    puback = PubackPacket.new.decode "\x00\xFF".to_stream
+    assert_equal puback.packet_id, 0xFF
+  end
+
+  def test_encode
+    puback = PubackPacket.new packet_id: 9
+    assert_equal puback.encode, "\x00\x09"
+  end
+end

data/test/pubcomp_packet_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class PubcompPacketTest < MiniTest::Test
+  def test_decode
+    pubcomp = PubcompPacket.new.decode "\x00\xFF".to_stream
+    assert_equal pubcomp.packet_id, 0xFF
+  end
+
+  def test_encode
+    pubcomp = PubcompPacket.new packet_id: 9
+    assert_equal pubcomp.encode, "\x00\x09"
+  end
+end

data/test/publish_packet_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class PublishPacketTest < MiniTest::Test
+  def setup
+    @inbound_publish_1 = PublishPacket.new.decode "\x00\x03a/b\x00\x0aMessageHere".to_stream, 0b1011
+    @inbound_publish_2 = PublishPacket.new.decode "\x00\x03a/bMessageHere".to_stream, 0b0000
+    @outbound_publish_1 = PublishPacket.new topic: 'help', message: 'SOS'
+    @outbound_publish_2 = PublishPacket.new topic: 'help', message: 'SOS',
+      qos: 1, dup: true, retain: true, packet_id: 5
+  end
+
+  def test_read_flags
+    assert @inbound_publish_1.dup
+    assert @inbound_publish_1.retain
+    assert_equal 1, @inbound_publish_1.qos
+
+    refute @inbound_publish_2.dup
+    refute @inbound_publish_2.retain
+    assert_equal 0, @inbound_publish_2.qos
+  end
+
+  def test_decode_topic_and_packet_id
+    assert_equal 'a/b', @inbound_publish_1.topic
+    assert_equal 10, @inbound_publish_1.packet_id
+
+    assert_equal 'a/b', @inbound_publish_2.topic
+    assert_equal nil, @inbound_publish_2.packet_id
+  end
+
+  def test_decode_message
+    assert_equal 'MessageHere', @inbound_publish_1.message
+    assert_equal 'MessageHere', @inbound_publish_2.message
+  end
+
+  def test_encode_flags
+    assert_equal 0b0000, @outbound_publish_1.flags
+    assert_equal 0b1011, @outbound_publish_2.flags
+  end
+
+  def test_encode_message
+    assert_equal "\x00\x04helpSOS", @outbound_publish_1.encode
+    assert_equal "\x00\x04help\x00\x05SOS", @outbound_publish_2.encode
+  end
+end

data/test/pubrec_packet_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class PubrecPacketTest < MiniTest::Test
+  def test_decode
+    pubrec = PubrecPacket.new.decode "\x00\xFF".to_stream
+    assert_equal pubrec.packet_id, 0xFF
+  end
+
+  def test_encode
+    pubrec = PubrecPacket.new packet_id: 9
+    assert_equal pubrec.encode, "\x00\x09"
+  end
+end

data/test/pubrel_packet_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class PubrelPacketTest < MiniTest::Test
+  def test_decode
+    pubrel = PubrelPacket.new.decode "\x00\xFF".to_stream
+    assert_equal pubrel.packet_id, 0xFF
+  end
+
+  def test_encode_and_flags
+    pubrel = PubrelPacket.new packet_id: 9
+    assert_equal pubrel.encode, "\x00\x09"
+    assert_equal 0b0010, pubrel.flags
+  end
+
+end

data/test/suback_packet_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class SubackPacketTest < MiniTest::Test
+  def test_decode
+    packet = SubackPacket.new
+    packet.decode "\x01\x00\x01\x00\x02".to_stream
+    assert_equal 256, packet.packet_id
+    assert_equal [1, 0, 2], packet.max_qos_accepted
+  end
+end

data/test/subscribe_packet_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class SubscribePacketTest < MiniTest::Test
+  def setup
+    @packet = SubscribePacket.new topics: { 'topic1' => 0, 'topic2' => 1 }
+    @packet2 = SubscribePacket.new topics: { 'topic3' => 0 }
+  end
+
+  def test_flags
+    assert_equal 0b0010, @packet.flags
+  end
+
+  def test_packet_ids
+    @packet.encode
+    @packet2.encode
+    assert @packet.packet_id > 0
+    assert @packet2.packet_id > @packet.packet_id
+  end
+
+  def test_encode
+    @packet.packet_id = 1
+    @packet2.packet_id = 2
+    assert_equal "\x00\x01\x00\x06topic1\x00\x00\x06topic2\x01", @packet.encode
+    assert_equal "\x00\x02\x00\x06topic3\x00", @packet2.encode
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'simplecov'
+SimpleCov.start
+
+$:.unshift File.join( __FILE__, "..", "..", "lib")
+require 'pry'
+require 'mini_mqtt'
+require 'minitest/autorun'
+
+class String
+  def to_stream
+    StringIO.new self
+  end
+end
+
+class MiniTest::Test
+  include MiniMqtt
+end

data/test/unsuback_packet_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class UnsubackPacketTest < MiniTest::Test
+  def test_decode
+    packet = UnsubackPacket.new.decode "\x00\xFF".to_stream
+    assert_equal packet.packet_id, 0xFF
+  end
+end

data/test/unsubscribe_packet_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class UnsubscribePacketTest < MiniTest::Test
+  def setup
+    @packet = UnsubscribePacket.new topics: ['topic1', 'topic2']
+  end
+
+  def test_flags
+    assert_equal 0b0010, @packet.flags
+  end
+
+  def test_packet_id
+    @packet.encode
+    assert @packet.packet_id > 0
+  end
+
+  def test_encode
+    @packet.packet_id = 1
+    assert_equal "\x00\x01\x00\x06topic1\x00\x06topic2", @packet.encode
+  end
+
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: mini_mqtt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Armando Andini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: Minimalist implementation of MQTT client purely in Ruby.
+email: armando.andini@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mini_mqtt.rb
+- lib/mini_mqtt/bin_helper.rb
+- lib/mini_mqtt/client.rb
+- lib/mini_mqtt/connect_packet.rb
+- lib/mini_mqtt/packet.rb
+- lib/mini_mqtt/packet_handler.rb
+- test/client_test.rb
+- test/connack_packet_test.rb
+- test/connect_packet_test.rb
+- test/disconnect_packet_test.rb
+- test/packet_handler_test.rb
+- test/ping_packets_test.rb
+- test/puback_packet_test.rb
+- test/pubcomp_packet_test.rb
+- test/publish_packet_test.rb
+- test/pubrec_packet_test.rb
+- test/pubrel_packet_test.rb
+- test/suback_packet_test.rb
+- test/subscribe_packet_test.rb
+- test/test_helper.rb
+- test/unsuback_packet_test.rb
+- test/unsubscribe_packet_test.rb
+homepage: http://github.com/antico5/mini_mqtt
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: MQTT Client for Ruby.
+test_files:
+- test/pubcomp_packet_test.rb
+- test/disconnect_packet_test.rb
+- test/publish_packet_test.rb
+- test/ping_packets_test.rb
+- test/connack_packet_test.rb
+- test/unsubscribe_packet_test.rb
+- test/connect_packet_test.rb
+- test/test_helper.rb
+- test/subscribe_packet_test.rb
+- test/unsuback_packet_test.rb
+- test/suback_packet_test.rb
+- test/puback_packet_test.rb
+- test/client_test.rb
+- test/pubrel_packet_test.rb
+- test/pubrec_packet_test.rb
+- test/packet_handler_test.rb