lsqs 0.0.1

data/spec/lsqs/aws_sdk_actions_spec.rb

@@ -0,0 +1,346 @@
+require 'spec_helper'
+require 'aws-sdk'
+
+describe 'Testing actions against the aws-sdk' do
+  before do
+  	base_url = 'www.example.com' 
+  	port 		 = 8080
+    @url     = "http://#{base_url}:#{port}"
+    Aws.config.update(:endpoint => @url)
+    @client = Aws::SQS::Client.new
+  end
+  
+  after do
+    list = @client.list_queues
+    list.queue_urls.each do |queue|
+      @client.delete_queue(:queue_url => queue)
+    end
+  end
+  
+  describe '#create_queue'
+  it 'creates a queue if it does not exist' do
+    response = @client.create_queue(:queue_name => 'foo_queue')
+    
+    response.queue_url.should == "#{@url}/foo_queue"
+    
+    response.data.kind_of?(Aws::SQS::Types::CreateQueueResult).should be_truthy
+  end
+  
+  it 'throws an error if queue exists' do
+    @client.create_queue(:queue_name => 'bar_queue')
+
+    expect{
+      @client.create_queue(:queue_name => 'bar_queue')
+    }.to raise_error(Aws::SQS::Errors::Error400, 'QueueNameExists')
+  end
+  
+  describe '#delete_queue' do
+    it 'deletes a queue if it exists' do
+      queue = @client.create_queue(:queue_name => 'bar')
+    
+      response = @client.delete_queue(:queue_url => queue.queue_url)
+
+      response.data.kind_of?(Aws::EmptyStructure).should be_truthy
+    end
+  
+    it 'throws an error if queue does not exist' do
+
+      expect{
+        @client.delete_queue(:queue_url => "#{@url}/no_queue")
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+  end
+  
+  describe '#purge_queue' do
+    it 'purges a queue if it exists' do
+      queue = @client.create_queue(:queue_name => 'another_queue')
+    
+      response = @client.purge_queue(:queue_url => queue.queue_url)
+
+      response.data.kind_of?(Aws::EmptyStructure).should be_truthy
+    end
+  
+    it 'throws an error if queue does not exist' do
+      expect{
+        @client.delete_queue(:queue_url => "#{@url}/not_there")
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+  end
+  
+  describe '#get_queue_url' do
+    it 'purges a queue if it exists' do
+      queue = @client.create_queue(:queue_name => 'this_queue')
+    
+      response = @client.get_queue_url(:queue_name => 'this_queue')
+      response.data.kind_of?(Aws::SQS::Types::GetQueueUrlResult).should be_truthy
+    end
+  
+    it 'throws an error if queue does not exist' do
+      expect{
+        @client.get_queue_url(:queue_name => 'foo_bar')
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+  end
+  
+  describe '#list_queues' do
+    it 'returns an empty array if there are no queues' do
+      list = @client.list_queues
+
+      list.queue_urls.empty?.should be_truthy
+    end
+    
+    it 'returns an array with the queue urls' do
+      queue = @client.create_queue(:queue_name => 'great_queue')
+      list = @client.list_queues
+
+      list.queue_urls.size.should eql(1)
+      list.queue_urls.first.should == queue.queue_url
+    end
+    
+    it 'searches for a url based on a prefix' do
+      @client.create_queue(:queue_name => 'bad_queue')
+      nice = @client.create_queue(:queue_name => 'nice_queue')
+      list = @client.list_queues(:queue_name_prefix => 'nice')
+
+      list.queue_urls.size.should eql(1)
+      list.queue_urls.first.should == nice.queue_url
+    end
+  end
+  
+  describe '#send_message' do
+    it 'throws an error if queue does not exist' do
+      entry     = {:foo => 'bar'}
+      queue_url = "#{@url}/test"
+      expect{
+        @client.send_message(
+          :queue_url => queue_url, 
+          :message_body => entry.to_json
+        )
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+    
+    it 'returns message on success' do
+      entry     = {:foo => 'bar'}
+      queue = @client.create_queue(:queue_name => 'test')
+      queue_url = queue.queue_url
+      response = @client.send_message(
+        :queue_url => queue_url, 
+        :message_body => entry.to_json
+      )
+      
+      response.message_id.kind_of?(String).should be_truthy
+      response.md5_of_message_body.kind_of?(String).should be_truthy
+      response.data.kind_of?(Aws::SQS::Types::SendMessageResult).should be_truthy
+    end
+  end
+  
+  describe '#send_message_batch' do
+    before do
+      @entries = [
+        {
+          :message_body => 'foo and bar', 
+          :id => 'foo_bar'
+        }, 
+        {
+          :message_body => 'hey hello', 
+          :id  => 'hey_hello'
+        }
+      ]
+    end
+    
+    it 'throws an error if queue does not exist' do      
+      queue_url = "#{@url}/test"
+      expect{
+        @client.send_message_batch(
+          :queue_url => queue_url, 
+          :entries => @entries
+        )
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+    
+    it 'returns messages on success' do
+      queue = @client.create_queue(:queue_name => 'test')
+      queue_url = queue.queue_url
+      response = @client.send_message_batch(
+        :queue_url => queue_url, 
+        :entries => @entries
+      )
+
+      response.successful.size.should == 2
+      response.data.kind_of?(Aws::SQS::Types::SendMessageBatchResult).should be_truthy
+    end
+  end
+  
+  describe '#receive_message' do
+    before do
+      @entries = [
+        {
+          :message_body => 'foo and bar', 
+          :id => 'foo_bar'
+        }, 
+        {
+          :message_body => 'hey hello', 
+          :id  => 'hey_hello'
+        }
+      ]
+    end
+    
+    it 'throws an error if queue does not exist' do      
+      queue_url = "#{@url}/test"
+      expect{
+        @client.receive_message(:queue_url => queue_url)
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+    
+    it 'receives an empty response if there are no messages' do
+      queue = @client.create_queue(:queue_name => 'receive_test')
+      queue_url = queue.queue_url
+      response = @client.receive_message(:queue_url => queue_url)
+
+      response.messages.size.should == 0
+    end
+    
+    it 'receives a message if there are messages in the queue' do    
+      queue = @client.create_queue(:queue_name => 'receive_test')
+      queue_url = queue.queue_url
+      @client.send_message_batch(:queue_url => queue_url, :entries => @entries)
+      response = @client.receive_message(:queue_url => queue_url)
+
+      response.messages.size.should == 1
+      response.data.class.kind_of?(Aws::SQS::Types::ReceiveMessageResult)
+    end
+    
+    it 'receives more message if maximum number of messages is set' do    
+      queue = @client.create_queue(:queue_name => 'receive_test')
+      queue_url = queue.queue_url
+      @client.send_message_batch(:queue_url => queue_url, :entries => @entries)
+
+      response = @client.receive_message(:queue_url => queue_url, :max_number_of_messages => 5)
+
+      response.messages.size.should == 2
+      response.data.class.kind_of?(Aws::SQS::Types::ReceiveMessageResult)
+    end
+  end
+  
+  describe '#delete_message' do
+    it 'throws an error if queue does not exist' do      
+      queue_url = "#{@url}/test"
+      expect{
+        @client.delete_message(:queue_url => queue_url, :receipt_handle => 'test')
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+    
+    it 'throws message not in flight error after deleting successfully' do
+      queue = @client.create_queue(:queue_name => 'delete_test')
+      entry     = {:foo => 'bar'}  
+      queue_url = queue.queue_url
+      @client.send_message(:queue_url => queue_url, :message_body => entry.to_json)
+      
+      response = @client.receive_message(:queue_url => queue_url)
+      
+      @client.delete_message(:queue_url => queue_url, :receipt_handle => response.messages.first.receipt_handle)
+      
+      expect{
+        @client.change_message_visibility(
+          :queue_url => queue_url, 
+          :receipt_handle => response.messages.first.receipt_handle, 
+          :visibility_timeout => 0
+        )
+      }.to raise_error(Aws::SQS::Errors::Error400, 'MessageNotInflight')
+    end
+  end
+  
+  describe '#delete_message_batch' do
+    it 'throws an error if queue does not exist' do  
+      entries = [
+              {
+                :receipt_handle => 'foo',
+                :id             => 'test1'
+              }, 
+              {
+                :receipt_handle => 'bar',
+                :id             => 'test2'
+              }
+            ]    
+      queue_url = "#{@url}/test"
+      expect{
+        @client.delete_message_batch(:queue_url => queue_url, :entries => entries)
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+    
+    it 'throws message not in flight error after deleting successfully' do
+      queue = @client.create_queue(:queue_name => 'delete_batch_test')
+      entry1    = {:foo => 'bar'}
+      entry2    = {:hey => 'hello'}
+      queue_url = queue.queue_url
+      
+      @client.send_message(:queue_url => queue_url, :message_body => entry1.to_json)
+      @client.send_message(:queue_url => queue_url, :message_body => entry2.to_json)
+      
+      response = @client.receive_message(:queue_url => queue_url, :max_number_of_messages => 2)
+      
+      entries = response.messages.map do |m| 
+        {:receipt_handle => m.receipt_handle, :id => m.message_id}
+      end
+      
+      @client.delete_message_batch(:queue_url => queue_url, :entries => entries)
+      
+      expect{
+        @client.change_message_visibility(
+          :queue_url => queue_url, 
+          :receipt_handle => response.messages.first.receipt_handle, 
+          :visibility_timeout => 0
+        )
+      }.to raise_error(Aws::SQS::Errors::Error400, 'MessageNotInflight')
+      
+      expect{
+        @client.change_message_visibility(
+          :queue_url => queue_url, 
+          :receipt_handle => response.messages.last.receipt_handle, 
+          :visibility_timeout => 0
+        )
+      }.to raise_error(Aws::SQS::Errors::Error400, 'MessageNotInflight')
+    end
+  end
+  
+  describe '#change_message_visibility' do
+    it 'throws an error if queue does not exist' do      
+      queue_url = "#{@url}/test"
+      expect{
+        @client.change_message_visibility(
+          :queue_url => queue_url, 
+          :receipt_handle => 'test', 
+          :visibility_timeout => 0
+        )
+      }.to raise_error(Aws::SQS::Errors::Error400, 'NonExistentQueue')
+    end
+    
+    it 'puts a message back in the queue when visibility is 0' do
+      queue = @client.create_queue(:queue_name => 'visibility_test')
+      entry     = {:foo => 'bar'}  
+      queue_url = queue.queue_url
+      @client.send_message(:queue_url => queue_url, :message_body => entry.to_json)
+      
+      response1 = @client.receive_message(:queue_url => queue_url)
+      
+      response1.messages.size.should == 1
+      
+      response2 = @client.receive_message(:queue_url => queue_url)
+      
+      response2.messages.size.should == 0
+      
+      @client.change_message_visibility(
+        :queue_url => queue_url, 
+        :receipt_handle => response1.messages.first.receipt_handle, 
+        :visibility_timeout => 0
+      )
+      
+      response3 = @client.receive_message(:queue_url => queue_url)
+      
+      response1.messages.size.should == 1
+
+      response1.messages.first.message_id.should == response3.messages.first.message_id
+      response1.messages.first.md5_of_body.should == response3.messages.first.md5_of_body      
+    end
+  end
+end

data/spec/lsqs/message_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe LSQS::Message do
+  before do
+    @attributes = {'MessageBody' => 'test'}
+    @message = described_class.new(@attributes)
+  end
+  describe '#attributes' do
+    it 'has same message body' do
+      @message.attributes['MessageBody'].should == @attributes['MessageBody']
+    end
+    
+    it 'has correct MD5 message hash' do
+      @message.attributes['MD5'].should == Digest::MD5.hexdigest(@attributes['MessageBody'])
+    end
+    
+    it 'has an Id' do
+      @message.attributes['Id'].kind_of?(String).should be_truthy
+    end
+    
+    it 'can initialize its id' do
+      attributes = {'MessageBody' => 'test', 'Id' => 'foo'}
+      message = described_class.new(attributes)
+      message.attributes['Id'].should == attributes['Id']
+    end
+    
+    it 'can initialize its md5' do
+      attributes = {'MessageBody' => 'test', 'MD5' => 'bar'}
+      message = described_class.new(attributes)
+      message.attributes['MD5'].should == attributes['MD5']
+    end
+  end
+  
+  describe '#expired?' do
+    it 'returns true if visibility_timeout is not set' do
+      @message.expired?.should be_truthy
+    end
+    
+    it 'returns false if visibility_timeout is set' do
+      @message.expire_in(30)
+      @message.expired?.should be_falsey
+    end
+  end
+  
+  describe '#expire_in' do
+    it 'sets the visibility_timeout' do
+      time = Time.now
+      @message.expire_in(30)
+      @message.visibility_timeout.should > time + 30
+    end
+  end
+  
+  describe '#expire' do
+    it 'resets the visibility_timeout' do
+      @message.expire_in(30)
+      @message.visibility_timeout.kind_of?(NilClass).should be_falsey
+      @message.expire
+      @message.visibility_timeout.kind_of?(NilClass).should be_truthy
+    end
+  end
+end

data/spec/lsqs/queue_list_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe LSQS::QueueList do
+  before do
+    @list = described_class.new
+  end
+  
+  describe '#initialize' do
+    it 'initializes properly' do
+      
+      list = described_class.new
+
+      list.queues.kind_of?(Hash).should be_truthy
+      list.queues.size.zero?.should be_truthy
+    end
+  end
+  
+  describe '#create' do
+    it 'creates a queue' do
+      @list.create('foo')
+      @list.create('bar')
+      
+      @list.queues.size.should == 2
+      @list.queues['foo'].kind_of?(LSQS::Queue).should be_truthy
+    end
+    
+    it 'throws an error if queue already exists' do
+      @list.create('test')
+      expect{@list.create('test')}.to raise_error(RuntimeError, 'QueueNameExists')
+    end
+  end
+  
+  describe '#inspect' do
+    it 'gives the list of queues' do
+      @list.create('foo')
+      @list.create('bar')
+      
+      result = @list.inspect
+      
+      result.size.should == 2
+      result.include?('bar').should be_truthy
+      result.include?('foo').should be_truthy
+      result.kind_of?(Array).should be_truthy
+    end
+    
+    it 'gives the list of queues by prefix' do
+      @list.create('foo')
+      @list.create('bar')
+      
+      result = @list.inspect('QueueNamePrefix' => 'foo')
+      
+      result.size.should == 1
+      result.include?('foo').should be_truthy
+      result.kind_of?(Array).should be_truthy
+    end
+  end
+  
+  describe '#find' do
+    it 'returns a single queue' do
+      @list.create('test')
+      
+      result = @list.find('test')
+      
+      result.kind_of?(LSQS::Queue).should be_truthy
+      result.name.should == 'test'
+    end
+    
+    it 'throws an error if queue does not exist' do
+      expect{@list.find('foo')}.to raise_error(RuntimeError, 'NonExistentQueue')
+    end
+  end
+  
+  describe '#delete' do
+    it 'deletes a queue' do
+      @list.create('test')
+      
+      @list.queues.size.should == 1
+      
+      @list.delete('test')
+      @list.queues.size.zero?.should be_truthy
+    end
+    
+    it 'throws an error if queue does not exist' do
+      expect{@list.delete('foo')}.to raise_error(RuntimeError, 'NonExistentQueue')
+    end
+  end
+  
+  describe '#purge' do
+    it 'empties the queue list' do
+      @list.create('test')
+      
+      @list.queues.size.should == 1
+      
+      @list.purge
+      
+      @list.queues.size.zero?.should be_truthy
+    end
+  end
+end

data/spec/lsqs/queue_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe LSQS::Queue do
+  before do
+    @queue = described_class.new('test')
+  end
+  
+  describe '#initialize' do
+    it 'has a name' do      
+      @queue.name.should == 'test'
+    end
+    
+    it 'has a messages array' do
+      @queue.messages.kind_of?(Array).should be_truthy
+      @queue.messages.empty?.should be_truthy
+    end
+    
+    it 'has an in_flight hash' do
+      @queue.in_flight.kind_of?(Hash).should be_truthy
+      @queue.in_flight.empty?.should be_truthy
+    end
+    
+    it 'has attributes hash' do
+      @queue.attributes.kind_of?(Hash).should be_truthy
+    end
+  end
+  
+  describe '#default_timeout' do
+    it 'has default visibility if not set' do
+      queue = described_class.new('test')
+      
+      queue.visibility_timeout.should == described_class::DEFAULT_TIMEOUT
+    end
+    
+    it 'has visibility timeout if set' do
+      queue = described_class.new('test', {'Attributes' => {'VisibilityTimeout' => 10}})
+      
+      queue.visibility_timeout.should == 10
+    end
+  end
+  
+  describe '#create_message' do
+    it 'creates a message' do
+      @queue.create_message
+      
+      @queue.messages.size.should == 1
+      @queue.messages.first.kind_of?(Message).should be_truthy
+    end
+  end
+  
+  describe '#get_messages' do
+    it 'gets a single message' do
+      @queue.create_message('MessageBody' => 'foo')
+      
+      result = @queue.get_messages
+      
+      result.size.should == 1
+      @queue.in_flight.size.should == 1
+      result.find{|k,v| v.body == 'foo'}.should be_truthy
+    end
+    
+    it 'gets a two messages if MaxNumberOfMessages is 2' do
+      @queue.create_message('MessageBody' => 'foo')
+      @queue.create_message('MessageBody' => 'bar')
+      @queue.create_message('MessageBody' => 'foo bar')
+      
+      result = @queue.get_messages('MaxNumberOfMessages' => 2)
+      
+      result.size.should == 2
+      @queue.in_flight.size.should == 2
+    end
+    
+    it 'gets a two messages if MaxNumberOfMessages is 5 and available are 2' do
+      @queue.create_message('MessageBody' => 'foo')
+      @queue.create_message('MessageBody' => 'bar')
+      
+      result = @queue.get_messages('MaxNumberOfMessages' => 5)
+      
+      result.size.should == 2
+      @queue.in_flight.size.should == 2
+    end
+    
+    it 'throws an error if max number is above 10' do
+      @queue.create_message('MessageBody' => 'foo')
+      @queue.create_message('MessageBody' => 'bar')
+      
+      expect{@queue.get_messages('MaxNumberOfMessages' => 11)}.to raise_error(RuntimeError, 'ReadCountOutOfRange')
+    end
+  end
+  
+  describe '#delete_message' do
+  end
+  
+  describe '#size' do
+    it 'calculates size correctly' do
+      @queue.create_message('MessageBody' => 'foo')
+      @queue.create_message('MessageBody' => 'bar')
+      @queue.create_message('MessageBody' => 'test')
+      
+      @queue.size.should == 3
+    end
+  end
+  
+  describe '#purge_queue' do
+    it 'clears the queue' do
+      @queue.create_message('MessageBody' => 'foo')
+      @queue.create_message('MessageBody' => 'bar')
+      
+      @queue.size.should == 2
+      @queue.in_flight.size.should == 0
+      
+      @queue.get_messages
+      
+      @queue.size.should == 1
+      @queue.in_flight.size.should == 1
+      
+      @queue.purge
+      
+      @queue.size.zero?.should be_truthy
+      @queue.in_flight.size.zero?.should be_truthy
+      
+    end
+  end
+  
+  describe '#generate_receipt' do
+    it 'generates a string' do
+      receipt = @queue.generate_receipt
+      receipt.kind_of?(String).should be_truthy
+      receipt.length.should == 32
+    end
+  end
+  
+  describe '#change_message_visibility' do
+    it 'puts the message back in the queue if seconds is 0' do
+      @queue.create_message
+      
+      @queue.size.should == 1
+      
+      result = @queue.get_messages
+      
+      @queue.size.zero?.should be_truthy
+      @queue.in_flight.size.should == 1
+      
+      @queue.change_message_visibility(result.first.first, 0)
+      
+      @queue.size.should == 1
+      @queue.in_flight.size.zero?.should be_truthy
+    end
+    
+    it 'throws an error if the message is not in flight' do
+      expect{@queue.change_message_visibility('foo', 0)}.to raise_error(RuntimeError, 'MessageNotInflight')
+    end
+    
+    it 'keeps the message in flight if seconds is more than 0' do
+      @queue.create_message
+      
+      @queue.size.should == 1
+      
+      result = @queue.get_messages
+      
+      @queue.size.zero?.should be_truthy
+      @queue.in_flight.size.should == 1
+      
+      @queue.change_message_visibility(result.first.first, 10)
+      
+      @queue.size.zero?.should be_truthy
+      @queue.in_flight.size.should == 1
+    end
+  end
+  
+  describe '#timeout_messages' do
+    it 'puts messages back in the queue' do
+      queue = described_class.new('test', {'Attributes' => {'VisibilityTimeout' => 1}})
+      
+      queue.create_message
+      
+      queue.size.should == 1
+      queue.in_flight.size.zero?.should be_truthy
+      
+      queue.get_messages
+      queue.size.zero?.should be_truthy
+      queue.in_flight.size.should == 1
+      
+      sleep(2)
+      
+      queue.timeout_messages
+      
+      queue.size.should == 1
+      queue.in_flight.size.zero?.should be_truthy
+    end
+  end
+end