dispatch-rider 1.4.0 → 1.4.2

data/spec/lib/dispatch-rider/publisher_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe DispatchRider::Publisher do
+
+  subject do
+    described_class.new
+  end
+
+  describe "#initialize" do
+    it "assigns the notification service registrar" do
+      subject.notification_service_registrar.store.should be_empty
+    end
+
+    it "assigns a publishing destination registrar" do
+      subject.publishing_destination_registrar.store.should be_empty
+    end
+
+    it "assigns a service channel mapper" do
+      subject.service_channel_mapper.destination_registrar.store.should be_empty
+    end
+
+    context "when not passing a configuration" do
+      it "loads the global configuration" do
+        DispatchRider::Publisher::ConfigurationReader.should_receive(:load_config).with(described_class.configuration, subject)
+      end
+    end
+
+    context "when passing a configuration" do
+      let(:configuration){ DispatchRider::Publisher::Configuration.new }
+
+      subject{ described_class.new(configuration) }
+
+      it "loads the configuration" do
+        DispatchRider::Publisher::ConfigurationReader.should_receive(:load_config).with(configuration, subject)
+      end
+    end
+  end
+
+  describe "#register_notification_service" do
+    it "registers a notification service" do
+      subject.register_notification_service(:aws_sns)
+      result = subject.notification_service_registrar.fetch(:aws_sns)
+      result.notifier.should respond_to(:topics)
+      result.channel_registrar.store.should be_empty
+    end
+
+    it "returns the publisher" do
+      subject.register_notification_service(:aws_sns).should eq(subject)
+    end
+  end
+
+  describe "#register_channel" do
+    before :each do
+      subject.register_notification_service(:aws_sns)
+    end
+
+    let(:notification_service) { subject.notification_service_registrar.fetch(:aws_sns) }
+
+    it "registers a channel for the notification service" do
+      subject.register_channel(:aws_sns, :foo, account: 123, region: "us-east-1", topic: "PlanOfAttack")
+      notification_service.channel_registrar.fetch(:foo).should eq('arn:aws:sns:us-east-1:123:PlanOfAttack')
+    end
+
+    it "returns the publisher" do
+      subject.register_channel(:aws_sns, :foo).should eq(subject)
+    end
+  end
+
+  describe "#register_destination" do
+    before :each do
+      subject.register_notification_service(:aws_sns)
+    end
+
+    it "registers the destination to be published to" do
+      subject.register_destination(:sns_foo, :aws_sns, :foo, account: 123, region: "us-east-1", topic: "PlanOfAttack")
+      result = subject.publishing_destination_registrar.fetch(:sns_foo)
+      result.service.should eq(:aws_sns)
+      result.channel.should eq(:foo)
+    end
+
+    it "returns the publisher" do
+      subject.register_destination(:sns_foo, :aws_sns, :foo, account: 123, region: "us-east-1", topic: "PlanOfAttack").should eq(subject)
+    end
+  end
+
+  describe "#publish" do
+    let :notifier do
+      subject.notification_service_registrar.fetch(:aws_sns).notifier
+    end
+
+    before :each do
+      subject.register_notification_service(:file_system)
+      subject.register_destination(:fs_foo, :file_system, :foo, path: "tmp/test_queue")
+    end
+
+    around do |ex|
+      begin
+        DispatchRider.config.debug = true
+        ex.call
+      ensure
+        DispatchRider.config.debug = false
+      end
+    end
+
+    it "publishes the message to the notification service" do
+      existing = Dir['tmp/test_queue/*']
+      expect {
+        subject.publish(:destinations => [:fs_foo], :message => {:subject => "bar_handler", :body => {"bar" => "baz"}})
+      }.to change { Dir['tmp/test_queue/*'].length }.by(1)
+      new_job = Dir['tmp/test_queue/*'] - existing
+      data = JSON.load(File.read(new_job.first))
+
+      expected_message = {
+        "subject" => "bar_handler",
+        "body" => {
+          "guid" => DispatchRider::Debug::PUBLISHER_MESSAGE_GUID,
+          "bar" => "baz",
+        },
+      }
+      expect(data).to eq(expected_message)
+    end
+  end
+end

data/spec/lib/dispatch-rider/queue_services/aws_sqs_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe DispatchRider::QueueServices::AwsSqs do
+
+  let(:visibility_timeout) { 100 }
+
+  let(:fake_response) do
+    AWS::SQS::Client.new.stub_for(:get_queue_url).tap { |response|
+      response.data[:queue_url] = "the.queue.url"
+      response.data[:attributes] = { "VisibilityTimeout" => visibility_timeout }
+    }
+  end
+
+  before do
+    AWS.config(stub_requests: true)
+    AWS::SQS::Client.any_instance.stub(:client_request).and_return(fake_response)
+  end
+
+  subject(:aws_sqs_queue) do
+    DispatchRider::QueueServices::AwsSqs.new(:name => "normal_priority")
+  end
+
+  describe "#assign_storage" do
+    context "when the aws gem is installed" do
+
+      context "when the name of the queue is passed in the options" do
+        it "should return an instance representing the aws sqs queue" do
+          aws_sqs_queue.assign_storage(:name => 'normal_priority')
+          aws_sqs_queue.queue.url.should eq('the.queue.url')
+        end
+      end
+
+      context "when the url of the queue is passed in the options" do
+        it "should return an instance representing the aws sqs queue" do
+          aws_sqs_queue.assign_storage(:url => 'https://sqs.us-east-1.amazonaws.com/12345/QueueName')
+          aws_sqs_queue.queue.url.should eq('the.queue.url')
+        end
+      end
+
+      context "when neither the name nor the url of the queue is assed in the options" do
+        it "should raise an exception" do
+          expect { aws_sqs_queue.assign_storage(:foo => 'bar') }.to raise_exception(DispatchRider::RecordInvalid)
+        end
+      end
+    end
+  end
+
+  describe "#insert" do
+    it "should insert an item into the queue" do
+      obj = {'subject' => 'foo', 'body' => 'bar'}.to_json
+      aws_sqs_queue.queue.should_receive(:send_message).with(obj)
+      aws_sqs_queue.insert(obj)
+    end
+  end
+
+  describe "#pop" do
+    context "when the sqs queue has items in it" do
+      let(:response_attributes) do
+        {
+          "SenderId" => "123456789012",
+          "SentTimestamp" => Time.now.to_i.to_s,
+          "ApproximateReceivedCount" => "12",
+          "ApproximateFirstReceiveTimestamp" => (Time.now + 12).to_i.to_s,
+        }
+      end
+
+      let(:response_message) do
+        {
+          :message_id => 12345,
+          :md5_of_body => "mmmddd555",
+          :body => {:subject => "foo", :body => {:bar => "baz"}}.to_json,
+          :receipt_handle => "HANDLE",
+          :attributes => response_attributes,
+        }
+      end
+
+      before :each do
+        response = AWS::SQS::Client.new.stub_for(:receive_message)
+        response.data[:messages] = [response_message]
+        AWS::SQS::Client::V20121105.any_instance.stub(:receive_message).and_return(response)
+        AWS::SQS::Queue.any_instance.stub(:verify_receive_message_checksum).and_return([])
+      end
+
+      context "when the block runs faster than the timeout" do
+        it "should yield the first item in the queue" do
+          aws_sqs_queue.pop do |message|
+            message.subject.should eq('foo')
+            message.body.should eq({'bar' => 'baz'})
+          end
+        end
+      end
+
+      context "when the block runs slower than the timeout" do
+        let(:visibility_timeout) { 1 }
+
+        it "should raise" do
+          expect {
+            aws_sqs_queue.pop do |message|
+              sleep(1.1)
+            end
+          }.to raise_exception(/message: foo,.+ took .+ seconds while the timeout was 1/)
+        end
+      end
+
+    end
+
+    context "when the sqs queue is empty" do
+      before :each do
+        aws_sqs_queue.queue.stub(:receive_message).and_return(nil)
+      end
+
+      it "should not yield" do
+        expect { |b|
+          aws_sqs_queue.pop(&b)
+        }.not_to yield_control
+      end
+    end
+
+  end
+  
+  describe "received message methods" do
+    let(:response_attributes) {{
+        "SenderId" => "123456789012",
+        "SentTimestamp" => Time.now.to_i.to_s,
+        "ApproximateReceivedCount" => "12",
+        "ApproximateFirstReceiveTimestamp" => (Time.now + 12).to_i.to_s,
+      }}
+
+      let(:response_message) { {
+        :message_id => 12345,
+        :md5_of_body => "mmmddd555",
+        :body => {:subject => "foo", :body => {:bar => "baz"}}.to_json,
+        :receipt_handle => "HANDLE",
+        :attributes => response_attributes,
+      } }
+      
+      before :each do
+        response = AWS::SQS::Client.new.stub_for(:receive_message)
+        response.data[:messages] = [response_message]
+        AWS::SQS::Client::V20121105.any_instance.stub(:receive_message).and_return(response)
+        AWS::SQS::Queue.any_instance.stub(:verify_receive_message_checksum).and_return([])
+      end
+      
+    it "should set the visibility timeout when extend is called" do
+      AWS::SQS::ReceivedMessage.any_instance.should_receive(:visibility_timeout=).with(10)
+      AWS::SQS::ReceivedMessage.any_instance.should_receive(:visibility_timeout=).with(0)
+      aws_sqs_queue.pop do |message|
+        message.extend_timeout(10)
+        message.total_timeout.should eq(10)
+        message.return_to_queue
+        message.total_timeout.should eq(10)
+      end
+    end
+  end
+
+  describe "#construct_message_from" do
+    context "when the item is directly published to AWS::SQS" do
+      let(:sqs_message){ OpenStruct.new(:body => {'subject' => 'foo', 'body' => 'bar'}.to_json) }
+
+      it "should return a message" do
+        result = aws_sqs_queue.construct_message_from(sqs_message)
+        result.subject.should eq('foo')
+        result.body.should eq('bar')
+      end
+    end
+
+    context "when the item is published through AWS::SNS" do
+      let(:sqs_message){ OpenStruct.new(:body => {"Type" => "Notification", "Message" => {'subject' => 'foo', 'body' => 'bar'}.to_json}.to_json) }
+
+      it "should return a message" do
+        result = aws_sqs_queue.construct_message_from(sqs_message)
+        result.subject.should eq('foo')
+        result.body.should eq('bar')
+      end
+    end
+  end
+
+  describe "#delete" do
+    let(:item_in_queue){ Object.new }
+
+    it "should delete the first message from the queue" do
+      item_in_queue.should_receive(:delete)
+      aws_sqs_queue.delete(item_in_queue)
+    end
+  end
+
+  describe "#size" do
+    it "should return the size of the aws queue" do
+      aws_sqs_queue.queue.should_receive(:approximate_number_of_messages)
+      aws_sqs_queue.size
+    end
+  end
+end

data/spec/lib/dispatch-rider/queue_services/base_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe DispatchRider::QueueServices::Base do
+  subject(:base_queue) do
+    DispatchRider::QueueServices::Base.any_instance.stub(:assign_storage).and_return([])
+    DispatchRider::QueueServices::Base.new
+  end
+
+  describe "#initialize" do
+    it "should initiate a queue" do
+      base_queue.queue.should eq([])
+    end
+  end
+
+  describe "#push" do
+    subject(:simple_queue) { DispatchRider::QueueServices::Simple.new }
+
+    it "should push the serialized object to the queue" do
+      simple_queue.push(DispatchRider::Message.new(:subject => "foo", :body => "bar"))
+      result = JSON.parse(simple_queue.queue.first)
+      result['subject'].should eq('foo')
+      result['body'].should eq('bar')
+    end
+  end
+
+  describe "#insert" do
+    it "should raise an exception" do
+      expect { base_queue.insert(DispatchRider::Message.new(:subject => "foo", :body => "bar")) }.to raise_exception(NotImplementedError)
+    end
+  end
+
+  describe "#pop" do
+    subject(:simple_queue) { DispatchRider::QueueServices::Simple.new }
+
+    before :each do
+      simple_queue.queue.push(DispatchRider::Message.new(:subject => "foo", :body => "bar").to_json)
+    end
+
+    context "when the block passed to process the popped message returns true" do
+      it "should return the first message in the queue" do
+        simple_queue.pop {|msg| true}.should eq(DispatchRider::Message.new(:subject => 'foo', :body => 'bar'))
+      end
+    end
+
+    context "when the block passed to process the popped message returns false" do
+      it "should return the first message in the queue" do
+        simple_queue.pop {|msg| false}.should eq(DispatchRider::Message.new(:subject => 'foo', :body => 'bar'))
+      end
+
+      it "should not remove the first message from the queue" do
+        simple_queue.pop do |msg|
+          msg.body = {:bar => "baz"}
+          false
+        end
+        simple_queue.should_not be_empty
+      end
+    end
+
+    context "when the queue is empty" do
+      before :each do
+        simple_queue.queue = []
+      end
+
+      it "should return nil" do
+        simple_queue.pop do |msg|
+          msg.body = {:bar => "baz"}
+          true
+        end.should be_nil
+      end
+    end
+  end
+
+  describe "#head" do
+    before { base_queue.stub(:raw_head).and_return(new_item) }
+
+    context "when there is no new item" do
+      let(:new_item){ nil }
+
+      it "should raise an exception" do
+        base_queue.head.should be_nil
+      end
+    end
+
+    context "when a new item exists" do
+      before { base_queue.stub(:construct_message_from){|item| item.message} }
+
+      let(:new_item){ OpenStruct.new(:message => new_message) }
+      let(:new_message){ :the_message }
+
+      it "should return the expected message" do
+        received_head = base_queue.head
+        received_head.item.should == new_item
+        received_head.to_sym == new_message
+      end
+    end
+  end
+
+  describe "#raw_head" do
+    it "should raise an exception" do
+      expect { base_queue.raw_head }.to raise_exception(NotImplementedError)
+    end
+  end
+
+  describe "#construct_message_from" do
+    it "should raise an exception" do
+      expect { base_queue.construct_message_from({:subject => 'foo', :body => {:bar => 'baz'}}.to_json) }.to raise_exception(NotImplementedError)
+    end
+  end
+
+  describe "#delete" do
+    it "should raise an exception" do
+      expect { base_queue.delete({:subject => 'foo', :body => {:bar => 'baz'}}.to_json) }.to raise_exception(NotImplementedError)
+    end
+  end
+
+  describe "#empty?" do
+    before :each do
+      base_queue.stub(:size) { base_queue.queue.size }
+    end
+
+    context "when the queue is empty" do
+      before :each do
+        base_queue.queue = []
+      end
+
+      it "should return true" do
+        base_queue.should be_empty
+      end
+    end
+
+    context "when the queue is not empty" do
+      before :each do
+        base_queue.queue << {:subject => 'foo', :body => 'bar'}.to_json
+      end
+
+      it "should return false" do
+        base_queue.should_not be_empty
+      end
+    end
+  end
+
+  describe "#size" do
+    it "should raise an exception" do
+      expect { base_queue.size }.to raise_exception(NotImplementedError)
+    end
+  end
+end