roundhousekiq 1.0.0

data/spec/roundhousekiq/runner_spec.rb

@@ -0,0 +1,350 @@
+require 'bunny'
+require './spec/fixtures/dummy_worker'
+
+describe Roundhousekiq::Runner do
+
+  # Method existence
+  it { should respond_to :connection }
+  it { should respond_to :channel }
+  it { should respond_to :queue }
+  it { should respond_to :consumer }
+  it { should respond_to :shutdown_runner }
+  it { should respond_to :exchange }
+  it { should respond_to :error_exchange }
+  it { should respond_to :queues }
+  it { should respond_to :queue_worker_map }
+  it { should respond_to :run }
+
+  describe 'constructor' do
+    it 'initializes queues with empty array' do
+      expect(subject.queues).to eq []
+    end
+
+    it 'initializes queue_worker_map with empty hash' do
+      expect(subject.queue_worker_map).to eq({})
+    end
+  end
+
+  describe '#run' do
+    before :each do
+      allow(subject).to receive(:establish_connection).and_return(nil)
+      allow(subject).to receive(:create_channel).and_return(nil)
+      allow(subject).to receive(:create_exchanges_and_queues).and_return(nil)
+      allow(subject).to receive(:setup_subscribers).and_return(nil)
+    end
+
+    it 'establishes an AMQP connection' do
+      expect(subject).to receive(:establish_connection)
+      subject.run
+    end
+
+    it 'creates a channel' do
+      expect(subject).to receive(:create_channel)
+      subject.run
+    end
+
+    it 'creates exchanges and queues' do
+      expect(subject).to receive(:create_exchanges_and_queues)
+      subject.run
+    end
+
+    it 'sets up subscribers' do
+      expect(subject).to receive(:setup_subscribers)
+      subject.run
+    end
+  end
+
+  describe '#shutdown' do
+    before :each do
+      allow(subject).to receive(:sleep).and_return(nil)
+    end
+
+    it 'sets shutdown_runner to true' do
+      allow(Thread).to receive(:new).and_return(nil)
+      expect(subject.shutdown_runner).to be_falsy
+      subject.shutdown
+      expect(subject.shutdown_runner).to be true
+    end
+
+    it 'closes the connection' do
+      subject.connection = double('connection')
+
+      allow(Thread).to receive(:new) do |&block|
+        expect(subject.connection).to receive(:try).with(:close)
+        block.call
+      end
+
+      subject.shutdown
+    end
+  end
+
+  describe '#shutdown?' do
+    it 'returns true if shutdown_runner is true' do
+      subject.shutdown_runner = true
+      expect(subject.shutdown?).to be true
+    end
+
+    it 'returns false if shutdown_runner is false' do
+      subject.shutdown_runner = false
+      expect(subject.shutdown?).to be false
+    end
+  end
+
+  describe '#establish_connection' do
+    before :each do
+      allow(Bunny).to receive(:new).and_return double('bunny', start: nil)
+    end
+
+    it 'creates a new Bunny instance' do
+      expect(Bunny).to receive(:new)
+      subject.establish_connection
+    end
+
+    it 'passes connection settings on to Bunny' do
+      settings = subject.class.connection_settings
+      expect(Bunny).to receive(:new).with(settings, any_args)
+      subject.establish_connection
+    end
+
+    it 'passes client properties on to Bunny' do
+      settings = subject.class.client_settings
+      expect(Bunny).to receive(:new).with(any_args, properties: settings)
+      subject.establish_connection
+    end
+
+    it 'calls #start on the connection' do
+      bunny = double('bunny', start: nil)
+      allow(Bunny).to receive(:new).and_return bunny
+      expect(bunny).to receive(:start)
+      subject.establish_connection
+    end
+  end
+
+  describe '.connection_settings' do
+    subject { Roundhousekiq::Runner }
+
+    it 'it requests the settings from Roundhousekiq' do
+      expect(Roundhousekiq).to receive(:config)
+      subject.connection_settings
+    end
+
+    it 'it returns a hash' do
+      expect(subject.connection_settings).to be_instance_of Hash
+    end
+
+    it 'it returns a hash with host, port, vhost, username and password' do
+      settings = subject.connection_settings
+
+      expect(settings).to have_key :host
+      expect(settings).to have_key :port
+      expect(settings).to have_key :vhost
+      expect(settings).to have_key :username
+      expect(settings).to have_key :password
+    end
+
+    it 'returns the settings configured in Roundhousekiq' do
+      Roundhousekiq.configure do |config|
+        config.host     = 'amqp-host'
+        config.port     = 1234
+        config.vhost    = 'rspec'
+        config.username = 'rspec_user'
+        config.password = 'very_secure'
+      end
+
+      settings = subject.connection_settings
+      expect(settings[:host]).to match 'amqp-host'
+      expect(settings[:port]).to match 1234
+      expect(settings[:vhost]).to match 'rspec'
+      expect(settings[:username]).to match 'rspec_user'
+      expect(settings[:password]).to match 'very_secure'
+    end
+  end
+
+  describe '.client_settings' do
+    subject { Roundhousekiq::Runner }
+
+    it 'takes the Bunny default settings' do
+      expect(Bunny::Session::DEFAULT_CLIENT_PROPERTIES).to receive(:merge)
+      subject.client_settings
+    end
+
+    it 'returns a hash' do
+      expect(subject.client_settings).to be_instance_of Hash
+    end
+
+    it 'sets the product name to "Roundhousekiq"' do
+      settings = subject.client_settings
+      expect(settings[:product]).to match 'Roundhousekiq'
+    end
+  end
+
+  describe '#create_channel' do
+    it 'sets up a new channel' do
+      channel = double('channel', prefetch: nil)
+      subject.connection = double('connection', create_channel: channel)
+      subject.create_channel
+    end
+
+    it 'sets the prefetch count to the value configured in config' do
+      config = double('config', prefetch: 512)
+      channel = double('channel', prefetch: nil)
+      subject.connection = double('connection', create_channel: channel)
+      expect(Roundhousekiq).to receive(:config).and_return config
+      expect(config).to receive(:prefetch)
+      expect(channel).to receive(:prefetch).with 512
+      subject.create_channel
+    end
+  end
+
+  describe '#create_exchanges_and_queues' do
+    let(:exchange) { double('exchange') }
+    let(:queue) { double('queue', bind: nil) }
+    let(:channel) { double('channel', exchange: exchange, queue: queue) }
+    let(:definition) do
+      definition = double 'definition'
+      allow(definition).to receive(:exchange).and_return({
+        name: 'exchange_name',
+        type: 'topic'
+      })
+      allow(definition).to receive(:queue).and_return({
+        name: 'queue_name',
+        durable: true,
+        auto_delete: false,
+        routing_key: 'routing_key'
+      })
+      definition
+    end
+
+    before :each do
+      subject.channel = channel
+      allow(Roundhousekiq::Workers).to receive(:definitions).and_return(
+        { DummyWorker => definition }
+      )
+    end
+
+    it 'requests the worker definitions from Roundhousekiq::Workers' do
+      subject.create_exchanges_and_queues
+    end
+
+    it 'creates the exchange for each worker' do
+      expect(channel).to receive(:exchange).with(
+        'exchange_name', type: 'topic', durable: true
+      )
+      subject.create_exchanges_and_queues
+    end
+
+    it 'creates a queue for each worker' do
+      expect(channel).to receive(:queue).with(
+        'queue_name', auto_delete: false, durable: true
+      )
+      subject.create_exchanges_and_queues
+    end
+
+    it 'sets up the binding for each worker' do
+      allow(channel).to receive(:queue).and_return queue
+      expect(queue).to receive(:bind).with exchange, routing_key: 'routing_key'
+      subject.create_exchanges_and_queues
+    end
+
+    it 'saves the queue in queues' do
+      allow(queue).to receive(:bind).and_return queue
+      subject.create_exchanges_and_queues
+      expect(subject.queues.include? queue).to be true
+    end
+
+    it 'adds each worker with the queue as key to the worker map' do
+      allow(queue).to receive(:bind).and_return queue
+      subject.create_exchanges_and_queues
+      expect(subject.queue_worker_map.keys.include? queue).to be true
+      expect(subject.queue_worker_map[queue]).to eq DummyWorker
+    end
+  end
+
+  describe '#setup_subscribers' do
+    let(:queue) { double('queue', subscribe: nil) }
+    let(:channel) { double('channel', ack: nil) }
+
+    before :each do
+      allow(subject).to receive(:sleep).and_return(nil)
+      allow(subject).to receive(:shutdown?).and_return(true)
+      allow(subject).to receive(:process_message).and_return(nil)
+      allow(subject).to receive(:queues).and_return([queue])
+      allow(subject).to receive(:channel).and_return(channel)
+    end
+
+    it 'sets up a subscription for each queue' do
+      expect(queue).to receive(:subscribe)
+      subject.setup_subscribers
+    end
+
+    it 'configures manual ACK for the subscriptions' do
+      expect(queue).to receive(:subscribe).with(manual_ack: true)
+      subject.setup_subscribers
+    end
+
+    it 'ACK each message once received' do
+      allow(queue).to receive(:subscribe) do |&block|
+        expect(subject.channel).to receive(:ack).with('amqp_tag')
+
+        block.call(
+          double('info', delivery_tag: 'amqp_tag'),
+          {},
+          "\{\}"
+        )
+      end
+      subject.setup_subscribers
+    end
+
+    it 'passes the received message to #process_message' do
+      allow(channel).to receive(:ack).and_return(nil)
+
+      payload = JSON.dump('foo' => 'bar')
+
+      allow(queue).to receive(:subscribe) do |&block|
+        expect(subject).to receive(:process_message)
+                            .with(queue, payload)
+
+        block.call(
+          double('info', delivery_tag: 'amqp_tag'),
+          {},
+          payload
+        )
+      end
+      subject.setup_subscribers
+    end
+
+    it 'blocks in a loop until shutdown and just sleeps in between' do
+      allow(subject).to receive(:shutdown?).and_return(false, true)
+
+      expect(subject).to receive(:shutdown?).twice
+      expect(subject).to receive(:sleep).once
+      subject.setup_subscribers
+    end
+  end
+
+  describe '#process_message' do
+    let(:worker) { double('worker', perform_async: nil) }
+
+    it 'fetches the corresponding worker' do
+      expect(subject.queue_worker_map).to receive(:[]).with('queue')
+                                                      .and_return(worker)
+      subject.process_message 'queue', "\{\}"
+    end
+
+    it 'schedules the worker' do
+      allow(subject.queue_worker_map).to receive(:[]).with('queue')
+                                                     .and_return(worker)
+      expect(worker).to receive(:perform_async)
+      subject.process_message 'queue', "\{\}"
+    end
+
+    it 'parses the message payload and passes it to the worker' do
+      allow(subject.queue_worker_map).to receive(:[]).with('queue')
+                                                     .and_return(worker)
+
+      payload = { 'foo' => 'bar' }
+      expect(worker).to receive(:perform_async).with payload
+      subject.process_message 'queue', JSON.dump(payload)
+    end
+  end
+end

data/spec/roundhousekiq/worker_definition_spec.rb

@@ -0,0 +1,76 @@
+describe Roundhousekiq::WorkerDefinition do
+  let(:definition) { Roundhousekiq::WorkerDefinition.new }
+
+  # Method existence
+  it { should respond_to :exchange }
+  it { should respond_to :queue }
+  it { should respond_to :exchange_name= }
+  it { should respond_to :exchange_type= }
+  it { should respond_to :queue_name= }
+  it { should respond_to :routing_key= }
+
+  describe '#exchange' do
+    it 'returns a hash' do
+      expect(definition.exchange).to be_instance_of Hash
+    end
+  end
+
+  describe '#exchange_name' do
+    it 'sets the name key in exchange' do
+      expect(definition.exchange[:name]).to be_nil
+      definition.exchange_name = 'rspec'
+      expect(definition.exchange[:name]).to match('rspec')
+    end
+  end
+
+  describe '#exchange_type' do
+    it 'sets the type key in exchange' do
+      expect(definition.exchange[:type]).to be_nil
+      definition.exchange_type = 'topic'
+      expect(definition.exchange[:type]).to match('topic')
+    end
+  end
+
+  describe '#queue_name' do
+    it 'sets the name in queue hash' do
+      expect(definition.queue[:name]).to be_nil
+      definition.queue_name = 'queue'
+      expect(definition.queue[:name]).to match('queue')
+    end
+
+    it 'defaults the queue name to empty string' do
+      expect(definition.queue[:name]).to be_nil
+      definition.queue_name = nil
+      expect(definition.queue[:name]).to match('')
+    end
+
+    it 'defines queue as durable for a named queue' do
+      definition.queue_name = 'named_queue'
+      expect(definition.queue[:durable]).to be true
+    end
+
+    it 'defines queue as non-durable for auto-generated queues' do
+      definition.queue_name = nil
+      expect(definition.queue[:durable]).to be false
+    end
+
+    it 'does not mark queue for auto-delete for a named queue' do
+      definition.queue_name = 'named_queue'
+      expect(definition.queue[:auto_delete]).to be false
+    end
+
+    it 'marks queue for auto-delete for auto-generated queues' do
+      definition.queue_name = nil
+      expect(definition.queue[:auto_delete]).to be true
+    end
+  end
+
+  describe '#routing_key' do
+    it 'sets the routing key in queue' do
+      expect(definition.queue[:routing_key]).to be_nil
+      definition.routing_key = 'routeMe'
+      expect(definition.queue[:routing_key]).to match('routeMe')
+    end
+  end
+
+end

data/spec/roundhousekiq/worker_spec.rb

@@ -0,0 +1,64 @@
+require './spec/fixtures/dummy_worker'
+
+describe Roundhousekiq::Worker do
+
+  # Method existence
+  it { should respond_to :included }
+
+  describe '.included' do
+    it 'extends the class methods module' do
+      worker = double('worker')
+      expect(worker).to receive(:extend)
+                          .with(Roundhousekiq::Worker::ClassMethods)
+      Roundhousekiq::Worker.send :included, worker
+    end
+
+    it 'registers the worker' do
+      worker = double('worker')
+      expect(Roundhousekiq::Workers).to receive(:register).with(worker)
+      Roundhousekiq::Worker.send :included, worker
+    end
+  end
+
+  describe '::ClassMethods' do
+    subject { DummyWorker }
+
+    it { should respond_to :exchange_name }
+    it { should respond_to :exchange_type }
+    it { should respond_to :queue_name }
+    it { should respond_to :routing_key }
+
+    describe '.exchange_name' do
+      it 'calls Roundhousekiq::Workers#exchange_name_for' do
+        expect(Roundhousekiq::Workers).to receive(:exchange_name_for)
+                                            .with(subject, 'notifications')
+        subject.exchange_name 'notifications'
+      end
+    end
+
+    describe '.exchange_type' do
+      it 'calls Roundhousekiq::Workers#exchange_type_for' do
+        expect(Roundhousekiq::Workers).to receive(:exchange_type_for)
+                                            .with(subject, 'topic')
+        subject.exchange_type 'topic'
+      end
+    end
+
+    describe '.queue_name' do
+      it 'calls Roundhousekiq::Workers#queue_name_for' do
+        expect(Roundhousekiq::Workers).to receive(:queue_name_for)
+                                            .with(subject, 'queue')
+        subject.queue_name 'queue'
+      end
+    end
+
+    describe '.routing_key' do
+      it 'calls Roundhousekiq::Workers#routing_key_for' do
+        expect(Roundhousekiq::Workers).to receive(:routing_key_for)
+                                            .with(subject, 'key.*')
+        subject.routing_key 'key.*'
+      end
+    end
+  end
+
+end

data/spec/roundhousekiq/workers_spec.rb

@@ -0,0 +1,71 @@
+require './spec/fixtures/dummy_worker'
+
+describe Roundhousekiq::Workers do
+  subject { Roundhousekiq::Workers }
+
+  # Methods
+  it { should respond_to :register }
+  it { should respond_to :definitions }
+  it { should respond_to :exchange_name_for }
+  it { should respond_to :exchange_type_for }
+  it { should respond_to :queue_name_for }
+  it { should respond_to :routing_key_for }
+
+  describe '.register' do
+    it 'creates a new definition for the given class' do
+      Roundhousekiq::Workers.register DummyWorker
+      definitions = Roundhousekiq::Workers.definitions
+      expect(definitions).to have_key DummyWorker
+      expect(definitions[DummyWorker]).to be_instance_of(
+        Roundhousekiq::WorkerDefinition
+      )
+    end
+  end
+
+  describe '.definitions' do
+    it 'returns the internal definitions hash' do
+      definitions = Roundhousekiq::Workers.class_variable_get '@@definitions'
+      expect(Roundhousekiq::Workers.definitions).to eq definitions
+    end
+  end
+
+  describe '.exchange_name_for' do
+    it 'passes the exchange name to the workers definition' do
+      worker = double('worker')
+      Roundhousekiq::Workers.register worker
+      definition = Roundhousekiq::Workers.definitions[worker]
+      expect(definition).to receive(:exchange_name=).with 'notifications'
+      subject.exchange_name_for worker, 'notifications'
+    end
+  end
+
+  describe '.exchange_type_for' do
+    it 'passes the exchange type to the workers definition' do
+      worker = double('worker')
+      Roundhousekiq::Workers.register worker
+      definition = Roundhousekiq::Workers.definitions[worker]
+      expect(definition).to receive(:exchange_type=).with 'topic'
+      subject.exchange_type_for worker, 'topic'
+    end
+  end
+
+  describe '.queue_name_for' do
+    it 'passes the queue name to the workers definition' do
+      worker = double('worker')
+      Roundhousekiq::Workers.register worker
+      definition = Roundhousekiq::Workers.definitions[worker]
+      expect(definition).to receive(:queue_name=).with 'importantQueue'
+      subject.queue_name_for worker, 'importantQueue'
+    end
+  end
+
+  describe '.routing_key_for' do
+    it 'passes the routing key to the workers definition' do
+      worker = double('worker')
+      Roundhousekiq::Workers.register worker
+      definition = Roundhousekiq::Workers.definitions[worker]
+      expect(definition).to receive(:routing_key=).with 'notifications.*'
+      subject.routing_key_for worker, 'notifications.*'
+    end
+  end
+end

data/spec/roundhousekiq_spec.rb

@@ -0,0 +1,34 @@
+describe Roundhousekiq do
+
+  # Method existence
+  it { should respond_to :config }
+  it { should respond_to :configure }
+
+  describe '.config' do
+    it 'returns a Configuration' do
+      expect(Roundhousekiq.config).to be_instance_of Roundhousekiq::Configuration
+    end
+
+    it 'always returns the same configuration' do
+      config = Roundhousekiq.config
+      expect(Roundhousekiq.config).to eq config
+    end
+  end
+
+  describe '.configure' do
+    it 'passes the Gem configuration to a block' do
+      Roundhousekiq.configure do |config|
+        expect(config).to be_instance_of Roundhousekiq::Configuration
+      end
+    end
+
+    it 'stores the configuration' do
+      configuration = nil
+      Roundhousekiq.configure do |config|
+        configuration = config
+      end
+
+      expect(Roundhousekiq.instance_variable_get '@config').to eq configuration
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,84 @@
+# Load Code Climate coverage reporter
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require './lib/roundhousekiq'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end