klomp 0.0.8 → 1.0.0

data/spec/klomp/connection_spec.rb

@@ -0,0 +1,329 @@
+require 'spec_helper'
+
+describe Klomp::Connection do
+
+  Given(:data)       { frame(:connected) }
+  Given(:server)     { "127.0.0.1:61613" }
+  Given(:options)    { { "login" => "admin", "passcode" => "password", "logger" => logger } }
+  Given(:socket)     { double(TCPSocket, gets:data, write:nil, set_encoding:nil, close:nil) }
+  Given(:logger)     { double("Logger", error:nil, warn:nil, info:nil, debug:nil).as_null_object }
+  Given(:subscriber) { double "subscriber", call:nil }
+  Given(:thread)     { double Thread }
+
+  Given do
+    IO.stub!(:select).and_return([[socket], [socket]])
+    TCPSocket.stub!(:new).and_return socket
+    Thread.stub!(:new).and_return {|*args,&blk| thread.stub!(:block => blk); thread }
+    Klomp::Sentinel.stub!(new: double("sentinel"))
+  end
+
+  context "new" do
+
+    When { Klomp::Connection.new server, options }
+
+    Then do
+      socket.should have_received(:set_encoding).with('UTF-8').ordered
+      socket.should have_received(:write).with(frame(:connect)).ordered
+      socket.should have_received(:gets).with("\x00").ordered
+    end
+
+  end
+
+  context "new with vhost" do
+
+    Given(:server) { "virtual-host:127.0.0.1:61613" }
+
+    When { Klomp::Connection.new server, options }
+
+    Then do
+      TCPSocket.should have_received(:new).with("127.0.0.1", 61613)
+      socket.should have_received(:write).with(frame(:connect_vhost)).ordered
+    end
+
+  end
+
+  context "new with stomp:// URL" do
+
+    Given(:server) { "stomp://admin:password@127.0.0.1:61613?host=virtual-host" }
+    Given(:options) { {} }
+
+    When { Klomp::Connection.new server, options }
+
+    Then do
+      TCPSocket.should have_received(:new).with("127.0.0.1", 61613)
+      socket.should have_received(:write).with(frame(:connect_vhost)).ordered
+    end
+
+  end
+
+  context "new with connection error" do
+
+    Given(:data) { frame(:auth_error) }
+
+    When(:expect_connect) { expect { Klomp::Connection.new server, options } }
+
+    Then { expect_connect.to raise_error(Klomp::Error) }
+  end
+
+  context "publish" do
+
+    Given(:connection) { Klomp::Connection.new server, options }
+
+    When { connection.publish "/queue/greeting", "hello" }
+
+    Then { socket.should have_received(:write).with(frame(:greeting)) }
+
+    context "logs when logger level is debug" do
+
+      Given(:logger) { double("Logger").as_null_object.tap {|l| l.stub!(debug?: true) } }
+
+      Then { logger.should have_received(:debug) }
+
+    end
+
+  end
+
+  context "subscribe" do
+
+    Given!(:connection) { Klomp::Connection.new server, options }
+
+    context "writes the subscribe message" do
+
+      When { connection.subscribe "/queue/greeting", subscriber }
+
+      Then { socket.should have_received(:write).with(frame(:subscribe)) }
+
+      context "and logs when logger level is debug" do
+
+        Given(:logger) { double("Logger").as_null_object.tap {|l| l.stub!(debug?: true) } }
+
+        Then { logger.should have_received(:debug) }
+
+      end
+
+    end
+
+    context "called twice writes to the socket only once" do
+
+      When do
+        connection.subscribe "/queue/greeting", subscriber
+        connection.subscribe "/queue/greeting", double("another subscriber that replaces the first", call:nil)
+      end
+
+      Then { socket.should have_received(:write).with(frame(:subscribe)).once }
+
+    end
+
+    context "and accepts a block as the subscriber" do
+
+      When { connection.subscribe("/queue/foo") { true } }
+
+      Then { connection.subscriptions["/queue/foo"].call.should == true }
+
+    end
+
+    context "and accepts an object that responds to #call as the subscriber" do
+
+      When { connection.subscribe("/queue/foo", subscriber) }
+
+      Then { connection.subscriptions["/queue/foo"].should == subscriber }
+
+    end
+
+    context "and dispatches to the message callback" do
+
+      When do
+        connection.subscribe "/queue/greeting", subscriber
+        socket.stub!(:gets).and_return frame(:message)
+        connection.send :close!
+        thread.block.call
+      end
+
+      Then do
+        subscriber.should have_received(:call).with(an_instance_of(Klomp::Frames::Message))
+      end
+
+    end
+
+    context "does not dispatch if an error frame was read" do
+
+      When do
+        connection.subscribe "/queue/greeting", subscriber
+        socket.stub!(:gets).and_return frame(:error)
+        connection.send :close!
+        thread.block.call
+      end
+
+      Then { subscriber.should_not have_received(:call) }
+
+      Then { logger.should have_received(:warn) }
+
+    end
+
+    context "fails if neither a subscriber nor a block is given" do
+
+      When(:expect_subscribe) { expect { connection.subscribe("/queue/greeting") } }
+
+      Then { expect_subscribe.to raise_error(Klomp::Error) }
+
+    end
+
+    context "fails if the subscriber does not respond to #call" do
+
+      When(:expect_subscribe) { expect { connection.subscribe("/queue/greeting", double("subscriber")) } }
+
+      Then { expect_subscribe.to raise_error(Klomp::Error) }
+
+    end
+
+    context "subscriptions" do
+
+      context "is not empty after subscribing" do
+
+        When { connection.subscribe("/queue/greeting") { true } }
+
+        Then { connection.subscriptions.length.should == 1 }
+
+        context "and empty after unsubscribing" do
+
+          When { connection.unsubscribe("/queue/greeting") }
+
+          Then { connection.subscriptions.length.should == 0 }
+
+        end
+
+      end
+
+    end
+
+  end
+
+  context "unsubscribe" do
+
+    Given(:connection) { Klomp::Connection.new server, options }
+
+    Given { connection.subscriptions["/queue/greeting"] = double "subscribers" }
+
+    When { connection.unsubscribe "/queue/greeting" }
+
+    Then { socket.should have_received(:write).with(frame(:unsubscribe)) }
+
+  end
+
+  context "disconnect" do
+
+    Given!(:connection) { Klomp::Connection.new server, options }
+
+    When { connection.disconnect }
+
+    Then do
+      socket.should have_received(:write).with(frame(:disconnect))
+      socket.should have_received(:close)
+    end
+
+    context "makes connection useless (raises error)" do
+
+      Then { expect { connection.publish "/queue/greeting", "hello" }.to raise_error(Klomp::Error) }
+
+    end
+
+  end
+
+  context "socket error on write causes connection to be disconnected" do
+
+    Given!(:connection) { Klomp::Connection.new server, options }
+    Given do
+      socket.stub!(:write).and_raise SystemCallError.new("some socket error")
+    end
+
+    When(:expect_publish) { expect { connection.publish "/queue/greeting", "hello" } }
+
+    Then do
+      expect_publish.to raise_error(SystemCallError)
+      connection.should_not be_connected
+    end
+
+    context "and subsequent calls raise Klomp::Error" do
+
+      Then do
+        expect_publish.to raise_error(SystemCallError)
+        expect_publish.to raise_error(Klomp::Error)
+      end
+
+    end
+
+    context "and starts reconnect sentinel" do
+
+      Then do
+        expect_publish.to raise_error(SystemCallError)
+        Klomp::Sentinel.should have_received(:new).with(connection)
+      end
+
+    end
+
+  end
+
+  context "socket error on read causes connection to be disconnected" do
+
+    Given!(:connection) { Klomp::Connection.new server, options }
+
+    Given do
+      thread.stub!(:raise).and_return {|e| raise e }
+      socket.stub!(:gets).and_raise SystemCallError.new("some socket error")
+    end
+
+    When do
+      connection.subscribe "/queue/greeting", subscriber
+      thread.block.call
+    end
+
+    Then { connection.should_not be_connected }
+
+  end
+
+  context "reconnect" do
+
+    Given!(:connection) { Klomp::Connection.new server, options }
+
+    context "creates new socket" do
+
+      Given { connection.disconnect }
+
+      When { connection.reconnect }
+
+      Then { connection.should be_connected }
+
+      Then { logger.should have_received(:warn) }
+
+    end
+
+    context "has no effect if connection is already connected" do
+
+      Given { socket.messages_received.clear }
+
+      When { connection.reconnect }
+
+      Then { connection.should be_connected }
+
+      Then { socket.should_not have_received(:write) }
+
+    end
+
+    context "re-subscribes all subscriptions" do
+
+      Given do
+        connection.subscribe "/queue/greeting", subscriber
+        thread.stub!(:raise)
+        connection.disconnect
+        socket.messages_received.clear
+      end
+
+      When { connection.reconnect }
+
+      Then { socket.should have_received(:write).with(frame(:subscribe)) }
+
+    end
+
+  end
+
+end

data/spec/klomp/frames_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Klomp::Frames do
+
+  context "CONNECT" do
+
+    Given(:options) { {'login' => 'admin', 'passcode' => 'password', 'host' => '127.0.0.1'} }
+
+    When(:connect) { Klomp::Frames::Connect.new(options).to_s }
+
+    Then { connect.should == frame(:connect) }
+
+  end
+
+  context "CONNECTED" do
+
+    When(:connected) { Klomp::Frames::Connected.new frame(:connected) }
+
+    Then { connected.headers['version'].should == "1.1" }
+
+  end
+
+end

data/spec/klomp/sentinel_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Klomp::Sentinel do
+
+  Given(:connection) { double "Connection", connected?:false, reconnect:nil }
+  Given(:sentinel) { Klomp::Sentinel.new connection }
+  Given(:thread) { double Thread }
+  Given do
+    Thread.stub!(:new).and_return {|*args,&blk| thread.stub!(:block => blk); thread }
+  end
+
+  context "does nothing if the connection is already connected" do
+
+    Given { connection.stub!(connected?: true) }
+
+    When { sentinel }
+
+    Then { Thread.should_not have_received(:new) }
+
+  end
+
+  context "reconnects the connection" do
+
+    When { sentinel ; thread.block.call }
+
+    Then { connection.should have_received(:reconnect) }
+
+  end
+
+  context "does fibonacci backoff if reconnection fails" do
+
+    Given(:number_of_reconnects) { 7 }
+    Given do
+      count = 0
+      connection.stub!(:reconnect).and_return { count += 1; raise Klomp::Error if count < number_of_reconnects }
+    end
+
+    When do
+      sentinel.stub!(:sleep)
+      thread.block.call
+    end
+
+    Then do
+      connection.should have_received(:reconnect).exactly(number_of_reconnects).times
+    end
+
+    Then do
+      sentinel.should have_received(:sleep).with(1).twice
+      sentinel.should have_received(:sleep).with(2)
+      sentinel.should have_received(:sleep).with(3)
+      sentinel.should have_received(:sleep).with(5)
+      sentinel.should have_received(:sleep).with(8)
+    end
+
+  end
+
+end

data/spec/klomp_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Klomp do
+
+  Given(:servers) { ["127.0.0.1:61613", "127.0.0.1:67673"] }
+  Given(:connections) { Hash[*servers.map {|s| [s, double("connection #{s}")] }.flatten] }
+  Given { Klomp::Connection.stub!(:new).and_return {|s| connections[s] } }
+  Given(:klomp) { Klomp.new servers }
+
+  context "new" do
+
+    context "raises ArgumentError" do
+
+      context "when created with no arguments" do
+
+        When(:expect_new) { expect { Klomp.new } }
+
+        Then { expect_new.to raise_error(ArgumentError) }
+
+      end
+
+      context "when created with an empty array" do
+
+        When(:expect_new) { expect { Klomp.new([]) } }
+
+        Then { expect_new.to raise_error(ArgumentError) }
+
+      end
+
+    end
+
+    context "creates a Klomp::Connection for each server" do
+
+      Given { Klomp::Connection.stub!(:new).and_return double(Klomp::Connection) }
+
+      When(:klomp) { Klomp.new servers }
+
+      Then { servers.each {|s| Klomp::Connection.should have_received(:new).with(s, {}) } }
+
+    end
+
+  end
+
+  context "publish" do
+
+    context "calls publish on one of the connections" do
+
+      Given do
+        connections.values.each do |conn|
+          conn.stub!(:connected? => false)
+          conn.stub!(:publish).and_return { conn.stub!(:connected? => true) }
+        end
+      end
+
+      When { klomp.publish "/queue/greeting", "hello" }
+
+      Then { connections.values.select {|conn| conn.connected? }.length.should == 1 }
+
+      Then { connections.values.detect {|conn| conn.connected? }.
+        should have_received(:publish).with("/queue/greeting", "hello", {}) }
+
+    end
+
+    context "calls publish on another connection if the first one fails" do
+
+      Given do
+        first_exception = false
+        connections.values.each do |conn|
+          conn.stub!(:connected? => false)
+          conn.stub!(:publish).and_return do
+            if first_exception
+              conn.stub!(:connected? => true)
+            else
+              first_exception = true
+              raise Klomp::Error.new
+            end
+          end
+        end
+      end
+
+      When { klomp.publish "/queue/greeting", "hello" }
+
+      Then { connections.values.select {|conn| conn.connected? }.length.should == 1 }
+
+      Then { connections.values.detect {|conn| conn.connected? }.
+        should have_received(:publish).with("/queue/greeting", "hello", {}) }
+
+    end
+
+    context "raises an exception if all connections failed" do
+
+      Given { connections.values.each {|conn| conn.stub!(:publish).and_raise(Klomp::Error.new) } }
+
+      When(:expect_publish) { expect { klomp.publish "/queue/greeting", "hello" } }
+
+      Then do
+        expect_publish.to raise_error(Klomp::Error)
+        connections.values.each {|conn| conn.should have_received(:publish) }
+      end
+
+    end
+
+  end
+
+  context "subscribe" do
+
+    context "calls subscribe on all of the servers" do
+
+      Given { connections.values.each {|conn| conn.stub!(:subscribe) } }
+
+      When { klomp.subscribe("/queue/greeting") { true } }
+
+      Then { connections.values.each {|conn| conn.should have_received(:subscribe).with("/queue/greeting", nil) } }
+
+    end
+
+    context "fails if any subscribe calls fail" do
+
+      Given { connections.values.each {|conn| conn.stub!(:subscribe).and_raise(Klomp::Error.new) } }
+
+      When(:expect_publish) { expect { klomp.subscribe("/queue/greeting") { true } } }
+
+      Then { expect_publish.to raise_error(Klomp::Error) }
+
+    end
+
+  end
+
+  context "unsubscribe" do
+
+    context "calls unsubscribe on all the servers" do
+
+      Given { connections.values.each {|conn| conn.stub!(:unsubscribe) } }
+
+      When { klomp.unsubscribe("/queue/greeting") }
+
+      Then { connections.values.each {|conn| conn.should have_received(:unsubscribe).with("/queue/greeting") } }
+
+    end
+
+    context "calls unsubscribe on all the servers even if the unsubscribe errs" do
+
+      Given { connections.values.each {|conn| conn.stub!(:unsubscribe).and_raise Klomp::Error.new } }
+
+      When { klomp.unsubscribe("/queue/greeting") }
+
+      Then { connections.values.each {|conn| conn.should have_received(:unsubscribe).with("/queue/greeting") } }
+
+    end
+
+  end
+
+  context "disconnect" do
+
+    context "disconnects all the servers" do
+
+      Given { connections.values.each {|conn| conn.stub!(:disconnect) } }
+
+      When { klomp.disconnect }
+
+      Then { connections.values.each {|conn| conn.should have_received(:disconnect) } }
+
+    end
+
+  end
+
+end