mbus 1.0.0

data/spec/messagebus/dottable_hash_spec.rb

@@ -0,0 +1,137 @@
+require 'messagebus/dottable_hash'
+
+describe Messagebus::DottableHash do
+  let (:dottable_hash) { Messagebus::DottableHash.new }
+
+  it "is a wrapper of Hash" do
+    Messagebus::DottableHash.ancestors.should include(Hash)
+  end
+
+  it "optionally takes a hash in the constructor" do
+    Messagebus::DottableHash.new({:this => "works"})
+  end
+
+  it "allows dot assignment" do
+    dottable_hash.foo = "bar"
+    dottable_hash.should == {"foo" => "bar"}
+  end
+
+  it "allows dot access" do
+    dottable_hash.foo = "baz"
+    dottable_hash.foo.should == "baz"
+  end
+
+  it "allows bracket assignment with a String key" do
+    dottable_hash["merica"] = "the free"
+    dottable_hash.should == {"merica" => "the free"}
+  end
+
+  it "allows bracket access with a String key" do
+    dottable_hash["foo"] = "hey"
+    dottable_hash["foo"].should == "hey"
+  end
+
+  it "allows bracket assignment with a Symbol key" do
+    dottable_hash[:patrick] = "gombert"
+    dottable_hash.should == {"patrick" => "gombert"}
+  end
+
+  it "allows bracket access with a Symbol key" do
+    dottable_hash[:patrick] = "gombert"
+    dottable_hash[:patrick].should == "gombert"
+  end
+
+  it "converts keys for Hashes upon bracket assignment" do
+    dottable_hash[:dave] = {:surname => {:original => "moore"}}
+    dottable_hash.dave.surname.original.should == "moore"
+  end
+
+  it "remains dottable after merging a plain ruby Hash" do
+    dottable_hash.merge!({:some => "plain old hash"})
+    dottable_hash.some.should == "plain old hash"
+  end
+
+  it "converts all keys in nested Hashes of any depth" do
+    dottable_hash.merge!({:some => {:plain => {:old => "hash"}}})
+    dottable_hash.should == {"some" => {"plain" => {"old" => "hash"}}}
+  end
+
+  it "converts all keys nested in an Array to Strings" do
+    dottable_hash.merge!({:some => [{:plain => "old hash"}]})
+    dottable_hash.should == {"some" => [{"plain" => "old hash"}]}
+  end
+
+  it "converts all keys in nested Arrays of any depth" do
+    dottable_hash.merge!({:some => [[{:plain => "old hash"}], "foo"]})
+    dottable_hash.should == {"some" => [[{"plain" => "old hash"}], "foo"]}
+  end
+
+  it "ignores elements which are not Hashes or Arrays" do
+    dottable_hash.merge!({:some => [{:plain => "old hash"}, "foo"]})
+    dottable_hash.should == {"some" => [{"plain" => "old hash"}, "foo"]}
+  end
+
+  it "makes deeply-nested hash structures dottable upon initialization" do
+    dottable_hash = Messagebus::DottableHash.new({:some => {:plain => {:old => "hash"}}})
+    dottable_hash.some.plain.old.should == "hash"
+  end
+
+  it "makes deeply Array-nested Hash structures dottable upon initialization" do
+    dottable_hash = Messagebus::DottableHash.new({:some => [[{:plain => "old hash"}]]})
+    dottable_hash.some[0][0].plain.should == "old hash"
+  end
+
+  it "#replace converts a plain old ruby hash to a dottable hash" do
+    replacement = {:dave => {:moore => "awesome"}}
+    result = Messagebus::DottableHash.new({ "foo" => "bar" }).replace(replacement)
+    result.dave.moore.should == "awesome"
+    result.has_key?("foo").should == false
+  end
+
+  it "#update converts a plain old ruby hash to a dottable hash" do
+    result = Messagebus::DottableHash.new({ "foo" => "bar" }).update({:something => :else})
+    result.should == {"something" => :else, "foo" => "bar"}
+  end
+
+  it "#merge converts a plain old ruby hash to a dottable hash" do
+    result = Messagebus::DottableHash.new({ "foo" => "bar" }).merge({:something => :else})
+    result.should == {"something" => :else, "foo" => "bar"}
+  end
+
+  it "#delete accepts Symbol as an argument" do
+    dottable_hash["foo"] = { "bar" => "bar", "baz" => "baz" }
+    dottable_hash.foo.delete(:bar)
+    dottable_hash.should == { "foo" => { "baz" => "baz" } }
+  end
+
+  it "#has_key? accepts Symbol as an argument" do
+    Messagebus::DottableHash.new({ "foo" => "bar" }).has_key?(:foo).should == true
+  end
+
+  it "#key? accepts a Symbol as an argument" do
+    Messagebus::DottableHash.new({ "foo" => "bar" }).key?(:foo).should == true
+  end
+
+  it "#fetch accepts a Symbol as an argument" do
+    Messagebus::DottableHash.new({ "foo" => "bar" }).fetch(:foo).should == "bar"
+  end
+
+  it "#include? accepts a Symbol as an argument" do
+    Messagebus::DottableHash.new({ "foo" => "bar" }).include?(:foo).should == true
+  end
+
+  it "#store accepts a Symbol as an argument" do
+    hash = Messagebus::DottableHash.new({ "foo" => "bar" })
+    hash.store(:bears, "scare me")
+    hash.bears.should == "scare me"
+  end
+
+  it "#values_at accepts Symbols as arguments" do
+    dottable_hash.merge({ "foo" => "bar", "zen" => "cool", "hey" => "now" })
+    dottable_hash.values_at(:foo, :zen).should =~ ["bar", "cool"]
+  end
+
+  it "#respond_to? returns true for everything" do
+    dottable_hash.respond_to?(:whatever).should == true
+  end
+end

data/spec/messagebus/message_spec.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Messagebus::Message do
+  describe "when checking non-ascii payload" do
+    describe "when checking conversions" do
+      before(:each) do
+        @msg_string_data1 = 'am – 5:00 pm,'
+        @gb2312_string = "\xC4\xE3\xBA\xC3"
+        @msg_string_data2 = 'ASCII String'
+        @msg_json_object = {:a=> '1', :b => {:x => 'Thorbjørn am – 5:00 pm,'}}
+        @msg_binary_data = "\xE5\xA5\xBD"
+      end
+      
+      it "check non-ascii string" do
+        message = Messagebus::Message.create(@msg_string_data1)
+        message2 = Messagebus::Message.get_message_from_thrift_binary(message.to_thrift_binary)
+        @msg_string_data1.bytes.to_a.should == message2.payload.bytes.to_a
+      end
+      
+      it "check ASCII string" do
+        if RUBY_VERSION.to_f >= 1.9
+          @msg_string_data2.force_encoding("ASCII")
+        end
+        message = Messagebus::Message.create(@msg_string_data2)
+        message2 = Messagebus::Message.get_message_from_thrift_binary(message.to_thrift_binary)
+        @msg_string_data2.bytes.to_a.should == message2.payload.bytes.to_a
+        
+      end
+
+      it "check gb2312 string" do
+        if RUBY_VERSION.to_f >= 1.9
+          @gb2312_string.force_encoding("GB2312")
+        end
+        message = Messagebus::Message.create(@gb2312_string)
+        message2 = Messagebus::Message.get_message_from_thrift_binary(message.to_thrift_binary)
+        @gb2312_string.bytes.to_a.should == message2.payload.bytes.to_a
+      end
+
+      it "check json thrift conversions" do
+        message = Messagebus::Message.create(@msg_json_object)
+        message2 = Messagebus::Message.get_message_from_thrift_binary(message.to_thrift_binary)
+        json_string = @msg_json_object.to_json
+        json_string.bytes.to_a.should == message2.payload.bytes.to_a
+      end
+
+      it "check binary thrift equality" do
+        message = Messagebus::Message.create(@msg_binary_data, nil, true)
+        message2 = Messagebus::Message.get_message_from_thrift_binary(message.to_thrift_binary)
+        @msg_binary_data.bytes.to_a == message2.payload.bytes.to_a
+        
+      end       
+
+      it "check message id are unique" do
+        message_ids = Set.new
+        (1..100).each do |i|
+          message = Messagebus::Message.create(@msg_binary_data)
+          message_ids.include?(message.message_id).should == false
+          message_ids.add(message.message_id)
+        end  
+      end
+    end
+  end
+  describe "#create" do
+    describe "with a hash" do
+      it "returns a message of json type" do
+        Messagebus::Message.create({:benjamin => :franklins}).
+          raw_message.payload.should be_json
+      end
+    end
+
+    describe "with an object that responds to to_json" do
+      it "returns a message of json type" do
+        Messagebus::Message.create(Object.new).
+          raw_message.payload.should be_json
+      end
+    end
+
+    describe "with a binary string and binary arg" do
+      it "returns a message of binary type" do
+        Messagebus::Message.create("\xE5", nil, true).
+          raw_message.payload.should be_binary
+      end
+    end
+
+    describe "with a string" do
+      it "returns a message of string type" do
+        Messagebus::Message.create("benjamins").
+          raw_message.payload.should be_string
+      end
+    end
+  end
+end

data/spec/messagebus/producer_spec.rb

@@ -0,0 +1,147 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Messagebus::Producer do
+  def start_test_producer(host_params, fake_stomp=stub(), options = {})
+    producer = Messagebus::Producer.new(host_params, options)
+    producer.stub!(:check_and_refresh_connection)
+    producer.should_receive(:start_server).with(host_params, "", "").and_return(fake_stomp)
+
+    producer
+  end
+
+  def test_publish_message(message, options={})
+    thrift_base64 = message.to_thrift_binary
+
+    fake_stomp = mock(Stomp::Client)
+    header_options = {}
+    if options[:header_options]
+      header_options = options[:header_options]
+    end
+
+    expected_header_options = header_options.merge(Messagebus::Producer::PUBLISH_HEADERS)
+
+    if options[:receipt]
+      receipt = stub(Stomp::Message)
+      receipt.should_receive(:command).and_return('RECEIPT')
+      fake_stomp.should_receive(:publish).with('jms.queue.testqueue', thrift_base64, expected_header_options).and_yield(receipt)
+    else
+      fake_stomp.should_receive(:publish).with('jms.queue.testqueue', thrift_base64, expected_header_options)
+    end
+
+    producer = start_test_producer(['localhost:61613'], fake_stomp, options)
+    # Start the producer.
+    producer.start
+
+    # Try publishing a simple string message.
+    producer.publish('jms.queue.testqueue', message, options[:header_options] || {}, options[:safe])
+
+    # also asserts that we can recreate the message from binary string receive.
+    message2 = Messagebus::Message.get_message_from_thrift_binary(thrift_base64)
+  end
+
+  before(:each) do
+    @msg_string_data1 = 'test data'
+
+    logger = mock(Logger, :info => true, :warn => true, :debug => true)
+    Messagebus::Client.stub!(:logger).and_return(logger)
+  end
+
+  describe "when starting a producer with multiple hosts" do
+    before do
+      @hosts = ["localhost:61613"]
+      @stomp = mock(Stomp)
+    end
+
+    it "starts a stomp server with multiple hosts" do
+      producer = Messagebus::Producer.new(@hosts)
+      producer.stub!(:refresh_server)
+      producer.should_receive(:start_server).with(@hosts, "", "").and_return(@stomp)
+      producer.start
+    end
+
+    it "starts a stomp server with one host" do
+      producer = Messagebus::Producer.new(@hosts.first)
+      producer.stub!(:refresh_server)
+      producer.should_receive(:start_server).with(@hosts, "", "").and_return(@stomp)
+      producer.start
+    end
+  end  
+
+  describe "publish" do
+    it "check publish() with string message." do 
+      message = Messagebus::Message.create(@msg_string_data1)
+      message2 = test_publish_message(message)
+      @msg_string_data1.should == message2.payload
+    end
+    
+    it "check publish() with json message" do
+      msg_json_object = {:a => '1', :b => {:x => '2'}}
+
+      message = Messagebus::Message.create(msg_json_object)
+      message2 = test_publish_message(message)
+      json_string = msg_json_object.to_json
+      json_string.should == message2.payload
+    end  
+    
+    it "check publish() with binary message" do
+      msg_binary_data = "\xE5\xA5\xBD"
+
+      message = Messagebus::Message.create(msg_binary_data, nil, true)
+      message2 = test_publish_message(message)
+      msg_binary_data.should == message2.payload
+    end 
+
+    context "deprecated dest_type parameter" do
+      before do
+        @fake_stomp = mock(Stomp::Client)
+        @producer = start_test_producer(['localhost:61613'], @fake_stomp)
+        @producer.start
+
+        @message = Messagebus::Message.create(@msg_string_data1)
+      end
+
+      it "supports not passing dest_type" do
+        @fake_stomp.should_receive(:publish).and_yield(stub.as_null_object)
+        @producer.publish('jms.queue.testqueue', @message)
+      end
+
+      it "supports 5 args with dest_type passed" do
+        @fake_stomp.should_receive(:publish).and_yield(stub.as_null_object)
+        @producer.publish('jms.queue.testqueue', 'topic', @message, {}, true)
+      end
+
+      it "supports 3 args with dest_type passed" do
+        @fake_stomp.should_receive(:publish).and_yield(stub.as_null_object)
+        @producer.publish('jms.queue.testqueue', 'topic', @message)
+      end
+    end
+  end
+  
+  it "check publishSafe() with string message fail with timeout." do  
+    message = Messagebus::Message.create(@msg_string_data1)
+
+    # Try publishing a simple string message, it should fail with timeout error.
+    Messagebus::Client.logger.should_receive(:error).with(/timeout while waiting for receipt/).twice
+    message2 = test_publish_message(message, :safe => true, :receipt_wait_timeout_ms => 250, :logger => @logger)
+  end 
+
+  it "check publishSafe() with string message" do  
+    message = Messagebus::Message.create(@msg_string_data1)
+    message2 = test_publish_message(message, :safe=>true, :receipt=>true, :receipt_wait_timeout_ms => 250)
+    @msg_string_data1.should == message2.payload
+  end    
+  
+  it "check publishSafe() with string message and scheduled message header" do  
+    message = Messagebus::Message.create(@msg_string_data1)
+    message2 = test_publish_message(message, :safe=>true, :receipt=>true, :receipt_wait_timeout_ms => 250, 
+      :header_options => {Messagebus::Producer::SCHEDULED_DELIVERY_TIME_MS_HEADER => '12345'})
+    @msg_string_data1.should == message2.payload
+  end 
+  
+  it "check publish() with string message and scheduled message header" do  
+    message = Messagebus::Message.create(@msg_string_data1)
+    message2 = test_publish_message(message, :header_options => {Messagebus::Producer::SCHEDULED_DELIVERY_TIME_MS_HEADER => '12345'})
+    @msg_string_data1.should == message2.payload
+  end 
+  
+end

data/spec/messagebus/swarm/controller_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Messagebus::Swarm::Controller do
+  describe ".after_fork" do
+    class SampleWorker ; end
+
+    module AfterForkSpecHelpers
+      def temp_file_base
+        "after-fork-spec.tmp"
+      end
+
+      def create_temp_file(id)
+        `touch #{temp_file_base}#{id}`
+      end
+
+      def cleanup_temp_files
+        `rm #{temp_file_base}* > /dev/null 2>&1`
+      end
+
+      def temp_files_count
+        `ls -l #{temp_file_base}* | wc -l`.to_i
+      end
+    end
+    include AfterForkSpecHelpers
+
+    before do
+      Messagebus::Swarm::Drone.any_instance.stub(:processing_loop => nil)
+    end
+
+    around do |example|
+      cleanup_temp_files
+
+      original_logger = Messagebus::Swarm::Controller.swarm_control_logger
+      @logger = Logger.new(StringIO.new)
+      Messagebus::Swarm::Controller.swarm_control_logger = @logger
+
+      example.run
+
+      Messagebus::Swarm::Controller.swarm_control_logger = original_logger
+
+      cleanup_temp_files
+    end
+
+    it "executes the after_fork block once per drone started" do
+      config = {
+        :swarm_config => {:fork => true},
+        :workers => [
+          {
+            :destination => "jms.topic.SampleTopic",
+            :worker => "SampleWorker",
+            :ack_on_error => false,
+            :subscription_id => "sample-subscriber-id",
+            :drones => 4
+          }
+        ],
+        :clusters => [
+          {
+            "consumer_address" => "localhost:61613",
+            "destinations" => ["jms.topic.SampleTopic"]
+          }
+        ]
+      }
+
+      Messagebus::Swarm::Controller.after_fork do
+        create_temp_file(rand)
+      end
+
+      Messagebus::Swarm::Controller.start(config, @logger, "jms.topic.SampleTopic")
+
+      temp_files_count.should == config[:workers].first[:drones]
+    end
+  end
+end