q3 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,18 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  #gem "rcov", ">= 0"
+end
+
+gem 'sinatra'
+gem 'builder'
+gem 'redis'
+gem 'redis-namespace'

data/Gemfile.lock

@@ -0,0 +1,42 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.2.2)
+    diff-lcs (1.1.3)
+    git (1.2.7)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rack (1.5.2)
+    rack-protection (1.5.3)
+      rack
+    rake (10.3.2)
+    redis (3.1.0)
+    redis-namespace (1.5.0)
+      redis (~> 3.0, >= 3.0.4)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    sinatra (1.4.5)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    tilt (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  builder
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  redis
+  redis-namespace
+  rspec (~> 2.3.0)
+  sinatra

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 tily
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,106 @@
+# Q3
+
+## Summary
+
+Simple Amazon SQS compatible API implementation with sinatra and redis.
+
+## Concept
+
+* simplicity
+* no authentication, open like wiki
+* no validation, just works as proxy to redis functions
+
+## Usage
+
+### global service
+
+You can try q3 easily with global endpoint <http://q3-global.herokuapp.com/>.
+
+	$ curl "http://q3-global.herokuapp.com/?Action=CreateQueue&QueueName=MyQueue001"
+	<?xml version="1.0" encoding="UTF-8"?>
+	<CreateQueueResponse>
+	  <CreateQueueResult>
+	    <QueueUrl>http://q3-global.herokuapp.com/*/MyQueue001</QueueUrl>
+	  </CreateQueueResult>
+	  <ResponseMetadata>
+	    <RequestId>9bcf7831-59a3-456c-b5fe-e0674f322b79</RequestId>
+	  </ResponseMetadata>
+	</CreateQueueResponse>
+
+You can use any Amazon SQS client.
+
+	require 'aws-sdk'
+	q3 = AWS::SQS.new(
+		:sqs_endpoint => 'q3-global.herokuapp.com',
+		:access_key_id => 'dummy',
+		:secret_access_key => 'dummy',
+		:use_ssl => false
+	)
+	
+	queue = q3.queues.create('MyQueue001')
+	queue.send_message('hello!')
+	p queue.receive_message.body # => "hello!"
+
+### as rack app
+
+Install gem and you can invoke `q3` command to run api.
+
+	$ gem install q3
+	$ ruby bin/q3
+	[2014-07-06 19:54:47] INFO  WEBrick 1.3.1
+	[2014-07-06 19:54:47] INFO  ruby 2.0.0 (2014-02-24) [universal.x86_64-darwin13]
+	== Sinatra/1.4.5 has taken the stage on 4567 for development with backup from WEBrick
+	[2014-07-06 19:54:47] INFO  WEBrick::HTTPServer#start: pid=29495 port=4567
+
+Or you can integrate q3 into your config.ru like this:
+
+	require 'q3.rb'
+	run Q3
+
+## Actions
+
+See for complete action list: [Welcome - Amazon Simple Queue Service](http://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Welcome.html).
+
+### implemented
+
+ * Queue Operation
+   * CreateQueue
+   * ListQueues
+   * GetQueueAttributes
+   * GetQueueUrl
+   * SetQueueAttributes
+   * DeleteQueue
+ * Message Operation
+   * SendMessage
+   * ReceiveMessage
+   * ChangeMessageVisibility
+   * DeleteMessage
+
+### will be implemented
+
+ * SendMessageBatch
+ * ChangeMessageVisibilityBatch
+ * DeleteMessageBatch
+ * ListDeadLetterSourceQueues
+
+### will not be implemented
+
+ * AddPermission
+ * RemovePermission
+
+## Data Schema
+
+| Key Name                                                | Type       | Content                        | Delete Timing                                 |
+| ------------------------------------------------------- | ---------- | ------------------------------ | --------------------------------------------- |
+| Queues                                                  | List       | Queue Names                    | -                                             |
+| Queues:${QueueName}                                     | Hash       | Queue Attributes               | DeleteQueue action                            |
+| Queues:${QueueName}:Messages                            | List       | Message Ids                    | DeleteQueue action                            |
+| Queues:${QueueName}:Messages:${MessageId}               | Hash       | Message Attributes             | expires due to MessageRetentionPeriod         |
+| Queues:${QueueName}:Messages:${MessageId}:Delayed       | String     | Message Id                     | expires due to DelaySeconds                   |
+| Queues:${QueueName}:Messages:${MessageId}:ReceiptHandle | String     | ReceiptHandle                  | expires due to VisibilityTimeout              |
+| Queues:${QueueName}:ReceiptHandles:${ReceiptHandle}     | String     | Message Id                     | expires due to VisibilityTimeout              |
+
+## TODO
+
+ * https
+ * mount on subdirectory

data/Rakefile

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "q3"
+  gem.homepage = "http://github.com/tily/q3"
+  gem.license = "MIT"
+  gem.summary = %Q{Simple Amazon SQS compatible API implementation with sinatra and redis}
+  gem.description = %Q{Simple Amazon SQS compatible API implementation with sinatra and redis}
+  gem.email = "tily05@gmail.com"
+  gem.authors = ["tily"]
+  # dependencies defined in Gemfile
+  gem.executables = ['q3']
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec

data/bin/q3

@@ -0,0 +1,2 @@
+$:.unshift File.dirname(__FILE__) + '/../lib' unless $:.include? File.dirname(__FILE__) + '/../lib'
+(require 'q3') && (Q3.run!)

data/config.ru

@@ -0,0 +1 @@
+(require './lib/q3.rb') && (run Q3)

data/lib/q3.rb

@@ -0,0 +1,257 @@
+%w(digest/md5 sinatra/base builder redis redis-namespace).each {|x| require x }
+
+class Q3 < Sinatra::Base
+	configure do
+		enable :logging
+	end
+
+	DEFAULTS = {
+		'VisibilityTimeout'             => 30,
+		'MaximumMessageSize'            => 262144,
+		'MessageRetentionPeriod'        => 345600,
+		'DelaySeconds'                  => 0,
+		'ReceiveMessageWaitTimeSeconds' => 0,
+	}
+	CREATE_QUEUE = %w(
+		VisibilityTimeout MessageRetentionPeriod MaximumMessageSize DelaySeconds ReceiveMessageWaitTimeSeconds
+	)
+	SET_QUEUE_ATTRIBUTES = %w(
+		DelaySeconds MaximumMessageSize MessageRetentionPeriod Policy ReceiveMessageWaitTimeSeconds
+		VisibilityTimeout RedrivePolicy
+	)
+
+	def self.dispatch!
+		@paths.each do |path, opts|
+			[:get, :post].each do |x|
+				send(x, path) do
+					if opt = opts.find {|opt| opt[:action] == params['Action'] }
+						instance_eval(&opt[:block])
+					end
+				end
+			end
+		end
+	end
+	
+	def self.action(action, path='/', &block)
+		@paths ||= Hash.new {|h, k| h[k] = [] }
+		@paths[path] << {action: action, block: block}
+	end
+
+	before do
+		logger.info "#{request_id}: request start with path = #{request.path_info}, params = #{params}"
+		content_type 'application/xml'
+	end
+
+	after do
+		logger.info "#{request_id}: request end with #{response.body}"
+	end
+
+	action('CreateQueue') do
+		halt 400, return_error_xml('Sender', 'MissingParameter', '') if params['QueueName'].nil?
+		timestamp = now
+		hash = CREATE_QUEUE.inject({'CreateTimestamp' => timestamp, 'LastModifiedTimestamp' => timestamp}) do |hash, attribute|
+			hash[attribute] = attributes[attribute] || DEFAULTS[attribute]
+			hash
+		end
+		redis.rpush("Queues", params[:QueueName])
+		redis.hmset("Queues:#{params[:QueueName]}", *hash.to_a)
+		return_xml {|xml| xml.QueueUrl queue_url("#{params[:QueueName]}") }
+	end
+	
+	action('ListQueues') do
+		return_xml do |xml|
+			redis.lrange('Queues', 0, -1).each {|queue_name| xml.QueueUrl queue_url(queue_name) }
+		end
+	end
+	
+	action('GetQueueUrl') do
+		validate_queue_existence
+		return_xml {|xml| xml.QueueUrl queue_url(params[:QueueName]) }
+	end
+	
+	action('GetQueueAttributes', '/*/:QueueName') do
+		validate_queue_existence
+		delayed = redis.keys("Queues:#{params[:QueueName]}:Messages:*:Delayed").size
+		not_visible = redis.keys("Queues:#{params[:QueueName]}:Messages:*:ReceiptHandle").size
+		messages = redis.llen("Queues:#{params[:QueueName]}:Messages") - delayed - not_visible
+		return_xml do |xml|
+			queue.each do |name, value|
+				xml.Attribute { xml.Name name; xml.Value value }
+			end
+			xml.Attribute { xml.Name 'ApproximateNumberOfMessages'           ; xml.Value messages    }
+			xml.Attribute { xml.Name 'ApproximateNumberOfMessagesNotVisible' ; xml.Value not_visible }
+			xml.Attribute { xml.Name 'ApproximateNumberOfMessagesDelayed'    ; xml.Value delayed     }
+		end
+	end
+	
+	action('SetQueueAttributes', '/*/:QueueName') do
+		validate_queue_existence
+		hash = SET_QUEUE_ATTRIBUTES.inject({'LastModifiedTimestamp' => now}) do |hash, attribute|
+			hash[attribute] = attributes[attribute] if attributes[attribute]
+			hash
+		end
+		redis.hmset("Queues:#{params[:QueueName]}", hash.to_a.flatten)
+		return_xml {}
+	end
+	
+	action('DeleteQueue', '/*/:QueueName') do
+		validate_queue_existence
+		redis.keys("Queues:#{params[:QueueName]}*").each {|key| redis.del(key) }
+		redis.lrem("Queues", 0, params[:QueueName])
+		return_xml {}
+	end
+	
+	action('SendMessage', '/*/:QueueName') do
+		validate_queue_existence
+		delay_seconds = params['DelaySeconds'] || queue['DelaySeconds']
+		message_id = SecureRandom.uuid
+		redis.rpush("Queues:#{params[:QueueName]}:Messages", message_id)
+		redis.hmset("Queues:#{params[:QueueName]}:Messages:#{message_id}",
+			'MessageId', message_id,
+			'MessageBody', params[:MessageBody],
+			'SenderId', '*',
+			'SentTimestamp', now,
+			'ApproximateReceiveCount', 0
+		)
+		redis.expire("Queues:#{params[:QueueName]}:Messages:#{message_id}", queue['MessageRetentionPeriod'])
+		if delay_seconds.to_i > 0
+			redis.set("Queues:#{params[:QueueName]}:Messages:#{message_id}:Delayed", message_id)
+			redis.expire("Queues:#{params[:QueueName]}:Messages:#{message_id}:Delayed", delay_seconds)
+		end
+		return_xml do |xml|
+			xml.MD5OfMessageBody Digest::MD5.hexdigest(params[:MessageBody])
+			xml.MessageId message_id
+		end
+	end
+	
+	action('ReceiveMessage', '/*/:QueueName') do
+		validate_queue_existence
+		wait_time_seconds = params['WaitTimeSeconds'] || queue['ReceiveMessageWaitTimeSeconds']
+		max_number_of_messages = params['MaxNumberOfMessages'] ? params['MaxNumberOfMessages'].to_i : 1
+		visibility_timeout = params['VisibilityTimeout'] || queue['VisibilityTimeout']
+		visible_messages = []
+		message_ids = redis.lrange("Queues:#{params[:QueueName]}:Messages", 0, -1)
+		message_ids.each do |message_id|
+			next if redis.exists("Queues:#{params[:QueueName]}:Messages:#{message_id}:ReceiptHandle")
+			next if redis.exists("Queues:#{params[:QueueName]}:Messages:#{message_id}:Delayed")
+			message = redis.hgetall("Queues:#{params[:QueueName]}:Messages:#{message_id}")
+			message['ApproximateFirstReceiveTimestamp'] ||= now
+			message['ApproximateReceiveCount'] = (message['ApproximateReceiveCount'].to_i + 1).to_s
+			redis.hmset("Queues:#{params[:QueueName]}:Messages:#{message_id}", message.to_a.flatten)
+			receipt_handle = SecureRandom.uuid
+			redis.set("Queues:#{params[:QueueName]}:Messages:#{message_id}:ReceiptHandle", receipt_handle)
+			redis.expire("Queues:#{params[:QueueName]}:Messages:#{message_id}:ReceiptHandle", visibility_timeout)
+			redis.set("Queues:#{params[:QueueName]}:ReceiptHandles:#{receipt_handle}", message_id)
+			redis.expire("Queues:#{params[:QueueName]}:ReceiptHandles:#{receipt_handle}", visibility_timeout)
+			visible_messages << {:MessageId => message_id, :MessageBody => message['MessageBody'], :ReceiptHandle => receipt_handle, :Attributes => message}
+			break if visible_messages.size >= max_number_of_messages
+		end
+		return_xml do |xml|
+			visible_messages.each do |message|
+				xml.Message do
+					xml.MessageId     message[:MessageId]
+					xml.ReceiptHandle message[:ReceiptHandle]
+					xml.MD5OfBody     Digest::MD5.hexdigest(message[:MessageBody])
+					xml.Body          message[:MessageBody]
+					%w(SenderId SentTimestamp ApproximateFirstReceiveTimestamp ApproximateReceiveCount).each do |name|
+						xml.Attribute { xml.Name name; xml.Value message[:Attributes][name] }
+					end
+				end
+			end
+		end
+	end
+	
+	action('ChangeMessageVisibility', '/*/:QueueName') do
+		validate_queue_existence
+		message_id = redis.get("Queues:#{params[:QueueName]}:ReceiptHandles:#{params[:ReceiptHandle]}")
+		redis.expire("Queues:#{params[:QueueName]}:Messages:#{message_id}:ReceiptHandle", params['VisibilityTimeout'])
+		redis.expire("Queues:#{params[:QueueName]}:ReceiptHandles:#{params[:ReceiptHandle]}", params['VisibilityTimeout'])
+		return_xml {}
+	end
+
+	action('DeleteMessage', '/*/:QueueName') do
+		validate_queue_existence
+		message_id = redis.get("Queues:#{params[:QueueName]}:ReceiptHandles:#{params[:ReceiptHandle]}")
+		redis.lrem("Queues:#{params[:QueueName]}:Messages", 0, message_id)
+		redis.del("Queues:#{params[:QueueName]}:ReceiptHandles:#{params[:ReceiptHandle]}")
+		return_xml {}
+	end
+
+	action('SendMessageBatch', '/*/:QueueName') do
+		validate_queue_existence
+		# not implemented yet
+	end
+
+	action('ChangeMessageVisibilityBatch', '/*/:QueueName') do
+		validate_queue_existence
+		# not implemented yet
+	end
+	
+	action('DeleteMessageBatch', '/*/:QueueName') do
+		validate_queue_existence
+		# not implemented yet
+	end
+	
+	helpers do
+		def redis
+			@redis ||= Redis::Namespace.new(:Q3, redis: Redis.new(url: ENV['REDISTOGO_URL'] || 'redis://localhost:6379/15'))
+		end
+	
+		def request_id
+			@request_id ||= SecureRandom.uuid
+		end
+
+		def queue
+			@queue ||= redis.hgetall("Queues:#{params[:QueueName]}")
+		end
+	
+		def queue_url(queue_name)
+			"http://#{request.host}/*/#{queue_name}"
+		end
+
+		def attributes
+			@attributes ||= (1..10).to_a.inject({}) do |attributes, i|
+				if (name = params["Attribute.#{i.to_s}.Name"]) && (value = params["Attribute.#{i.to_s}.Value"])
+					attributes[name] = value
+				end
+				attributes
+			end
+		end
+	
+		def return_xml(&block)
+			builder do |xml|
+				xml.instruct!
+				xml.tag!("#{params['Action']}Response") do
+					xml.tag!("#{params['Action']}Result") do
+						block.call(xml)
+					end
+					xml.ResponseMetadata { xml.RequestId request_id }
+				end
+			end
+		end
+	
+		def return_error_xml(type, code, message)
+			builder do |xml|
+				xml.instruct!
+				xml.ErrorResponse do
+					xml.Error do
+						xml.Type type
+						xml.Code code
+						xml.Message message
+					end
+					xml.ResponseMetadata { xml.RequestId request_id }
+				end
+			end
+		end
+
+		def validate_queue_existence
+			halt 400, return_error_xml('Sender', 'NonExistentQueue', 'The specified queue does not exist for this wsdl version.') if queue.empty?
+		end
+
+		def now
+			(Time.now.to_f * 1000.0).to_i
+		end
+	end
+
+	dispatch!
+end

data/spec/q3_spec.rb

@@ -0,0 +1,341 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Q3" do
+	before do
+		client.list_queues[:queue_urls].each do |queue_url|
+			client.delete_queue(:queue_url => queue_url)
+		end
+	end
+
+	after do
+		client.list_queues[:queue_urls].each do |queue_url|
+			client.delete_queue(:queue_url => queue_url)
+		end
+	end
+
+	context 'Actions' do
+		context 'Queue' do
+			context "CreateQueue" do
+				it 'should create queue' do
+					client.create_queue(:queue_name => 'myqueue001')
+					expect(client.list_queues[:queue_urls]).to include('http://localhost/*/myqueue001')
+				end
+			end
+			
+			context "ListQueues" do
+				it 'should list queues' do
+					1.upto(5) do |i|
+						client.create_queue(:queue_name => "myqueue00#{i}")
+					end
+					expect(client.list_queues[:queue_urls]).to eq %w(
+						http://localhost/*/myqueue001
+						http://localhost/*/myqueue002
+						http://localhost/*/myqueue003
+						http://localhost/*/myqueue004
+						http://localhost/*/myqueue005
+					)
+				end
+			end
+			
+			context "GetQueueUrl" do
+				it 'should get queue url' do
+					client.create_queue(queue_name: 'myqueue001')
+					res = client.get_queue_url(queue_name: 'myqueue001')
+					expect(res[:queue_url]).to eq('http://localhost/*/myqueue001')
+				end
+
+				it 'should raise error when non existent queue is specified' do
+					expect {
+						client.get_queue_url(queue_name: 'myqueue002')
+					}.to raise_error(AWS::SQS::Errors::NonExistentQueue)
+				end
+			end
+			
+			context "GetQueueAttributes" do
+				it 'should get queue attributes' do
+					now = (Time.now.to_f * 1000.0).to_i
+					client.create_queue(queue_name: 'myqueue001')
+					res = client.get_queue_attributes(queue_url: 'http://localhost/*/myqueue001')
+        	                        expect(res[:attributes]["CreateTimestamp"].to_i).to be_within(5000).of(now)
+					expect(res[:attributes]["LastModifiedTimestamp"].to_i).to be_within(5000).of(now)
+					expect(res[:attributes]["VisibilityTimeout"]).to eq("30")
+					expect(res[:attributes]["MessageRetentionPeriod"]).to eq("345600")
+					expect(res[:attributes]["MaximumMessageSize"]).to eq("262144")
+					expect(res[:attributes]["DelaySeconds"]).to eq("0")
+					expect(res[:attributes]["ReceiveMessageWaitTimeSeconds"]).to eq("0")
+					expect(res[:attributes]["ApproximateNumberOfMessages"]).to eq("0")
+					expect(res[:attributes]["ApproximateNumberOfMessagesNotVisible"]).to eq("0")
+					expect(res[:attributes]["ApproximateNumberOfMessagesDelayed"]).to eq("0")
+				end
+
+				it 'should get updated LastModifiedTimestamp' do
+					past = (Time.now.to_f * 1000.0).to_i
+					queue = q3.queues.create('myqueue001')
+					sleep 3
+					now = (Time.now.to_f * 1000.0).to_i
+					queue.visibility_timeout = 1
+					expect(queue.last_modified_timestamp.to_i).not_to be_within(2000).of(past)
+					expect(queue.last_modified_timestamp.to_i).to be_within(2000).of(now)
+				end
+
+				it 'should get precise ApproximateNumberOfMessages*' do
+					queue = q3.queues.create('myqueue001')
+
+					queue.send_message('hello', delay_seconds: 5)
+					queue.send_message('hello')
+					queue.send_message('hello')
+					queue.receive_message
+
+					res = client.get_queue_attributes(queue_url: 'http://localhost/*/myqueue001')
+					expect(res[:attributes]["ApproximateNumberOfMessages"]).to eq("1")
+					expect(res[:attributes]["ApproximateNumberOfMessagesNotVisible"]).to eq("1")
+					expect(res[:attributes]["ApproximateNumberOfMessagesDelayed"]).to eq("1")
+				end
+			end
+
+			context "SetQueueAttributes" do
+				it 'should set queue attributes' do
+					client.create_queue(queue_name: 'myqueue001')
+					client.set_queue_attributes(
+						queue_url: 'http://localhost/*/myqueue001',
+						attributes: {
+							'VisibilityTimeout' => '1',
+							'MessageRetentionPeriod' => '2',
+							'MaximumMessageSize' => '3',
+							'DelaySeconds' => '4',
+							'ReceiveMessageWaitTimeSeconds' => '5',
+						}
+					)
+					res = client.get_queue_attributes(queue_url: 'http://localhost/*/myqueue001')
+					expect(res[:attributes]["VisibilityTimeout"]).to eq("1")
+					expect(res[:attributes]["MessageRetentionPeriod"]).to eq("2")
+					expect(res[:attributes]["MaximumMessageSize"]).to eq("3")
+					expect(res[:attributes]["DelaySeconds"]).to eq("4")
+					expect(res[:attributes]["ReceiveMessageWaitTimeSeconds"]).to eq("5")
+				end
+			end
+			
+			context "DeleteQueue" do
+				it 'should delete queue' do
+					client.create_queue(queue_name: 'myqueue001')
+					client.delete_queue(queue_url: 'http://localhost/*/myqueue001')
+					expect(client.list_queues[:queue_urls]).not_to include('http://localhost/*/myqueue001')
+				end
+			end
+		end
+
+		context 'Message' do
+			context "SendMessage" do
+				it 'should send message' do
+					client.create_queue(queue_name: 'myqueue001')
+					client.send_message(
+						queue_url: 'http://localhost/*/myqueue001',
+						message_body: 'hello'
+					)
+					res = client.receive_message(queue_url: 'http://localhost/*/myqueue001')
+					expect(res[:messages].first[:body]).to eq('hello')
+				end
+			end
+			
+			context "ReceiveMessage" do
+				it 'should receive message' do
+					client.create_queue(queue_name: 'myqueue001')
+					client.send_message(
+						queue_url: 'http://localhost/*/myqueue001',
+						message_body: 'hello'
+					)
+					res = client.receive_message(queue_url: 'http://localhost/*/myqueue001')
+					expect(res[:messages].first[:body]).to eq('hello')
+				end
+
+				it 'should receive message attributes' do
+					queue = q3.queues.create('myqueue001')
+					sent_at = Time.now.to_i
+					queue.send_message('hello')
+
+					sleep 3
+					now = Time.now.to_i
+					message  = queue.receive_message(visibility_timeout: 1)
+					expect(message.sender_id).to eq('*')
+					expect(message.sent_timestamp.to_i).to be_within(1).of(sent_at)
+					expect(message.approximate_first_receive_timestamp.to_i).to be_within(1).of(now)
+					expect(message.approximate_receive_count.to_i).to eq(1)
+
+					sleep 2
+					message = queue.receive_message(visibility_timeout: 1)
+					expect(message.approximate_receive_count.to_i).to eq(2)
+				end
+
+				it 'should receive message attributes' do
+					queue = q3.queues.create('myqueue001')
+					1.upto(10) do |i|
+						queue.send_message("hello #{i}")
+					end
+					res = q3.client.receive_message(
+						queue_url: 'http://localhost/*/myqueue001',
+						max_number_of_messages: 5
+					)
+					expect(res[:messages].size).to eq(5)
+				end
+			end
+			
+			context "ChangeMessageVisibility" do
+				it 'should change message visibility' do
+					client.create_queue(queue_name: 'myqueue001')
+					client.send_message(
+						queue_url: 'http://localhost/*/myqueue001',
+						message_body: 'hello'
+					)
+					res = client.receive_message(queue_url: 'http://localhost/*/myqueue001')
+					receipt_handle = res[:messages].first[:receipt_handle]
+					client.change_message_visibility(
+						queue_url: 'http://localhost/*/myqueue001',
+						receipt_handle: receipt_handle,
+						visibility_timeout: 3,
+					)
+					sleep 5
+					res = client.receive_message(queue_url: 'http://localhost/*/myqueue001')
+					expect(res[:messages].first[:body]).to eq('hello')
+				end
+			end
+
+			context "DeleteMessage" do
+				it 'should delete message' do
+					client.create_queue(queue_name: 'myqueue001')
+					client.send_message(
+						queue_url: 'http://localhost/*/myqueue001',
+						message_body: 'hello'
+					)
+					res = client.receive_message(queue_url: 'http://localhost/*/myqueue001')
+					receipt_handle = res[:messages].first[:receipt_handle]
+					client.delete_message(
+						queue_url: 'http://localhost/*/myqueue001',
+						receipt_handle: receipt_handle
+					)
+					res = client.receive_message(queue_url: 'http://localhost/*/myqueue001')
+					expect(res[:messages]).to be_empty
+				end
+			end
+		end
+	end
+
+	context 'Features' do
+		context 'Message Extention Period' do
+			it 'with CreateQueue MessageExtentionPeriod' do
+				queue = q3.queues.create('myqueue001', :message_retention_period => 3)
+
+				queue.send_message('hello')
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+
+				queue.send_message('hello')
+				sleep 4
+				message = queue.receive_message
+				expect(message).to be_nil
+			end
+
+			it 'with SetQueueAttributes MessageExtentionPeriod' do
+				queue = q3.queues.create('myqueue001')
+				queue.message_retention_period = 3
+
+				queue.send_message('hello')
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+
+				queue.send_message('hello')
+				sleep 4
+				message = queue.receive_message
+				expect(message).to be_nil
+			end
+		end
+
+		context 'First In First Out' do
+			it 'First in first out' do
+				queue = q3.queues.create('myqueue001', :visibility_timeout => 3)
+
+				1.upto(10) do |i|
+					queue.send_message("hello #{i}")
+				end
+
+				1.upto(10) do |i|
+					message = queue.receive_message
+					expect(message.body).to eq("hello #{i}")
+				end
+			end
+		end
+
+		context 'Long Polling' do
+			pending 'not implemented yet'
+		end
+
+		context 'Visibility Timeout' do
+			it 'with CreateQueue VisibilityTimeout' do
+				queue = q3.queues.create('myqueue001', :visibility_timeout => 3)
+
+				queue.send_message('hello')
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+
+				message = queue.receive_message
+				expect(message).to be_nil
+
+				sleep 4
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+			end
+
+			it 'with SetQueueAttributes VisibilityTimeout' do
+				queue = q3.queues.create('myqueue001')
+				queue.visibility_timeout = 3
+
+				queue.send_message('hello')
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+
+				message = queue.receive_message
+				expect(message).to be_nil
+
+				sleep 4
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+			end
+
+			it 'with ReceiveMessage VisibilityTimeout' do
+				queue = q3.queues.create('myqueue001')
+
+				queue.send_message('hello')
+				message = queue.receive_message(visibility_timeout: 3)
+				expect(message.body).to eq('hello')
+
+				message = queue.receive_message
+				expect(message).to be_nil
+
+				sleep 4
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+			end
+		end
+
+		context 'Delayed Message' do
+			it 'with CreateQueue DelaySeconds' do
+				queue = q3.queues.create('myqueue001', :delay_seconds => 3)
+				queue.send_message('hello')
+				message = queue.receive_message
+				expect(message).to be_nil
+				sleep 4
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+			end
+
+			it 'with SendMessage DelaySeconds' do
+				queue = q3.queues.create('myqueue001')
+				queue.send_message('hello', :delay_seconds => 3)
+				message = queue.receive_message
+				expect(message).to be_nil
+				sleep 4
+				message = queue.receive_message
+				expect(message.body).to eq('hello')
+			end
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'q3'
+require 'aws-sdk'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end
+
+#AWS.config(
+#	logger: Logger.new($stdout),
+#	log_level: :debug,
+#	http_wire_trace: true
+#)
+
+def q3
+	@q3 ||= AWS::SQS.new(
+		:sqs_endpoint => 'localhost',
+		:access_key_id => 'dummy',
+		:secret_access_key => 'dummy',
+		:use_ssl => false
+	)
+end
+
+def client
+  q3.client
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: q3
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- tily
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+description: Simple Amazon SQS compatible API implementation with sinatra and redis
+email: tily05@gmail.com
+executables:
+- q3
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/q3
+- config.ru
+- lib/q3.rb
+- spec/q3_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/tily/q3
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1071069083813068665
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Simple Amazon SQS compatible API implementation with sinatra and redis
+test_files: []