waz-storage 1.2.0 → 1.3.0

data/lib/waz/tables/table.rb

@@ -1,75 +1,75 @@
-module WAZ
-  module Tables
-    # This class represents a Table on Windows Azure Tables API. These are the methods implemented from Microsoft's API description 
-    # available on MSDN at http://msdn.microsoft.com/en-us/library/dd179423.aspx
-    #
-    #	# list available tables
-    #	tables = WAZ::Tables::Table.list
-    #
-    #	# list more tables
-    #	WAZ::Tables::Table.list(tables.continuation_token)
-    #
-  	# # get a specific table
-  	# my_table = WAZ::Tables::Table.find('my-table')
-  	#    
-    #	# delete table
-    #	my_table.destroy!
-    #
-    #	# create a new table
-    #	WAZ::Tables::Table.create('new-table')
-    #
-    class Table
-      class << self
-        INVALID_TABLE_ERROR_MESSAGE = "must start with at least one lower/upper characted, can have character or any digit starting from the second position, must be from 3 through 63 characters long"
-        
-        # Finds a table by name. It will return nil if no table was found.
-        def find(table_name)
-          raise WAZ::Storage::InvalidParameterValue, {:name => table_name, :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
-          begin 
-            WAZ::Tables::Table.new(service_instance.get_table(table_name))
-          rescue WAZ::Tables::TableDoesNotExist
-            return nil
-          end
-        end
-                
-        # Returns an array of the existing tables (WAZ::Tables::Table) on the current 
-        # Windows Azure Storage account.
-        def list(continuation_token = {})
-            table_list, next_table_name = service_instance.list_tables(continuation_token['NextTableName'])
-            tables = TableArray.new(table_list.map { |table| WAZ::Tables::Table.new({ :name => table[:name], :url => table[:url] }) })
-            tables.continuation_token = {'NextTableName' => next_table_name} unless next_table_name.nil?
-            return tables
-        end
-        
-        # Creates a table on the current account.
-        def create(table_name)
-          raise WAZ::Storage::InvalidParameterValue, {:name => table_name, :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
-          WAZ::Tables::Table.new(service_instance.create_table(table_name))
-        end
-        
-        # This method is internally used by this class. It's the way we keep a single instance of the 
-        # service that wraps the calls the Windows Azure Tables API. It's initialized with the values
-        # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
-        def service_instance
-          options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "table")
-          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
-        end       
-      end
-
-      attr_accessor :name, :url
-
-      def initialize(options = {})
-        raise WAZ::Storage::InvalidOption, :name unless options.keys.include?(:name) and !options[:name].empty?
-        raise WAZ::Storage::InvalidOption, :url unless options.keys.include?(:url) and !options[:url].empty?        
-        raise WAZ::Storage::InvalidParameterValue, {:name => options[:name], :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(options[:name])        
-        self.name = options[:name]
-        self.url = options[:url]        
-      end
-      
-      # Removes the table from the current account.
-      def destroy!
-        self.class.service_instance.delete_table(self.name)
-      end
-    end
-  end
+module WAZ
+  module Tables
+    # This class represents a Table on Windows Azure Tables API. These are the methods implemented from Microsoft's API description 
+    # available on MSDN at http://msdn.microsoft.com/en-us/library/dd179423.aspx
+    #
+    #	# list available tables
+    #	tables = WAZ::Tables::Table.list
+    #
+    #	# list more tables
+    #	WAZ::Tables::Table.list(tables.continuation_token)
+    #
+  	# # get a specific table
+  	# my_table = WAZ::Tables::Table.find('my-table')
+  	#    
+    #	# delete table
+    #	my_table.destroy!
+    #
+    #	# create a new table
+    #	WAZ::Tables::Table.create('new-table')
+    #
+    class Table
+      class << self
+        INVALID_TABLE_ERROR_MESSAGE = "must start with at least one lower/upper characted, can have character or any digit starting from the second position, must be from 3 through 63 characters long"
+        
+        # Finds a table by name. It will return nil if no table was found.
+        def find(table_name)
+          raise WAZ::Storage::InvalidParameterValue, {:name => table_name, :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+          begin 
+            WAZ::Tables::Table.new(service_instance.get_table(table_name))
+          rescue WAZ::Tables::TableDoesNotExist
+            return nil
+          end
+        end
+                
+        # Returns an array of the existing tables (WAZ::Tables::Table) on the current 
+        # Windows Azure Storage account.
+        def list(continuation_token = {})
+            table_list, next_table_name = service_instance.list_tables(continuation_token['NextTableName'])
+            tables = TableArray.new(table_list.map { |table| WAZ::Tables::Table.new({ :name => table[:name], :url => table[:url] }) })
+            tables.continuation_token = {'NextTableName' => next_table_name} unless next_table_name.nil?
+            return tables
+        end
+        
+        # Creates a table on the current account.
+        def create(table_name)
+          raise WAZ::Storage::InvalidParameterValue, {:name => table_name, :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+          WAZ::Tables::Table.new(service_instance.create_table(table_name))
+        end
+        
+        # This method is internally used by this class. It's the way we keep a single instance of the 
+        # service that wraps the calls the Windows Azure Tables API. It's initialized with the values
+        # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
+        def service_instance
+          options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "table")
+          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
+        end       
+      end
+
+      attr_accessor :name, :url
+
+      def initialize(options = {})
+        raise WAZ::Storage::InvalidOption, :name unless options.keys.include?(:name) and !options[:name].empty?
+        raise WAZ::Storage::InvalidOption, :url unless options.keys.include?(:url) and !options[:url].empty?        
+        raise WAZ::Storage::InvalidParameterValue, {:name => options[:name], :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(options[:name])        
+        self.name = options[:name]
+        self.url = options[:url]        
+      end
+      
+      # Removes the table from the current account.
+      def destroy!
+        self.class.service_instance.delete_table(self.name)
+      end
+    end
+  end
 end

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,21 +1,8 @@
-#!/usr/bin/env rake
-require 'rspec/core/rake_task'
-require 'rake/rdoctask'
-require 'bundler/gem_tasks'
-
-RSpec::Core::RakeTask.new do |t|
-  t.name = :specs
-  t.pattern = "tests/**/*_test.rb"
-  t.rspec_opts = ['-cfn']
-end
-
-namespace :docs do
-  Rake::RDocTask.new do |t|
-  	t.rdoc_dir = 'rdoc'
-  	t.title    = "Windows Azure Storage library - simple gem for accessing WAZ's Storage REST API"
-  	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
-  	t.options << '--charset' << 'utf-8'
-  	t.rdoc_files.include('README.rdoc')
-  	t.rdoc_files.include('lib/**/*.rb')
-  end
-end
+#!/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/{tests → 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/{tests/waz/blobs/blob_object_test.rb → 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 '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
+# 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/{tests/waz/blobs/container_test.rb → spec/waz/blobs/container_spec.rb}

@@ -1,162 +1,175 @@
-# 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
+# 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