mbus 1.0.0

data/spec/messagebus/cluster_map_spec.rb

@@ -0,0 +1,178 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Messagebus::ClusterMap do
+  before do
+    @config = {
+      "user" => "RandySavage",
+      "passwd" => "snap.into.a.slim.jim",
+      "clusters" => ["name" => "producer-cluster", "producer_address" => "localhost:61613", "destinations" => [
+        "jms.queue.testQueue1", "jms.topic.testTopic1"]
+      ]
+    }
+
+    logger = mock(Logger, :info => true, :debug => true)
+    Messagebus::Client.stub!(:logger).and_return(logger)
+  end
+
+  describe "constructing a cluster map" do
+    before do
+      @producer = mock(Messagebus::Producer, :host_params => true)
+      Messagebus::Producer.stub!(:new).and_return(@producer)
+    end
+
+    it "creates a producer for each cluster configured" do
+      cluster = @config["clusters"].first
+      cluster_config = cluster.dup
+      host_params = cluster_config.delete("producer_address")
+
+      Messagebus::Producer.should_receive(:new).with(host_params, hash_including({
+        :user => "RandySavage", :passwd => "snap.into.a.slim.jim", :receipt_wait_timeout_ms => nil,
+        :conn_lifetime_sec => nil
+      }))
+      Messagebus::ClusterMap.new(@config)
+    end
+
+    it "creates a destination for each cluster destination name configured" do
+      expected_map = {
+        "jms.queue.testQueue1" => @producer,
+        "jms.topic.testTopic1" => @producer
+      }
+
+      clustermap = Messagebus::ClusterMap.new(@config)
+      expected_map.should == clustermap.destinations
+      clustermap.destinations.each do |destination, producer|
+
+      end
+    end
+
+    it "fails with exception if no destinations are configured" do
+      lambda {
+        @config["clusters"].first.merge!("destinations" => [])
+        Messagebus::ClusterMap.new(@config)
+      }.should raise_error(Messagebus::Client::InitializationError)
+
+      lambda {
+        @config["clusters"].first.merge!("destinations" => nil)
+        Messagebus::ClusterMap.new(@config)
+      }.should raise_error(Messagebus::Client::InitializationError)
+    end
+  end
+
+  describe "#start" do
+    before do
+      @producer = mock(Messagebus::Producer, :host_params => true)
+      Messagebus::Producer.stub!(:new).and_return(@producer)
+    end
+
+    it "producer start is called" do
+      @producer.should_receive(:start)
+      Messagebus::ClusterMap.new(@config).start
+    end
+  end
+
+  describe "update clusters with top level configurations" do
+    before do
+      @producer = mock(Messagebus::Producer, :host_params => true)
+      Messagebus::Producer.stub!(:new).and_return(@producer)
+
+      @config = {
+        "user" => "top-level-name",
+        "clusters" => ["name" => "producer-cluster", "producer_address" => "localhost:61613", "destinations" => [
+          "jms.queue.testQueue1", "jms.topic.testTopic1"]
+        ]
+      }
+    end
+
+    it "creates a producer for each cluster configured with top level name." do
+      cluster = @config["clusters"].first
+      cluster_config = cluster.dup
+      host_params = cluster_config.delete("producer_address")
+
+      Messagebus::Producer.should_receive(:new).with(host_params, hash_including({
+        :user => 'top-level-name', :passwd => nil, :receipt_wait_timeout_ms => nil,
+        :conn_lifetime_sec => nil
+      }))
+      Messagebus::ClusterMap.new(@config)
+    end
+
+    it "creates a producer for each cluster configured with cluster level name." do
+      @config["clusters"].first.merge!({"user" => 'cluster-level-name'})
+      cluster = @config["clusters"].first
+      cluster_config = cluster.dup
+      host_params = cluster_config.delete("producer_address")
+
+      Messagebus::Producer.should_receive(:new).with(host_params, hash_including({
+        :user => 'cluster-level-name', :passwd => nil, :receipt_wait_timeout_ms => nil,
+        :conn_lifetime_sec => nil
+      }))
+      Messagebus::ClusterMap.new(@config)
+    end
+  end
+
+  describe "#stop" do
+    before do
+      @producer = mock(Messagebus::Producer, :host_params => true)
+      Messagebus::Producer.stub!(:new).and_return(@producer)
+      @producer.stub!(:started?).and_return(true)
+    end
+
+    it "producer stop is called" do
+      @producer.should_receive(:stop)
+      Messagebus::ClusterMap.new(@config).stop
+    end
+  end
+
+  describe "#find" do
+    before do
+      @producer = mock(Messagebus::Producer, :host_params => true)
+      Messagebus::Producer.stub!(:new).and_return(@producer)
+    end
+
+    it "succeeds in finding a destination by name" do
+      Messagebus::ClusterMap.new(@config).find("jms.queue.testQueue1").should == @producer
+    end
+  end
+  
+  describe "#update_config" do
+    before do
+      @producer = Messagebus::Producer.new(
+              "localhost:61613",
+              :user => "RandySavage",
+              :passwd => "snap.into.a.slim.jim" 
+              )
+      Messagebus::Producer.stub!(:new).and_return(@producer) 
+    end
+    
+    it "update_cluster is called" do
+      clustermap = Messagebus::ClusterMap.new(@config)
+      cluster_config = @config["clusters"].first
+      cluster = @config.merge(cluster_config)
+      clustermap.should_receive(:update_cluster).with(cluster)
+      clustermap.update_config(@config)
+    end
+    
+    it "succeeds in loading new destiantions from config" do
+      clustermap = Messagebus::ClusterMap.new(@config)
+      @config["clusters"].first["destinations"].push("jms.topic.testTopic2")
+      clustermap.update_config(@config)
+      expected_map = {
+             "jms.queue.testQueue1" => @producer,
+             "jms.topic.testTopic1" => @producer,
+             "jms.topic.testTopic2" => @producer
+           }
+      expected_map.should == clustermap.destinations
+    end
+    
+   
+    it "succeeds in creating new clusters" do
+      clustermap = Messagebus::ClusterMap.new(@config)
+      @config["clusters"].push("name" => "customer-cluster", "producer_address" => "localhost:61613", "destinations" => [
+        "jms.queue.testQueue1", "jms.topic.testTopic1"]
+      )
+      cluster_config = @config["clusters"][1]
+      cluster = @config.merge(cluster_config)
+      clustermap.should_receive(:create_cluster).with(cluster,true)
+      clustermap.update_config(@config)
+    end
+  end
+end 

data/spec/messagebus/consumer_spec.rb

@@ -0,0 +1,338 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+require 'thread'
+require 'net/http'
+
+describe Messagebus::Consumer do
+  DYNAMIC_URL = "http://localhost:8081/jmx?command=get_attribute&args=org.hornetq%3Amodule%3DCore%2Ctype%3DServer%20ListOfBrokers"
+
+  def start_test_consumer(host_params, options = {})
+    consumer = Messagebus::Consumer.new(host_params, options.merge({
+     :destination_name => 'jms.queue.testqueue'
+    }))
+
+    if options[:any_host_params]
+      consumer.should_receive(:start_servers).at_least(1)
+    else
+      consumer.should_receive(:start_servers).with(host_params, true).at_least(1)
+    end
+
+    consumer
+  end
+
+  def test_receive_message(host_params, message, options = {})
+    consumer = start_test_consumer(host_params, options)
+    fakeClient = mock(Stomp::Client)
+
+    expected_message = options[:expected_message]
+      
+    if not expected_message.nil?
+      fakeClient.should_receive(:credit).with(message)
+    end
+     
+    consumer.servers_running[host_params[0]] = fakeClient 
+    if not message.nil?
+      if not options[:push_message_delay]
+        consumer.received_messages.push({:msg => message, :host_param => host_params[0], :decoded_msg => expected_message})
+      else
+        Thread.start do
+          sleep options[:push_message_delay]
+          consumer.received_messages.push({:msg => message, :host_param => host_params[0], :decoded_msg => expected_message})
+        end
+      end
+    end
+
+    consumer.start
+
+    if options[:receive] == 'blocking'
+        received_message = consumer.receive
+    end
+
+    if  options[:receive] == 'timeout'
+      received_message = consumer.receive_timeout(options[:timeout_ms] || 100)
+    end
+
+    if  options[:receive] == 'immediate'
+      received_message = consumer.receive_immediate
+    end
+
+    if(received_message != nil && options[:ack_type] == Messagebus::ACK_TYPE_AUTO_CLIENT)
+      fakeClient.should_receive(:acknowledge).with(message)
+    end
+
+    if( options[:will_call_ack])
+      fakeClient.should_receive(:acknowledge).with(message)
+    end
+
+    if( options[:will_call_nack])
+      fakeClient.should_receive(:nack).with(message)
+    end
+    
+    if( options[:will_call_keepalive])
+      fakeClient.should_receive(:keepalive)
+    end
+
+    if( options[:will_call_ack_safe])
+      receipt = stub(Stomp::Message)
+      receipt.should_receive(:command).and_return('RECEIPT')
+      fakeClient.should_receive(:acknowledge).with(message).and_yield(receipt)
+      #fakeClient.should_receive(:acknowledge).and_yield
+    end
+
+    received_message.class.should == expected_message.class
+    if received_message.class == Messagebus::Message
+      received_message.raw_message.should == expected_message.raw_message
+    else
+      received_message.should == expected_message
+    end
+
+    consumer
+  end
+
+  before(:each) do
+    @message = Messagebus::Message.create("hello world1")
+    @msg = Stomp::Message.new(nil)
+    @msg.body = @message.to_thrift_binary
+    @msg_id = 'id-1'
+    @msg_string_data1 = 'test data'
+    @msg_json_object = {:a=> '1', :b => {:x => '2'}}
+    @msg_binary_data = "\xE5\xA5\xBD"
+
+    logger = mock(Logger, :info => true, :error => true)
+    Messagebus::Client.stub!(:logger).and_return(logger)
+  end
+
+  describe ".start (class method)" do
+    before do
+      @consumer = Messagebus::Consumer.new(['localhost:61613'], :destination_name => 'jms.queue.testqueue')
+      @consumer.should_receive(:start_servers)
+      Messagebus::Consumer.stub!(:new).and_return(@consumer)
+    end
+
+    it "auto closes the connection when a block is given" do
+      Messagebus::Consumer.start(['localhost:61613']) {}
+      @consumer.stopped?.should be_true
+    end
+
+    it "makes sure it stops if the block errors out" do
+      proc do
+        Messagebus::Consumer.start(['localhost:61613']) do
+          raise "error123"
+        end
+      end.should raise_error("error123")
+      @consumer.stopped?.should be_true
+    end
+
+    it "doesn't auto close if a block isn't given" do
+      Messagebus::Consumer.start(['localhost:61613'])
+      @consumer.stopped?.should be_false
+      @consumer.started?.should be_true
+    end 
+  end
+
+  describe "start" do
+    it "starts a server" do
+      consumer = start_test_consumer(['localhost:61613'])
+      consumer.start
+      consumer.stopped?.should be_false
+      consumer.started?.should be_true
+    end
+
+    it "start server attached to multiple hosts" do
+      consumer = start_test_consumer(['localhost:61613', 'localhost:61614'])
+      consumer.start
+    end
+  end
+
+  context "connection failure" do
+    it "closes connections when only some start" do
+      consumer = Messagebus::Consumer.new(['host1:1', 'host2:2'], :destination_name => 'jms.queue.testqueue')
+      lambda do
+        good_client = stub.as_null_object
+        good_client.should_receive(:close)
+
+        Stomp::Client.should_receive(:new).and_return(good_client)
+        Stomp::Client.should_receive(:new).and_raise("2nd client blows up")
+        consumer.start
+      end.should raise_error("2nd client blows up")
+    end
+
+    it "raises an exception when we fail to connect" do
+      consumer = Messagebus::Consumer.new(['non_existant_host:1111'], :destination_name => 'jms.queue.testqueue')
+      lambda do
+        consumer.start
+      end.should raise_error
+    end
+  end
+
+  it "check refresh timer task" do
+    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'], :conn_lifetime_sec => 0.100)
+    consumer.should_receive(:refresh_servers).at_least(1)
+    consumer.start
+    sleep(0.500)
+  end
+  
+  it "check refresh timer task with dynamic fetch url return nil." do
+    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'], :conn_lifetime_sec => 0.100,
+    :enable_dynamic_serverlist_fetch => 'true', :dynamic_serverlist_fetch_url_override => 'test', :any_host_params=>true)
+    consumer.should_receive(:fetch_serverlist).at_least(1).and_return(nil)
+    consumer.start
+    sleep(0.200)
+  end
+
+  it "check get dynamic fetch url host param String." do
+    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'], :conn_lifetime_sec => 0.100)
+    consumer.start
+
+    DYNAMIC_URL.should == consumer.get_dynamic_fetch_url('localhost:61613')
+  end
+
+  it "check get dynamic fetch url host param array." do
+    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'], :conn_lifetime_sec => 0.100)
+    consumer.start
+
+    DYNAMIC_URL.should == consumer.get_dynamic_fetch_url(['localhost:61613'])
+  end
+
+  it "check fetch_serverlist url success." do
+    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'], :enable_dynamic_serverlist_fetch => 'true', :dynamic_serverlist_fetch_url_override => 'test')
+    consumer.should_receive(:fetch_uri).with("test").at_least(1).and_return('localhost:61612, localhost:61614')
+    consumer.should_receive(:start_servers).with(['localhost:61612', 'localhost:61614']);
+    consumer.start
+    consumer.fetch_serverlist.should =~ ['localhost:61612', 'localhost:61614']
+  end
+
+  it "check fetch_serverlist url fail." do
+    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'], :enable_dynamic_serverlist_fetch => 'true', :dynamic_serverlist_fetch_url_override => 'test')
+    consumer.should_receive(:fetch_uri).with("test").at_least(1).and_return('<fail="localhostocalhost:61614">')
+
+     consumer.start
+     consumer.fetch_serverlist.should == nil
+  end
+
+  it "check refresh timer task with dynamic fetch url with no change." do
+    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'], :conn_lifetime_sec => 0.100,
+                                   :enable_dynamic_serverlist_fetch => 'true', :dynamic_serverlist_fetch_url_override => 'test')
+    consumer.should_receive(:fetch_serverlist).at_least(1).and_return(['localhost:61613', 'localhost:61614'])
+    consumer.should_receive(:stop_servers) do |array|
+      array.should =~ ['localhost:61613', 'localhost:61614']
+    end.at_least(1)
+
+    consumer.servers_running = {'localhost:61613' => 'test', 'localhost:61614' => 'test', }
+    consumer.start
+
+    sleep(0.150)
+    consumer.stop
+  end
+
+  it "check refresh timer task with dynamic fetch url return with added servers." do
+    consumer = start_test_consumer(['localhost:61613'], :conn_lifetime_sec => 0.100, :enable_dynamic_serverlist_fetch => 'true', :dynamic_serverlist_fetch_url_override => 'test')
+    consumer.should_receive(:fetch_serverlist).at_least(1).and_return(['localhost:61613', 'localhost:61614'])        
+    consumer.should_receive(:start_servers).with(['localhost:61614']).at_least(1)
+
+    consumer.servers_running = {'localhost:61613' => 'test'}
+    consumer.start
+
+    sleep(0.150)
+    consumer.stop
+  end
+
+# TODO (bbansal): Disabling dynamic server delete for now, seems like an overkill.
+#                 There are chances where any user error can be disastorous.
+#  it "check refresh timer task with dynamic fetch url return with deleted servers." do
+#    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'], :conn_lifetime_sec => 0.100, :enable_dynamic_serverlist_fetch => 'true', :dynamic_serverlist_fetch_url_override => 'test')
+#    consumer.should_receive(:fetch_serverlist).at_least(1).and_return(['localhost:61613'])
+#    consumer.should_receive(:stop_servers).with(['localhost:61613']).at_least(1)
+#    consumer.should_receive(:start_servers).with(['localhost:61613']).at_least(1)
+#    consumer.should_receive(:stop_servers).with(['localhost:61614'])
+#    consumer.should_receive(:stop_servers).with(['localhost:61613', 'localhost:61614']).at_least(1)
+#
+#    consumer.servers_running = {'localhost:61613' => 'test', 'localhost:61614' => 'test'}
+#    consumer.start
+#
+#    sleep(0.150)
+#    consumer.stop
+#  end
+
+  it "check delete subscriptions." do
+    consumer = start_test_consumer(['localhost:61613', 'localhost:61614'])
+    fakeClient1 = mock(Stomp::Client)
+    fakeClient2 = mock(Stomp::Client)
+
+    fakeClient1.should_receive(:unsubscribe).with('jms.queue.testqueue')
+    fakeClient2.should_receive(:unsubscribe).with('jms.queue.testqueue')
+
+    consumer.servers_running = {'localhost:61613' => fakeClient1, 'localhost:61614' => fakeClient2}
+    consumer.should_receive(:refresh_servers);
+    consumer.start
+    consumer.delete_subscription
+  end
+
+  it "check consumer receive blocking message available." do
+    test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :receive => 'blocking', :expected_message => @message)
+  end
+
+  it "check consumer receive blocking parallel thread." do
+    test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :receive => 'blocking', :push_message_delay => 0.050,
+    :expected_message => @message)
+  end
+
+  it "check consumer receive immediate success." do
+    test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :receive => 'immediate', :expected_message => @message)
+  end
+
+  it "check consumer receive immediate fail." do
+    test_receive_message(['localhost:61613', 'localhost:61614'], nil, :receive => 'immediate', :expected_message => nil)
+  end
+
+  it "check consumer receive immediate fail with delayed push message" do
+    test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :receive => 'immediate',
+                         :push_message_delay => 0.050, :expected_message => nil)
+  end
+
+  it "check consumer receive immediate with client ack" do
+    consumer = test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :ack_type => Messagebus::ACK_TYPE_CLIENT, :receive => 'immediate',
+                                     :expected_message => @message, :will_call_ack => true)
+    
+    consumer.ack
+  end
+
+  it "check consumer sends ack with block in safe mode" do
+    consumer = test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :ack_type => Messagebus::ACK_TYPE_CLIENT, :receive => 'immediate',
+                                     :expected_message => @message, :will_call_ack_safe => true)
+    consumer.ack true
+  end
+
+  it "check consumer receive immediate with client nack" do
+    consumer = test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :ack_type => Messagebus::ACK_TYPE_CLIENT, :receive => 'immediate',
+                                     :expected_message => @message, :will_call_nack => true)
+    
+    consumer.nack
+  end
+  
+  it "check consumer keepalive" do
+    consumer = test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :ack_type => Messagebus::ACK_TYPE_CLIENT, :receive => 'immediate',
+                                     :expected_message => @message, :will_call_keepalive => true)
+    
+    consumer.keepalive
+  end
+
+  it "check consumer receive timeout fail." do
+    expect {
+      test_receive_message(['localhost:61613', 'localhost:61614'], nil, :receive => 'timeout', :timeout_ms => 100, :push_message_delay => 0.500,
+        :expected_message => nil)
+    }.to raise_error(Messagebus::MessageReceiveTimeout, /receive timeout/)
+
+    sleep(0.200)
+  end
+
+  it "check consumer receive timeout success." do
+    test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :receive => 'timeout', :timeout_ms => 100,
+                         :push_message_delay => 0.050, :expected_message => @message)
+  end
+
+  it "check consumer receive string message success." do
+    test_receive_message(['localhost:61613', 'localhost:61614'], @msg, :receive => 'timeout', :timeout_ms => 100,
+                         :push_message_delay => 0.050, :expected_message => @message)
+  end
+end