waz-storage 1.1.1 → 1.1.2

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

data/tests/waz/storage/base_tests.rb

@@ -0,0 +1,81 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'tests/configuration'
+require 'lib/waz-blobs'
+
+describe "Base class for connection management" do
+  it "should throw an exception when it is not connected" do
+    lambda {WAZ::Storage::Base.default_connection}.should raise_error(WAZ::Storage::NotConnected)
+  end
+  
+  it "establish connection and set it as default connection" do
+    WAZ::Storage::Base.establish_connection!(:account_name => 'myAccount',
+                                             :access_key => "accountKey",
+                                             :use_ssl => true)
+
+    connection = WAZ::Storage::Base.default_connection                                     
+    connection[:account_name].should == "myAccount"
+    connection[:access_key].should == "accountKey"
+    connection[:use_ssl].should == true
+  end
+  
+  it "should throw an exception when no account_name is provided" do
+    lambda {WAZ::Storage::Base.establish_connection!(:access_key => "accountKey", :use_ssl => false)}.should raise_error(WAZ::Storage::InvalidOption)
+  end
+  
+  it "should throw an exception when no access_key is provided and no use_sas_auth_only" do
+    lambda {WAZ::Storage::Base.establish_connection!(:account_name => "my_account", :use_ssl => false)}.should raise_error(WAZ::Storage::InvalidOption)
+  end
+
+  it "should throw and exception when use_sas_auth_only is provided but no sharedaccessignature" do
+    lambda {WAZ::Storage::Base.establish_connection!(:account_name => "my_account",:use_sas_auth_only => true, :use_ssl => false)}.should raise_error(WAZ::Storage::InvalidOption)
+  end
+
+  
+  it "should set use_ssl to false when no paramter provided" do
+    WAZ::Storage::Base.establish_connection!(:account_name => 'myAccount',
+                                           :access_key => "accountKey")
+
+    connection = WAZ::Storage::Base.default_connection                                     
+    connection[:account_name].should == "myAccount"
+    connection[:access_key].should == "accountKey"
+    connection[:use_ssl].should == false
+  end
+
+  it "should set :use_sas_auth_only to false when no parameter provided" do
+    WAZ::Storage::Base.establish_connection!(:account_name => 'myAccount',
+						:access_key => "accountKey")
+    connection = WAZ::Storage::Base.default_connection
+    connection[:account_name].should == "myAccount"
+    connection[:access_key].should == "accountKey"
+    connection[:use_sas_auth_only] == false 
+  end  
+
+
+  it "should be able to tell whether it's connected or not" do
+    WAZ::Storage::Base.establish_connection!(:account_name => 'myAccount',
+                                           :access_key => "accountKey")
+    
+    WAZ::Storage::Base.connected?.should == true
+  end  
+ 
+  it "should be able to tell whters it's connected by shared access signature" do
+    WAZ::Storage::Base.establish_connection!(:account_name => 'myAccount',:use_sas_auth_only=>true, :sharedaccesssignature=>"?se=2011-12-13T23%3A54%3A07Z&sr=c&si=escrituraPAC&sig=e%2Bz6wsGhVRg%2FaxWATiS8A4WjWU%2FbfWjWa6zJ%2BTQIPzM%3D")
+    WAZ::Storage::Base.connected?.should == true
+  end
+ 
+  it "should be able manage scoped connections" do
+    WAZ::Storage::Base.establish_connection!(:account_name => 'myAccount', :access_key => "accountKey")
+    
+    WAZ::Storage::Base.default_connection[:account_name].should == 'myAccount'
+
+    block_executed = false
+    WAZ::Storage::Base.establish_connection(:account_name => 'otherAccount', :access_key => "accountKey") do
+      WAZ::Storage::Base.default_connection[:account_name].should == 'otherAccount'
+      block_executed = true
+    end
+    block_executed.should == true
+    
+    WAZ::Storage::Base.default_connection[:account_name].should == 'myAccount'    
+  end
+end

data/tests/waz/storage/shared_key_core_service_test.rb

@@ -0,0 +1,142 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'tests/configuration'
+require 'lib/waz-queues'
+
+describe "storage service core behavior" do 
+  it "should generate URI with given operation" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.generate_request_uri(nil, :comp => 'list').should == "https://mock-account.queue.localhost/?comp=list"
+  end
+  
+  it "should generate an URI without operation when operation is not given" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.generate_request_uri("queue").should == "https://mock-account.queue.localhost/queue"
+  end
+  
+  it "should generate a safe URI when path includes forward slash" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.generate_request_uri("/queue").should == "https://mock-account.queue.localhost/queue"
+  end
+  
+  it "should include additional parameters when given" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.generate_request_uri("/queue", {:comp => 'list', :prefix => "p"}).should == "https://mock-account.queue.localhost/queue?comp=list&prefix=p"
+  end
+
+  it "should include additional parameters when given althought when there is no comp" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.generate_request_uri("/queue", {:prefix => "p", :other => "other"}).should == "https://mock-account.queue.localhost/queue?other=other&prefix=p"
+  end
+  
+  it "should include additional parameters when given althought when there is no comp" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.generate_request_uri("/queue", {:comp => "metadata", :messagettl => 650}).should == "https://mock-account.queue.localhost/queue?comp=metadata&messagettl=650"
+  end
+  
+  it "should include additional parameters when given althought when there is no comp" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.generate_request_uri("/queue", {:item => "%"}).should == "https://mock-account.queue.localhost/queue?item=%25"
+  end
+  
+  it "should canonicalize headers (order lexicographical, trim values, and join by NEW_LINES)" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    headers = { "Content-Type" => "application/xml",
+                "x-ms-prop-z" => "p",
+                "x-ms-meta-name" => "a ",
+                "x-other" => "other"}
+
+    service.canonicalize_headers(headers).should == "x-ms-meta-name:a\nx-ms-prop-z:p"
+  end
+  
+  it "should return empty string when no MS headers" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    headers = { "Content-Type" => "application/xml",
+                "x-other" => "other"}
+
+    service.canonicalize_headers(headers).should == ""
+  end
+  
+  it "should cannonicalize message by appending account_name to the request path" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.canonicalize_message("http://localhost/queue?comp=list").should == "/mock-account/queue?comp=list"
+  end
+  
+  it "should ignore every other querystring parameter rather than comp=" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.canonicalize_message("http://localhost/queue?myparam=1").should == "/mock-account/queue"
+  end
+  
+  it "should properly canonicalize message when no parameter associated with it" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.canonicalize_message("http://mock-account.queue.core.windows.net/").should == "/mock-account/"
+  end
+  
+  it "should properly canonicalize message when a resource is associated with it" do
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    service.canonicalize_message("http://mock-account.queue.core.windows.net/resource?comp=list").should == "/mock-account/resource?comp=list"
+  end
+  
+  it "should generate request with proper headers" do
+    mock_time = Time.new
+    Time.stubs(:new).returns(mock_time)
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    
+    expected_request_hash = {:headers => {'x-ms-Date' => mock_time.httpdate, "Content-Length" => "payload".length},
+                             :method => :put, 
+                             :url => "http://localhost/johnny",
+                             :payload  => "payload"}
+    
+    # mock the generate signature method since we want to assert against a know value 
+    service.expects(:generate_signature).with(expected_request_hash).returns("a_mock_signature")
+    
+    request = service.generate_request("PUT", "http://localhost/johnny", nil, "payload")
+    request.headers["x-ms-Date"].should == mock_time.httpdate
+    request.headers["Content-Length"].should == "payload".length
+    request.headers["Authorization"] = "SharedKey mock-account:a_mock_signature"
+  end
+  
+  it "should set content length when it is not provided" do
+    mock_time = Time.new
+    Time.stubs(:new).returns(mock_time)
+    service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    
+    expected_request_hash = {:headers => {'x-ms-Date' => mock_time.httpdate, 'Content-Length' => 0},
+                             :method => :put, 
+                             :url => "http://localhost/johnny",
+                             :payload => nil}
+    
+    # mock the generate signature method since we want to assert against a know value 
+    service.expects(:generate_signature).with(expected_request_hash).returns("a_mock_signature")
+    
+    request = service.generate_request("PUT", "http://localhost/johnny", nil)
+    request.headers["x-ms-Date"].should == mock_time.httpdate
+    request.headers["Content-Length"].should == 0
+    request.headers["Authorization"] = "SharedKey mock-account:a_mock_signature"
+  end
+  
+  it "should name headers properly when they are provided as symbols" do
+     mock_time = Time.new
+      Time.stubs(:new).returns(mock_time)
+      service = WAZ::Queues::Service.new(:account_name => "mock-account", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+
+      expected_request_hash = {:headers => {'x-ms-Date' => mock_time.httpdate, "Content-Length" => 0, 'Content-Type' => "plain/xml"},
+                               :method => :put, 
+                               :url => "http://localhost/johnny",
+                               :payload  => nil}
+
+      # mock the generate signature method since we want to assert against a know value 
+      service.expects(:generate_signature).with(expected_request_hash).returns("a_mock_signature")
+    
+    request = service.generate_request("PUT", "http://localhost/johnny", {:Content_Type => "plain/xml"})
+    request.headers["x-ms-Date"].should == mock_time.httpdate
+    request.headers["Content-Length"].should == 0
+    request.headers["Authorization"] = "SharedKey mock-account:a_mock_signature"
+  end
+  
+  it "should cannonicalize message by appending account_name to the request path following 2009-09-19 version of the API" do
+    service = WAZ::Queues::Service.new(:account_name => "myaccount", :access_key => "mock-key", :type_of_service => "queue", :use_ssl => true, :base_url => "localhost")
+    canonical_message = service.canonicalize_message20090919("http://myaccount.blob.core.windows.net/mycontainer?restype=container&comp=metadata")
+    canonical_message.should == "/myaccount/mycontainer\ncomp:metadata\nrestype:container"
+  end
+end