beetle 3.4.2 → 3.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08db25367467939ff6a625b0caf2b940832b398c7988189ac2a0e91d5244a78b'
-  data.tar.gz: d9ffc4a722b0d86db98e81e0f9080b76e2fbd01537cbb4a6839b00665e778f19
+  metadata.gz: bce54bf1dc2290bb4c1598f6210b1c292d09691e91df2f67e913747535c90f2d
+  data.tar.gz: e6f510fb5b78a7ed0483f713920222ff1959e7a3e3073aac61abed25af56b0bd
 SHA512:
-  metadata.gz: c7f986880a871a59a74ee9e3fc63b9b384097713eedc9f106c7b799cd6b8762714d05d181665ac5aadea0675fd10f30acfbaec8fcdf921a31721c609220b95ad
-  data.tar.gz: 3beb91290f71cf8191f9abe0a116732e0e880a3e0e57d2c774c2c417bde4fb697b7980e2d2f6af0bdfcd601b124c7c4286a796fada014771be3bb8b049130d12
+  metadata.gz: 8682a1720108f7e95ad9802bcfe5b30283c735cfaa67323e5aca6bca1e1c06d0b6bb58d8fd2b8f4fc1fb7032579832667b78bab0c0f7013a937556650ad14ad7
+  data.tar.gz: 255b3fd3827a1f33c1c244967649ab8eaa1adc8f6daa3a111b21e299f1bcc0341f324a1bee3f2c578f5c93b39eeb913caf2c3a6d8ea88d1e89c028c48576e1b0

data/Rakefile

@@ -115,18 +115,14 @@ Rake::TestTask.new do |t|
   t.warning = false
 end
 
-require 'rdoc/task'
-
-RDoc::Task.new do |rdoc|
-  rdoc.rdoc_dir = 'site/rdoc'
-  rdoc.title    = 'Beetle'
-  rdoc.main     = 'README.rdoc'
-  rdoc.options << '--line-numbers' << '--inline-source' << '--quiet'
-  rdoc.rdoc_files.include('**/*.rdoc')
-  rdoc.rdoc_files.include('MIT-LICENSE')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+task :clean do
+  sh "rm -f tmp/*.output tmp/*.log tmp/master-dir/* tmp/slave-dir/* tmp/*lock tmp/*pid test.log" unless ENV['GITHUB_ACTIONS']
 end
 
-task :clean do
-  sh "rm -f tmp/*.output tmp/*.log tmp/master-dir/* tmp/slave-dir/* tmp/*lock tmp/*pid test.log"
+require 'yard'
+
+YARD::Rake::YardocTask.new do |t|
+  OTHER_PATHS = %w()
+  t.files = ['lib/**/*.rb'] + OTHER_PATHS
+  t.options = %w(--markup-provider=redcarpet --markup=markdown --main=README.md --output-dir=site/yard)
 end

data/beetle.gemspec

@@ -39,8 +39,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency "mocha",               "~> 1.3.0"
   s.add_development_dependency "mysql2",              "~> 0.4.4"
   s.add_development_dependency "rake",                "~> 13.0"
-  s.add_development_dependency "rdoc",                "~> 4.0"
   s.add_development_dependency "simplecov",           "~> 0.15"
   s.add_development_dependency "webmock",             "~> 3.0"
   s.add_development_dependency "websocket-eventmachine-client"
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'redcarpet'
+  s.add_development_dependency 'github-markup'
 end

data/examples/redundant.rb

@@ -17,7 +17,7 @@ Beetle.config.logger.level = Logger::INFO
 client = Beetle::Client.new
 
 # use two servers
-Beetle.config.servers = "localhost:5672, localhost:5673"
+Beetle.config.servers = ENV["RABBITMQ_SERVERS"] || "localhost:5672, localhost:5673"
 # instantiate a client
 client = Beetle::Client.new
 

data/examples/rpc.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__)+"/../lib/beetle")
 
 # suppress debug messages
 Beetle.config.logger.level = Logger::INFO
-Beetle.config.servers = "localhost:5672, localhost:5673"
+Beetle.config.servers = ENV["RABBITMQ_SERVERS"] || "localhost:5672, localhost:5673"
 # instantiate a client
 
 client = Beetle::Client.new

data/features/redis_auto_failover.feature

@@ -24,6 +24,26 @@ Feature: Redis auto failover
     Given a redis server "redis-1" exists as master
     Then the role of redis server "redis-1" should be "slave"
 
+  Scenario: Successful redis master switch with multiple slaves
+    And a redis server "redis-3" exists as slave of "redis-3"
+    Given a redis configuration server using redis servers "redis-1,redis-2,redis-3" with clients "rc-client-1,rc-client-2" exists
+    And a redis configuration client "rc-client-1" using redis servers "redis-1,redis-2,redis-3" exists
+    And a redis configuration client "rc-client-2" using redis servers "redis-1,redis-2,redis-3" exists
+    And a beetle handler using the redis-master file from "rc-client-1" exists
+    And redis server "redis-1" is down
+    And the retry timeout for the redis master check is reached
+    Then a system notification for "redis-1" not being available should be sent
+    And the role of redis server "redis-2" should be "master"
+    And the redis master file of the redis configuration server should contain "redis-2"
+    And the redis master of "rc-client-1" should be "redis-2"
+    And the redis master of "rc-client-2" should be "redis-2"
+    And the redis master of the beetle handler should be "redis-2"
+    And a system notification for switching from "redis-1" to "redis-2" should be sent
+    Given a redis server "redis-1" exists as master
+    Then the role of redis server "redis-1" should be "slave"
+    And the redis server "redis-1" is a slave of "redis-2"
+    And the redis server "redis-3" is a slave of "redis-2"
+
   Scenario: Successful single redis master switch with multiple failover sets
     Given a redis server "redis-3" exists as master
     And a redis server "redis-4" exists as slave of "redis-3"

data/features/step_definitions/redis_auto_failover_steps.rb

@@ -1,8 +1,9 @@
 Given /^consul state has been cleared$/ do
+  consul_host = ENV["CONSUL_HOST"] || "localhost:8500"
   system "killall beetle beetle_handler >/dev/null 2>/dev/null"
-  system "curl --silent --request PUT http://localhost:8500/v1/kv/apps/beetle/config/ >/dev/null"
-  system "curl --silent --request PUT http://localhost:8500/v1/kv/shared/config/ >/dev/null"
-  system "curl --silent --request DELETE http://localhost:8500/v1/kv/apps/beetle/state/redis_master_file_content >/dev/null"
+  system "curl --silent --request PUT http://#{consul_host}/v1/kv/apps/beetle/config/ >/dev/null"
+  system "curl --silent --request PUT http://#{consul_host}/v1/kv/shared/config/ >/dev/null"
+  system "curl --silent --request DELETE http://#{consul_host}/v1/kv/apps/beetle/state/redis_master_file_content >/dev/null"
 end
 
 Given /^a redis server "([^\"]*)" exists as master$/ do |redis_name|
@@ -93,7 +94,6 @@ Given /^an old redis master file for "([^\"]*)" with master "([^\"]*)" exists$/
   end
 end
 
-
 Then /^the role of redis server "([^\"]*)" should be "(master|slave)"$/ do |redis_name, role|
   expected_role = false
   10.times do
@@ -103,6 +103,16 @@ Then /^the role of redis server "([^\"]*)" should be "(master|slave)"$/ do |redi
   assert expected_role, "#{redis_name} is not a #{role}"
 end
 
+Then /^the redis server "([^\"]*)" is a slave of "([^\"]*)"$/ do |redis_name, redis_master_name|
+  master = TestDaemons::Redis[redis_master_name].redis
+  slave = TestDaemons::Redis[redis_name].redis
+  3.times do
+    sleep 1
+    break if slave.slave_of?(master.host, master.port)
+  end
+  assert slave.slave_of?(master.host, master.port)
+end
+
 Then /^the redis master of "([^\"]*)" (?:in system "([^"]*)" )?should be "([^\"]*)"$/ do |redis_configuration_client_name, system_name, redis_name|
   system_name ||= "system"
   master_file = redis_master_file(redis_configuration_client_name)
@@ -143,11 +153,21 @@ end
 Then /^the redis master of the beetle handler should be "([^\"]*)"$/ do |redis_name|
   Beetle.config.servers = "127.0.0.1:5672" # rabbitmq
   Beetle.config.logger.level = Logger::INFO
-  client = Beetle::Client.new.configure :auto_delete => true do |config|
-    config.queue(:echo, :lazy => true, :dead_lettering => true)
-    config.message(:echo)
+  redis_master = TestDaemons::Redis[redis_name].ip_with_port
+  response = nil
+  expected_response = ['OK', redis_master]
+  3.times do |i|
+    client = Beetle::Client.new.configure :auto_delete => true do |config|
+      config.queue(:echo, :lazy => true, :dead_lettering => true)
+      config.message(:echo)
+    end
+    t1 = Time.now
+    response = client.rpc(:echo, 'echo')
+    t2 = Time.now
+    # puts "OK,#{redis_master} =?= #{response.join(',')} after #{t2-t1}, attempt #{i+1}"
+    break if expected_response == response
   end
-  assert_match /#{TestDaemons::Redis[redis_name].ip_with_port}/, client.rpc(:echo, 'nil').second
+  assert_equal expected_response, response
 end
 
 Then /^a system notification for "([^\"]*)" not being available should be sent$/ do |redis_name|

data/features/support/test_daemons/redis_configuration_server.rb

@@ -25,9 +25,10 @@ module TestDaemons
 
     def self.daemon_controller
       clients_parameter_string = @@redis_configuration_clients.blank? ? "" : "--client-ids #{@@redis_configuration_clients}"
+      consul_host = ENV["CONSUL_HOST"] || "localhost:8500"
       DaemonController.new(
          :identifier    => "Redis configuration test server",
-         :start_command => "./beetle configuration_server -v -d --redis-master-file #{redis_master_file} --redis-servers '#{@@redis_servers}' #{clients_parameter_string} --redis-master-retry-interval 1 --pid-file #{pid_file} --log-file #{log_file} --redis-failover-confidence-level #{@@confidence_level} --consul http://localhost:8500",
+         :start_command => "./beetle configuration_server -v -d --redis-master-file #{redis_master_file} --redis-servers '#{@@redis_servers}' #{clients_parameter_string} --redis-master-retry-interval 1 --pid-file #{pid_file} --log-file #{log_file} --redis-failover-confidence-level #{@@confidence_level} --consul http://#{consul_host}",
          :ping_command  => lambda{ answers_text_requests? },
          :pid_file      => pid_file,
          :log_file      => log_file,

data/lib/beetle/base.rb

@@ -67,23 +67,25 @@ module Beetle
           logger.debug("Beetle: binding queue #{name} with internal name #{opts[:amqp_name]} on server #{@server}")
           queue_name = opts[:amqp_name]
           creation_options = opts.slice(*QUEUE_CREATION_KEYS)
-          the_queue = nil
+
+          the_queue = declare_queue!(queue_name, creation_options)
           @client.bindings[name].each do |binding_options|
             exchange_name = binding_options[:exchange]
             binding_options = binding_options.slice(*QUEUE_BINDING_KEYS)
-            the_queue = bind_queue!(queue_name, creation_options, exchange_name, binding_options)
+            logger.debug("Beetle: binding queue #{queue_name} to #{exchange_name} with opts: #{binding_options.inspect}")
+            bind_queue!(the_queue, exchange_name, binding_options)
           end
           the_queue
         end
     end
 
-    def bind_dead_letter_queue!(channel, target_queue, creation_keys = {})
+    def bind_dead_letter_queue!(channel, target_queue, creation_options = {})
       policy_options = @client.queues[target_queue].slice(:dead_lettering, :lazy, :dead_lettering_msg_ttl)
       policy_options[:message_ttl] = policy_options.delete(:dead_lettering_msg_ttl)
       dead_letter_queue_name = "#{target_queue}_dead_letter"
       if policy_options[:dead_lettering]
-        logger.debug("Beetle: creating dead letter queue #{dead_letter_queue_name} with opts: #{creation_keys.inspect}")
-        channel.queue(dead_letter_queue_name, creation_keys)
+        logger.debug("Beetle: creating dead letter queue #{dead_letter_queue_name} with opts: #{creation_options.inspect}")
+        channel.queue(dead_letter_queue_name, creation_options)
       end
       return {
         :queue_name => target_queue,
@@ -93,7 +95,7 @@ module Beetle
       }.merge(policy_options)
     end
 
-    # called by <tt>bind_queue!</tt>
+    # called by <tt>declare_queue!</tt>
     def publish_policy_options(options)
       # avoid endless recursion
       return if options[:queue_name] == @client.config.beetle_policy_updates_queue_name

data/lib/beetle/client.rb

@@ -280,6 +280,13 @@ module Beetle
       publisher.throttled?
     end
 
+    # set up queues and policies for all configured queues. Otherwise this will
+    # happen on first use of an exchange, which can be undesired for latency
+    # sensitive endpoints. Only needs to be called once.
+    def setup_queues_and_policies
+      publisher.setup_queues_and_policies
+    end
+
     # traces queues without consuming them. useful for debugging message flow.
     def trace(queue_names=self.queues.keys, tracer=nil, &block)
       queues_to_trace = self.queues.slice(*queue_names)
@@ -378,8 +385,12 @@ module Beetle
     end
 
     def load_brokers_from_config
-      @servers = config.servers.split(/ *, */)
-      @additional_subscription_servers = config.additional_subscription_servers.split(/ *, */)
+      @servers = parse_server_list(config.servers)
+      @additional_subscription_servers = parse_server_list(config.additional_subscription_servers) - @servers
+    end
+
+    def parse_server_list(s)
+      s.split(/ *, */).uniq.reject(&:blank?)
     end
   end
 end

data/lib/beetle/publisher.rb

@@ -34,7 +34,7 @@ module Beetle
         Bunny::ConnectionError, Bunny::ForcedChannelCloseError, Bunny::ForcedConnectionCloseError,
         Bunny::MessageError, Bunny::ProtocolError, Bunny::ServerDownError, Bunny::UnsubscribeError,
         Bunny::AcknowledgementError, Qrack::BufferOverflowError, Qrack::InvalidTypeError,
-        Errno::EHOSTUNREACH, Errno::ECONNRESET, Timeout::Error
+        Errno::EHOSTUNREACH, Errno::ECONNRESET, Errno::ETIMEDOUT, Timeout::Error
       ]
     end
 
@@ -66,6 +66,7 @@ module Beetle
         logger.debug "Beetle: message sent!"
         published = 1
       rescue *bunny_exceptions => e
+        logger.warn("Beetle: publishing exception #{e} #{e.backtrace[0..4].join("\n")}")
         stop!(e)
         tries -= 1
         # retry same server on receiving the first exception for it (might have been a normal restart)
@@ -98,6 +99,7 @@ module Beetle
           published << @server
           logger.debug "Beetle: message sent (#{published})!"
         rescue *bunny_exceptions => e
+          logger.warn("Beetle: publishing exception #{e} #{e.backtrace[0..4].join("\n")}")
           stop!(e)
           retry if (tries += 1) == 1
           mark_server_dead
@@ -169,10 +171,14 @@ module Beetle
       end
     end
 
-    def setup_queues_and_policies(queue_names) #:nodoc:
+    def setup_queues_and_policies
       each_server do
-        queue_names.each do |name|
-          queue(name, create_policies: true)
+        begin
+          @client.queues.keys.each do |name|
+            queue(name)
+          end
+        rescue => e
+          logger.warn "Beetle: failed setting up queues and policies on #{@server}: #{e}"
         end
       end
     end
@@ -247,17 +253,19 @@ module Beetle
       @exchanges_with_bound_queues[exchange_name] = true
     end
 
-    # TODO: Refactor, fetch the keys and stuff itself
-    def bind_queue!(queue_name, creation_keys, exchange_name, binding_keys)
-      logger.debug("Beetle: creating queue with opts: #{creation_keys.inspect}")
-      queue = bunny.queue(queue_name, creation_keys)
-      logger.debug("Beetle: binding queue #{queue_name} to #{exchange_name} with opts: #{binding_keys.inspect}")
-      queue.bind(exchange(exchange_name), binding_keys)
-      policy_options = bind_dead_letter_queue!(bunny, queue_name, creation_keys)
+    def declare_queue!(queue_name, creation_options)
+      logger.debug("Beetle: creating queue with opts: #{creation_options.inspect}")
+      queue = bunny.queue(queue_name, creation_options)
+
+      policy_options = bind_dead_letter_queue!(bunny, queue_name, creation_options)
       publish_policy_options(policy_options)
       queue
     end
 
+    def bind_queue!(queue, exchange_name, binding_options)
+      queue.bind(exchange(exchange_name), binding_options)
+    end
+
     def stop!(exception=nil)
       return unless bunny?
       timeout = @client.config.publishing_timeout + @client.config.publisher_connect_timeout + 1

data/lib/beetle/subscriber.rb

@@ -214,18 +214,20 @@ module Beetle
       channel.__send__(opts[:type], name, opts.slice(*EXCHANGE_CREATION_KEYS))
     end
 
-    def bind_queue!(queue_name, creation_keys, exchange_name, binding_keys)
-      queue = channel.queue(queue_name, creation_keys)
+    def declare_queue!(queue_name, creation_options)
+      queue = channel.queue(queue_name, creation_options)
       unless tracing?
         # we don't want to create dead-letter queues for tracing
-        policy_options = bind_dead_letter_queue!(channel, queue_name, creation_keys)
+        policy_options = bind_dead_letter_queue!(channel, queue_name, creation_options)
         publish_policy_options(policy_options)
       end
-      exchange = exchange(exchange_name)
-      queue.bind(exchange, binding_keys)
       queue
     end
 
+    def bind_queue!(queue, exchange_name, binding_options)
+      queue.bind(exchange(exchange_name), binding_options)
+    end
+
     def connection_settings
       {
         :host => current_host, :port => current_port, :logging => false,

data/lib/beetle/version.rb

@@ -1,3 +1,3 @@
 module Beetle
-  VERSION = "3.4.2"
+  VERSION = "3.5.3"
 end

data/test/beetle/amqp_gem_behavior_test.rb

@@ -7,7 +7,7 @@ class AMQPGemBehaviorTest < Minitest::Test
     begin
       exception = nil
       EM.run do
-        AMQP.start(:logging => false) do |connection|
+        AMQP.start(logging: false, host: ENV['RABBITMQ_SERVERS'] || 'localhost') do |connection|
           EM::Timer.new(1){ connection.close { EM.stop }}
           channel = AMQP::Channel.new(connection)
           channel.on_error { puts "woot"}

data/test/beetle/base_test.rb

@@ -26,7 +26,7 @@ module Beetle
     end
 
     test "server should be initialized" do
-      assert_equal @bs.servers.first, @bs.server
+      assert @bs.server
     end
 
     test "current_host should return the hostname of the current server" do

data/test/beetle/client_test.rb

@@ -8,7 +8,7 @@ module Beetle
     end
 
     test "should have a default server" do
-      assert_equal ["localhost:5672"], @client.servers
+      assert !@client.servers.empty?
     end
 
     test "should have no additional subscription servers" do
@@ -282,6 +282,12 @@ module Beetle
       client.stop_publishing
     end
 
+    test "should delegate setup_queues_and_policies to the publisher instance" do
+      client = Client.new
+      client.send(:publisher).expects(:setup_queues_and_policies)
+      client.setup_queues_and_policies
+    end
+
     test "should delegate queue purging to the publisher instance" do
       client = Client.new
       client.register_queue(:queue)
@@ -337,17 +343,17 @@ module Beetle
 
     test "trying to listen to an unknown queue should raise an exception" do
       client = Client.new
-      assert_raises(UnknownQueue) { Client.new.listen_queues([:foobar])}
+      assert_raises(UnknownQueue) { client.listen_queues([:foobar])}
     end
 
     test "trying to pause listening on an unknown queue should raise an exception" do
       client = Client.new
-      assert_raises(UnknownQueue) { Client.new.pause_listening(:foobar)}
+      assert_raises(UnknownQueue) { client.pause_listening(:foobar)}
     end
 
     test "trying to resume listening on an unknown queue should raise an exception" do
       client = Client.new
-      assert_raises(UnknownQueue) { Client.new.pause_listening(:foobar)}
+      assert_raises(UnknownQueue) { client.pause_listening(:foobar)}
     end
 
     test "should delegate stop_listening to the subscriber instance" do
@@ -451,4 +457,39 @@ module Beetle
       msg_stub
     end
   end
+
+  class ServerDeduplicationTest < Minitest::Test
+    def setup
+      @config = Configuration.new
+      @config.servers = "localhost:5672,localhost:5672"
+      @config.additional_subscription_servers = @config.servers + ",localhost:1234,localhost:1234"
+      @client = Client.new(@config)
+    end
+
+    test "duplicates are removed from the server list" do
+      assert_equal ["localhost:5672"], @client.servers
+    end
+
+    test "duplicates and servers in the server list are removed from the additional subscription server list" do
+      assert_equal ["localhost:1234"], @client.additional_subscription_servers
+    end
+  end
+
+  class EmptyServerStringTest < Minitest::Test
+    def setup
+      @config = Configuration.new
+      @config.servers = "localhost:5672,\t,localhost:5672, "
+      @config.additional_subscription_servers = @config.servers + ",localhost:1234, , ,,"
+      @client = Client.new(@config)
+    end
+
+    test "empty strings are removed from the server list" do
+      assert_equal ["localhost:5672"], @client.servers
+    end
+
+    test "empty strings are removed from the additional subscription server list" do
+      assert_equal ["localhost:1234"], @client.additional_subscription_servers
+    end
+  end
+
 end

data/test/beetle/deduplication_store_test.rb

@@ -87,7 +87,7 @@ module Beetle
     private
     def redis_test_master_file(server_string)
       tmp_dir = File.expand_path("../../../tmp", __FILE__)
-      Dir.mkdir(tmp_dir) unless File.exists?(tmp_dir)
+      Dir.mkdir(tmp_dir) unless File.exist?(tmp_dir)
       path = tmp_dir + "/redis-master-for-unit-tests"
       File.open(path, "w"){|f| f.puts server_string}
       path

data/test/beetle/publisher_test.rb

@@ -77,7 +77,9 @@ module Beetle
 
   class PublisherPublishingTest < Minitest::Test
     def setup
-      @client = Client.new
+      @config = Configuration.new
+      @config.servers = ENV['RABBITMQ_SERVERS'].split(',').first if ENV['RABBITMQ_SERVERS']
+      @client = Client.new(@config)
       @pub = Publisher.new(@client)
       @pub.stubs(:bind_queues_for_exchange)
       @client.register_queue("mama", :exchange => "mama-exchange")
@@ -277,6 +279,7 @@ module Beetle
   class PublisherQueueManagementTest < Minitest::Test
     def setup
       @config = Configuration.new
+      @config.servers = ENV['RABBITMQ_SERVERS'] if ENV['RABBITMQ_SERVERS']
       @client = Client.new(@config)
       @pub = Publisher.new(@client)
     end
@@ -304,7 +307,11 @@ module Beetle
       @client.register_queue('test_queue_1', :exchange => 'test_exchange')
       @client.register_queue('test_queue_2', :exchange => 'test_exchange')
       @client.register_queue('test_queue_3', :exchange => 'test_exchange_2')
-      @pub.expects(:bind_queue!).returns(1).times(3)
+      queue = mock("queue")
+      @pub.expects(:bind_queue!).with(queue, "test_exchange", {:key => "test_queue_1"}).once
+      @pub.expects(:bind_queue!).with(queue, "test_exchange", {:key => "test_queue_2"}).once
+      @pub.expects(:bind_queue!).with(queue, "test_exchange_2", {:key => "test_queue_3"}).once
+      @pub.expects(:declare_queue!).returns(queue).times(3)
       @pub.send(:bind_queues_for_exchange, 'test_exchange')
       @pub.send(:bind_queues_for_exchange, 'test_exchange_2')
     end
@@ -312,8 +319,22 @@ module Beetle
     test "should not rebind the defined queues for the used exchanges if they already have been bound" do
       @client.register_queue('test_queue_1', :exchange => 'test_exchange')
       @client.register_queue('test_queue_2', :exchange => 'test_exchange')
-      @pub.expects(:bind_queue!).twice
+      queue = mock("queue")
+      @pub.expects(:declare_queue!).returns(queue).twice
+      @pub.expects(:bind_queue!).with(queue, "test_exchange", {:key => "test_queue_1"}).once
+      @pub.expects(:bind_queue!).with(queue, "test_exchange", {:key => "test_queue_2"}).once
+      @pub.send(:bind_queues_for_exchange, 'test_exchange')
       @pub.send(:bind_queues_for_exchange, 'test_exchange')
+    end
+
+    test "should declare queues only once even with many bindings" do
+
+      @client.register_queue('test_queue', :exchange => 'test_exchange')
+      @client.register_binding('test_queue', :exchange => 'test_exchange', :key => 'sir-message-a-lot')
+      queue = mock("queue")
+      @pub.expects(:declare_queue!).returns(queue).once
+      @pub.expects(:bind_queue!).with(queue, "test_exchange", {:key => "test_queue"}).once
+      @pub.expects(:bind_queue!).with(queue, "test_exchange", {:key => "sir-message-a-lot"}).once
       @pub.send(:bind_queues_for_exchange, 'test_exchange')
     end
 
@@ -342,14 +363,34 @@ module Beetle
     end
 
     test "setting up queues and policies should iterate over all servers" do
-      @pub.servers = %w(a b)
-      queue = mock("queue")
+      client = Client.new
+      client.register_queue("queue")
+      pub = Publisher.new(client)
+      pub.servers = %w(a b)
+
       s = sequence("setup")
-      @pub.expects(:set_current_server).with("a").in_sequence(s)
-      @pub.expects(:queue).with("queue", :create_policies => true).returns(queue).in_sequence(s)
-      @pub.expects(:set_current_server).with("b").in_sequence(s)
-      @pub.expects(:queue).with("queue", :create_policies => true).returns(queue).in_sequence(s)
-      @pub.setup_queues_and_policies(["queue"])
+      pub.expects(:set_current_server).with("a").in_sequence(s)
+      pub.expects(:queue).with(client.config.beetle_policy_updates_queue_name).in_sequence(s)
+      pub.expects(:queue).with("queue").in_sequence(s)
+      pub.expects(:set_current_server).with("b").in_sequence(s)
+      pub.expects(:queue).with(client.config.beetle_policy_updates_queue_name).in_sequence(s)
+      pub.expects(:queue).with("queue").in_sequence(s)
+
+      pub.setup_queues_and_policies()
+    end
+
+    test "setting up queues and policies should handle ephemeral errors" do
+      client = Client.new
+      pub = Publisher.new(client)
+      client.register_queue("queue")
+      pub.servers = %w(a b)
+      pub.stubs(:queue).raises(StandardError)
+
+      s = sequence("setup")
+      pub.expects(:set_current_server).with("a").in_sequence(s)
+      pub.expects(:set_current_server).with("b").in_sequence(s)
+
+      pub.setup_queues_and_policies()
     end
 
     test "reports whether it has been throttled" do
@@ -516,10 +557,11 @@ module Beetle
     end
   end
 
-
   class RPCTest < Minitest::Test
     def setup
-      @client = Client.new
+      @config = Configuration.new
+      @config.servers = ENV['RABBITMQ_SERVERS'].split(',').first if ENV['RABBITMQ_SERVERS']
+      @client = Client.new(@config)
       @pub = Publisher.new(@client)
       @client.register_message(:test, :exchange => :some_exchange)
     end

data/test/beetle/subscriber_test.rb

@@ -52,7 +52,9 @@ module Beetle
 
   class SubscriberPauseAndResumeTest < Minitest::Test
     def setup
-      @client = Client.new
+      @config = Configuration.new
+      @config.servers = "localhost:5672"
+      @client = Client.new(@config)
       @sub = @client.send(:subscriber)
       @sub.servers << "localhost:7777"
       @server1, @server2 = @sub.servers
@@ -127,7 +129,7 @@ module Beetle
       @sub = @client.send(:subscriber)
     end
 
-    test "subscribers server list should contain addtional subcription hosts" do
+    test "subscribers server list should contain additional subcription hosts" do
       assert_equal ["localhost:5672", "localhost:1234"], @sub.servers
     end
   end
@@ -168,6 +170,17 @@ module Beetle
       @sub.send(:bind_queues, %W(x y))
     end
 
+    test "binding queues with many bindings should create it only once" do
+      @client.register_queue(:x, :exchange => 'test_exchange')
+      @client.register_binding(:x, :exchange => 'test_exchange', :key => 'sir-message-a-lot')
+      @client.register_handler(%w(x)){}
+      @sub.stubs(:exchange)
+      queue = mock("queue")
+      queue.expects(:bind).twice
+      @sub.expects(:declare_queue!).returns(queue).once
+      @sub.send(:bind_queues, %W(x))
+    end
+
     test "subscribing to queues should subscribe on all queues" do
       @client.register_queue(:x)
       @client.register_queue(:y)
@@ -331,7 +344,9 @@ module Beetle
 
   class SubscriptionTest < Minitest::Test
     def setup
-      @client = Client.new
+      @config = Configuration.new
+      @config.servers = "locahost:5672"
+      @client = Client.new(@config)
       @sub = @client.send(:subscriber)
     end