mosquitto 0.2 → 0.3

data/test/test_callbacks.rb

@@ -14,7 +14,7 @@ class TestCallbacks < MosquittoTestCase
     client.on_disconnect do |rc|
       disconnected = true
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     client.wait_readable
     assert client.disconnect
     sleep 3
@@ -30,11 +30,13 @@ class TestCallbacks < MosquittoTestCase
     client.on_log do |level, msg|
       logs << msg
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
-    assert client.disconnect
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     client.wait_readable
-    assert_equal 2, logs.size
+    assert_equal 1, logs.size
     assert_match(/CONNECT/, logs[0])
+    assert client.disconnect
+    sleep 0.5
+    assert_equal 2, logs.size
     assert_match(/DISCONNECT/, logs[1])
   end
 
@@ -56,7 +58,7 @@ class TestCallbacks < MosquittoTestCase
     client.on_unsubscribe do |mid|
       unsubscribed = true
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     client.wait_readable
     assert subscribed
     assert unsubscribed
@@ -73,8 +75,9 @@ class TestCallbacks < MosquittoTestCase
     publisher.on_connect do |rc|
       publisher.publish(nil, "message_callback", "test", Mosquitto::AT_MOST_ONCE, true)
     end
-    publisher.connect(TEST_HOST, TEST_PORT, 10)
+    publisher.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     publisher.wait_readable
+
     publisher.loop_stop(true)
 
     subscriber = Mosquitto::Client.new
@@ -82,11 +85,12 @@ class TestCallbacks < MosquittoTestCase
     subscriber.on_connect do |rc|
       subscriber.subscribe(nil, "message_callback", Mosquitto::AT_MOST_ONCE)
     end
-    subscriber.connect(TEST_HOST, TEST_PORT, 10)
     subscriber.on_message do |msg|
       message = msg
     end
+    subscriber.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     subscriber.wait_readable
+
     subscriber.loop_stop(true)
     assert_equal "test", message.to_s
   end

data/test/test_client.rb

@@ -50,9 +50,9 @@ class TestClient < MosquittoTestCase
     client = Mosquitto::Client.new
     assert client.loop_start
     assert_raises TypeError do
-      client.connect(:invalid, TEST_PORT, 10)
+      client.connect(:invalid, TEST_PORT, TIMEOUT)
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
   ensure
     client.loop_stop(true)
   end
@@ -61,9 +61,9 @@ class TestClient < MosquittoTestCase
     client = Mosquitto::Client.new
     assert client.loop_start
     assert_raises TypeError do
-      client.connect_bind("localhost", TEST_PORT, 10, :invalid)
+      client.connect_bind("localhost", TEST_PORT, TIMEOUT, :invalid)
     end
-    assert client.connect_bind(TEST_HOST, TEST_PORT, 10, "0.0.0.0")
+    assert client.connect_bind(TEST_HOST, TEST_PORT, TIMEOUT, "0.0.0.0")
   ensure
     client.loop_stop(true)
   end
@@ -72,9 +72,9 @@ class TestClient < MosquittoTestCase
     client = Mosquitto::Client.new
     assert client.loop_start
     assert_raises TypeError do
-      client.connect_async(:invalid, TEST_PORT, 10)
+      client.connect_async(:invalid, TEST_PORT, TIMEOUT)
     end
-    assert client.connect_async(TEST_HOST, TEST_PORT, 10)
+    assert client.connect_async(TEST_HOST, TEST_PORT, TIMEOUT)
     client.wait_readable
     assert client.socket != -1
   ensure
@@ -85,9 +85,9 @@ class TestClient < MosquittoTestCase
     client = Mosquitto::Client.new
     assert client.loop_start
     assert_raises TypeError do
-      client.connect_bind_async(TEST_HOST, TEST_PORT, 10, :invalid)
+      client.connect_bind_async(TEST_HOST, TEST_PORT, TIMEOUT, :invalid)
     end
-    assert client.connect_bind_async(TEST_HOST, TEST_PORT, 10, '0.0.0.0')
+    assert client.connect_bind_async(TEST_HOST, TEST_PORT, TIMEOUT, '0.0.0.0')
     client.wait_readable
     assert client.socket != -1
   ensure
@@ -100,7 +100,8 @@ class TestClient < MosquittoTestCase
     assert_raises Mosquitto::Error do
       client.disconnect
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
+    client.wait_readable
     assert client.disconnect
   ensure
     client.loop_stop(true)
@@ -111,7 +112,8 @@ class TestClient < MosquittoTestCase
     assert_raises Mosquitto::Error do
       client.reconnect
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
+    client.wait_readable
     assert client.reconnect
   end
 

data/test/test_custom_logger.rb

@@ -16,9 +16,11 @@ class TestCustomLogger < MosquittoTestCase
 
     client.logger = logger
     client.loop_start
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
-    assert client.subscribe(nil, "custom_logger", Mosquitto::AT_MOST_ONCE)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     client.wait_readable
+    assert client.subscribe(nil, "custom_logger", Mosquitto::AT_MOST_ONCE)
+
+    sleep 2
 
     logs = log_dev.string
     assert_match(/DEBUG/, logs)
@@ -26,5 +28,8 @@ class TestCustomLogger < MosquittoTestCase
     assert_match(/sending SUBSCRIBE/, logs)
     assert_match(/custom_logger/, logs)
     assert_match(/Client mosq/, logs)
+
+  ensure
+    client.loop_stop(true)
   end
 end

data/test/test_integration.rb

@@ -10,6 +10,7 @@ class TestIntegration < MosquittoTestCase
   CLIENT_IDS = %w(test_integration test_lwt test_clean_session test_duplicate)
 
   def setup
+    super
     @result = nil
     @client = nil
     connected = false
@@ -22,16 +23,21 @@ class TestIntegration < MosquittoTestCase
     @client.on_message do |msg|
       @result = msg.to_s
     end
-    assert @client.connect(TEST_HOST, TEST_PORT, 10)
+    assert @client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     wait{ connected }
   end
 
   def teardown
+    super
     disconnected, connected = false, false
     @client.on_disconnect do |rc|
       disconnected = true
     end
-    @client.disconnect
+    begin
+      @client.disconnect
+    rescue Mosquitto::Error
+      disconnected = true
+    end
     wait{ disconnected }
     @client.loop_stop(true)
 
@@ -43,9 +49,13 @@ class TestIntegration < MosquittoTestCase
         disconnected = true
       end
       client.on_connect do |rc|
-        assert client.disconnect
+        begin
+          assert client.disconnect
+        rescue Mosquitto::Error
+          disconnected = true
+        end
       end
-      assert client.connect(TEST_HOST, TEST_PORT, 10)
+      assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
       wait{ disconnected }
       client.loop_stop(true)
     end
@@ -60,7 +70,7 @@ class TestIntegration < MosquittoTestCase
         assert client.publish(nil, msg.topic, "", Mosquitto::AT_LEAST_ONCE, true) 
       end
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     wait{ connected }
 
     TOPICS.each do |topic|
@@ -68,8 +78,11 @@ class TestIntegration < MosquittoTestCase
     end
 
     sleep 5
-    client.disconnect
-    client.loop_stop(true)
+    begin
+      client.disconnect
+      client.loop_stop(true)
+    rescue Mosquitto::Error
+    end
   end
 
   def test_basic
@@ -424,7 +437,7 @@ class TestIntegration < MosquittoTestCase
     assert @client.subscribe(nil, "a/+/#", Mosquitto::AT_MOST_ONCE)
     assert @client.subscribe(nil, "#", Mosquitto::AT_MOST_ONCE)
 
-    sleep 1
+    sleep 3
 
     @result = nil
     expected = "should get everything"
@@ -476,14 +489,14 @@ class TestIntegration < MosquittoTestCase
       client1.loop_stop(true)
       client2.loop_stop(true)
     end
-    client1.connect(TEST_HOST, TEST_PORT, 10)
+    client1.connect(TEST_HOST, TEST_PORT, TIMEOUT)
 
     client1.wait_readable
 
     client2 = Mosquitto::Client.new("test_duplicate")
     client2.loop_start
     client2.logger = Logger.new(STDOUT)
-    client2.connect(TEST_HOST, TEST_PORT, 10)
+    client2.connect(TEST_HOST, TEST_PORT, TIMEOUT)
 
     client2.wait_readable
 
@@ -496,7 +509,7 @@ class TestIntegration < MosquittoTestCase
     client1.logger = Logger.new(STDOUT)
     client1.loop_start
     client1.will_set("l/w/t", "This is an LWT", Mosquitto::AT_LEAST_ONCE, false)
-    client1.connect(TEST_HOST, TEST_PORT, 10)
+    client1.connect(TEST_HOST, TEST_PORT, TIMEOUT)
 
     assert client1.subscribe(nil, "a/b/c", Mosquitto::AT_LEAST_ONCE)
 
@@ -507,7 +520,7 @@ class TestIntegration < MosquittoTestCase
 
     client1.on_disconnect do |rc|
       assert @client.publish(nil, "a/b/c", expected, Mosquitto::AT_LEAST_ONCE, false)
-      client1.connect(TEST_HOST, TEST_PORT, 10)
+      client1.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     end
 
     client1.disconnect
@@ -515,6 +528,7 @@ class TestIntegration < MosquittoTestCase
     sleep 1
 
     assert_nil @result
+    client1.loop_stop(true)
   end
 
   def test_retain
@@ -532,7 +546,7 @@ class TestIntegration < MosquittoTestCase
     client1.on_message do |msg|
       result = msg.to_s
     end
-    client1.connect(TEST_HOST, TEST_PORT, 10)
+    client1.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     client1.wait_readable
 
     assert client1.subscribe(nil, "a/b/c", Mosquitto::AT_LEAST_ONCE)
@@ -547,25 +561,37 @@ class TestIntegration < MosquittoTestCase
     result = nil
     # clear retained message
     assert @client.publish(nil, "a/b/c", "", Mosquitto::AT_LEAST_ONCE, true)
+
+    client1.loop_stop(true)
   end
 
   def test_lwt
-    assert @client.subscribe(nil, "will/topic", Mosquitto::AT_MOST_ONCE)
+    connected = false
+    assert @client.subscribe(nil, "will/topic", Mosquitto::AT_LEAST_ONCE)
+
+    sleep 1
 
     will = "This is an LWT"
     client1 = Mosquitto::Client.new("test_lwt")
     client1.logger = Logger.new(STDOUT)
     client1.loop_start
+    sleep 1
     client1.will_set("will/topic", will, Mosquitto::AT_LEAST_ONCE, false)
+    sleep 1
     client1.on_connect do |rc|
-      client1.disconnect
-      client1.loop_stop(true)
+      connected = true
     end
-    client1.connect(TEST_HOST, TEST_PORT, 10)
+    client1.connect(TEST_HOST, TEST_PORT, TIMEOUT)
 
-    client1.wait_readable
+    wait{ connected }
+
+    sleep 5
+
+    IO.for_fd(client1.socket).close
+    client1.destroy
+
+    sleep 5
 
-    @result = nil
     wait{ @result }
     assert_equal will, @result
   end

data/test/test_loops.rb

@@ -5,11 +5,13 @@ require File.join(File.dirname(__FILE__), 'helper')
 class TestLoops < MosquittoTestCase
   def test_socket
     client = Mosquitto::Client.new
+    client.loop_start
     assert_equal(-1, client.socket)
     assert client.socket == -1
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
-    assert_instance_of Fixnum, client.socket
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     client.wait_readable
+
+    assert_instance_of Fixnum, client.socket
     assert client.socket != -1
   end
 
@@ -18,15 +20,17 @@ class TestLoops < MosquittoTestCase
     assert_raises Mosquitto::Error do
       client.loop(10,10)
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
-    assert client.publish(nil, "loop", "test", Mosquitto::AT_MOST_ONCE, true)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
     assert client.loop(10,10)
+    client.wait_readable
+
+    assert client.publish(nil, "loop", "test", Mosquitto::AT_MOST_ONCE, true)
   end
 
   def test_loop_forever
     connected = false
+    client = Mosquitto::Client.new
     Thread.new do
-      client = Mosquitto::Client.new
       client.on_connect do |rc|
         connected = true
         Thread.current.kill
@@ -34,23 +38,31 @@ class TestLoops < MosquittoTestCase
       assert_raises TypeError do
         client.loop_forever(:invalid,1)
       end
-      assert client.connect(TEST_HOST, 1883, 10)
+      assert client.connect(TEST_HOST, 1883, TIMEOUT)
+
       assert client.loop_forever(-1,1)
-    end.join(1)
+    end.join(2)
+    client.wait_readable
     assert connected
   end
 
   def test_loop_stop_start
     client = Mosquitto::Client.new
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
-    assert client.publish(nil, "loop_stop_start", "test", Mosquitto::AT_MOST_ONCE, true)
     assert client.loop_start
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
+    client.wait_readable
+
+    assert client.publish(nil, "loop_stop_start", "test", Mosquitto::AT_MOST_ONCE, true)
+    sleep 1
     assert client.loop_stop(true)
   end
 
   def test_want_write_p
     client = Mosquitto::Client.new
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    client.loop_start
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
+    client.wait_readable
+
     assert !client.want_write?
   end
 end

data/test/test_mosquitto.rb

@@ -4,7 +4,7 @@ require File.join(File.dirname(__FILE__), 'helper')
 
 class TestMosquitto < MosquittoTestCase
   def test_version
-    assert_equal 1002003, Mosquitto.version
+    assert_equal 1003001, Mosquitto.version
   end
 
   def test_constants

data/test/test_pub_sub.rb

@@ -5,10 +5,13 @@ require File.join(File.dirname(__FILE__), 'helper')
 class TestPubSub < MosquittoTestCase
   def test_publish
     client = Mosquitto::Client.new
+    client.loop_start
     assert_raises Mosquitto::Error do
       client.publish(nil, "publish", "test", Mosquitto::AT_MOST_ONCE, true)
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
+    client.wait_readable
+
     assert_raises TypeError do
       client.publish(nil, :invalid, "test", Mosquitto::AT_MOST_ONCE, true)
     end
@@ -18,33 +21,44 @@ class TestPubSub < MosquittoTestCase
 
   def test_subscribe
     client = Mosquitto::Client.new
+    client.loop_start
     assert_raises Mosquitto::Error do
       client.subscribe(nil, "subscribe", Mosquitto::AT_MOST_ONCE)
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
+    client.wait_readable
+
     assert_raises TypeError do
       client.subscribe(nil, :topic, Mosquitto::AT_MOST_ONCE)
     end
+
     assert client.subscribe(nil, "subscribe", Mosquitto::AT_MOST_ONCE)
     assert client.subscribe(3, "subscribe", Mosquitto::AT_MOST_ONCE)
   end
 
   def test_unsubscribe
     client = Mosquitto::Client.new
+    client.loop_start
     assert_raises Mosquitto::Error do
       client.unsubscribe(nil, "unsubscribe")
     end
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
+    client.wait_readable
+
     assert_raises TypeError do
       client.unsubscribe(nil, :topic)
     end
+
     assert client.unsubscribe(nil, "unsubscribe")
     assert client.unsubscribe(3, "unsubscribe")
   end
 
   def test_subscribe_unsubscribe
     client = Mosquitto::Client.new
-    assert client.connect(TEST_HOST, TEST_PORT, 10)
+    client.loop_start
+    assert client.connect(TEST_HOST, TEST_PORT, TIMEOUT)
+    client.wait_readable
+
     assert client.subscribe(nil, "subscribe_unsubscribe", Mosquitto::AT_MOST_ONCE)
     assert client.unsubscribe(nil, "subscribe_unsubscribe")
   end