waz-storage 1.1.1 → 1.1.2

data/tests/waz/blobs/service_test.rb

@@ -0,0 +1,282 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'tests/configuration'
+require 'lib/waz-blobs'
+
+describe "blobs service behavior" do
+  it "should create container" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute)
+    service.expects(:generate_request_uri).with("mock-container", {:restype => 'container'}).returns("mock-uri")
+    service.expects(:generate_request).with(:put, "mock-uri", {:x_ms_version => '2009-09-19'}, nil).returns(RestClient::Request.new(:method => :put, :url => "http://localhost"))
+    service.create_container('mock-container')
+  end
+
+  it "should get container properties" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    mock_response = mock()
+    mock_response.stubs(:headers).returns(RestClient::AbstractResponse.beautify_headers({"x-ms-meta-Name" => ["customName"]}))
+    RestClient::Request.any_instance.expects(:execute).returns(mock_response)
+    service.expects(:generate_request_uri).with("mock-container", {:restype => 'container'}).returns("mock-uri")
+    service.expects(:generate_request).with(:get, "mock-uri", {:x_ms_version => '2009-09-19'}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    properties = service.get_container_properties('mock-container')
+    properties[:x_ms_meta_name].should == "customName"
+  end
+
+  it "should set container properties" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute)
+    service.expects(:generate_request_uri).with("mock-container", {:restype => 'container', :comp => 'metadata'}).returns("mock-uri")
+    service.expects(:generate_request).with(:put, "mock-uri", {:x_ms_version => '2009-09-19', :x_ms_meta_Name => "myName"}, nil).returns(RestClient::Request.new(:method => :put, :url => "http://localhost"))
+    properties = service.set_container_properties('mock-container', {:x_ms_meta_Name => "myName"})
+  end
+  
+  it "should get container acl" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    mock_response = mock()
+    mock_response.stubs(:headers).returns(RestClient::AbstractResponse.beautify_headers({:x_ms_blob_public_access.to_s => [true]}))
+    RestClient::Request.any_instance.expects(:execute).returns(mock_response)
+    service.expects(:generate_request_uri).with("mock-container", {:restype => 'container', :comp => 'acl'}).returns("mock-uri")
+    service.expects(:generate_request).with(:get, "mock-uri", {:x_ms_version => '2009-09-19'}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    service.get_container_acl('mock-container').should == true
+  end
+
+  it "should set container acl" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute)
+    service.expects(:generate_request_uri).with("mock-container", :restype => 'container', :comp => 'acl').returns("mock-uri")
+    service.expects(:generate_request).with(:put, "mock-uri", {:x_ms_version => '2009-09-19', :x_ms_blob_public_access => false}, nil).returns(RestClient::Request.new(:method => :put, :url => "http://localhost"))
+    properties = service.set_container_acl('mock-container', false)
+  end
+
+  it "should list containers" do
+    response = <<-eos
+                <?xml version="1.0" encoding="utf-8"?>
+                <EnumerationResults AccountName="http://myaccount.blob.core.windows.net">
+                  <Containers>
+                    <Container>
+                      <Name>mycontainer</Name>
+                      <Url>http://localhost/mycontainer</Url>
+                      <LastModified>2009-09-11</LastModified>
+                    </Container>
+                    <Container>
+                      <Name>othercontainer</Name>
+                      <Url>http://localhost/othercontainer</Url>
+                      <LastModified>2009-09-11</LastModified>
+                    </Container>
+                  </Containers>
+                </EnumerationResults>
+                eos
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(response)
+    service.expects(:generate_request_uri).with(nil, {:comp => 'list'}).returns("mock-uri")
+    service.expects(:generate_request).with(:get, "mock-uri", {}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    containers = service.list_containers
+    containers[0][:name].should == "mycontainer"
+    containers[1][:name].should == "othercontainer"    
+  end
+
+  it "should delete container" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute)
+    service.expects(:generate_request_uri).with("mock-container", {:restype => 'container'}).returns("mock-uri")
+    service.expects(:generate_request).with(:delete, "mock-uri", {:x_ms_version => '2009-09-19'}, nil).returns(RestClient::Request.new(:method => :put, :url => "http://localhost"))
+    service.delete_container('mock-container')
+  end
+
+  it "should list blobs" do
+    response = <<-eos
+                <?xml version="1.0" encoding="utf-8"?>
+                <EnumerationResults AccountName="http://myaccount.blob.core.windows.net">
+                 <Blobs>
+                     <Blob>
+                       <Url>http://localhost/container/blob</Url>
+                       <Name>blob</Name>
+                       <Properties>
+                          <Content-Type>text/xml</Content-Type>
+                       </Properties>
+                       <Metadata>   
+                           <Name>value</Name>
+                       </Metadata>
+                     </Blob>
+                     <Blob>
+                       <Url>http://localhost/container/blob2</Url>
+                       <Name>blob2</Name>
+                       <Properties>
+                          <Content-Type>application/x-stream</Content-Type>
+                       </Properties>
+                       <Metadata>   
+                           <Name>value</Name>
+                       </Metadata>
+                     </Blob>
+                   </Blobs>
+                </EnumerationResults>
+                eos
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(response)
+    service.expects(:generate_request_uri).with("container", {:restype => 'container', :comp => 'list'}).returns("mock-uri")
+    service.expects(:generate_request).with(:get, "mock-uri", {:x_ms_version => '2009-09-19'}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    blobs = service.list_blobs("container")
+    blobs[0][:name].should == "blob"
+    blobs[1][:name].should == "blob2"
+    blobs[0][:url].should == "http://localhost/container/blob"
+    blobs[1][:url].should == "http://localhost/container/blob2"
+    blobs[0][:content_type].should == "text/xml"
+    blobs[1][:content_type].should == "application/x-stream"
+  end
+
+  it "should put blob" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(nil)
+    service.expects(:generate_request_uri).with("container/blob", nil).returns("mock-uri")
+    service.expects(:generate_request).with(:put, "mock-uri", {'Content-Type' => 'application/octet-stream', :x_ms_version => "2009-09-19", :x_ms_blob_type => "BlockBlob"}, "payload").returns(RestClient::Request.new(:method => :put, :url => "http://localhost"))
+    service.put_blob("container/blob", "payload")
+  end
+
+  it "should get blob" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns("payload")
+    service.expects(:generate_request_uri).with("container/blob", {}).returns("mock-uri")
+    service.expects(:generate_request).with(:get, "mock-uri", {:x_ms_version => "2009-09-19"}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    service.get_blob("container/blob").should == "payload"
+  end
+
+  it "should delete blob" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(nil)
+    service.expects(:generate_request_uri).with("container/blob", nil).returns("mock-uri")
+    service.expects(:generate_request).with(:delete, "mock-uri", {:x_ms_version => "2009-09-19"}, nil).returns(RestClient::Request.new(:method => :put, :url => "http://localhost"))
+    service.delete_blob("container/blob")
+  end
+
+  it "should get blob properties" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    response = mock()
+    response.stubs(:headers).returns(RestClient::AbstractResponse.beautify_headers({"x-ms-meta-Name" => ["customName"]}))
+    RestClient::Request.any_instance.expects(:execute).returns(response)
+    service.expects(:generate_request_uri).with("container/blob", {}).returns("mock-uri")
+    service.expects(:generate_request).with(:head, "mock-uri", {:x_ms_version => '2009-09-19'}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    service.get_blob_properties("container/blob").should == response.headers
+  end
+
+  it "should set blob properties" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(nil)
+    service.expects(:generate_request_uri).with("container/blob", :comp => 'properties').returns("mock-uri")
+    service.expects(:generate_request).with(:put, "mock-uri", {:x_ms_version => '2009-09-19', :x_ms_meta_Name => "johnny"}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    service.set_blob_properties("container/blob", {:x_ms_meta_Name => "johnny"})
+  end
+
+  it "should copy blob" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(nil)
+    service.expects(:generate_request_uri).with("container/blob-copy", nil).returns("mock-uri")
+    service.expects(:generate_request).with(:put, "mock-uri", {:x_ms_version => "2009-09-19", :x_ms_copy_source => "/mock-account/container/blob"}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    service.copy_blob("container/blob", "container/blob-copy")
+  end
+
+  it "should put block" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(nil)
+    service.expects(:generate_request_uri).with("container/blob", { :blockid => 'block_id', :comp => 'block'}).returns("mock-uri")
+    service.expects(:generate_request).with(:put, "mock-uri", {'Content-Type' => 'application/octet-stream'}, "payload").returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    service.put_block("container/blob", "block_id", "payload")
+  end
+
+  it "should put block list" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(nil)
+    service.expects(:generate_request_uri).with("container/blob", { :comp => 'blocklist'}).returns("mock-uri")
+    service.expects(:generate_request).with(:put, "mock-uri", {'Content-Type' => 'text/plain', :x_ms_version => '2009-09-19'}, '<?xml version="1.0" encoding="utf-8"?><BlockList><Latest>AAAAAA==</Latest><Latest>AQAAAA==</Latest></BlockList>').returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    service.put_block_list("container/blob", ["AAAAAA==", "AQAAAA=="], "text/plain")
+  end
+
+  it "should list blocks" do
+    response = <<-eos
+                <?xml version="1.0" encoding="utf-8"?>
+                <BlockList>
+                  <CommittedBlocks>
+                    <Block>
+                      <Name>AAAAAA==</Name>
+                      <Size>1048576</Size>
+                    </Block>
+                  </CommittedBlocks>
+                  <UncommittedBlocks>
+                    <Block>
+                      <Name>AQAAAA==</Name>
+                      <Size>1048576</Size>
+                    </Block>
+                    <Block>
+                      <Name>AgAAAA==</Name>
+                      <Size>402848</Size>
+                    </Block>
+                  </UncommittedBlocks>
+                </BlockList>
+                eos
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(response)
+    service.expects(:generate_request_uri).with('container/blob', {:comp => 'blocklist', :blocklisttype => 'all'}).returns("mock-uri")
+    service.expects(:generate_request).with(:get, "mock-uri", {:x_ms_version => "2009-04-14"}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    blocks = service.list_blocks('container/blob')
+    blocks.first[:name].should == "AAAAAA=="
+    blocks.first[:size].should == "1048576"
+    blocks.first[:committed].should == true
+    blocks.last[:name].should == "AgAAAA=="
+    blocks.last[:size].should == "402848"
+    blocks.last[:committed].should == false
+  end
+
+  it "should list with additional parameters" do
+    response = <<-eos
+                <?xml version="1.0" encoding="utf-8"?>
+                <BlockList>
+                  <CommittedBlocks>
+                    <Block>
+                      <Name>AAAAAA==</Name>
+                      <Size>1048576</Size>
+                    </Block>
+                  </CommittedBlocks>
+                  <UncommittedBlocks>
+                    <Block>
+                      <Name>AQAAAA==</Name>
+                      <Size>1048576</Size>
+                    </Block>
+                    <Block>
+                      <Name>AgAAAA==</Name>
+                      <Size>402848</Size>
+                    </Block>
+                  </UncommittedBlocks>
+                </BlockList>
+                eos
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    RestClient::Request.any_instance.expects(:execute).returns(response)
+    service.expects(:generate_request_uri).with('container/blob', {:comp => 'blocklist', :blocklisttype => 'committed'}).returns("mock-uri")
+    service.expects(:generate_request).with(:get, "mock-uri", {:x_ms_version => "2009-04-14"}, nil).returns(RestClient::Request.new(:method => :get, :url => "http://localhost"))
+    blocks = service.list_blocks('container/blob', 'COMMITTED')
+    blocks.first[:name].should == "AAAAAA=="
+    blocks.first[:size].should == "1048576"
+    blocks.first[:committed].should == true
+    blocks.last[:name].should == "AgAAAA=="
+    blocks.last[:size].should == "402848"
+    blocks.last[:committed].should == false
+  end
+
+  it "should throw when block list type is nil or doesn't fall into the valid values" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    lambda { service.list_blocks('container/blob', 'whatever') }.should raise_error(WAZ::Storage::InvalidParameterValue)
+    lambda { service.list_blocks('container/blob', nil) }.should raise_error(WAZ::Storage::InvalidParameterValue)    
+  end
+
+  it "should take blob snapshots" do
+    service = WAZ::Blobs::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    
+    mock_response = mock()
+    mock_response.stubs(:headers).returns({:x_ms_snapshot => Time.new.httpdate})
+    mock_request = mock()
+    mock_request.stubs(:execute).returns(mock_response)
+    
+    service.expects(:generate_request_uri).with("container/blob", {:comp => "snapshot"}).returns("container/blob")
+    service.expects(:generate_request).with(:put, "container/blob", {:x_ms_version => "2009-09-19"}, nil).returns(mock_request)
+    service.snapshot_blob("container/blob").should == mock_response.headers[:x_ms_snapshot]
+  end
+end

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