waz-storage 1.1.1 → 1.1.2

data/lib/waz-storage.rb

@@ -1,4 +1,12 @@
-%w{time cgi base64 rexml/document rexml/xpath restclient hmac-sha2 net/http}.each(&method(:require))
+require 'time'
+require 'cgi' 
+require 'base64'
+require 'rexml/document'
+require 'rexml/xpath'
+require 'restclient' 
+require 'hmac-sha2'
+require 'net/http'
+
 app_files = File.expand_path(File.join(File.dirname(__FILE__), 'waz', 'storage', '*.rb'))
 Dir[app_files].each(&method(:load))
 

data/lib/waz/blobs/blob_object.rb

@@ -35,7 +35,7 @@ module WAZ
         end
       end
       
-      attr_accessor :name, :url, :content_type, :snapshot_date
+      attr_accessor :name, :url, :content_type, :snapshot_date, :railsetag
       
       # Creates a new instance of the Blob object. This constructor is internally used by the Container
       # it's initialized thru a hash that's received as parameter. It has the following requirements:
@@ -49,6 +49,7 @@ module WAZ
         self.url = options[:url]
         self.content_type = options[:content_type]
         self.snapshot_date = options[:snapshot_date]
+        self.railsetag = options[:railsetag]
       end
       
       # Returns the blob properties from Windows Azure. This properties always come as HTTP Headers and they include standard headers like

data/lib/waz/blobs/container.rb

@@ -145,7 +145,8 @@ module WAZ
           properties = self.class.service_instance.get_blob_properties("#{self.name}/#{blob_name}")
           return BlobObject.new(:name => blob_name, 
                                 :url => self.class.service_instance.generate_request_uri("#{self.name}/#{blob_name}"),
-                                :content_type => properties[:content_type])
+                                :content_type => properties[:content_type],
+                                :railsetag => properties[:x_ms_meta_railsetag])
         rescue RestClient::ResourceNotFound
           return nil
         end

data/lib/waz/blobs/service.rb

@@ -7,12 +7,12 @@ module WAZ
       
       # Creates a container on the current Windows Azure Storage account.
       def create_container(container_name)
-        execute :put, container_name, {:restype => 'container'}, {:x_ms_version => '2009-09-19'}
+        execute :put, container_name, {:restype => 'container'}, {:x_ms_version => '2011-08-18'}
       end
       
       # Retrieves all the properties existing on the container.
       def get_container_properties(container_name)
-        execute(:get, container_name, {:restype => 'container'}, {:x_ms_version => '2009-09-19'}).headers
+        execute(:get, container_name, {:restype => 'container'}, {:x_ms_version => '2011-08-18'}).headers
       end
       
       # Set the container properties (metadata). 
@@ -20,14 +20,14 @@ module WAZ
       # Remember that custom properties should be named as :x_ms_meta_{propertyName} in order
       # to have Windows Azure to persist them.
       def set_container_properties(container_name, properties = {})
-        execute :put, container_name, { :restype => 'container', :comp => 'metadata' }, properties.merge!({:x_ms_version => '2009-09-19'})
+        execute :put, container_name, { :restype => 'container', :comp => 'metadata' }, properties.merge!({:x_ms_version => '2011-08-18'})
       end
       
       # Retrieves the value of the :x_ms_prop_publicaccess header from the
       # container properties indicating whether the container is publicly 
       # accessible or not.
       def get_container_acl(container_name)
-        headers = execute(:get, container_name, { :restype => 'container', :comp => 'acl' }, {:x_ms_version => '2009-09-19'}).headers
+        headers = execute(:get, container_name, { :restype => 'container', :comp => 'acl' }, {:x_ms_version => '2011-08-18'}).headers
         headers[:x_ms_blob_public_access]
       end
 
@@ -37,7 +37,7 @@ module WAZ
       #
       # Default is _false_
       def set_container_acl(container_name, public_available = WAZ::Blobs::BlobSecurity::Private)
-        publicity = {:x_ms_version => '2009-09-19' }
+        publicity = {:x_ms_version => '2011-08-18' }
         publicity[:x_ms_blob_public_access] = public_available unless public_available == WAZ::Blobs::BlobSecurity::Private
         execute :put, container_name, { :restype => 'container', :comp => 'acl' }, publicity
       end
@@ -57,12 +57,12 @@ module WAZ
 
       # Deletes the given container from the Windows Azure Storage account.
       def delete_container(container_name)
-        execute :delete, container_name, {:restype => 'container'}, {:x_ms_version => '2009-09-19'}
+        execute :delete, container_name, {:restype => 'container'}, {:x_ms_version => '2011-08-18'}
       end
 
       # Lists all the blobs inside the given container.
       def list_blobs(container_name)
-        content = execute(:get, container_name, { :restype => 'container', :comp => 'list'}, {:x_ms_version => '2009-09-19'})
+        content = execute(:get, container_name, { :restype => 'container', :comp => 'list'}, {:x_ms_version => '2011-08-18'})
         doc = REXML::Document.new(content)
         containers = []
         REXML::XPath.each(doc, '//Blob/') do |item|
@@ -82,7 +82,7 @@ module WAZ
       #
       # metadata is a hash that stores all the properties that you want to add to the blob when creating it.
       def put_blob(path, payload, content_type = "application/octet-stream", metadata = {})
-        default_headers = {"Content-Type" => content_type, :x_ms_version => "2009-09-19", :x_ms_blob_type => "BlockBlob"}
+        default_headers = {"Content-Type" => content_type, :x_ms_version => "2011-08-18", :x_ms_blob_type => "BlockBlob", :x_ms_meta_railsetag => Digest::MD5.hexdigest(payload)}
         execute :put, path, nil, metadata.merge(default_headers), payload
       end
 
@@ -94,38 +94,38 @@ module WAZ
       #
       # metadata is a hash that stores all the properties that you want to add to the blob when creating it.
       def put_block_list(path, blockids, content_type = "application/octet-stream", metadata = {})
-        default_headers = {"Content-Type" => content_type, :x_ms_version => "2009-09-19"}
+        default_headers = {"Content-Type" => content_type, :x_ms_version => "2011-08-18"}
         execute :put, path, { :comp => 'blocklist' }, metadata.merge(default_headers), '<?xml version="1.0" encoding="utf-8"?><BlockList>' + blockids.map {|id| "<Latest>#{id.rstrip}</Latest>"}.join + '</BlockList>'
       end
 
       # Retrieves a blob (content + headers) from the current path.
       def get_blob(path, options = {})
-        execute :get, path, options, {:x_ms_version => "2009-09-19"}
+        execute :get, path, options, {:x_ms_version => "2011-08-18"}
       end
 
       # Deletes the blob existing on the current path.
       def delete_blob(path)
-        execute :delete, path, nil, {:x_ms_version => "2009-09-19"}
+        execute :delete, path, nil, {:x_ms_version => "2011-08-18"}
       end
             
       # Retrieves the properties associated with the blob at the given path.
       def get_blob_properties(path, options = {})
-        execute(:head, path, options, {:x_ms_version => "2009-09-19"}).headers
+        execute(:head, path, options, {:x_ms_version => "2011-08-18"}).headers
       end
 
       # Sets the properties (metadata) associated to the blob at given path.
       def set_blob_properties(path, properties ={})
-        execute :put, path, { :comp => 'properties' }, properties.merge({:x_ms_version => "2009-09-19"})
+        execute :put, path, { :comp => 'properties' }, properties.merge({:x_ms_version => "2011-08-18"})
       end
       
       # Set user defined metadata - overwrites any previous metadata key:value pairs
       def set_blob_metadata(path, metadata = {}) 
-        execute :put, path, { :comp => 'metadata' }, metadata.merge({:x_ms_version => "2009-09-19"})
+        execute :put, path, { :comp => 'metadata' }, metadata.merge({:x_ms_version => "2011-08-18"})
       end 
 
       # Copies a blob within the same account (not necessarily to the same container)
       def copy_blob(source_path, dest_path)
-        execute :put, dest_path, nil, { :x_ms_version => "2009-09-19", :x_ms_copy_source => canonicalize_message(source_path) }
+        execute :put, dest_path, nil, { :x_ms_version => "2011-08-18", :x_ms_copy_source => canonicalize_message(source_path) }
       end
       
       # Adds a block to the block list of the given blob
@@ -149,7 +149,7 @@ module WAZ
       
       # Creates a read-only snapshot of a blob as it looked like in time.
       def snapshot_blob(path)
-        execute(:put, path, { :comp => 'snapshot' }, {:x_ms_version => "2009-09-19"}).headers[:x_ms_snapshot]
+        execute(:put, path, { :comp => 'snapshot' }, {:x_ms_version => "2011-08-18"}).headers[:x_ms_snapshot]
       end
     end
   end

data/lib/waz/queues/service.rb

@@ -10,7 +10,7 @@ module WAZ
       # When the options :include => 'metadata' is passed it returns
       # the corresponding metadata for each queue on the listing.
       def list_queues(options ={})
-        content = execute(:get, nil, { :comp => 'list' }.merge!(options), { :x_ms_version => "2009-09-19" })
+        content = execute(:get, nil, { :comp => 'list' }.merge!(options), { :x_ms_version => "2011-08-18" })
         doc = REXML::Document.new(content)
         queues = []
         
@@ -31,22 +31,22 @@ module WAZ
       # Creates a queue on the current storage account. Throws WAZ::Queues::QueueAlreadyExists when 
       # existing metadata and given metadata differ.
       def create_queue(queue_name, metadata = {})
-        execute(:put, queue_name, nil, metadata.merge!(:x_ms_version => '2009-09-19'))
+        execute(:put, queue_name, nil, metadata.merge!(:x_ms_version => '2011-08-18'))
       end
       
       # Deletes the given queue from the current storage account.
       def delete_queue(queue_name)
-        execute(:delete, queue_name, {}, {:x_ms_version => '2009-09-19'})
+        execute(:delete, queue_name, {}, {:x_ms_version => '2011-08-18'})
       end
       
       # Gets the given queue metadata.
       def get_queue_metadata(queue_name)
-        execute(:head, queue_name, { :comp => 'metadata'}, :x_ms_version => '2009-09-19').headers
+        execute(:head, queue_name, { :comp => 'metadata'}, :x_ms_version => '2011-08-18').headers
       end
       
       # Sets the given queue metadata.
       def set_queue_metadata(queue_name, metadata = {})
-        execute(:put, queue_name, { :comp => 'metadata' }, metadata.merge!(:x_ms_version => '2009-09-19'))
+        execute(:put, queue_name, { :comp => 'metadata' }, metadata.merge!(:x_ms_version => '2011-08-18'))
       end
       
       # Enqueues a message on the current queue.
@@ -55,7 +55,7 @@ module WAZ
       # is omitted, the default time-to-live is 7 days.
       def enqueue(queue_name, message_payload, ttl = 604800)
         payload = "<?xml version=\"1.0\" encoding=\"utf-8\"?><QueueMessage><MessageText>#{message_payload}</MessageText></QueueMessage>"
-        execute(:post, "#{queue_name}/messages", { :messagettl => ttl }, { 'Content-Type' => 'application/xml', :x_ms_version => "2009-09-19"}, payload)
+        execute(:post, "#{queue_name}/messages", { :messagettl => ttl }, { 'Content-Type' => 'application/xml', :x_ms_version => "2011-08-18"}, payload)
       end
       
       # Locks N messages (1 default) from the given queue.
@@ -66,7 +66,7 @@ module WAZ
       def get_messages(queue_name, options = {})
         raise WAZ::Queues::OptionOutOfRange, {:name => :num_of_messages, :min => 1, :max => 32} if (options.keys.include?(:num_of_messages) && (options[:num_of_messages].to_i < 1 || options[:num_of_messages].to_i > 32))
         raise WAZ::Queues::OptionOutOfRange, {:name => :visibility_timeout, :min => 1, :max => 7200} if (options.keys.include?(:visibility_timeout) && (options[:visibility_timeout].to_i < 1 || options[:visibility_timeout].to_i > 7200))
-        content = execute(:get, "#{queue_name}/messages", options, {:x_ms_version => "2009-09-19"})
+        content = execute(:get, "#{queue_name}/messages", options, {:x_ms_version => "2011-08-18"})
         doc = REXML::Document.new(content)
         messages = []
         REXML::XPath.each(doc, '//QueueMessage/') do |item|
@@ -99,7 +99,7 @@ module WAZ
       
       # Marks every message on the given queue for deletion.
       def clear_queue(queue_name)
-        execute :delete, "#{queue_name}/messages", {}, :x_ms_version => '2009-09-19'
+        execute :delete, "#{queue_name}/messages", {}, :x_ms_version => '2011-08-18'
       end
     end
   end

data/lib/waz/storage/core_service.rb

@@ -68,7 +68,7 @@ module WAZ
       # the canonicalized header line and the canonical form of the message, all of the joined by \n character. Encoded with 
       # Base64 and encrypted with SHA256 using the access_key as the seed.
       def generate_signature(options = {})
-        return generate_signature20090919(options) if options[:headers]["x-ms-version"] == "2009-09-19"
+        return generate_signature20090919(options) if options[:headers]["x-ms-version"] == "2011-08-18"
 
         signature = options[:method].to_s.upcase + "\x0A" +
                      (options[:headers]["Content-MD5"] or "") + "\x0A" +

data/rakefile

@@ -1,46 +1,16 @@
-require 'rake'
-require 'rubygems'
+#!/usr/bin/env rake
 require 'rspec/core/rake_task'
-require 'rake/gempackagetask'
 require 'rake/rdoctask'
-require 'lib/waz-storage'
-
-task :default => [:specs]
+require 'bundler/gem_tasks'
 
 RSpec::Core::RakeTask.new do |t|
   t.name = :specs
-  t.pattern = "tests/**/*.rb"
+  t.pattern = "tests/**/*_test.rb"
   t.rcov = true
   t.rcov_opts = ['--text-report', '--exclude', "exclude.*/.gem,test,Library,#{ENV['GEM_HOME']}", '--sort', 'coverage' ]
   t.rspec_opts = ['-cfn']
 end
 
-
-namespace :dist do  
-  spec = Gem::Specification.new do |s|
-    s.name              = 'waz-storage'
-    s.version           = Gem::Version.new(WAZ::Storage::Version)
-    s.summary           = "Client library for Windows Azure's Storage Service REST API"
-    s.description       = "A simple implementation of Windows Azure Storage API for Ruby, inspired by the S3 gems and self experience of dealing with queues. The major goal of the whole gem is to enable ruby developers [like me =)] to leverage Windows Azure Storage features and have another option for cloud storage."
-    s.email             = 'johnny.halife@me.com'
-    s.author            = 'Johnny G. Halife'
-    s.homepage          = 'http://waz-storage.heroku.com'
-    s.require_paths     = ["lib"]
-    s.files             = FileList['rakefile', 'lib/**/*.rb']
-    s.test_files        = Dir['test/**/*']
-    s.has_rdoc          = true
-    s.rdoc_options      << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
-    
-    # Dependencies
-    s.add_dependency 'rest-client'
-    s.add_dependency 'ruby-hmac'
-  end
-  
-  Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_tar = true
-  end
-end
-
 namespace :docs do
   Rake::RDocTask.new do |t|
   	t.rdoc_dir = 'rdoc'
@@ -50,4 +20,4 @@ namespace :docs do
   	t.rdoc_files.include('README.rdoc')
   	t.rdoc_files.include('lib/**/*.rb')
   end
-end
+end

data/tests/configuration.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rspec'
+require 'rspec/autorun'
+require 'mocha'
+require 'restclient'
+require 'time'
+require 'hmac-sha2'
+require 'base64'
+require 'rexml/document'
+require 'rexml/xpath'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/tests/waz/blobs/blob_object_test.rb

@@ -0,0 +1,80 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'tests/configuration'
+require 'lib/waz-blobs'
+
+describe "Windows Azure Blobs interface API" do
+  it "should return blob path from url" do
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "application/xml")  
+    blob.path.should == "container/blob"
+  end
+  
+  it "should return blob metdata" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_blob_properties).with("container/blob").returns({:x_ms_meta_name => "blob_name"})
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "application/xml")  
+    blob.metadata.should == { :x_ms_meta_name => "blob_name" }
+  end
+  
+  it "should put blob metadataa" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:set_blob_properties).with("container/blob", {:x_ms_meta_name => "blob_name"})
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "application/xml")  
+    blob.put_properties!({ :x_ms_meta_name => "blob_name" })
+  end
+  
+  it "should get blob contents" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_blob).with("container/blob").returns("this is the blob content")
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "application/xml")  
+    blob.value.should == "this is the blob content"
+  end
+  
+  it "should put blob contents" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_blob_properties).with("container/blob").returns({})
+    WAZ::Blobs::Service.any_instance.expects(:put_blob).with("container/blob", "my new blob value", "application/xml", {}).returns("this is the blob content")
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "application/xml")  
+    blob.value = "my new blob value"
+  end
+  
+  it "should destroy blob" do
+   WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+   WAZ::Blobs::Service.any_instance.expects(:delete_blob).with("container/blob")
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "application/xml")  
+   blob.destroy!
+  end
+  
+  it "should copy blob" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})   
+    WAZ::Blobs::BlobObject.service_instance.expects(:copy_blob).with('container/blob', 'container/blob-copy')
+    WAZ::Blobs::BlobObject.service_instance.expects(:get_blob_properties).with('container/blob-copy').returns(:content_type => "plain/text")
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "plain/text")  
+    copy = blob.copy('container/blob-copy')
+    copy.path.should == "container/blob-copy"
+  end
+  
+  it "should take a snapshot of a blob" do
+    mock_time = Time.new 
+    Time.stubs(:new).returns(mock_time)
+    
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})   
+    WAZ::Blobs::BlobObject.service_instance.expects(:get_blob_properties).with('container/blob').returns(:content_type => "plain/text")
+    WAZ::Blobs::BlobObject.service_instance.expects(:snapshot_blob).with('container/blob').returns(mock_time.httpdate)
+    
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "plain/text")  
+    blob_snapshot = blob.snapshot
+    blob_snapshot.snapshot_date.should === mock_time.httpdate
+  end
+  
+  it "should not allow snapshoted blobs to perform write operations" do    
+    snapshot = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob", :content_type => "plain/text", :snapshot_date => Time.new.httpdate)  
+    lambda { snapshot.value = "new-value" }.should raise_error(WAZ::Blobs::InvalidOperation)    
+    lambda { snapshot.put_properties!({:x_ms_meta_name => "foo"}) }.should raise_error(WAZ::Blobs::InvalidOperation)    
+  end
+  
+  it "blob path should include snapshot parameter" do
+    blob = WAZ::Blobs::BlobObject.new(:name => "blob_name", :url => "http://localhost/container/blob?snapshot=foo", :content_type => "application/xml")  
+    blob.path.should == "container/blob?snapshot=foo"
+  end
+end

data/tests/waz/blobs/container_test.rb

@@ -0,0 +1,162 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'tests/configuration'
+require 'lib/waz-blobs'
+
+describe "Windows Azure Containers interface API" do 
+  
+  it "should should throw when no container name is provided" do
+    lambda {WAZ::Blobs::Container.new}.should raise_error(WAZ::Storage::InvalidOption)
+  end
+  
+  it "should list containers" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:list_containers).returns([{:name => 'my-container'}, {:name => 'other container'}])
+    containers = WAZ::Blobs::Container.list
+    containers.size.should == 2
+    containers.first().name.should == "my-container"
+  end
+  
+  it "should be able to create a container" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:create_container).with("my-container")
+    container = WAZ::Blobs::Container.create('my-container')
+    container.name.should == 'my-container'
+  end
+  
+  it "should be able to return a container by name" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:name => "container-name", :x_ms_meta_name => "container-name"}).twice
+    container = WAZ::Blobs::Container.find('container-name')
+    container.metadata[:x_ms_meta_name].should == 'container-name'
+  end
+  
+  it "should be able to return container metadata" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:create_container).with("container-name")
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    container = WAZ::Blobs::Container.create('container-name')
+    container.metadata[:x_ms_meta_name].should == 'container-name'  
+  end
+  
+  it "should be able to say whether the container is public or not" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_acl).with("container-name").returns(false)
+    container = WAZ::Blobs::Container.find("container-name")
+    container.public_access?.should == false
+  end
+  
+  it "should be able to set whether the container is public or not" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:set_container_acl).with('container-name', false)
+    container = WAZ::Blobs::Container.find("container-name")
+    container.public_access = false
+  end
+  
+  it "should be able to set container properties" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:set_container_properties).with("container-name", {:x_ms_meta_meta1 => "meta1"}).returns(false)
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    container = WAZ::Blobs::Container.find("container-name")
+    container.put_properties!(:x_ms_meta_meta1 => "meta1")
+  end
+  
+  it "should be able to return a list files within the container" do
+    expected_blobs = [ {:name => 'blob1', :url => 'url', :content_type => 'app/xml'}, {:name => 'blob2', :url => 'url', :content_type => 'app/xml'} ]
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:list_blobs).with("container-name").returns(expected_blobs)
+    container = WAZ::Blobs::Container.find("container-name")
+    container_blobs = container.blobs
+    container_blobs.first().name = expected_blobs[0][:name]
+    container_blobs[1].name = expected_blobs[1][:name]
+  end
+  
+  it "should destroy container" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:delete_container).with("container-name")
+    container = WAZ::Blobs::Container.find("container-name")
+    container.destroy!
+  end
+  
+  it "should be able to return null when container not found by name" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").raises(RestClient::ResourceNotFound)
+    container = WAZ::Blobs::Container.find('container-name')
+    container.nil?.should == true
+  end
+  
+  it "should be able to put blob inside given container" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:put_blob).with("container-name/my_blob", "this is the blob content", "text/plain; charset=UTF-8", {:x_ms_meta_custom_property => "customValue"})
+    container = WAZ::Blobs::Container.find("container-name")
+    blob = container.store("my_blob", "this is the blob content", "text/plain; charset=UTF-8", {:x_ms_meta_custom_property => "customValue"})
+    blob.name.should == "my_blob"
+    blob.url.should == "http://my_account.blob.core.windows.net/container-name/my_blob"
+    blob.content_type.should == "text/plain; charset=UTF-8"
+  end
+
+  it "should be able to upload a stream to a blob inside a given container" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:put_block).with("container-name/my_blob", Base64.encode64('%064d' % 0), "this is the blob content")
+    WAZ::Blobs::Service.any_instance.expects(:put_block_list).with("container-name/my_blob", [Base64.encode64('%064d' % 0)], "text/plain; charset=UTF-8", {:x_ms_meta_custom_property => "customValue"})
+    container = WAZ::Blobs::Container.find("container-name")
+    blob = container.upload("my_blob", StringIO.new("this is the blob content"), "text/plain; charset=UTF-8", {:x_ms_meta_custom_property => "customValue"})
+    blob.name.should == "my_blob"
+    blob.url.should == "http://my_account.blob.core.windows.net/container-name/my_blob"
+    blob.content_type.should == "text/plain; charset=UTF-8"
+  end
+
+  it "should be able to put blob inside given container (when simulating fake containers)" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:put_blob).with("container-name/fake-container/blob", "this is the blob content", "text/plain; charset=UTF-8", {:x_ms_meta_custom_property => "customValue"})
+    container = WAZ::Blobs::Container.find("container-name")
+    blob = container.store("/fake-container/blob", "this is the blob content", "text/plain; charset=UTF-8", {:x_ms_meta_custom_property => "customValue"})
+    blob.name.should == "fake-container/blob"
+    blob.url.should == "http://my_account.blob.core.windows.net/container-name/fake-container/blob"
+    blob.content_type.should == "text/plain; charset=UTF-8"
+  end
+  
+  it "should return a specific blob for the given container" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:get_blob_properties).with("container-name/my_blob").returns({ :content_type => "application/xml" })
+    container = WAZ::Blobs::Container.find("container-name")
+    blob = container['my_blob']
+    blob.name.should == 'my_blob'
+    blob.content_type.should == 'application/xml'
+    blob.url.should == 'http://my_account.blob.core.windows.net/container-name/my_blob'
+  end
+  
+  it "should return nil when the file does not exist" do
+    WAZ::Storage::Base.stubs(:default_connection).returns({:account_name => "my_account", :access_key => "key"})
+    WAZ::Blobs::Service.any_instance.expects(:get_container_properties).with("container-name").returns({:x_ms_meta_name => "container-name"})
+    WAZ::Blobs::Service.any_instance.expects(:get_blob_properties).with("container-name/my_blob").raises(RestClient::ResourceNotFound)
+    container = WAZ::Blobs::Container.find('container-name')
+    blob = container['my_blob']
+    blob.nil?.should == true
+  end
+  
+  it "should raise an exception when container name starts with - (hypen)" do
+    lambda { WAZ::Blobs::Container.create('-container')  }.should raise_error(WAZ::Storage::InvalidParameterValue)
+  end
+  
+  it "should raise an exception when container name  ends with - (hypen)" do
+    lambda { WAZ::Blobs::Container.create('container-')  }.should raise_error(WAZ::Storage::InvalidParameterValue)
+  end
+  
+  it "should raise an exception when container name is less than 3" do
+    lambda { WAZ::Blobs::Container.create('co')  }.should raise_error(WAZ::Storage::InvalidParameterValue)
+  end
+  
+  it "should raise an exception when container name is longer than 63" do
+    lambda { WAZ::Blobs::Container.create('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')  }.should raise_error(WAZ::Storage::InvalidParameterValue)
+  end
+
+end