shoryuken 0.0.5 → 1.0.0

data/spec/shoryuken/client_spec.rb

@@ -1,62 +1,21 @@
 require 'spec_helper'
 
 describe Shoryuken::Client do
-  let(:sqs)              { double 'SQS' }
-  let(:queue_collection) { double 'Queues Collection' }
-  let(:sqs_queue)        { double 'SQS Queue' }
-  let(:queue)            { 'shoryuken' }
+  let(:credentials) { Aws::Credentials.new('access_key_id', 'secret_access_key') }
+  let(:sqs)         { Aws::SQS::Client.new(stub_responses: true, credentials: credentials) }
+  let(:queue_name)  { 'shoryuken' }
+  let(:queue_url)   { 'https://eu-west-1.amazonaws.com:6059/123456789012/shoryuken' }
 
   before do
-    allow(described_class).to receive(:sqs).and_return(sqs)
-    allow(sqs).to receive(:queues).and_return(queue_collection)
-    allow(queue_collection).to receive(:named).and_return(sqs_queue)
+    described_class.sqs = sqs
   end
 
-  describe '.queues' do
+  describe '.queue' do
     it 'memoizes queues' do
-      expect(queue_collection).to receive(:named).once.with(queue).and_return(sqs_queue)
+      sqs.stub_responses(:get_queue_url, { queue_url: queue_url }, { queue_url: 'xyz' })
 
-      expect(Shoryuken::Client.queues(queue)).to eq sqs_queue
-      expect(Shoryuken::Client.queues(queue)).to eq sqs_queue
-    end
-  end
-
-  describe '.send_message' do
-    it 'enqueues a message' do
-      expect(sqs_queue).to receive(:send_message).with('test', {})
-
-      described_class.send_message(queue, 'test')
-    end
-
-    it 'enqueues a message with options' do
-      expect(sqs_queue).to receive(:send_message).with('test2', delay_seconds: 60)
-
-      described_class.send_message(queue, 'test2', delay_seconds: 60)
-    end
-
-    it 'parsers as JSON by default' do
-      msg = { field: 'test', other_field: 'other' }
-
-      expect(sqs_queue).to receive(:send_message).with(JSON.dump(msg), {})
-
-      described_class.send_message(queue, msg)
-    end
-
-    it 'parsers as JSON by default and keep the options' do
-      msg = { field: 'test', other_field: 'other' }
-
-      expect(sqs_queue).to receive(:send_message).with(JSON.dump(msg), { delay_seconds:  60 })
-
-      described_class.send_message(queue, msg, delay_seconds: 60)
-    end
-  end
-
-  describe '.visibility_timeout' do
-    it 'memoizes visibility_timeout' do
-      expect(sqs_queue).to receive(:visibility_timeout).once.and_return(30)
-
-      expect(Shoryuken::Client.visibility_timeout(queue)).to eq 30
-      expect(Shoryuken::Client.visibility_timeout(queue)).to eq 30
+      expect(Shoryuken::Client.queues(queue_name).url).to eq queue_url
+      expect(Shoryuken::Client.queues(queue_name).url).to eq queue_url
     end
   end
 end

data/spec/shoryuken/default_worker_registry_spec.rb

@@ -48,7 +48,7 @@ describe Shoryuken::DefaultWorkerRegistry do
         string_value: explicit_worker.to_s,
         data_type: 'String' } if explicit_worker
 
-      double AWS::SQS::ReceivedMessage,
+      double Aws::SQS::Message,
         body: 'test',
         message_attributes: attributes,
         message_id: SecureRandom.uuid

data/spec/shoryuken/fetcher_spec.rb

@@ -3,62 +3,68 @@ require 'shoryuken/manager'
 require 'shoryuken/fetcher'
 
 describe Shoryuken::Fetcher do
-  let(:manager)   { double Shoryuken::Manager }
-  let(:sqs_queue) { double 'sqs_queue' }
-  let(:queue)     { 'default' }
-  let(:sqs_msg)   { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test' }
+  let(:manager)    { double Shoryuken::Manager }
+  let(:queue)      { double Aws::SQS::Queue }
+  let(:queue_name) { 'default' }
+
+  let(:sqs_msg) do
+    double Aws::SQS::Message,
+      queue_url: queue_name,
+      body: 'test',
+      message_id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e'
+  end
 
   subject { described_class.new(manager) }
 
   before do
     allow(manager).to receive(:async).and_return(manager)
-    allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+    allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
   end
 
 
   describe '#fetch' do
     it 'calls pause when no message' do
-      allow(sqs_queue).to receive(:receive_message).with(limit: 1, message_attribute_names: ['shoryuken_class']).and_return([])
+      allow(queue).to receive(:receive_messages).with(max_number_of_messages: 1, message_attribute_names: ['All']).and_return([])
 
-      expect(manager).to receive(:pause_queue!).with(queue)
+      expect(manager).to receive(:pause_queue!).with(queue_name)
       expect(manager).to receive(:dispatch)
 
-      subject.fetch(queue, 1)
+      subject.fetch(queue_name, 1)
     end
 
     it 'assigns messages' do
-      allow(sqs_queue).to receive(:receive_message).with(limit: 5, message_attribute_names: ['shoryuken_class']).and_return(sqs_msg)
+      allow(queue).to receive(:receive_messages).with(max_number_of_messages: 5, message_attribute_names: ['All']).and_return(sqs_msg)
 
-      expect(manager).to receive(:rebalance_queue_weight!).with(queue)
-      expect(manager).to receive(:assign).with(queue, sqs_msg)
+      expect(manager).to receive(:rebalance_queue_weight!).with(queue_name)
+      expect(manager).to receive(:assign).with(queue_name, sqs_msg)
       expect(manager).to receive(:dispatch)
 
-      subject.fetch(queue, 5)
+      subject.fetch(queue_name, 5)
     end
 
     it 'assigns messages in batch' do
       TestWorker.get_shoryuken_options['batch'] = true
 
-      allow(sqs_queue).to receive(:receive_message).with(limit: described_class::FETCH_LIMIT, message_attribute_names: ['shoryuken_class']).and_return(sqs_msg)
+      allow(queue).to receive(:receive_messages).with(max_number_of_messages: described_class::FETCH_LIMIT, message_attribute_names: ['All']).and_return(sqs_msg)
 
-      expect(manager).to receive(:rebalance_queue_weight!).with(queue)
-      expect(manager).to receive(:assign).with(queue, [sqs_msg])
+      expect(manager).to receive(:rebalance_queue_weight!).with(queue_name)
+      expect(manager).to receive(:assign).with(queue_name, [sqs_msg])
       expect(manager).to receive(:dispatch)
 
-      subject.fetch(queue, 5)
+      subject.fetch(queue_name, 5)
     end
 
     context 'when worker not found' do
-      let(:queue) { 'notfound' }
+      let(:queue_name) { 'notfound' }
 
       it 'ignores batch' do
-        allow(sqs_queue).to receive(:receive_message).with(limit: 5, message_attribute_names: ['shoryuken_class']).and_return(sqs_msg)
+        allow(queue).to receive(:receive_messages).with(max_number_of_messages: 5, message_attribute_names: ['All']).and_return(sqs_msg)
 
-        expect(manager).to receive(:rebalance_queue_weight!).with(queue)
-        expect(manager).to receive(:assign).with(queue, sqs_msg)
+        expect(manager).to receive(:rebalance_queue_weight!).with(queue_name)
+        expect(manager).to receive(:assign).with(queue_name, sqs_msg)
         expect(manager).to receive(:dispatch)
 
-        subject.fetch(queue, 5)
+        subject.fetch(queue_name, 5)
       end
     end
   end

data/spec/shoryuken/middleware/server/auto_delete_spec.rb

@@ -1,9 +1,17 @@
 require 'spec_helper'
 
 describe Shoryuken::Middleware::Server::AutoDelete do
-  let(:sqs_msg)   { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test' }
   let(:queue)     { 'default' }
-  let(:sqs_queue) { double AWS::SQS::Queue }
+  let(:sqs_queue) { double Aws::SQS::Queue }
+
+  def build_message
+    double Aws::SQS::Message,
+      queue_url: queue,
+      body: 'test',
+      receipt_handle: SecureRandom.uuid
+  end
+
+  let(:sqs_msg) { build_message }
 
   before do
     allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
@@ -12,7 +20,8 @@ describe Shoryuken::Middleware::Server::AutoDelete do
   it 'deletes a message' do
     TestWorker.get_shoryuken_options['auto_delete'] = true
 
-    expect(sqs_queue).to receive(:batch_delete).with(sqs_msg)
+    expect(sqs_queue).to receive(:delete_messages).with(entries: [
+      { id: '0', receipt_handle: sqs_msg.receipt_handle }])
 
     subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) {}
   end
@@ -20,12 +29,15 @@ describe Shoryuken::Middleware::Server::AutoDelete do
   it 'deletes a batch' do
     TestWorker.get_shoryuken_options['auto_delete'] = true
 
-    sqs_msg2 = double 'SQS msg', body: 'test'
-    sqs_msg3 = double 'SQS msg', body: 'test'
+    sqs_msg2 = build_message
+    sqs_msg3 = build_message
 
     sqs_msgs = [sqs_msg, sqs_msg2, sqs_msg3]
 
-    expect(sqs_queue).to receive(:batch_delete).with(*sqs_msgs)
+    expect(sqs_queue).to receive(:delete_messages).with(entries: [
+      { id: '0', receipt_handle: sqs_msg.receipt_handle },
+      { id: '1', receipt_handle: sqs_msg2.receipt_handle },
+      { id: '2', receipt_handle: sqs_msg3.receipt_handle }])
 
     subject.call(TestWorker.new, queue, sqs_msgs, [sqs_msg.body, sqs_msg2.body, sqs_msg3.body]) {}
   end
@@ -33,14 +45,14 @@ describe Shoryuken::Middleware::Server::AutoDelete do
   it 'does not delete a message' do
     TestWorker.get_shoryuken_options['auto_delete'] = false
 
-    expect(sqs_queue).to_not receive(:batch_delete)
+    expect(sqs_queue).to_not receive(:delete_messages)
 
     subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) {}
   end
 
   context 'when exception' do
     it 'does not delete a message' do
-      expect(sqs_queue).to_not receive(:batch_delete)
+      expect(sqs_queue).to_not receive(:delete_messages)
 
       expect {
         subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise }

data/spec/shoryuken/middleware/server/timing_spec.rb

@@ -1,10 +1,21 @@
 require 'spec_helper'
 
 describe Shoryuken::Middleware::Server::Timing do
-  let(:sqs_msg) { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test' }
-  let(:queue)   { 'default' }
+  let(:queue) { 'default' }
+  let(:sqs_queue) { double Aws::SQS::Queue, visibility_timeout: 60 }
+
+  let(:sqs_msg) do
+    double Aws::SQS::Message,
+      queue_url: queue,
+      body: 'test',
+      message_id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e'
+  end
+
+  before do
+    allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+  end
 
-  xit 'logs timing' do
+  it 'logs timing' do
     expect(Shoryuken.logger).to receive(:info).with(/started at/)
     expect(Shoryuken.logger).to receive(:info).with(/completed in/)
 
@@ -13,7 +24,6 @@ describe Shoryuken::Middleware::Server::Timing do
 
   context 'when exceeded the `visibility_timeout`' do
     it 'logs exceeded' do
-      allow(Shoryuken::Client).to receive(:visibility_timeout).and_return(60)
       allow(subject).to receive(:elapsed).and_return(120000)
 
       expect(Shoryuken.logger).to receive(:info).with(/started at/)

data/spec/shoryuken/processor_spec.rb

@@ -4,9 +4,17 @@ require 'shoryuken/manager'
 
 describe Shoryuken::Processor do
   let(:manager)   { double Shoryuken::Manager, processor_done: nil }
-  let(:sqs_queue) { double AWS::SQS::Queue, visibility_timeout: 30 }
+  let(:sqs_queue) { double Aws::SQS::Queue, visibility_timeout: 30 }
   let(:queue)     { 'default' }
-  let(:sqs_msg)   { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test', message_attributes: {} }
+
+  let(:sqs_msg) do
+    double Aws::SQS::Message,
+      queue_url: queue,
+      body: 'test',
+      message_attributes: {},
+      message_id: SecureRandom.uuid,
+      receipt_handle: SecureRandom.uuid
+  end
 
   subject { described_class.new(manager) }
 
@@ -110,29 +118,66 @@ describe Shoryuken::Processor do
 
           def perform(sqs_msg, body); end
         end
+      end
 
-        Shoryuken.configure_server do |config|
-          config.server_middleware do |chain|
-            chain.add WorkerCalledMiddleware
+      context 'server' do
+        before do
+          allow(Shoryuken).to receive(:server?).and_return(true)
+          WorkerCalledMiddlewareWorker.instance_variable_set(:@server_chain, nil) # un-memoize middleware
+
+          Shoryuken.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.add WorkerCalledMiddleware
+            end
           end
         end
-      end
 
-      after do
-        Shoryuken.configure_server do |config|
-          config.server_middleware do |chain|
-            chain.remove WorkerCalledMiddleware
+        after do
+          Shoryuken.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.remove WorkerCalledMiddleware
+            end
           end
         end
+
+        it 'invokes middleware' do
+          expect(manager).to receive(:processor_done).with(queue, subject)
+
+          expect_any_instance_of(WorkerCalledMiddlewareWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
+          expect_any_instance_of(WorkerCalledMiddlewareWorker).to receive(:called).with(sqs_msg, queue)
+
+          subject.process(queue, sqs_msg)
+        end
       end
 
-      it 'invokes middleware' do
-        expect(manager).to receive(:processor_done).with(queue, subject)
+      context 'client' do
+        before do
+          allow(Shoryuken).to receive(:server?).and_return(false)
+          WorkerCalledMiddlewareWorker.instance_variable_set(:@server_chain, nil) # un-memoize middleware
 
-        expect_any_instance_of(WorkerCalledMiddlewareWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
-        expect_any_instance_of(WorkerCalledMiddlewareWorker).to receive(:called).with(sqs_msg, queue)
+          Shoryuken.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.add WorkerCalledMiddleware
+            end
+          end
+        end
 
-        subject.process(queue, sqs_msg)
+        after do
+          Shoryuken.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.remove WorkerCalledMiddleware
+            end
+          end
+        end
+
+        it "doesn't invoke middleware" do
+          expect(manager).to receive(:processor_done).with(queue, subject)
+
+          expect_any_instance_of(WorkerCalledMiddlewareWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
+          expect_any_instance_of(WorkerCalledMiddlewareWorker).to_not receive(:called).with(sqs_msg, queue)
+
+          subject.process(queue, sqs_msg)
+        end
       end
     end
 
@@ -143,7 +188,7 @@ describe Shoryuken::Processor do
 
       expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
 
-      expect(sqs_queue).to receive(:batch_delete).with(sqs_msg)
+      expect(sqs_queue).to receive(:delete_messages).with(entries: [{ id: '0', receipt_handle: sqs_msg.receipt_handle }])
 
       subject.process(queue, sqs_msg)
     end
@@ -155,18 +200,23 @@ describe Shoryuken::Processor do
 
       expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
 
-      expect(sqs_queue).to_not receive(:batch_delete)
+      expect(sqs_queue).to_not receive(:delete_messages)
 
       subject.process(queue, sqs_msg)
     end
 
     context 'when shoryuken_class header' do
-      let(:sqs_msg) { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test', message_attributes: {
-        'shoryuken_class' => {
-          string_value: TestWorker.to_s,
-          data_type: 'String'
-        }
-      } }
+      let(:sqs_msg) do
+        double Aws::SQS::Message,
+          queue_url: queue,
+          body: 'test',
+          message_attributes: {
+            'shoryuken_class' => {
+              string_value: TestWorker.to_s,
+              data_type: 'String' }},
+          message_id: SecureRandom.uuid,
+          receipt_handle: SecureRandom.uuid
+      end
 
       it 'performs without delete' do
         Shoryuken.worker_registry.clear # unregister TestWorker
@@ -175,7 +225,7 @@ describe Shoryuken::Processor do
 
         expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
 
-        expect(sqs_queue).to_not receive(:batch_delete)
+        expect(sqs_queue).to_not receive(:delete_messages)
 
         subject.process(queue, sqs_msg)
       end

data/spec/shoryuken/sns_arn_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Shoryuken::SnsArn do
+  let(:account_id) { '1234567890' }
+  let(:region) { 'eu-west-1' }
+  let(:topic) { 'topic-x' }
+
+  before do
+    Shoryuken::Client.account_id = account_id
+    Aws.config = { region: region }
+  end
+
+  subject { described_class.new(topic).to_s }
+
+  describe '#to_s' do
+    context 'when the Aws config includes all the information necessary' do
+      it 'generates an SNS arn' do
+        expect(subject).to eq('arn:aws:sns:eu-west-1:1234567890:topic-x')
+      end
+    end
+
+    context 'when the Aws config does not include the account id' do
+      before do
+        Shoryuken::Client.account_id = nil
+      end
+
+      it 'fails' do
+        expect { subject }.to raise_error(/an :account_id/)
+      end
+    end
+
+    context 'when the Aws config does not include the region' do
+      before do
+        Aws.config.delete :region
+      end
+
+      it 'fails' do
+        expect { subject }.to raise_error(/a :region/)
+      end
+    end
+  end
+end