em-amazon-sqs 0.1.0

data/lib/simple_qs/request.rb

@@ -0,0 +1,24 @@
+module SimpleQS
+  module Request
+    autoload :Base,     'simple_qs/request/base'
+    autoload :Get,      'simple_qs/request/get'
+    autoload :Post,     'simple_qs/request/post'
+    
+    class UnknownHttpMethod < StandardError; end
+    
+    HTTP_METHODS = {
+      :get    => :Get,
+      :post   => :Post
+    }
+    
+    class << self
+      def build(request, params = {})
+        if SimpleQS::Request::HTTP_METHODS.keys.include?(request)
+          SimpleQS::Request.const_get(HTTP_METHODS[request]).new(params)
+        else
+          raise SimpleQS::Request::UnknownHttpMethod, "Method #{request} is unknown or unsupported"
+        end
+      end
+    end
+  end
+end

data/lib/simple_qs/request/base.rb

@@ -0,0 +1,105 @@
+require 'uri'
+require 'net/http'
+require 'base64'
+require 'hmac-sha1'
+
+module SimpleQS
+  module Request
+    class Base
+      
+      RESERVED_CHARACTERS = /[^a-zA-Z0-9\-\.\_\~]/
+      SIGNATURE_VERSION   = 2
+      SIGNATURE_METHOD    = 'HmacSHA1'
+      
+      def initialize(params = {})
+        self.query_params = params
+      end
+      
+      def ==(other)
+        self.class.http_method == other.class.http_method\
+          && query_params == other.query_params\
+          && query_string == other.query_string
+      end
+
+      def timestamp
+        @timestamp ||= _timestamp
+      end
+      
+      def timestamp=(time)
+        raise ArgumentError, "expected Time object, bug got #{time.class.to_s} instead." unless time.kind_of?(Time)
+        @timestamp = time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      end
+
+      def query_params
+        @query_params ||= {}
+        @query_params = {
+          'SignatureVersion'    => SIGNATURE_VERSION,
+          'SignatureMethod'     => SIGNATURE_METHOD,
+          'Version'             => SimpleQS::API_VERSION,
+          'Timestamp'           => timestamp,
+          'AWSAccessKeyId'      => SimpleQS.access_key_id
+        }.merge(@query_params)
+        @query_params.delete('Timestamp') if @query_params['Expires']
+        
+        @query_params
+      end
+      attr_writer :query_params
+      
+      def update_query_params(params)
+        @query_params = query_params.merge params
+      end
+
+      def query_string
+        @query_string ||= "/"
+      end
+      
+      def query_string=(value)
+        value = value.join('/') if value.kind_of?(Array)
+        @query_string = (value =~ /^\// ? value : "/#{value}")
+      end
+
+      # Canonicalizes query string
+      def canonical_query_string
+        params_to_query(query_params.sort)
+      end
+
+      def signature_base_string
+        [
+          self.class.http_method.to_s.upcase,
+          SimpleQS.host.downcase,
+          query_string,
+          canonical_query_string
+        ].join("\n")
+      end
+
+      def uri(with_query_params = false)
+        "http://#{SimpleQS.host}#{query_string}" << (with_query_params ? "?#{params_to_query(query_params)}" : '')
+      end
+      
+      def sign!
+        update_query_params({
+          'Signature'   => Base64.encode64(HMAC::SHA1.digest(SimpleQS.secret_access_key, signature_base_string)).chomp
+        })
+        self
+      end
+
+      def params_to_query(params)
+        params.map {|pair| pair.map {|value| URI.escape(value.to_s, RESERVED_CHARACTERS)}.join('=')}.join('&')
+      end
+      
+      class << self
+        def http_method(value = nil)
+          @http_method = value if value
+          @http_method
+        end
+      end
+      
+      protected
+
+      # Generates UTC timestamp in dateTime object format
+      def _timestamp
+        Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      end
+    end
+  end
+end

data/lib/simple_qs/request/get.rb

@@ -0,0 +1,14 @@
+module SimpleQS
+  module Request
+    class Get < Base
+      http_method :get
+      
+      def perform
+        sign!
+        http = EM::HttpRequest.new(URI.parse(uri(true))).get
+        #SimpleQS::Responce.new Net::HTTP.get(URI.parse(uri(true)))
+        SimpleQS::Responce.new http.response
+      end
+    end
+  end
+end

data/lib/simple_qs/request/post.rb

@@ -0,0 +1,14 @@
+module SimpleQS
+  module Request
+    class Post < Base
+      http_method :post
+
+      def perform
+        sign!
+        http = EM::HttpRequest.new(URI.parse(uri)).post :body => query_params
+        #SimpleQS::Responce.new Net::HTTP.post_form(URI.parse(uri), query_params).body
+        SimpleQS::Responce.new http.response
+      end
+    end
+  end
+end

data/lib/simple_qs/responce.rb

@@ -0,0 +1,30 @@
+require 'xmlsimple'
+
+require 'simple_qs/responce/exceptions'
+
+module SimpleQS
+  class Responce
+    
+    autoload :SuccessfulBuilder,    'simple_qs/responce/successful_builder'
+    autoload :FailureBuilder,       'simple_qs/responce/failure_builder'
+    
+    def initialize(xml)
+      _parse xml
+    end
+    
+    def successful?
+      !@xml_data.key?('ErrorResponse')
+    end
+
+    def root_element
+      @xml_data.keys[0]
+    end
+    
+    private
+    
+    def _parse(xml)
+      @xml_data = XmlSimple.xml_in(xml, {'ForceArray' => false, 'KeepRoot' => true})
+      (successful? ? SuccessfulBuilder : FailureBuilder).build(self)
+    end
+  end
+end

data/lib/simple_qs/responce/exceptions.rb

@@ -0,0 +1,39 @@
+module SimpleQS
+  class Responce
+
+    class Error < StandardError; end
+
+    class AccessDeniedError                           < Error; end
+    class AuthFailureError                            < Error; end
+    class AWSSimpleQueueServiceInternalError          < Error; end
+    class AWSSimpleQueueServiceNonExistentQueueError  < Error; end
+    class AWSSimpleQueueServiceQueueDeletedRecently   < Error; end
+    class AWSSimpleQueueServiceQueueNameExists        < Error; end
+    class ConflictingQueryParameterError              < Error; end
+    class InvalidParameterValueError                  < Error; end
+    class InternalError                               < Error; end
+    class InvalidAccessKeyIdError                     < Error; end
+    class InvalidActionError                          < Error; end
+    class InvalidAddressError                         < Error; end
+    class InvalidClientTokenIdError                   < Error; end
+    class InvalidHttpRequestError                     < Error; end
+    class InvalidParameterCombinationError            < Error; end
+    class InvalidParameterValueError                  < Error; end
+    class InvalidQueryParameterError                  < Error; end
+    class InvalidRequestError                         < Error; end
+    class InvalidSecurityError                        < Error; end
+    class InvalidSecurityTokenError                   < Error; end
+    class MalformedVersionError                       < Error; end
+    class MissingClientTokenIdError                   < Error; end
+    class MissingCredentialsError                     < Error; end
+    class MissingParameterError                       < Error; end
+    class NoSuchVersionError                          < Error; end
+    class NotAuthorizedToUseVersionError              < Error; end
+    class OptInRequiredError                          < Error; end
+    class RequestExpiredError                         < Error; end
+    class RequestThrottledError                       < Error; end
+    class ServiceUnavailableError                     < Error; end
+    class SignatureDoesNotMatchError                  < Error; end
+    class X509ParseError                              < Error; end
+  end
+end

data/lib/simple_qs/responce/failure_builder.rb

@@ -0,0 +1,33 @@
+module SimpleQS
+  class Responce
+    class FailureBuilder
+      def self.build responce
+        responce.instance_eval do
+          def sender_error?
+            @xml_data[root_element]['Error']['Type'] == 'Sender'
+          end
+
+          def receiver_error?
+            @xml_data[root_element]['Error']['Type'] == 'Receiver'
+          end
+
+          def request_id
+            @xml_data[root_element]['RequestId']
+          end
+
+          def error_code
+            @xml_data[root_element]['Error']['Code'].gsub(/\./, '')
+          end
+          
+          def error_message
+            @xml_data[root_element]['Error']['Message']
+          end
+
+          def to_error
+            self.class.const_get(error_code =~ /Error$/ ? error_code : "#{error_code}Error").new error_message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_qs/responce/successful_builder.rb

@@ -0,0 +1,26 @@
+module SimpleQS
+  class Responce
+    class SuccessfulBuilder
+      def self.build responce
+        responce.instance_eval do
+
+          def action_name
+            @action_name ||= root_element.gsub(/Response/, '')
+          end
+
+          def request_id
+            @xml_data[root_element]['ResponseMetadata']['RequestId']
+          end
+
+          @xml_data[root_element]["#{action_name}Result"].each do |key, value|
+            self.instance_eval %{
+              def #{key.gsub(/([A-Z]+)/, '_\1').downcase.gsub(/^_/, '')}
+                #{value.inspect}
+              end
+            }
+          end if @xml_data[root_element]["#{action_name}Result"]
+        end
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module SimpleQS
+  VERSION = '0.2'
+end

data/simple_qs.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'version'))
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'simple_qs'
+  s.version     = SimpleQS::VERSION
+  s.summary     = 'Amazon SQS service library'
+  s.description = 'SimpleQS is Ruby wrapper for Amazon Simple Queue Service (SQS) REST API. It allows you perform all kind of calls on queues and messages.'
+
+  s.required_ruby_version     = '>= 1.8.7'
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.author            = "Marjan Krekoten' (Мар'ян Крекотень)"
+  s.email             = 'krekoten@gmail.com'
+  s.homepage          = 'http://github.com/krekoten/SimpleQS'
+
+  s.add_dependency('xml-simple', '>= 1.0.12')
+  s.add_dependency('ruby-hmac', '>= 0.3.2')
+  
+  s.add_development_dependency("rspec")
+  
+  s.require_path = 'lib'
+  s.files        = Dir.glob("lib/**/*") + %w(LICENSE README.md CHANGELOG.md TODO.md)
+end

data/spec/simple_qs/message_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+module SimpleQS
+  describe Message do
+    before :all do
+      @queue = SimpleQS::Queue.new('testQueue')
+    end
+
+    it 'should accept string as message' do
+      string = 'Test message from SimpleQS::Message spec'
+      message = SimpleQS::Message.new(@queue, string)
+      message.body.should == string
+    end
+
+    it 'should return message instance when sent from class method' do
+      string = 'Test message from SimpleQS::Message spec'
+
+      message = SimpleQS::Message.send(@queue, string)
+
+      message.should be_instance_of(SimpleQS::Message)
+      message.body.should == string
+      message.message_id.should_not be_empty
+    end
+
+    it 'should receive messages' do
+      messages = SimpleQS::Message.receive(@queue)
+      messages.should have_at_least(1).message
+      messages[0].should be_instance_of(SimpleQS::Message)
+    end
+
+    it 'should receive at least 3 messages with attributes' do
+      string = 'Test message from SimpleQS::Message spec'
+      message = SimpleQS::Message.new(@queue, string)
+      message.send
+      message.resend
+      message.resend
+      message.resend
+
+      messages = SimpleQS::Message.receive(@queue, :All, 3, 30)
+      messages.should have_at_least(3).message
+      messages[0].should be_instance_of(SimpleQS::Message)
+    end
+
+    describe 'when message is not sent' do
+      before :each do
+        @message = SimpleQS::Message.new(@queue, 'Test message from SimpleQS::Message spec')
+      end
+
+      it "should be sendable" do
+        lambda do
+          @message.send
+        end.should_not raise_error
+      end
+    end
+
+    describe 'when message is sent' do
+      before :each do
+        @message = SimpleQS::Message.new(@queue, 'Test message from SimpleQS::Message spec')
+        @message.send
+      end
+
+      it "should not be sendable" do
+        lambda do
+          @message.send
+        end.should raise_error(SimpleQS::Message::DoubleSendError)
+      end
+
+      it 'should be able to be resend' do
+        lambda do
+          @message.resend
+        end.should_not raise_error
+      end
+      
+      describe 'and then is resent' do
+        it 'should not be equal to orginal message' do
+          new_message = @message.resend
+          new_message.should_not == @message
+        end
+      end
+    end
+
+    describe 'when receive messages' do
+      before :each do
+        @queue.send_message('Message 1')
+        @queue.send_message('Message 2')
+        @queue.send_message('Message 3')
+        @messages = SimpleQS::Message.receive(@queue, nil, 10)
+      end
+
+      it 'should be able to delete message' do
+        lambda do
+          @messages.each do |message|
+            message.delete
+          end
+        end.should_not raise_error
+      end
+    end
+
+    describe 'change visibility of message' do
+      it 'should be able when message is received' do
+        lambda do
+          @queue.send_message('Message')
+          SimpleQS::Message.receive(@queue).last.change_visibility(120)
+        end.should_not raise_error
+      end
+
+      it 'should not be able when message is not received' do
+        lambda do
+          SimpleQS::Message.new(@queue, 'Message').change_visibility(120)
+        end.should raise_error(SimpleQS::Message::NotReceivedError)
+      end
+    end
+  end
+end

data/spec/simple_qs/queue_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+module SimpleQS
+  describe Queue do
+    describe 'create method' do
+      it 'should raise error if queue name is longer than 80 characters' do
+        lambda do
+          SimpleQS::Queue.create('a' * 81)
+        end.should raise_error(ArgumentError)
+      end
+      
+      it 'should accept only alphanumeric characters, hyphens (-), and underscores (_)' do
+        lambda do
+          SimpleQS::Queue.check_queue_name('test&queue')
+        end.should raise_error(ArgumentError)
+        
+        lambda do
+          SimpleQS::Queue.check_queue_name('test_queue-123ABC')
+        end.should_not raise_error(ArgumentError)
+      end
+      
+      it 'should raise error if passed too long visibility timeout' do
+        lambda do
+          SimpleQS::Queue.check_visibility_timeout(SimpleQS::Queue::MAX_VISIBILITY_TIMEOUT + 1)
+        end.should raise_error(SimpleQS::Queue::MaxVisibilityError)
+      end
+      
+      it 'should raise error if passed negative visibility timeout' do
+        lambda do
+          SimpleQS::Queue.check_visibility_timeout(-1)
+        end.should raise_error(SimpleQS::Queue::MaxVisibilityError)
+      end
+      
+      it 'should raise error if visibility timeout is not fixnum' do
+        lambda do
+          SimpleQS::Queue.check_visibility_timeout(Object.new)
+        end.should raise_error(ArgumentError)
+      end
+      
+      it 'should return SimpleQS::Queue instance' do
+        SimpleQS::Queue.create('testQueue').should be_instance_of(SimpleQS::Queue)
+      end
+      
+      it 'should pass SimpleQS::Queue instance to block' do
+        _queue = nil
+        SimpleQS::Queue.create('testQueue') do |queue|
+          _queue = queue
+        end
+        
+        _queue.should be_instance_of(SimpleQS::Queue)
+      end
+    end
+    
+    it 'should have at least 1 queue' do
+      SimpleQS::Queue.list.should have_at_least(1).queue
+    end
+
+    it 'should find at least 1 queue by beggining of the name' do
+      SimpleQS::Queue.list('test').should have_at_least(1).queue
+    end
+
+    it 'should find 0 queues with nonexistent names' do
+      SimpleQS::Queue.list('nonExistantQueueName').should have(0).queue
+    end
+
+    it 'should be able to get all queue attributes' do
+      SimpleQS::Queue.new('testQueue').get_attributes(:All).should_not be_empty
+    end
+
+    it 'should be able to change default visibility timeout for queue' do
+      lambda do
+        SimpleQS::Queue.new('testQueue').set_visibility_timeout(60)
+      end.should_not raise_error
+    end
+    
+    it 'should be able to change maximum message size' do
+      lambda do
+        SimpleQS::Queue.new('testQueue').set_maximum_message_size(65536)
+      end.should_not raise_error
+    end
+    
+    it 'should raise error if message size is wrong' do
+      lambda do
+        SimpleQS::Queue.new('testQueue').set_maximum_message_size(65537)
+      end.should raise_error(SimpleQS::Queue::MaxMessageSizeError)
+      
+      lambda do
+        SimpleQS::Queue.new('testQueue').set_maximum_message_size(1023)
+      end.should raise_error(SimpleQS::Queue::MaxMessageSizeError)
+    end
+    
+    it 'should be able to change message retention period' do
+      lambda do
+        SimpleQS::Queue.new('testQueue').set_message_retention_period(1209600)
+      end.should_not raise_error
+    end
+    
+    it 'should raise error if message retention period is wrong' do
+      lambda do
+        SimpleQS::Queue.new('testQueue').set_message_retention_period(3599)
+      end.should raise_error(SimpleQS::Queue::MessageRetentionPeriodError)
+      
+      lambda do
+        SimpleQS::Queue.new('testQueue').set_message_retention_period(1209601)
+      end.should raise_error(SimpleQS::Queue::MessageRetentionPeriodError)
+    end
+
+    it 'should be able to set default visibility timeout for queue using set_attributes' do
+      lambda do
+        SimpleQS::Queue.new('testQueue').set_attributes({:VisibilityTimeout => 30})
+      end.should_not raise_error
+    end
+
+    it 'should be able to add permissions' do
+      lambda do
+        SimpleQS::Queue.new('testQueue').add_permissions('testPerms', [
+          {:account_id => '098166147350', :action => 'SendMessage'},
+          {:account_id => '098166147350', :action => 'ReceiveMessage'}
+        ])
+      end.should_not raise_error
+    end
+
+    it 'should be able to remove permissions' do
+      lambda do
+        SimpleQS::Queue.new('testQueue').remove_permissions('testPerms')
+      end.should_not raise_error
+    end
+    
+    it 'should respond true if queue exists' do
+      SimpleQS::Queue.exists?('testQueue').should == true
+    end
+    
+    it 'should respond false if queue does not exist' do
+      SimpleQS::Queue.exists?('nonExistantQueue123').should == false
+    end
+
+    it 'should be able to delete queue' do
+      lambda do
+        queue_name = Time.now.to_i.to_s
+        SimpleQS::Queue.create(queue_name)
+        SimpleQS::Queue.delete(queue_name)
+      end.should_not raise_error
+    end
+  end
+end