fake_sqs 0.0.2

data/lib/fake_sqs/server.rb

@@ -0,0 +1,172 @@
+module FakeSQS
+  class Server
+
+    attr_reader :port, :host, :queues, :responder
+
+    def initialize(options = {})
+      @host      = options.fetch(:host)
+      @port      = options.fetch(:port)
+      @queues    = options.fetch(:queues)
+      @responder = options.fetch(:responder)
+    end
+
+    def call(action, *args)
+      public_send(action, *args)
+    end
+
+    # Actions for Queues
+
+    def create_queue(params)
+      name = params.fetch("QueueName")
+      queue = queues.create(name, params)
+      respond :CreateQueue do |xml|
+        xml.QueueUrl url_for(queue.name)
+      end
+    end
+
+    def delete_queue(name, params)
+      queues.delete(name, params)
+      respond :DeleteQueue
+    end
+
+    def list_queues(params)
+      found = queues.list(params)
+      respond :ListQueues do |xml|
+        found.each do |queue|
+          xml.QueueUrl url_for(queue.name)
+        end
+      end
+    end
+
+    def get_queue_url(params)
+      name = params.fetch("QueueName")
+      queue = queues.get(name, params)
+      respond :GetQueueUrl do |xml|
+        xml.QueueUrl url_for(queue.name)
+      end
+    end
+
+    def get_queue_attributes(name, params)
+    end
+
+    def set_queue_attributes(name, params)
+    end
+
+    # Actions for Access Control on Queues
+
+    def add_permission(name, params)
+    end
+
+    def remove_persmission(name, params)
+    end
+
+    # Actions for Messages
+
+    def send_message(name, params)
+      queue = queues.get(name)
+      message = queue.send_message(params)
+      respond :SendMessage do |xml|
+        xml.MD5OfMessageBody message.md5
+        xml.MessageId message.id
+      end
+    end
+
+    def receive_message(name, params)
+      queue = queues.get(name)
+      messages = queue.receive_message(params)
+      respond :ReceiveMessage do |xml|
+        messages.each do |receipt, message|
+          xml.Message do
+            xml.MessageId message.id
+            xml.ReceiptHandle receipt
+            xml.MD5OfMessageBody message.md5
+            xml.Body message.body
+          end
+        end
+      end
+    end
+
+    def delete_message(name, params)
+      queue = queues.get(name)
+
+      receipt = params.fetch("ReceiptHandle")
+      queue.delete_message(receipt)
+      respond :DeleteMessage
+    end
+
+    def delete_message_batch(name, params)
+      queue = queues.get(name)
+      receipts = params.select { |k,v| k =~ /DeleteMessageBatchRequestEntry\.\d+\.ReceiptHandle/ }
+
+      deleted = []
+
+      receipts.each do |key, value|
+        id = key.split('.')[1]
+        queue.delete_message(value)
+        deleted << params.fetch("DeleteMessageBatchRequestEntry.#{id}.Id")
+      end
+
+      respond :DeleteMessageBatch do |xml|
+        deleted.each do |id|
+          xml.DeleteMessageBatchResultEntry do
+            xml.Id id
+          end
+        end
+      end
+    end
+
+    def send_message_batch(name, params)
+      queue = queues.get(name)
+
+      messages = params.select { |k,v| k =~ /SendMessageBatchRequestEntry\.\d+\.MessageBody/ }
+
+      results = {}
+
+      messages.each do |key, value|
+        id = key.split('.')[1]
+        msg_id = params.fetch("SendMessageBatchRequestEntry.#{id}.Id")
+        delay = params["SendMessageBatchRequestEntry.#{id}.DelaySeconds"]
+        message = queue.send_message("MessageBody" => value, "DelaySeconds" => delay)
+        results[msg_id] = message
+      end
+
+      respond :SendMessageBatch do |xml|
+        results.each do |msg_id, message|
+          xml.SendMessageBatchResultEntry do
+            xml.Id msg_id
+            xml.MessageId message.id
+            xml.MD5OfMessageBody message.md5
+          end
+        end
+      end
+    end
+
+
+    def change_message_visibility(name, params)
+    end
+
+    def change_message_visibility_batch(name, params)
+    end
+
+    # Fake actions
+
+    def reset
+      queues.reset
+    end
+
+    def expire
+      queues.expire
+    end
+
+    private
+
+    def respond(*args, &block)
+      responder.call(*args, &block)
+    end
+
+    def url_for(id)
+      "http://#{host}:#{port}/#{id}"
+    end
+
+  end
+end

data/lib/fake_sqs/show_output.rb

@@ -0,0 +1,18 @@
+module FakeSQS
+  class ShowOutput
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      result = @app.call(env)
+      puts request.params.to_yaml
+      puts
+      puts *result.last
+      result
+    end
+
+  end
+end

data/lib/fake_sqs/version.rb

@@ -0,0 +1,3 @@
+module FakeSQS
+  VERSION = "0.0.2"
+end

data/lib/fake_sqs/web_interface.rb

@@ -0,0 +1,45 @@
+require 'sinatra/base'
+
+module FakeSQS
+  class WebInterface < Sinatra::Base
+
+    configure do
+      set :sqs, FakeSQS.server(port: settings.port, host: settings.bind)
+    end
+
+    helpers do
+
+      def action
+        underscore(params.fetch("Action"))
+      end
+
+      def underscore(string)
+        string.gsub(/([A-Z])/) { |m| "_#{m[0]}".downcase }.sub(/^_/, '')
+      end
+
+    end
+
+    get "/" do
+      200
+    end
+
+    delete "/" do
+      settings.sqs.reset
+      200
+    end
+
+    put "/" do
+      settings.sqs.expire
+      200
+    end
+
+    post "/" do
+      settings.sqs.call(action, params)
+    end
+
+    post "/:queue" do |queue|
+      settings.sqs.call(action, queue, params)
+    end
+
+  end
+end

data/spec/acceptance/message_actions_spec.rb

@@ -0,0 +1,59 @@
+require 'support/aws'
+
+describe "Actions for Messages", :acceptance do
+
+  before do
+    sqs.queues.create("test")
+  end
+
+  let(:sqs) { AWS::SQS.new }
+  let(:queue) { sqs.queues.named("test") }
+
+  specify "SendMessage" do
+    msg = "this is my message"
+    result = queue.send_message(msg)
+    result.md5.should eq Digest::MD5.hexdigest(msg)
+  end
+
+  specify "ReceiveMessage" do
+    body = "test 123"
+    queue.send_message(body)
+    message = queue.receive_message
+    message.body.should eq body
+  end
+
+  specify "DeleteMessage" do
+    queue.send_message("test")
+
+    message1 = queue.receive_message
+    message1.delete
+
+    let_messages_in_flight_expire
+
+    message2 = queue.receive_message
+    message2.should be_nil
+  end
+
+  specify "DeleteMessageBatch" do
+    queue.send_message("test1")
+    queue.send_message("test2")
+
+    message1 = queue.receive_message
+    message2 = queue.receive_message
+    queue.batch_delete(message1, message2)
+
+    let_messages_in_flight_expire
+
+    message3 = queue.receive_message
+    message3.should be_nil
+  end
+
+  specify "SendMessageBatch" do
+    bodies = %w(a b c)
+    queue.batch_send(*bodies)
+
+    messages = queue.receive_message(:limit => 10)
+    messages.map(&:body).should match_array bodies
+  end
+
+end

data/spec/acceptance/queue_actions_spec.rb

@@ -0,0 +1,44 @@
+require 'support/aws'
+
+describe "Actions for Queues", :acceptance do
+
+  let(:sqs) { AWS::SQS.new }
+
+  specify "CreateQueue" do
+    queue = sqs.queues.create("test-create-queue")
+    queue.url.should eq "http://0.0.0.0:4567/test-create-queue"
+  end
+
+  specify "GetQueueUrl" do
+    sqs.queues.create("test-get-queue-url")
+    queue = sqs.queues.named("test-get-queue-url")
+    queue.url.should eq "http://0.0.0.0:4567/test-get-queue-url"
+  end
+
+  specify "ListQueues" do
+    sqs.queues.create("test-list-1")
+    sqs.queues.create("test-list-2")
+    queues = sqs.queues.map(&:url).should eq [
+      "http://0.0.0.0:4567/test-list-1",
+      "http://0.0.0.0:4567/test-list-2"
+    ]
+  end
+
+  specify "ListQueues with prefix" do
+    sqs.queues.create("test-list-1")
+    sqs.queues.create("test-list-2")
+    sqs.queues.create("other-list-3")
+    queues = sqs.queues.with_prefix("test").map(&:url).should eq [
+      "http://0.0.0.0:4567/test-list-1",
+      "http://0.0.0.0:4567/test-list-2"
+    ]
+  end
+
+  specify "DeleteQueue" do
+    url = sqs.queues.create("test-delete").url
+    sqs.should have(1).queues
+    sqs.queues[url].delete
+    sqs.should have(0).queues
+  end
+
+end

data/spec/support/aws.rb

@@ -0,0 +1,99 @@
+require 'aws-sdk'
+require 'fake_sqs'
+require 'faraday'
+require 'uri'
+require 'thin'
+
+Thread.abort_on_exception = true
+
+ENV['RACK_ENV'] = 'test'
+
+require 'webmock/rspec'
+WebMock.disable_net_connect!(:allow_localhost => true)
+
+Thin::Logging.silent = true
+
+class FakeServer
+
+  attr_reader :url
+
+  def initialize(url = "http://localhost:4567")
+    @url = url
+  end
+
+  def uri
+    @uri ||= URI.parse(url)
+  end
+
+  def port
+    uri.port
+  end
+
+  def host
+    uri.host
+  end
+
+  def ssl?
+    uri.scheme == "https"
+  end
+
+  def start
+    return if @started
+    @started = true
+    @fake_sqs_thread = Thread.new {
+      load File.expand_path('../../../bin/fake_sqs', __FILE__)
+      Sinatra::Application.run!
+    }
+    wait_until_up
+  end
+
+  def stop
+    @fake_sqs_thread.kill
+  end
+
+  def reset
+    Faraday.delete(url)
+  end
+
+  def expire_messages_in_flight
+    Faraday.put(url)
+  end
+
+  def wait_until_up(tries = 0)
+    fail "Server didn't start in time" if tries > 200
+    response = Faraday.get(url)
+    if response.status != 200
+      wait_until_up(tries + 1)
+    end
+  rescue Faraday::Error::ConnectionFailed
+    wait_until_up(tries + 1)
+  end
+
+end
+
+$fake_server = FakeServer.new
+
+module FakeServerHelper
+
+  def let_messages_in_flight_expire
+    $fake_server.expire_messages_in_flight
+  end
+
+end
+
+AWS.config(
+  :use_ssl           => $fake_server.ssl?,
+  :sqs_endpoint      => $fake_server.host,
+  :sqs_port          => $fake_server.port,
+  :access_key_id     => "access key id",
+  :secret_access_key => "secret access key"
+)
+
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.before(:suite) { $fake_server.start }
+  config.after(:suite)  { $fake_server.stop }
+  config.before(:each, :acceptance) { $fake_server.reset }
+  config.include FakeServerHelper
+end