waz-storage 1.3.1 → 1.3.2

data/lib/waz/tables/table_array.rb

@@ -1,11 +1,11 @@
-module WAZ
-  module Tables
-    class TableArray < Array
-      attr_accessor :continuation_token
-      
-      def initialize(array)
-        super(array)
-      end
-    end
-  end
+module WAZ
+  module Tables
+    class TableArray < Array
+      attr_accessor :continuation_token
+      
+      def initialize(array)
+        super(array)
+      end
+    end
+  end
 end

data/rakefile

@@ -1,8 +1,8 @@
-#!/usr/bin/env rake
-require 'rspec/core/rake_task'
-require 'bundler/gem_tasks'
-
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = "spec/**/*_spec.rb"
-  t.rspec_opts = ['-cfn']
+#!/usr/bin/env rake
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.rspec_opts = ['-cfn']
 end  

data/spec/configuration.rb

@@ -1,22 +1,22 @@
-require 'simplecov'
-SimpleCov.start do
-  add_group "Gem files" do |src_file|
-    lib_path = File.expand_path("../lib", File.dirname(__FILE__))
-    src_file.filename.start_with?(lib_path)
-  end
-end
-
-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
+require 'simplecov'
+SimpleCov.start do
+  add_group "Gem files" do |src_file|
+    lib_path = File.expand_path("../lib", File.dirname(__FILE__))
+    src_file.filename.start_with?(lib_path)
+  end
+end
+
+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/spec/waz/blobs/blob_object_spec.rb

@@ -1,80 +1,80 @@
-# enabling the load of files from root (on RSpec)
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../../')
-require 'spec/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
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../../')
+require 'spec/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/spec/waz/blobs/container_spec.rb

@@ -1,175 +1,175 @@
-# enabling the load of files from root (on RSpec)
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
-require 'spec/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 be able to return statistics of the container" do
-    options = {:maxresults => 100, :marker => "marker"}
-    expected_values = {:size => 200, :files => 100, :next_marker => "next-marker"}
-    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(:statistics).with("container-name", options).returns(expected_values)
-    container = WAZ::Blobs::Container.find("container-name")
-    statistics = container.statistics(options)
-    statistics[:size].should == 200
-    statistics[:files].should == 100
-    statistics[:next_marker].should == "next-marker"
-  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
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec/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 be able to return statistics of the container" do
+    options = {:maxresults => 100, :marker => "marker"}
+    expected_values = {:size => 200, :files => 100, :next_marker => "next-marker"}
+    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(:statistics).with("container-name", options).returns(expected_values)
+    container = WAZ::Blobs::Container.find("container-name")
+    statistics = container.statistics(options)
+    statistics[:size].should == 200
+    statistics[:files].should == 100
+    statistics[:next_marker].should == "next-marker"
+  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