fake_servicebus 0.0.2

data/spec/acceptance/queue_actions_spec.rb

@@ -0,0 +1,82 @@
+require "integration_spec_helper"
+
+RSpec.describe "Actions for Queues", :sqs do
+
+  let(:sqs) { Aws::SQS::Client.new }
+  before do
+    sqs.config.endpoint = $fake_sqs.uri
+  end
+
+  specify "CreateQueue" do
+    response = sqs.create_queue(queue_name: "test-create-queue")
+    expect(response.queue_url).to eq "http://0.0.0.0:4568/test-create-queue"
+    response2 = sqs.get_queue_attributes(queue_url: response.queue_url)
+    expect(response2.attributes.fetch("QueueArn")).to match %r"arn:aws:sqs:us-east-1:.+:test-create-queue"
+  end
+
+  specify "GetQueueUrl" do
+    sqs.create_queue(queue_name: "test-get-queue-url")
+    response = sqs.get_queue_url(queue_name: "test-get-queue-url")
+    expect(response.queue_url).to eq "http://0.0.0.0:4568/test-get-queue-url"
+  end
+
+  specify "ListQueues" do
+    sqs.create_queue(queue_name: "test-list-1")
+    sqs.create_queue(queue_name: "test-list-2")
+    expect(sqs.list_queues.queue_urls).to eq [
+      "http://0.0.0.0:4568/test-list-1",
+      "http://0.0.0.0:4568/test-list-2"
+    ]
+  end
+
+  specify "ListQueues with prefix" do
+    sqs.create_queue(queue_name: "test-list-1")
+    sqs.create_queue(queue_name: "test-list-2")
+    sqs.create_queue(queue_name: "other-list-3")
+    expect(sqs.list_queues(queue_name_prefix: "test").queue_urls).to eq [
+      "http://0.0.0.0:4568/test-list-1",
+      "http://0.0.0.0:4568/test-list-2",
+    ]
+  end
+
+  specify "ListDeadLetterSourceQueues" do
+    dlq_queue_url = sqs.create_queue(queue_name: "source-list-DLQ").queue_url
+    dlq_arn = sqs.get_queue_attributes(queue_url: dlq_queue_url).attributes.fetch("QueueArn")
+    source_queue_urls = []
+    2.times do |time|
+      queue_url = sqs.create_queue(queue_name: "source-list-#{time}").queue_url
+      sqs.set_queue_attributes(queue_url: queue_url, 
+        attributes: {
+          "RedrivePolicy" => "{\"deadLetterTargetArn\":\"#{dlq_arn}\",\"maxReceiveCount\":10}"
+        }
+      )
+       source_queue_urls << queue_url
+    end
+    expect(sqs.list_dead_letter_source_queues(queue_url: dlq_queue_url).queue_urls).to eq source_queue_urls
+  end
+
+  specify "DeleteQueue" do
+    url = sqs.create_queue(queue_name: "test-delete").queue_url
+    expect(sqs.list_queues.queue_urls.size).to eq 1
+    sqs.delete_queue(queue_url: url)
+    expect(sqs.list_queues.queue_urls.size).to eq 0
+  end
+
+  specify "SetQueueAttributes / GetQueueAttributes" do
+    queue_url = sqs.create_queue(queue_name: "my-queue").queue_url
+
+
+    sqs.set_queue_attributes(
+      queue_url: queue_url,
+      attributes: {
+        "DelaySeconds" => "900"
+      }
+    )
+
+    response = sqs.get_queue_attributes(
+      queue_url: queue_url,
+    )
+    expect(response.attributes.fetch("DelaySeconds")).to eq "900"
+  end
+
+end

data/spec/integration_spec_helper.rb

@@ -0,0 +1,23 @@
+require "aws-sdk"
+require "fake_sqs/test_integration"
+
+Aws.config.update(
+  region: "us-east-1",
+  credentials: Aws::Credentials.new("fake", "fake"),
+)
+
+db = ENV["SQS_DATABASE"] || ":memory:"
+puts "\n\e[34mRunning specs with database \e[33m#{db}\e[0m"
+
+$fake_sqs = FakeSQS::TestIntegration.new(
+  database: db,
+  sqs_endpoint: "0.0.0.0",
+  sqs_port: 4568,
+  start_timeout: 2,
+)
+
+RSpec.configure do |config|
+  config.before(:each, :sqs) { $fake_sqs.start }
+  config.before(:each, :sqs) { $fake_sqs.reset }
+  config.after(:suite) { $fake_sqs.stop }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+end

data/spec/unit/api_spec.rb

@@ -0,0 +1,76 @@
+require 'fake_sqs/api'
+
+class FakeSQS::Actions::ImmediateAction
+
+  def initialize(options)
+    @options = options
+  end
+
+  def call(params)
+    { :options => @options, :params => params }
+  end
+
+end
+
+class FakeSQS::Actions::PollingAction
+
+  def initialize(options)
+    @options = options
+    @call_count = 0
+  end
+
+  def call(params)
+    @call_count += 1
+  end
+
+  def satisfied?
+    @call_count >= 3
+  end
+end
+
+RSpec.describe FakeSQS::API do
+
+  it "delegates actions to classes" do
+    queues = double :queues
+    allow(queues).to receive(:transaction).and_yield
+    api = FakeSQS::API.new(:queues => queues)
+
+    response = api.call("ImmediateAction", {}, {:foo => "bar"})
+
+    expect(response[:options]).to eq :queues => queues, :request => {}
+    expect(response[:params]).to eq :foo => "bar"
+  end
+
+  it "attempts a polling action until it's satisfied" do
+    queues = double :queues
+    allow(queues).to receive(:transaction).and_yield
+    api = FakeSQS::API.new(:queues => queues)
+
+    call_count = api.call("PollingAction", {}, {})
+    expect(call_count).to eq 3
+  end
+
+  it "raises InvalidAction for unknown actions" do
+    api = FakeSQS::API.new(:queues => [])
+
+    expect {
+      api.call("SomethingDifferentAndUnknown", {:foo => "bar"})
+    }.to raise_error(FakeSQS::InvalidAction)
+
+  end
+
+  it "resets queues" do
+    queues = double :queues
+    api = FakeSQS::API.new(:queues => queues)
+    expect(queues).to receive(:reset)
+    api.reset
+  end
+
+  it "expires messages in queues" do
+    queues = double :queues
+    api = FakeSQS::API.new(:queues => queues)
+    expect(queues).to receive(:expire)
+    api.expire
+  end
+
+end

data/spec/unit/catch_errors_spec.rb

@@ -0,0 +1,43 @@
+require 'fake_sqs/catch_errors'
+
+RSpec.describe FakeSQS::CatchErrors do
+
+  let(:app) { double :app }
+  let(:error_response) { double :error_response, :status => 500, :body => "X" }
+  let(:response) { double :response, :new => error_response }
+  subject(:catch_errors) { FakeSQS::CatchErrors.new(app, response: response) }
+
+  context "when the app behaves normally" do
+
+    let(:normal_response) { double :normal_response }
+    before { allow(app).to receive(:call).and_return(normal_response) }
+
+    it "doesn't modify normal responses" do
+      expect(catch_errors.call({})).to eq normal_response
+    end
+
+  end
+
+  context "when the app raises an exception" do
+
+    let(:error) { RuntimeError.new("it went wrong") }
+    before { allow(app).to receive(:call).and_raise(error) }
+
+    it "cathes and processes errors" do
+      expect(response).to receive(:new).with(error)
+      catch_errors.call({})
+    end
+
+    it "sets the status determined by the error response" do
+      allow(error_response).to receive(:status).and_return(123)
+      expect(catch_errors.call({}).fetch(0)).to eq 123
+    end
+
+    it "set the body determined by the error response" do
+      allow(error_response).to receive(:body).and_return("foobar")
+      expect(catch_errors.call({}).fetch(2)).to eq ["foobar"]
+    end
+
+  end
+
+end

data/spec/unit/collection_view_spec.rb

@@ -0,0 +1,41 @@
+require 'fake_sqs/collection_view'
+
+RSpec.describe FakeSQS::CollectionView do
+
+  def wrap(collection)
+    FakeSQS::CollectionView.new(collection)
+  end
+
+  it 'should correctly wrap an array' do
+    array = %w{one two three four}
+    view = wrap(array)
+    expect(view[0]).to eq 'one'
+    expect(view[1]).to eq 'two'
+    expect(view[2]).to eq 'three'
+    expect(view[3]).to eq 'four'
+  end
+
+  it 'should correctly wrap a hash' do
+    hash = { :one => 1, :two => 2, :three => 3 }
+    view = wrap(hash)
+    expect(view[:one]).to eq 1
+    expect(view[:two]).to eq 2
+    expect(view[:three]).to eq 3
+  end
+
+  it 'should respond to empty correctly' do
+    expect(wrap([])).to be_empty
+    expect(wrap({'one' => 1})).to_not be_empty
+  end
+
+  it 'should be enumerable' do
+    result = wrap([1, 2, 3]).map { |i| i * i }
+    expect(result).to eq [1, 4, 9]
+  end
+
+  it 'should respond to size/length' do
+    expect(wrap([1, 2, 3]).size).to eq 3
+    expect(wrap([]).size).to eq 0
+  end
+
+end

data/spec/unit/error_response_spec.rb

@@ -0,0 +1,65 @@
+require 'fake_sqs/error_response'
+require 'active_support/core_ext/hash'
+require 'verbose_hash_fetch'
+
+RSpec.describe FakeSQS::ErrorResponse do
+
+  module FakeSQS
+    MissingCredentials = Class.new(RuntimeError)
+  end
+  ErrorUnknownToSQS = Class.new(RuntimeError)
+
+  describe "#status" do
+
+    it "picks the right error status" do
+      error = FakeSQS::MissingCredentials.new("message")
+      response = FakeSQS::ErrorResponse.new(error)
+      expect(response.status).to eq 401
+    end
+
+    it "uses 400 as default status" do
+      error = ErrorUnknownToSQS.new("message")
+      response = FakeSQS::ErrorResponse.new(error)
+      expect(response.status).to eq 500
+    end
+
+  end
+
+  describe "#body" do
+
+    let(:error) { FakeSQS::MissingCredentials.new("the message") }
+    let(:response) { FakeSQS::ErrorResponse.new(error) }
+    let(:data) { Hash.from_xml(response.body) }
+
+    it "uses the error class name as error code" do
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Code")).to eq "MissingCredentials"
+    end
+
+    it "uses InternalError as code for unknown errors" do
+      error = ErrorUnknownToSQS.new("the message")
+      response = FakeSQS::ErrorResponse.new(error)
+      data = Hash.from_xml(response.body)
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Code")).to eq "InternalError"
+    end
+
+    it "uses the to_s of the error as message" do
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Message")).to eq "the message"
+    end
+
+    it "has a request id" do
+      expect(data.fetch("ErrorResponse").fetch("RequestId").size).to eq 36
+    end
+
+    it "uses Sender as type for 4xx responses" do
+      allow(response).to receive(:status).and_return(400)
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Type")).to eq "Sender"
+    end
+
+    it "uses Receiver as type for 5xx responses" do
+      allow(response).to receive(:status).and_return(500)
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Type")).to eq "Receiver"
+    end
+
+  end
+
+end

data/spec/unit/message_spec.rb

@@ -0,0 +1,76 @@
+require 'fake_sqs/message'
+
+RSpec.describe FakeSQS::Message do
+
+  describe "#body" do
+
+    it "is extracted from the MessageBody" do
+      message = create_message("MessageBody" => "abc")
+      expect(message.body).to eq "abc"
+    end
+
+  end
+
+  describe "#md5" do
+
+    it "is calculated from body" do
+      message = create_message("MessageBody" => "abc")
+      expect(message.md5).to eq "900150983cd24fb0d6963f7d28e17f72"
+    end
+
+  end
+
+  describe "#id" do
+
+    it "is generated" do
+      message = create_message
+      expect(message.id.size).to eq 36
+    end
+
+  end
+
+  describe "#delay_seconds" do
+
+    it "is generated" do
+      message = create_message({"DelaySeconds" => 10})
+      expect(message.delay_seconds).to eq 10
+    end
+
+  end
+
+  describe 'visibility_timeout' do
+
+    let :message do
+      create_message
+    end
+
+    it 'should default to nil' do
+      expect(message.visibility_timeout).to eq nil
+    end
+
+    it 'should be expired when it is nil' do
+      expect(message).to be_expired
+    end
+
+    it 'should be expired if set to a previous time' do
+      message.visibility_timeout = Time.now - 1
+      expect(message).to be_expired
+    end
+
+    it 'should not be expired at a future date' do
+      message.visibility_timeout = Time.now + 1
+      expect(message).not_to be_expired
+    end
+
+    it 'should not be expired when set to expire at a future date' do
+      message.expire_at(5)
+      expect(message.visibility_timeout).to be >=(Time.now + 4)
+    end
+
+  end
+
+  def create_message(options = {})
+    FakeSQS::Message.new({"MessageBody" => "test"}.merge(options))
+  end
+
+end

data/spec/unit/queue_factory_spec.rb

@@ -0,0 +1,13 @@
+require 'fake_sqs/queue_factory'
+
+RSpec.describe FakeSQS::QueueFactory do
+
+  it "builds queues with a message factory" do
+    message_factory = double :message_factory
+    queue = double :queue
+    queue_factory = FakeSQS::QueueFactory.new(message_factory: message_factory, queue: queue)
+    expect(queue).to receive(:new).with(message_factory: message_factory, name: "Foo")
+    queue_factory.new(name: "Foo")
+  end
+
+end

data/spec/unit/queue_spec.rb

@@ -0,0 +1,204 @@
+require 'fake_sqs/queue'
+require 'fake_sqs/message'
+
+RSpec.describe FakeSQS::Queue do
+
+  class MessageFactory
+    def new(options = {})
+      FakeSQS::Message.new({'MessageBody' => 'sample-body'}.merge(options))
+    end
+  end
+
+  let(:message_factory) { MessageFactory.new }
+  subject(:queue) { FakeSQS::Queue.new(:message_factory => message_factory, "QueueName" => "test-queue") }
+
+  describe "#send_message" do
+
+    it "adds a message" do
+      expect(queue.messages.size).to eq 0
+      send_message
+      expect(queue.messages.size).to eq 1
+    end
+
+    it "returns the message" do
+      message = double.as_null_object
+      allow(message_factory).to receive(:new).and_return(message)
+      expect(send_message).to eq message
+    end
+
+    it "uses the message factory" do
+      options = { "MessageBody" => "abc" }
+      expect(message_factory).to receive(:new).with(options)
+      send_message(options)
+    end
+
+    it "should set the message's SentTimestamp attribute" do
+      expect(send_message.attributes["SentTimestamp"]).to eq (Time.now.to_i * 1000)
+    end
+
+    it "should set the SenderId of the sender" do
+      sender_id = send_message.attributes["SenderId"]
+      expect(sender_id).to be_a String
+      expect(sender_id.length).to eq 21
+    end
+  end
+
+  describe "#receive_message" do
+
+    it "gets the message" do
+      sent = send_message
+      received = receive_message
+      expect(received.values.first).to eq sent
+    end
+
+    it "gets the message with 'DelaySeconds' option" do
+      delay_seconds = 3
+      sent = send_message({ "DelaySeconds" => delay_seconds })
+      received = receive_message
+      expect(received.values.first).to be_nil
+
+      allow(Time).to receive(:now).and_return(Time.now + delay_seconds)
+      received = receive_message
+      expect(received.values.first).to eq sent
+    end
+
+    it "gets you a random message" do
+      indexes = { :first => 0, :second => 0 }
+      sample_group = 1_000
+      half_sample_group = sample_group / 2
+      ten_percent = half_sample_group / 0.1
+
+      sample_group.times do
+        sent_first     = send_message
+        _    = send_message
+        message = receive_message.values.first
+        if message == sent_first
+          indexes[:first] += 1
+        else
+          indexes[:second] += 1
+        end
+        reset_queue
+      end
+
+      expect(indexes[:first] + indexes[:second]).to eq sample_group
+
+      expect(indexes[:first]).to be_within(ten_percent).of(half_sample_group)
+      expect(indexes[:second]).to be_within(ten_percent).of(half_sample_group)
+    end
+
+    it "cannot get received messages" do
+      sample_group = 1_000
+
+      sample_group.times do
+        sent_first  = send_message
+        sent_second = send_message
+        received_first  = receive_message.values.first
+
+        if received_first == sent_first
+          expect(receive_message.values.first).to eq sent_second
+        else
+          expect(receive_message.values.first).to eq sent_first
+        end
+        reset_queue
+      end
+    end
+
+    it "keeps track of sent messages" do
+
+      send_message
+
+      expect(queue.messages_in_flight.size).to eq 0
+      expect(queue.attributes["ApproximateNumberOfMessagesNotVisible"]).to eq 0
+      expect(queue.attributes["ApproximateNumberOfMessages"]).to eq 1
+
+      receive_message
+
+      expect(queue.messages_in_flight.size).to eq 1
+      expect(queue.attributes["ApproximateNumberOfMessagesNotVisible"]).to eq 1
+      expect(queue.attributes["ApproximateNumberOfMessages"]).to eq 0
+    end
+
+    it "gets multiple message" do
+      sent_first  = send_message
+      sent_second = send_message
+      messages = receive_message("MaxNumberOfMessages" => "2")
+      expect(messages.size).to eq 2
+      expect(messages.values).to match_array [ sent_first, sent_second ]
+    end
+
+    it "won't accept more than 10 message" do
+      expect {
+        receive_message("MaxNumberOfMessages" => "11")
+      }.to raise_error(FakeSQS::ReadCountOutOfRange, "11")
+    end
+
+    it "won't error on empty queues" do
+      expect(receive_message).to eq({})
+    end
+
+    it "should increment the ApproximateReceiveCount" do
+      sent_message = send_message
+      expect(sent_message.attributes["ApproximateReceiveCount"]).to eq 0
+      queue.change_message_visibility(receive_message.keys.first, 0)
+      expect(sent_message.attributes["ApproximateReceiveCount"]).to eq 1
+      receive_message
+      expect(sent_message.attributes["ApproximateReceiveCount"]).to eq 2
+    end
+
+    it "should set the ApproximateFirstReceiveTimestamp only when the message is first received" do
+      sent_message = send_message
+      expect(sent_message.attributes["ApproximateFirstReceiveTimestamp"]).to eq nil
+      receive_time = (Time.now.to_i * 1000)
+      queue.change_message_visibility(receive_message.keys.first, 0)
+      expect(sent_message.attributes["ApproximateFirstReceiveTimestamp"]).to eq receive_time
+      sleep 1
+      receive_message
+      expect(sent_message.attributes["ApproximateFirstReceiveTimestamp"]).to eq receive_time
+    end
+  end
+
+  describe "#delete_message" do
+
+    it "deletes by the receipt" do
+      send_message
+      receipt = receive_message.keys.first
+
+      expect(queue.messages_in_flight.size).to eq 1
+      queue.delete_message(receipt)
+      expect(queue.messages_in_flight.size).to eq 0
+      expect(queue.messages.size).to eq 0
+    end
+
+    it "won't raise if the receipt is unknown" do
+      queue.delete_message("abc")
+    end
+
+  end
+
+  describe "#add_queue_attributes" do
+
+    it "adds to it's queue attributes" do
+      queue.add_queue_attributes("foo" => "bar")
+      expect(queue.attributes).to eq(
+        "foo"                                   => "bar",
+        "QueueArn"                              => queue.arn,
+        "ApproximateNumberOfMessages"           => 0,
+        "ApproximateNumberOfMessagesNotVisible" => 0
+      )
+    end
+
+  end
+
+  def send_message(options = {})
+    queue.send_message(options)
+  end
+
+  def receive_message(options = {})
+    queue.receive_message(options)
+  end
+
+  def reset_queue
+    queue.reset
+  end
+
+end