sparqcode-waz-storage 1.1.1

data/tests/waz/queues/message_test.rb

@@ -0,0 +1,33 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'tests/configuration'
+require 'lib/waz-queues'
+
+describe "Message object behavior" do
+  it "should delete message" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:delete_message).with("queue-10", "message id", "receipt")
+    options = {:message_id => "message id", :message_text => "text", :expiration_time => Time.new, 
+               :insertion_time => Time.new, :pop_receipt => "receipt", :queue_name => "queue-10"}
+
+    message = WAZ::Queues::Message.new(options)
+    message.destroy!
+  end
+  
+  it "should throw when trying to delete a message peeked (no pop_receipt)" do
+    options = {:message_id => "message id", :message_text => "text", :expiration_time => Time.new, 
+               :insertion_time => Time.new, :queue_name => "queue-10" }
+
+    message = WAZ::Queues::Message.new(options)
+
+    lambda { message.destroy! }.should raise_error(WAZ::Queues::InvalidOperation)
+  end
+  
+  it "should respond to dequeue_count property" do
+    options = {:message_id => "message id", :message_text => "text", :expiration_time => Time.new, 
+               :insertion_time => Time.new, :pop_receipt => "receipt", :queue_name => "queue-10", :dequeue_count => 1}
+
+    message = WAZ::Queues::Message.new(options)
+    message.dequeue_count.should == 1
+  end
+end

data/tests/waz/queues/queue_test.rb

@@ -0,0 +1,206 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'tests/configuration'
+require 'lib/waz-queues'
+
+describe "Queue object behavior" do
+  it "should list queues by name" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:list_queues).returns([{:name => 'queue1', :url => 'queue1_url'}, {:name => 'queue2', :url => 'queue2_url'}])
+    containers = WAZ::Queues::Queue.list
+    containers.size.should == 2
+    containers.first().name.should == "queue1"
+    containers.first().url.should == "queue1_url"
+    containers.last().name.should == "queue2"
+  end
+  
+  it "should throw when not name provided for the queue" do
+    lambda { WAZ::Queues::Queue.new({:foo => "bar"}) }.should raise_error(WAZ::Storage::InvalidOption)
+  end
+  
+  it "should throw when not url provided for the queue" do
+    lambda { WAZ::Queues::Queue.new({:name => "mock-queue"}) }.should raise_error(WAZ::Storage::InvalidOption)
+  end
+  
+  it "should create queue" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:create_queue)
+    queue = WAZ::Queues::Queue.create('queue1') 
+    queue.name.should == "queue1"
+    queue.url.should == "http://my-account.queue.core.windows.net/queue1"
+  end
+  
+  it "should find queue" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).returns {  }
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.name.should == "queue1"
+    queue.url.should == "http://my-account.queue.core.windows.net/queue1"
+  end
+  
+  it "should return null when the queue isn't found" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").raises(RestClient::ResourceNotFound)
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.nil?.should == true
+  end
+  
+  it "should delete queue" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({})
+    WAZ::Queues::Service.any_instance.expects(:delete_queue).with("queue1").returns()
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.destroy!
+  end
+  
+  it "should get queue metadata" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({:x_ms_meta_property => "value"}).twice
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.metadata[:x_ms_meta_property].should == "value"
+  end
+  
+  it "should get queue length" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({:x_ms_approximate_messages_count => "2"}).twice
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.size.should == 2
+  end
+  
+  it "should merge queue metadata new metadata" do
+    existing_metadata = {:x_ms_approximate_message_count => 2, :x_ms_request_id => 2, :x_ms_meta_property1 => "value1"}
+    valid_metadata = {:x_ms_meta_property1 => "value1"}
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns(existing_metadata).twice
+    WAZ::Queues::Service.any_instance.expects(:set_queue_metadata).with(valid_metadata.merge(:x_ms_meta_property2 => "value2"))
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.put_properties!({:x_ms_meta_property2 => "value2"})
+  end
+  
+  it "should override queue metadata new metadata" do
+    existing_metadata = {:x_ms_approximate_message_count => 2, :x_ms_request_id => 2, :x_ms_meta_property1 => "value1"}
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns(existing_metadata)
+    WAZ::Queues::Service.any_instance.expects(:set_queue_metadata).with({:x_ms_meta_property2 => "value2"})
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.put_properties!({:x_ms_meta_property2 => "value2"}, true)
+  end
+  
+  it "should enqueue message on the queue" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({}).once
+    WAZ::Queues::Service.any_instance.expects(:enqueue).with("queue1", "this is my message enqueued", 604800)
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.enqueue!("this is my message enqueued")
+  end
+  
+  it "should enqueue message on the queue with specific time to live" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({}).once
+    WAZ::Queues::Service.any_instance.expects(:enqueue).with("queue1", "this is my message enqueued", 600)
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.enqueue!("this is my message enqueued", 600)
+  end
+  
+  it "should peek lock a single message from the queue" do
+    expected_message = {:message_id => "message id", :message_text => "text", :expiration_time => Time.new, :insertion_time => Time.new, :pop_receipt => "receipt"}
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({}).once
+    WAZ::Queues::Service.any_instance.expects(:get_messages).with('queue1', {:num_of_messages => 1}).returns([expected_message])
+    queue = WAZ::Queues::Queue.find('queue1') 
+    message = queue.lock()
+    message.queue_name == "queue1"
+    message.message_id.should == "message id"
+    message.message_text.should == "text"
+    message.pop_receipt.should == "receipt"    
+  end
+  
+  it "should peek lock messages from the queue" do
+    expected_messages = [ {:message_id => "message id", :message_text => "text", :expiration_time => Time.new, :insertion_time => Time.new, :pop_receipt => "receipt"},
+                         {:message_id => "message id2", :message_text => "text-second", :expiration_time => Time.new, :insertion_time => Time.new, :pop_receipt => "receipt"}]
+                         
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({}).once
+    WAZ::Queues::Service.any_instance.expects(:get_messages).with('queue1', {:num_of_messages => 2}).returns(expected_messages)
+    queue = WAZ::Queues::Queue.find('queue1') 
+    messages = queue.lock(2)
+    messages.last().queue_name == "queue1"
+    messages.last().message_id.should == "message id2"
+    messages.last().message_text.should == "text-second"
+    messages.last().pop_receipt.should == "receipt"    
+  end
+  
+  it "should peek a single message from the queue" do
+    expected_message = {:message_id => "message id", :message_text => "text", :expiration_time => Time.new, :insertion_time => Time.new, :pop_receipt => "receipt"}
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({}).once
+    WAZ::Queues::Service.any_instance.expects(:peek).with('queue1', {:num_of_messages => 1}).returns([expected_message])
+    queue = WAZ::Queues::Queue.find('queue1') 
+    message = queue.peek()
+    message.queue_name == "queue1"
+    message.message_id.should == "message id"
+    message.message_text.should == "text"
+    message.pop_receipt.should == "receipt"    
+  end
+  
+  it "should peek messages from the queue" do
+    expected_messages = [{:message_id => "message id", :message_text => "text", :expiration_time => Time.new, :insertion_time => Time.new, :pop_receipt => "receipt"},
+                         {:message_id => "message id2", :message_text => "text-second", :expiration_time => Time.new, :insertion_time => Time.new, :pop_receipt => "receipt"}]
+                         
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({}).once
+    WAZ::Queues::Service.any_instance.expects(:peek).with('queue1', {:num_of_messages => 2}).returns(expected_messages)
+    queue = WAZ::Queues::Queue.find('queue1') 
+    messages = queue.peek(2)
+    messages.last().queue_name == "queue1"
+    messages.last().message_id.should == "message id2"
+    messages.last().message_text.should == "text-second"
+    messages.last().pop_receipt.should == "receipt"
+  end
+  
+  it "should clear queue" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:get_queue_metadata).with("queue1").returns({}).once
+    WAZ::Queues::Service.any_instance.expects(:clear_queue).with('queue1').returns()
+    queue = WAZ::Queues::Queue.find('queue1') 
+    queue.clear()
+  end
+  
+  it "should list queues including metadata when requested" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Service.any_instance.expects(:list_queues).with({:include => 'metadata'}).returns({}).once
+    queue = WAZ::Queues::Queue.list(true) 
+  end
+  
+  it "should raise an exception when queue name starts with - (hypen)" do
+    lambda { WAZ::Queues::Queue.create('-queue')  }.should raise_error(WAZ::Storage::InvalidParameterValue)
+  end
+  
+  it "should raise an exception when queue name  ends with - (hypen)" do
+    lambda { WAZ::Queues::Queue.create('queue-')  }.should raise_error(WAZ::Storage::InvalidParameterValue)
+  end
+  
+  it "should raise an exception when queue name is less than 3" do
+    lambda { WAZ::Queues::Queue.create('q')  }.should raise_error(WAZ::Storage::InvalidParameterValue)
+  end
+  
+  it "should raise an exception when queue name is longer than 63" do
+    lambda { WAZ::Queues::Queue.create('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')  }.should raise_error(WAZ::Storage::InvalidParameterValue)
+  end
+  
+  it "should create the queue if it doesn't exists when calling ensure" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Queue.expects(:create).with("queue1")
+    WAZ::Queues::Queue.expects(:find).with("queue1").returns(nil)
+    
+    queue = WAZ::Queues::Queue.ensure("queue1")    
+  end
+  
+  it "should retrieve the queue if it already exists when calling ensure" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my-account", :access_key => "key"})
+    WAZ::Queues::Queue.expects(:create).with("queue1").never
+    WAZ::Queues::Queue.expects(:find).with("queue1").returns(mock())
+    
+    queue = WAZ::Queues::Queue.ensure("queue1")    
+  end
+end

data/tests/waz/queues/service_test.rb

@@ -0,0 +1,299 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'tests/configuration'
+require 'lib/waz-queues'
+
+describe "Windows Azure Queues API service" do 
+  it "should list queues" do
+    # setup mocks
+    expected_url = "http://my_account.queue.core.windows.net/?comp=list"
+    expected_response = <<-eos
+                      <?xml version="1.0" encoding="utf-8"?>
+                      <EnumerationResults AccountName="http://myaccount.queue.core.windows.net">
+                        <Queues>
+                          <Queue>
+                            <Name>mock-queue</Name>
+                            <Url>http://myaccount.queue.core.windows.net/mock-queue</Url>
+                          </Queue>
+                        </Queues>
+                      </EnumerationResults>
+                      eos
+
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.expects(:execute).returns(expected_response)
+
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with(nil, :comp => 'list').returns(expected_url)
+    service.expects(:generate_request).with(:get, expected_url, {:x_ms_version => '2009-09-19'}, nil).returns(mock_request)
+
+    queues = service.list_queues()
+    queues.first()[:name].should == "mock-queue"
+    queues.first()[:url].should == "http://myaccount.queue.core.windows.net/mock-queue"
+  end
+  
+  it "should create queue" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue"
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute)
+    
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue", nil).returns(expected_url)
+    service.expects(:generate_request).with(:put, expected_url, {:x_ms_meta_priority => "high-importance", :x_ms_version => '2009-09-19'}, nil).returns(mock_request)
+
+    service.create_queue("mock-queue", {:x_ms_meta_priority => "high-importance"})
+  end
+  
+  it "should delete queue" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue"
+    mock_response = mock()
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute).returns(mock_response)
+
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue", {}).returns(expected_url)
+    service.expects(:generate_request).with(:delete, expected_url, {:x_ms_version => '2009-09-19'}, nil).returns(mock_request)
+    service.delete_queue('mock-queue')
+  end
+  
+  it "should get queue metadata" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue?comp=metadata"
+    mock_response = mock()
+    mock_response.stubs(:headers).returns({ :x_ms_request_id => "fake-id" })
+    mock_request = RestClient::Request.new(:method => :head, :url => expected_url)
+    mock_request.stubs(:execute).returns(mock_response)
+    
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue", {:comp => 'metadata'}).returns(expected_url)
+    service.expects(:generate_request).with(:head, expected_url, {:x_ms_version => '2009-09-19'}, nil).returns(mock_request)
+    service.get_queue_metadata('mock-queue').should == mock_response.headers
+  end
+  
+  it "should set queue metadata" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue"
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute)
+
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue", :comp => 'metadata').returns(expected_url)
+    service.expects(:generate_request).with(:put, expected_url, {:x_ms_version => '2009-09-19', :x_ms_meta_priority => "high-importance"}, nil).returns(mock_request)
+
+    service.set_queue_metadata("mock-queue", {:x_ms_meta_priority => "high-importance"})
+  end
+  
+  it "should enqueue message" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue/messages?messagettl=604800"
+    mock_request = RestClient::Request.new(:method => :post, :url => expected_url)
+    mock_request.stubs(:execute)
+    
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    payload = "<?xml version=\"1.0\" encoding=\"utf-8\"?><QueueMessage><MessageText>this is the message payload</MessageText></QueueMessage>"                       
+    service.expects(:generate_request_uri).with("mock-queue/messages", { :messagettl => 604800 }).returns(expected_url)
+    service.expects(:generate_request).with(:post, expected_url, { 'Content-Type' => "application/xml", :x_ms_version => '2009-09-19'}, payload).returns(mock_request)
+
+    service.enqueue("mock-queue", "this is the message payload")
+  end
+  
+  it "should get messages from queue" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue/messages"
+    expected_response = <<-eos 
+                        <?xml version="1.0" encoding="utf-8"?>
+                          <QueueMessagesList>
+                            <QueueMessage>
+                              <MessageId>message_id</MessageId>
+                              <InsertionTime>Mon, 22 Sep 2008 23:29:20 GMT</InsertionTime>
+                              <ExpirationTime>Mon, 29 Sep 2008 23:29:20 GMT</ExpirationTime>
+                              <PopReceipt>receipt</PopReceipt>
+                              <TimeNextVisible>Tue, 23 Sep 2008 05:29:20 GMT</TimeNextVisible>
+                              <MessageText>text</MessageText>
+                            </QueueMessage>
+                          </QueueMessagesList>
+                        eos
+                        
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute).returns(expected_response)
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue/messages", {}).returns(expected_url)
+    service.expects(:generate_request).with(:get, expected_url, {:x_ms_version => "2009-09-19"}, nil).returns(mock_request)
+
+    messages = service.get_messages("mock-queue")
+    messages.first()[:message_id].should == "message_id"
+    messages.first()[:pop_receipt].should == "receipt"
+    messages.first()[:message_text].should == "text"
+    messages.first()[:insertion_time].nil?.should == false
+    messages.first()[:expiration_time].nil?.should == false
+    messages.first()[:time_next_visible].nil?.should == false
+  end
+  
+  it "should get messages from queue specifiying additional parameters" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue/messages"
+    expected_response = <<-eos 
+                        <?xml version="1.0" encoding="utf-8"?>
+                          <QueueMessagesList>
+                            <QueueMessage>
+                              <MessageId>message_id</MessageId>
+                              <InsertionTime>Mon, 22 Sep 2008 23:29:20 GMT</InsertionTime>
+                              <ExpirationTime>Mon, 29 Sep 2008 23:29:20 GMT</ExpirationTime>
+                              <PopReceipt>receipt</PopReceipt>
+                              <TimeNextVisible>Tue, 23 Sep 2008 05:29:20 GMT</TimeNextVisible>
+                              <MessageText>text</MessageText>
+                            </QueueMessage>
+                          </QueueMessagesList>
+                        eos
+                        
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute).returns(expected_response)
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue/messages", {:num_of_messages => 2, :visibility_timeout => 3}).returns(expected_url)
+    service.expects(:generate_request).with(:get, expected_url, {:x_ms_version => "2009-09-19"}, nil).returns(mock_request)
+
+    messages = service.get_messages("mock-queue", :num_of_messages => 2, :visibility_timeout => 3)
+    messages.first()[:message_id].should == "message_id"
+    messages.first()[:pop_receipt].should == "receipt"
+    messages.first()[:message_text].should == "text"
+    messages.first()[:insertion_time].nil?.should == false
+    messages.first()[:expiration_time].nil?.should == false
+    messages.first()[:time_next_visible].nil?.should == false
+  end
+  
+  it "should raise exception when :num_of_messages is out of range (1 - 32)" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    lambda{ service.get_messages("mock-queue", :num_of_messages => 0) }.should raise_error(WAZ::Queues::OptionOutOfRange)
+    lambda{ service.get_messages("mock-queue", :num_of_messages => 33) }.should raise_error(WAZ::Queues::OptionOutOfRange)    
+  end
+  
+  it "should raise exception when :visibility_timeout is out of range (1 - 7200)" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    lambda{ service.get_messages("mock-queue", :visibility_timeout => 0) }.should raise_error(WAZ::Queues::OptionOutOfRange)
+    lambda{ service.get_messages("mock-queue", :visibility_timeout => 7201) }.should raise_error(WAZ::Queues::OptionOutOfRange)    
+  end
+  
+  it "should peek message from queue" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue/messages"
+    expected_response = <<-eos 
+                        <?xml version="1.0" encoding="utf-8"?>
+                          <QueueMessagesList>
+                            <QueueMessage>
+                              <MessageId>message_id</MessageId>
+                              <InsertionTime>Mon, 22 Sep 2008 23:29:20 GMT</InsertionTime>
+                              <ExpirationTime>Mon, 29 Sep 2008 23:29:20 GMT</ExpirationTime>
+                              <MessageText>text</MessageText>
+                              <DequeueCount>5</DequeueCount>
+                            </QueueMessage>
+                          </QueueMessagesList>
+                        eos
+                        
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute).returns(expected_response)
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue/messages", {:peek_only => true}).returns(expected_url)
+    service.expects(:generate_request).with(:get, expected_url, {:x_ms_version => "2009-09-19"}, nil).returns(mock_request)
+
+    messages = service.peek("mock-queue")
+    messages.first()[:message_id].should == "message_id"
+    messages.first()[:message_text].should == "text"
+    messages.first()[:insertion_time].nil?.should == false
+    messages.first()[:expiration_time].nil?.should == false
+    messages.first()[:dequeue_count].should == 5
+  end
+  
+  it "should peek messages from queue when :num_of_messages is specified" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue/messages"
+    expected_response = <<-eos 
+                        <?xml version="1.0" encoding="utf-8"?>
+                          <QueueMessagesList>
+                            <QueueMessage>
+                              <MessageId>message_id</MessageId>
+                              <InsertionTime>Mon, 22 Sep 2008 23:29:20 GMT</InsertionTime>
+                              <ExpirationTime>Mon, 29 Sep 2008 23:29:20 GMT</ExpirationTime>
+                              <MessageText>text</MessageText>
+                              <DequeueCount>5</DequeueCount>
+                            </QueueMessage>
+                          </QueueMessagesList>
+                        eos
+                        
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute).returns(expected_response)
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue/messages", {:peek_only => true, :num_of_messages => 32}).returns(expected_url)
+    service.expects(:generate_request).with(:get, expected_url, {:x_ms_version => "2009-09-19"}, nil).returns(mock_request)
+
+    messages = service.peek("mock-queue", {:num_of_messages => 32})
+    messages.first()[:message_id].should == "message_id"
+    messages.first()[:message_text].should == "text"
+    messages.first()[:insertion_time].nil?.should == false
+    messages.first()[:expiration_time].nil?.should == false
+    messages.first()[:dequeue_count].should == 5
+  end
+  
+  it "should delete message" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue/messages/message_id?popreceipt=pop_receipt"
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute)
+
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue/messages/message_id", { :pop_receipt => "pop_receipt" }).returns(expected_url)
+    service.expects(:generate_request).with(:delete, expected_url, {}, nil).returns(mock_request)
+
+    service.delete_message("mock-queue", "message_id", "pop_receipt")
+  end
+  
+  it "should clear queue" do
+    expected_url = "http://myaccount.queue.core.windows.net/mock-queue/messages"
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.stubs(:execute)
+
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with("mock-queue/messages", {}).returns(expected_url)
+    service.expects(:generate_request).with(:delete, expected_url, {:x_ms_version => '2009-09-19'}, nil).returns(mock_request)
+
+    service.clear_queue("mock-queue")
+  end
+  
+  it "should list queues with metadata" do
+    # setup mocks
+    expected_url = "http://my_account.queue.core.windows.net/?comp=list&include=metadata"
+    expected_response = <<-eos
+                      <?xml version="1.0" encoding="utf-8"?>
+                      <EnumerationResults AccountName="http://myaccount.queue.core.windows.net">
+                        <Queues>
+                          <Queue>
+                            <Name>mock-queue</Name>
+                            <Url>http://myaccount.queue.core.windows.net/mock-queue</Url>
+                            <Metadata>
+                              <x-ms-name>Custom Queue</x-ms-name>
+                            </Metadata>
+                          </Queue>
+                        </Queues>
+                      </EnumerationResults>
+                      eos
+
+    mock_request = RestClient::Request.new(:method => :get, :url => expected_url)
+    mock_request.expects(:execute).returns(expected_response)
+
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    # setup mocha expectations
+    service.expects(:generate_request_uri).with(nil, {:comp => 'list', :include => 'metadata'}).returns(expected_url)
+    service.expects(:generate_request).with(:get, expected_url, {:x_ms_version => '2009-09-19'}, nil).returns(mock_request)
+
+    queues = service.list_queues({:include => 'metadata'})
+    queues.first()[:name].should == "mock-queue"
+    queues.first()[:url].should == "http://myaccount.queue.core.windows.net/mock-queue"
+    queues.first()[:metadata][:x_ms_name] = 'Custom Queue'
+  end
+end