chore-core 1.5.2

data/spec/chore/queues/sqs/consumer_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe Chore::Queues::SQS::Consumer do
+  let(:queue_name) { "test" }
+  let(:queue_url) { "test_url" }
+  let(:queues) { double("queues") }
+  let(:queue) { double("test_queue") }
+  let(:options) { {} }
+  let(:consumer) { Chore::Queues::SQS::Consumer.new(queue_name) }
+  let(:message) { TestMessage.new("handle",queue_name,"message body", 1) }
+  let(:pool) { double("pool") }
+  let(:sqs) { double('AWS::SQS') }
+
+  before do
+    AWS::SQS.stub(:new).and_return(sqs)
+    sqs.stub(:queues).and_return { queues }
+     
+    queues.stub(:url_for) { queue_url }
+    queues.stub(:[]) { queue }
+    queue.stub(:receive_message) { message }
+    queue.stub(:visibility_timeout) { 10 }
+    pool.stub(:empty!) { nil }
+  end
+
+  describe "consuming messages" do
+    let!(:consumer_run_for_one_message) { consumer.stub(:running?).and_return(true, false) }
+    let!(:messages_be_unique) { Chore::DuplicateDetector.any_instance.stub(:found_duplicate?).and_return(false) }
+    let!(:queue_contain_messages) { queue.stub(:receive_messages).and_return(message) }
+
+    it 'should configure sqs' do
+      Chore.config.stub(:aws_access_key).and_return('key')
+      Chore.config.stub(:aws_secret_key).and_return('secret')
+
+      AWS::SQS.should_receive(:new).with(
+        :access_key_id => 'key',
+        :secret_access_key => 'secret',
+        :logger => Chore.logger,
+        :log_level => :debug
+      ).and_return(sqs)
+      consumer.consume
+    end
+
+    it 'should not configure sqs multiple times' do
+      consumer.stub(:running?).and_return(true, true, false)
+
+      AWS::SQS.should_receive(:new).once.and_return(sqs)
+      consumer.consume
+    end
+
+    it 'should look up the queue url based on the queue name' do
+      queues.should_receive(:url_for).with('test').and_return(queue_url)
+      consumer.consume
+    end
+
+    it 'should look up the queue based on the queue url' do
+      queues.should_receive(:[]).with(queue_url).and_return(queue)
+      consumer.consume
+    end
+
+    context "should receive a message from the queue" do
+
+      it 'should use the default size of 10 when no queue_polling_size is specified' do
+        queue.should_receive(:receive_messages).with(:limit => 10, :attributes => [:receive_count])
+        consumer.consume
+      end
+
+      it 'should respect the queue_polling_size when specified' do
+        Chore.config.stub(:queue_polling_size).and_return(5)
+        queue.should_receive(:receive_messages).with(:limit => 5, :attributes => [:receive_count])
+        consumer.consume
+      end
+    end
+
+    it "should check the uniqueness of the message" do
+      Chore::DuplicateDetector.any_instance.should_receive(:found_duplicate?).with(message).and_return(false)
+      consumer.consume
+    end
+
+    it "should yield the message to the handler block" do
+      expect { |b| consumer.consume(&b) }.to yield_with_args('handle', queue_name, 10, 'message body', 0)
+    end
+
+    it 'should not yield for a dupe message' do
+      Chore::DuplicateDetector.any_instance.should_receive(:found_duplicate?).with(message).and_return(true)
+      expect {|b| consumer.consume(&b) }.not_to yield_control
+    end
+
+    context 'with no messages' do
+      let!(:consumer_run_for_one_message) { consumer.stub(:running?).and_return(true, true, false) }
+      let!(:queue_contain_messages) { queue.stub(:receive_messages).and_return(message, nil) }
+
+      it 'should sleep' do
+        consumer.should_receive(:sleep).with(1)
+        consumer.consume
+      end
+    end
+
+    context 'with messages' do
+      let!(:consumer_run_for_one_message) { consumer.stub(:running?).and_return(true, true, false) }
+      let!(:queue_contain_messages) { queue.stub(:receive_messages).and_return(message, message) }
+
+      it 'should not sleep' do
+        consumer.should_not_receive(:sleep)
+        consumer.consume
+      end
+    end
+  end
+
+  describe '#reset_connection!' do
+    it 'should reset the connection after a call to reset_connection!' do
+      AWS::Core::Http::ConnectionPool.stub(:pools).and_return([pool])
+      pool.should_receive(:empty!)
+      Chore::Queues::SQS::Consumer.reset_connection!
+      consumer.send(:queue)
+    end
+
+    it 'should not reset the connection between calls' do
+      sqs = consumer.send(:queue)
+      sqs.should be consumer.send(:queue)
+    end
+
+    it 'should reconfigure sqs' do
+      consumer.stub(:running?).and_return(true, false)
+      Chore::DuplicateDetector.any_instance.stub(:found_duplicate?).and_return(false)
+
+      queue.stub(:receive_messages).and_return(message)
+      consumer.consume
+
+      Chore::Queues::SQS::Consumer.reset_connection!
+      AWS::SQS.should_receive(:new).and_return(sqs)
+
+      consumer.stub(:running?).and_return(true, false)
+      consumer.consume
+    end
+  end
+end

data/spec/chore/queues/sqs/publisher_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module Chore
+  describe Queues::SQS::Publisher do
+    let(:job) { {'class' => 'TestJob', 'args'=>[1,2,'3']}}
+    let(:queue_name) { 'test_queue' }
+    let(:queue_url) {"http://www.queue_url.com/test_queue"}
+    let(:queue) { double('queue', :send_message => nil) }
+    let(:sqs) do
+      double('sqs', :queues => double('queues', :named => queue, :url_for => queue_url, :[] => queue))
+    end
+    let(:publisher) { Queues::SQS::Publisher.new }
+    let(:pool) { double("pool") }
+
+    before(:each) do
+      AWS::SQS.stub(:new).and_return(sqs)
+    end
+
+    it 'should configure sqs' do
+      Chore.config.stub(:aws_access_key).and_return('key')
+      Chore.config.stub(:aws_secret_key).and_return('secret')
+
+      AWS::SQS.should_receive(:new).with(
+        :access_key_id => 'key',
+        :secret_access_key => 'secret',
+        :logger => Chore.logger,
+        :log_level => :debug
+      )
+      publisher.publish(queue_name,job)
+    end
+
+    it 'should create send an encoded message to the specified queue' do
+      queue.should_receive(:send_message).with(job.to_json)
+      publisher.publish(queue_name,job)
+    end
+
+    it 'should lookup the queue when publishing' do
+      sqs.queues.should_receive(:url_for).with('test_queue')
+      publisher.publish('test_queue', job)
+    end
+
+    it 'should lookup multiple queues if specified' do
+      sqs.queues.should_receive(:url_for).with('test_queue')
+      sqs.queues.should_receive(:url_for).with('test_queue2')
+      publisher.publish('test_queue', job)
+      publisher.publish('test_queue2', job)
+    end
+
+    it 'should only lookup a named queue once' do
+      sqs.queues.should_receive(:url_for).with('test_queue').once
+      2.times { publisher.publish('test_queue', job) }
+    end
+
+    describe '#reset_connection!' do
+      it 'should reset the connection after a call to reset_connection!' do
+        AWS::Core::Http::ConnectionPool.stub(:pools).and_return([pool])
+        pool.should_receive(:empty!)
+        Chore::Queues::SQS::Publisher.reset_connection!
+        publisher.queue(queue_name)
+      end
+  
+      it 'should not reset the connection between calls' do
+        sqs = publisher.queue(queue_name)
+        sqs.should be publisher.queue(queue_name)
+      end
+  
+      it 'should reconfigure sqs' do
+        Chore::Queues::SQS::Publisher.reset_connection!
+        AWS::SQS.should_receive(:new)
+        publisher.queue(queue_name)
+      end
+    end
+  end
+end

data/spec/chore/queues/sqs_spec.rb

@@ -0,0 +1,37 @@
+module Chore
+  describe Queues::SQS do
+    context "when managing queues" do
+      let(:fake_sqs) {double(Object)}
+      let(:fake_queue_collection) {double(Object)}
+      let(:queue_name) {"test"}
+      let(:queue_url) {"http://amazon.sqs.url/queues/#{queue_name}"}
+      let(:fake_queue) {double(Object)}
+
+      before(:each) do
+        AWS::SQS.stub(:new).and_return(fake_sqs)
+        Chore.stub(:prefixed_queue_names) {[queue_name]}
+        fake_queue.stub(:delete)
+    
+        fake_queue_collection.stub(:[]) do |key|
+          fake_queue
+        end
+    
+        fake_queue_collection.stub(:create)
+        fake_sqs.stub(:queues).and_return(fake_queue_collection)
+        fake_queue_collection.stub(:url_for).with(queue_name).and_return(queue_url)
+      end
+
+      it 'should create queues that are defined in its internal job name list' do
+        #Only one job defined in the spec suite
+        fake_queue_collection.should_receive(:create)
+        Chore::Queues::SQS.create_queues!
+      end
+
+      it 'should delete queues that are defined in its internal job name list' do
+        #Only one job defined in the spec suite
+        fake_queue.should_receive(:delete)
+        Chore::Queues::SQS.delete_queues!
+      end
+    end
+  end
+end

data/spec/chore/signal_spec.rb

@@ -0,0 +1,244 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Chore::Signal do
+  let(:signal_handlers) {{}}
+  before :each do
+    ::Signal.stub(:trap) do |signal, command=nil, &block|
+      if command
+        signal_handlers.delete(signal)
+      else
+        signal_handlers[signal] = block
+      end
+    end
+
+    Process.stub(:kill) do |signal, process_id|
+      signal_handlers[signal].call if signal_handlers[signal]
+      sleep 0.1
+    end
+  end
+
+  after(:each) do
+    described_class.reset
+  end
+
+  describe 'trap' do
+    context 'without any handlers' do
+      it 'should not be intercepted by Chore::Signal' do
+        described_class.should_not_receive(:process).with("SIG1")
+        lambda { Process.kill('SIG1', Process.pid) }
+      end
+    end
+
+    context 'with a command' do
+      before(:each) do
+        described_class.trap('SIG1', 'DEFAULT')
+      end
+
+      it 'should result in Rubys default behavior for the signal' do
+        lambda { Process.kill('SIG1', Process.pid) }.should_not raise_error(SignalException)
+      end
+    end
+
+    context 'with a command and handler' do
+      before(:each) do
+        @callbacks = []
+        described_class.trap('SIG1', 'DEFAULT') do
+          @callbacks << :usr2
+        end
+      end
+
+      it 'should result in Rubys default behavior for the signal' do
+        lambda { Process.kill('SIG1', Process.pid) }.should_not raise_error(SignalException)
+      end
+
+      it 'should not call the handler' do
+        begin
+          Process.kill('SIG1', Process.pid)
+        rescue SignalException => e
+
+        end
+        @callbacks.should match_array([])
+      end
+    end
+
+    context 'with a single handler' do
+      before(:each) do
+        @callbacks = []
+      end
+
+      context 'without exceptions' do
+        before(:each) do
+          described_class.trap('SIG1') do
+            @callbacks << :sig1
+          end
+        end
+
+        it 'should not call the handler if signal does not match' do
+          lambda { Process.kill('SIG2', Process.pid) }.should_not raise_error(SignalException)
+          @callbacks.should match_array([])
+        end
+
+        it 'should call the handler if the signal matches' do
+          Process.kill('SIG1', Process.pid)
+          @callbacks.should match_array([:sig1])
+        end
+      end
+
+      context 'with exceptions' do
+        before(:each) do
+          @count = 0
+          @callbacks = []
+          described_class.trap('SIG1') do
+            @count += 1
+            raise ArgumentError if @count == 1
+            @callbacks << :sig1
+          end
+        end
+
+        it 'should not retry the callback' do
+          Process.kill('SIG1', Process.pid)
+          @callbacks.should match_array([])
+        end
+
+        it 'should still continue processing' do
+          2.times { Process.kill('SIG1', Process.pid) }
+          @callbacks.should match_array([:sig1])
+        end
+      end
+    end
+
+    context 'with multiple handlers' do
+      before(:each) do
+        @callbacks = []
+        described_class.trap('SIG1') do
+          @callbacks << :first
+        end
+        described_class.trap('SIG1') do
+          @callbacks << :second
+        end
+      end
+
+      it 'should only call the last recorded handler' do
+        Process.kill('SIG1', Process.pid)
+        @callbacks.should match_array([:second])
+      end
+    end
+
+    context 'with reset handler' do
+      before(:each) do
+        @callbacks = []
+        described_class.trap('SIG1') do
+          @callbacks << :first
+        end
+        described_class.trap('SIG1', 'DEFAULT')
+      end
+
+      it 'should not call the original handler' do
+        Process.kill('SIG1', Process.pid)
+        @callbacks.should match_array([])
+      end
+    end
+
+    context 'with multiple signals' do
+      before(:each) do
+        @callbacks = []
+        described_class.trap('SIG1') do
+          @callbacks << :sig1
+        end
+        described_class.trap('SIG2') do
+          @callbacks << :sig2
+        end
+      end
+
+      it 'should handle each one' do
+        Process.kill('SIG1', Process.pid)
+        Process.kill('SIG2', Process.pid)
+        @callbacks.should match_array([:sig1, :sig2])
+      end
+
+      it 'should process most recent signals first' do
+        mutex = Mutex.new
+        described_class.trap('SIG1') do
+          @callbacks << :sig1
+          mutex.lock
+        end
+        described_class.trap('SIG3') do
+          @callbacks << :sig3
+        end
+
+        mutex.lock
+        Process.kill('SIG1', Process.pid)
+        Process.kill('SIG1', Process.pid)
+        Process.kill('SIG2', Process.pid)
+        Process.kill('SIG3', Process.pid)
+        mutex.unlock
+        sleep 0.1
+
+        @callbacks.should match_array([:sig1, :sig3, :sig2, :sig1])
+      end
+
+      it 'should process primary signals first' do
+        mutex = Mutex.new
+        described_class.trap('SIG1') do
+          @callbacks << :sig1
+          mutex.lock
+        end
+        described_class.trap('SIG3') do
+          @callbacks << :sig3
+        end
+
+        mutex.lock
+        Process.kill('SIG1', Process.pid)
+        Process.kill('SIG2', Process.pid)
+        Process.kill('SIG3', Process.pid)
+        mutex.unlock
+        sleep 0.1
+
+        @callbacks.should match_array([:sig1, :sig2, :sig3])
+      end
+    end
+  end
+
+  describe 'reset' do
+    it 'should clear existing handlers' do
+      callbacks = []
+      described_class.trap('SIG1') do
+        callbacks << :sig1
+      end
+      described_class.reset
+      Process.kill('SIG1', Process.pid)
+      callbacks.should match_array([])
+    end
+
+    it 'should not run unprocessed signals' do
+      callbacks = []
+      mutex = Mutex.new
+      described_class.trap('SIG1') do
+        callbacks << :sig1
+        mutex.lock
+      end
+      described_class.trap('SIG2') do
+        callbacks << :sig2
+      end
+      mutex.lock
+      Process.kill('SIG1', Process.pid)
+      Process.kill('SIG2', Process.pid)
+      described_class.reset
+      mutex.unlock
+      callbacks.should match_array([:sig1])
+    end
+
+    it 'should still listen for new traps' do
+      callbacks = []
+      described_class.trap('SIG1') do
+        callbacks << :sig1
+      end
+      described_class.reset
+      described_class.trap('SIG1') do
+        callbacks << :sig1
+      end
+      Process.kill('SIG1', Process.pid)
+      callbacks.should match_array([:sig1])
+    end
+  end
+end

data/spec/chore/strategies/consumer/batcher_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Chore::Strategy::Batcher do
+  let(:batch_size) { 5 }
+  let(:callback) { double("callback") }
+  subject do
+    batcher = Chore::Strategy::Batcher.new(batch_size)
+    batcher.callback = callback
+    batcher
+  end
+
+  context 'with no items' do
+    it 'should not be ready' do
+      subject.should_not be_ready
+    end
+
+    it 'should not invoke the callback when executed' do
+      callback.should_not_receive(:call)
+      subject.execute
+    end
+
+    it 'should not invoke the callback when force-executed' do
+      callback.should_not_receive(:call)
+      subject.execute(true)
+    end
+
+    it 'should not invoke callback when adding a new item' do
+      callback.should_not_receive(:call)
+      subject.add('test')
+    end
+  end
+
+  context 'with partial batch completed' do
+    let(:batch) { ['test'] * 3 }
+
+    before(:each) do
+      subject.batch = batch.dup
+    end
+
+    it 'should not be ready' do
+      subject.should_not be_ready
+    end
+
+    it 'should not invoke callback when executed' do
+      callback.should_not_receive(:call)
+      subject.execute
+    end
+
+    it 'should invoke callback when force-executed' do
+      callback.should_receive(:call).with(batch)
+      subject.execute(true)
+    end
+
+    it 'should invoke callback when add completes the batch' do
+      subject.add('test')
+      callback.should_receive(:call).with(['test'] * 5)
+      subject.add('test')
+    end
+  end
+
+  context 'with batch completed' do
+    let(:batch) { ['test'] * 5 }
+
+    before(:each) do
+      subject.batch = batch.dup
+    end
+
+    it 'should be ready' do
+      subject.should be_ready
+    end
+
+    it 'should invoke callback when executed' do
+      callback.should_receive(:call).with(batch)
+      subject.execute
+    end
+
+    it 'should invoke callback when force-executed' do
+      callback.should_receive(:call).with(batch)
+      subject.execute(true)
+    end
+
+    it 'should invoke callback with subset-only when added to' do
+      callback.should_receive(:call).with(['test'] * 5)
+      subject.add('test')
+    end
+
+    it 'should leave remaining batch when added to' do
+      callback.stub(:call)
+      subject.add('test')
+      subject.batch.should == ['test']
+    end
+  end
+end

data/spec/chore/strategies/consumer/single_consumer_strategy_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Chore::Strategy::SingleConsumerStrategy do
+  let(:fetcher) { double("fetcher") }
+  let(:manager) { double("manager") }
+  let(:consumer) { double("consumer") }
+  let(:test_queues) { ["test-queue"] }
+  let(:strategy) { Chore::Strategy::SingleConsumerStrategy.new(fetcher) }
+
+  before do
+    fetcher.stub(:manager) { manager }
+    Chore.config.stub(:queues).and_return(test_queues)
+    Chore.config.stub(:consumer).and_return(consumer)
+    
+  end
+
+  it "should consume and then assign a message" do
+    consumer.should_receive(:new).with(test_queues.first).and_return(consumer)
+    consumer.should_receive(:consume).and_yield(1, 'test-queue', 60, "test", 0)
+    manager.should_receive(:assign).with(Chore::UnitOfWork.new(1, 'test-queue', 60, "test", 0, consumer))
+    strategy.fetch
+  end
+end