fog-azure-rm 0.1.0 → 0.1.1

data/test/integration/zone.rb

@@ -27,39 +27,47 @@ dns = Fog::DNS.new(
 ######################                                 Prerequisites                              ######################
 ########################################################################################################################
 
-rs.resource_groups.create(
-  name: 'TestRG-ZN',
-  location: 'eastus'
-)
+begin
+  resource_group = rs.resource_groups.create(
+    name: 'TestRG-ZN',
+    location: LOCATION
+  )
 
-########################################################################################################################
-######################                                Create Zone                                 ######################
-########################################################################################################################
+  ########################################################################################################################
+  ######################                                Create Zone                                 ######################
+  ########################################################################################################################
 
-dns.zones.create(
-  name: 'test-zone.com',
-  location: 'global',
-  resource_group: 'TestRG-ZN'
-)
+  zone = dns.zones.create(
+    name: 'test-zone.com',
+    location: 'global',
+    resource_group: 'TestRG-ZN'
+  )
+  puts "Created zone: #{zone.name}"
 
-########################################################################################################################
-######################                    Get All Zones in a Subscription                         ######################
-########################################################################################################################
+  ########################################################################################################################
+  ######################                    Get All Zones in a Subscription                         ######################
+  ########################################################################################################################
 
-dns.zones.each do |z|
-  puts "Resource Group:#{z.resource_group} name:#{z.name}"
-end
+  puts 'List zones in a subscription:'
+  dns.zones.each do |z|
+    puts "Resource Group:#{z.resource_group} name:#{z.name}"
+  end
 
-########################################################################################################################
-######################               Get and Destroy Zone in a Resource Group                     ######################
-########################################################################################################################
+  ########################################################################################################################
+  ######################               Get and Destroy Zone in a Resource Group                     ######################
+  ########################################################################################################################
 
-zone = dns.zones.get('TestRG-ZN', 'test-zone.com')
-zone.destroy
+  zone = dns.zones.get('TestRG-ZN', 'test-zone.com')
+  puts "Get zone: #{zone.name}"
+  puts "Deleted zone: #{zone.destroy}"
 
-########################################################################################################################
-######################                                   CleanUp                                  ######################
-########################################################################################################################
+  ########################################################################################################################
+  ######################                                   CleanUp                                  ######################
+  ########################################################################################################################
 
-rg = rs.resource_groups.get('TestRG-ZN')
-rg.destroy
+  rg = rs.resource_groups.get('TestRG-ZN')
+  rg.destroy
+rescue
+  puts 'Integration Test for zone is failing'
+  resource_group.destroy unless resource_group.nil?
+end

data/test/models/storage/test_directories.rb

@@ -3,23 +3,16 @@ require File.expand_path '../../test_helper', __dir__
 # Test class for Container Collection
 class TestDirectories < Minitest::Test
   def setup
-    Fog.mock!
-    @mock_service = Fog::Storage::AzureRM.new(storage_account_credentials)
-    @mock_directories = Fog::Storage::AzureRM::Directories.new(service: @mock_service)
-    Fog.unmock!
     @service = Fog::Storage::AzureRM.new(storage_account_credentials)
-    @blob_client = @service.instance_variable_get(:@blob_client)
     @directories = Fog::Storage::AzureRM::Directories.new(service: @service)
-    @get_metadata_result = ApiStub::Models::Storage::Directory.test_get_container_metadata
-    @list_results = ApiStub::Models::Storage::Directory.list_containers
-    @acl_results = ApiStub::Models::Storage::Directory.get_container_access_control_list
-    @mocked_response = mocked_storage_http_error
+
+    @container_list = ApiStub::Models::Storage::Directory.container_list
+    @container = ApiStub::Models::Storage::Directory.container
+    @blob_list = ApiStub::Models::Storage::Directory.blob_list
   end
 
   def test_collection_methods
     methods = [
-      :get_metadata,
-      :set_metadata,
       :all,
       :get
     ]
@@ -28,78 +21,40 @@ class TestDirectories < Minitest::Test
     end
   end
 
-  def test_all_method_http_exception
-    http_exception = -> (_option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :list_containers, http_exception do
-      assert_raises(RuntimeError) do
-        @directories.all
+  def test_all_method_success
+    @service.stub :list_containers, @container_list do
+      dirs = @directories.all
+      assert_instance_of Fog::Storage::AzureRM::Directories, dirs
+      assert_equal @container_list.size, dirs.size
+      dirs.each do |directory|
+        assert_instance_of Fog::Storage::AzureRM::Directory, directory
+        assert_equal 'unknown', directory.attributes[:acl]
       end
     end
   end
 
-  def test_all_method_mock
-    assert_instance_of Fog::Storage::AzureRM::Directories, @mock_directories.all
-    assert @mock_directories.all.size >= 1
-    @mock_directories.all.each do |directory|
-      assert_instance_of Fog::Storage::AzureRM::Directory, directory
-    end
-  end
-
-  def test_get_container_metadata
-    @service.stub :get_container_metadata, @get_metadata_result do
-      assert_equal @get_metadata_result, @directories.get_metadata('Test-container')
-    end
-  end
-
-  def test_get_container_metadata_http_exception
-    http_exception = -> (_container_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :get_container_metadata, http_exception do
-      assert_raises(RuntimeError) do
-        @directories.get_metadata 'Test-container'
+  def test_get_method_success
+    @service.stub :get_container_properties, @container do
+      @service.stub :list_blobs, @blob_list do
+        directory = @directories.get('test_container')
+        assert_instance_of Fog::Storage::AzureRM::Directory, directory
+        assert_equal 'unknown', directory.attributes[:acl]
       end
     end
   end
 
-  def test_get_container_metadata_mock
-    directory = @mock_directories.get_metadata 'Test-container'
-    assert_instance_of Hash, directory
-  end
-
-  def test_set_container_metadata
-    @service.stub :set_container_metadata, true do
-      assert @directories.set_metadata('Test-container', @get_metadata_result)
+  def test_get_method_container_not_found
+    exception = ->(*) { raise 'NotFound' }
+    @service.stub :get_container_properties, exception do
+      assert @directories.get('test_container').nil?
     end
   end
 
-  def test_set_container_metadata_http_exception
-    http_exception = -> (_container_name, _metadata, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :set_container_metadata, http_exception do
+  def test_get_method_exception
+    exception = ->(*) { raise 'Error' }
+    @service.stub :get_container_properties, exception do
       assert_raises(RuntimeError) do
-        @directories.set_metadata 'Test-container', @get_metadata_result
-      end
-    end
-  end
-
-  def test_set_container_metadata_mock
-    assert @mock_directories.set_metadata('Test-container', @get_metadata_result)
-  end
-
-  def test_all_method
-    directories = Fog::Storage::AzureRM::Directories.new(service: @service)
-    @service.stub :list_containers, @list_results do
-      assert_instance_of Fog::Storage::AzureRM::Directories, directories.all
-      assert directories.all.size >= 1
-      directories.all.each do |directory|
-        assert_instance_of Fog::Storage::AzureRM::Directory, directory
-      end
-    end
-  end
-
-  def test_get_method
-    @service.stub :list_containers, @list_results do
-      @service.stub :get_container_access_control_list, @acl_results do
-        assert_instance_of Fog::Storage::AzureRM::Directory, @directories.get('testcontainer1')
-        assert @directories.get('wrong-name').nil?, true
+        @directories.get('test_container')
       end
     end
   end

data/test/models/storage/test_directory.rb

@@ -3,24 +3,24 @@ require File.expand_path '../../test_helper', __dir__
 # Test class for Storage Container Model
 class TestDirectory < Minitest::Test
   def setup
-    Fog.mock!
-    @mock_service = Fog::Storage::AzureRM.new(storage_account_credentials)
-    @mock_directory = storage_container(@mock_service)
-    Fog.unmock!
     @service = Fog::Storage::AzureRM.new(storage_account_credentials)
-    @directory = storage_container(@service)
-    @create_result = ApiStub::Models::Storage::Directory.create_container
-    @get_properties_result = ApiStub::Models::Storage::Directory.get_container_properties
-    @get_access_control_list_result = ApiStub::Models::Storage::Directory.get_container_access_control_list
-    @blob_client = @service.instance_variable_get(:@blob_client)
-    @mocked_response = mocked_storage_http_error
+    @directory = directory(@service)
+
+    @container = ApiStub::Models::Storage::Directory.container
+    @container_acl = ApiStub::Models::Storage::Directory.container_acl
+    @container_https_url = ApiStub::Models::Storage::Directory.container_https_url
   end
 
   def test_model_methods
     methods = [
+      :acl=,
+      :acl,
+      :destroy,
+      :files,
+      :public=,
+      :public_url,
       :save,
-      :create,
-      :destroy
+      :persisted?
     ]
     methods.each do |method|
       assert_respond_to @directory, method
@@ -37,89 +37,142 @@ class TestDirectory < Minitest::Test
       :lease_status,
       :metadata
     ]
-    @service.stub :create_container, @create_result do
+    @service.stub :create_container, @container do
       attributes.each do |attribute|
         assert_respond_to @directory, attribute
       end
     end
   end
 
-  def test_save_method_response
-    @service.stub :create_container, @create_result do
-      assert_instance_of Fog::Storage::AzureRM::Directory, @directory.save
-    end
-    @service.stub :create_container, @create_result do
-      assert_instance_of Fog::Storage::AzureRM::Directory, @directory.create
+  def test_set_acl_method_success
+    result = @directory.acl = 'container'
+    assert_equal 'container', result
+    assert_equal 'container', @directory.attributes[:acl]
+  end
+
+  def test_set_acl_method_exception
+    assert_raises(ArgumentError) do
+      @directory.acl = 'invalid-acl'
     end
   end
 
-  def test_save_http_exception
-    http_exception = -> (_container_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :create_container, http_exception do
-      assert_raises(RuntimeError) do
-        @directory.save
+  def test_get_acl_method_success
+    # Return 'unknonw' when directory is not persist and acl is 'unknown'
+    @directory.acl = 'unknown'
+    @directory.stub :persisted?, false do
+      assert_equal 'unknown', @directory.acl
+    end
+
+    # Return actual value directly when directory is not persist and acl is not 'unknown'
+    @directory.acl = 'blob'
+    @directory.stub :persisted?, false do
+      assert_equal 'blob', @directory.acl
+    end
+
+    # Query actual value and return it when directory is persist and acl is 'unknown'
+    @directory.acl = 'unknown'
+    @directory.stub :persisted?, true do
+      @service.stub :get_container_acl, @container_acl do
+        assert_equal 'container', @directory.acl
+        assert_equal 'container', @directory.attributes[:acl]
       end
     end
   end
 
-  def test_save_mock
-    assert_instance_of Fog::Storage::AzureRM::Directory, @mock_directory.save
+  def test_get_acl_method_without_key_exception
+    @directory.attributes.delete(:key)
+    assert_raises(ArgumentError) do
+      @directory.acl
+    end
   end
 
-  def test_get_container_properties_method_response
-    @service.stub :get_container_properties, @get_properties_result do
-      assert_instance_of Fog::Storage::AzureRM::Directory, @directory.get_properties
+  def test_destroy_method_success
+    @service.stub :delete_container, true do
+      assert @directory.destroy
     end
   end
 
-  def test_get_container_properties_http_exception
-    http_exception = -> (_container_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :get_container_properties, http_exception do
-      assert_raises(RuntimeError) do
-        @directory.get_properties
-      end
+  def test_destroy_method_without_key_exception
+    @directory.attributes.delete(:key)
+    assert_raises(ArgumentError) do
+      @directory.destroy
     end
   end
 
-  def test_get_container_properties_mock
-    assert_instance_of Fog::Storage::AzureRM::Directory, @mock_directory.get_properties
+  def test_files_method_success
+    assert_instance_of Fog::Storage::AzureRM::Files, @directory.files
   end
 
-  def test_get_access_control_list_method_response
-    @service.stub :get_container_access_control_list, @get_access_control_list_result do
-      assert_instance_of Fog::Storage::AzureRM::Directory, @directory.access_control_list
-    end
+  def test_set_public_method_success
+    # Set public
+    result = @directory.public = true
+    assert result
+    assert_equal 'container', @directory.attributes[:acl]
+
+    # Set private
+    result = @directory.public = false
+    assert !result
+    assert_equal nil, @directory.attributes[:acl]
   end
 
-  def test_get_access_control_list_http_exception
-    http_exception = -> (_container_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :get_container_acl, http_exception do
-      assert_raises(RuntimeError) do
-        @directory.access_control_list
+  def test_public_url_method_with_public_success
+    @directory.stub :acl, 'container' do
+      @service.stub :get_container_url, @container_https_url do
+        assert_equal @container_https_url, @directory.public_url
       end
     end
   end
 
-  def test_get_access_control_list_mock
-    assert_instance_of Fog::Storage::AzureRM::Directory, @mock_directory.access_control_list
+  def test_public_url_method_with_private_success
+    @directory.stub :acl, nil do
+      assert @directory.public_url.nil?
+    end
   end
 
-  def test_delete_method_true_response
-    @service.stub :delete_container, true do
-      assert @directory.destroy
+  def test_public_url_method_without_key_exception
+    @directory.attributes.delete(:key)
+    assert_raises(ArgumentError) do
+      @directory.public_url
+    end
+  end
+
+  def test_save_method_create_success
+    @service.stub :create_container, @container do
+      assert @directory.save
+      assert @directory.attributes[:is_persisted]
     end
   end
 
-  def test_delete_method_exception
-    exception = -> (_container_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :delete_container, exception do
-      assert_raises(RuntimeError) do
-        assert @directory.destroy
+  def test_save_method_update_success
+    options = { is_create: false }
+    @service.stub :put_container_acl, true do
+      @service.stub :put_container_metadata, true do
+        @service.stub :get_container_properties, @container do
+          assert @directory.save(options)
+          assert @directory.attributes[:is_persisted]
+        end
       end
     end
   end
 
-  def test_delete_method_response_mock
-    assert @mock_directory.destroy
+  def test_save_method_without_key_exception
+    @directory.attributes.delete(:key)
+    assert_raises(ArgumentError) do
+      @directory.save
+    end
+  end
+
+  def test_persisted_method_success
+    @directory.attributes[:is_persisted] = true
+    @directory.attributes[:last_modified] = nil
+    assert @directory.persisted?
+
+    @directory.attributes[:is_persisted] = false
+    @directory.attributes[:last_modified] = 'datetime'
+    assert @directory.persisted?
+
+    @directory.attributes[:is_persisted] = false
+    @directory.attributes[:last_modified] = nil
+    assert !@directory.persisted?
   end
 end

data/test/models/storage/test_file.rb

@@ -3,31 +3,29 @@ require File.expand_path '../../test_helper', __dir__
 # Test class for Storage Container Model
 class TestFile < Minitest::Test
   def setup
-    Fog.mock!
-    @mock_service = Fog::Storage::AzureRM.new(storage_account_credentials)
-    @mock_file = storage_blob(@mock_service)
-    Fog.unmock!
     @service = Fog::Storage::AzureRM.new(storage_account_credentials)
-    @file = storage_blob(@service)
-    @cloud_blob = storage_cloud_blob
-    @blob_client = @service.instance_variable_get(:@blob_client)
+    @directory = directory(@service)
+    @file = file(@service)
+    @raw_cloud_blob = storage_blob
+
     @mocked_response = mocked_storage_http_error
-    @content = Array.new(1024 * 1024) { 'a' }.join
-    @get_metadata_result = ApiStub::Models::Storage::File.test_get_blob_metadata
-    @create_result = ApiStub::Models::Storage::File.upload_block_blob_from_file
-    @download_result = ApiStub::Models::Storage::File.download_blob_to_file
-    @get_properties_result = ApiStub::Models::Storage::File.get_blob_properties
+    @blob = ApiStub::Models::Storage::File.blob
+    @metadata = ApiStub::Models::Storage::File.blob_metadata
+    @blob_list = ApiStub::Models::Storage::File.blob_list
+    @blob_https_url = ApiStub::Models::Storage::File.blob_https_url
   end
 
   def test_model_methods
     methods = [
       :save,
-      :save_to_file,
-      :get_properties,
-      :set_properties,
-      :set_metadata,
-      :get_metadata,
-      :destroy
+      :body,
+      :body=,
+      :copy,
+      :copy_from_uri,
+      :destroy,
+      :public?,
+      :public_url,
+      :url
     ]
     methods.each do |method|
       assert_respond_to @file, method
@@ -37,14 +35,15 @@ class TestFile < Minitest::Test
   def test_model_attributes
     attributes = [
       :key,
+      :body,
+      :directory,
       :accept_ranges,
-      :cache_control,
-      :committed_block_count,
       :content_length,
       :content_type,
       :content_md5,
       :content_encoding,
       :content_language,
+      :cache_control,
       :content_disposition,
       :copy_completion_time,
       :copy_status,
@@ -52,207 +51,244 @@ class TestFile < Minitest::Test
       :copy_id,
       :copy_progress,
       :copy_source,
-      :directory,
       :etag,
-      :file_path,
       :last_modified,
       :lease_duration,
       :lease_state,
       :lease_status,
-      :metadata,
       :sequence_number,
-      :blob_type
+      :blob_type,
+      :metadata
     ]
     attributes.each do |attribute|
       assert_respond_to @file, attribute
     end
   end
 
-  def test_save_method_response
-    @file.file_path = 'test.txt'
-    @service.stub :upload_block_blob_from_file, @create_result do
-      assert_instance_of Fog::Storage::AzureRM::File, @file.save
-    end
-    @service.stub :upload_block_blob_from_file, @create_result do
-      assert_instance_of Fog::Storage::AzureRM::File, @file.create
+  def test_save_method_with_small_block_blob_success
+    @file.body = 'd' * 1025 # SINGLE_BLOB_PUT_THRESHOLD is 32 * 1024 * 1024
+
+    @service.stub :create_block_blob, @raw_cloud_blob do
+      assert @file.save
     end
   end
 
-  def test_save_small_blob_method_response
-    small_file_name = 'small_test_file.dat'
-    small_file = File.new(small_file_name, 'w')
-    small_file.puts(@content)
-    small_file.close
-    @file.file_path = small_file_name
-    @blob_client.stub :create_block_blob, @create_result do
-      assert_instance_of Fog::Storage::AzureRM::File, @file.create
-    end
-    io_exception = -> (_container_name, _blob_name, _file_path, _option) { raise IOError.new }
-    @blob_client.stub :create_block_blob, io_exception do
-      assert_raises(RuntimeError) do
-        @file.create
-      end
-    end
-    http_exception = -> (_container_name, _blob_name, _file_path, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :create_block_blob, http_exception do
-      assert_raises(RuntimeError) do
-        @file.create
+  def test_save_method_with_large_block_blob_success
+    @file.body = 'd' * (32 * 1024 * 1024 + 1) # SINGLE_BLOB_PUT_THRESHOLD is 32 * 1024 * 1024
+
+    @service.stub :multipart_save_block_blob, true do
+      @service.stub :get_blob_properties, @raw_cloud_blob do
+        assert @file.save
       end
     end
-    File.delete(small_file_name)
   end
 
-  def test_save_large_blob_method_response
-    large_file_name = 'large_test_file.dat'
-    large_file = File.new(large_file_name, 'w')
-    33.times do
-      large_file.puts(@content)
-    end
-    large_file.close
-    @file.file_path = large_file_name
-    @blob_client.stub :put_blob_block, true do
-      @blob_client.stub :commit_blob_blocks, @create_result do
-        assert_instance_of Fog::Storage::AzureRM::File, @file.create
+  def test_save_method_with_page_blob_success
+    options = { blob_type: 'PageBlob' }
+    @file.metadata = @metadata
+    @file.body = 'd' * 5 * 1024 * 1024 # MAXIMUM_CHUNK_SIZE is 4 * 1024 * 1024
+
+    @service.stub :save_page_blob, true do
+      @service.stub :get_blob_properties, @raw_cloud_blob do
+        assert @file.save(options)
       end
     end
-    File.delete(large_file_name)
   end
 
-  def test_save_method_response_mock
-    @mock_file.file_path = 'mock_test.txt'
-    assert_instance_of Fog::Storage::AzureRM::File, @mock_file.save
+  def test_save_method_with_not_update_body_success
+    options = { update_body: false }
+    @file.metadata = @metadata
+
+    @service.stub :put_blob_metadata, true do
+      @service.stub :put_blob_properties, true do
+        @service.stub :get_blob_properties, @raw_cloud_blob do
+          assert @file.save(options)
+        end
+      end
+    end
   end
 
-  def test_save_to_file
-    @service.stub :download_blob_to_file, @download_result do
-      assert_instance_of Fog::Storage::AzureRM::File, @file.save_to_file('test.txt')
+  def test_save_method_without_directory_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:directory)
+      @file.save
     end
   end
 
-  def test_save_to_file_io_exception
-    io_exception = -> (_container_name, _blob_name, _option) { raise IOError.new }
-    @blob_client.stub :get_blob, io_exception do
-      assert_raises(RuntimeError) do
-        @file.save_to_file('test.txt')
-      end
+  def test_save_method_without_key_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:key)
+      @file.save
     end
   end
 
-  def test_save_to_file_http_exception
-    http_exception = -> (_container_name, _blob_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :get_blob, http_exception do
-      assert_raises(RuntimeError) do
-        @file.save_to_file('test.txt')
-      end
+  def test_save_method_create_without_body_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:body)
+      @file.save
     end
   end
 
-  def test_save_to_file_mock
-    assert_instance_of Fog::Storage::AzureRM::File, @mock_file.save_to_file('test.txt')
+  def test_get_body_method_local_success
+    @file.attributes[:body] = 'body'
+    assert_equal 'body', @file.body
+
+    @file.attributes[:body] = nil
+    @file.attributes[:last_modified] = nil
+    assert_equal '', @file.body
   end
 
-  def test_get_blob_properties
-    @service.stub :get_blob_properties, @get_properties_result do
-      assert_instance_of Fog::Storage::AzureRM::File, @file.get_properties
+  def test_get_body_method_remote_success
+    @file.attributes[:body] = nil
+    remote_file = @file.dup
+    body_content = 'data'
+    @file.collection.stub :get, remote_file do
+      remote_file.stub :body, body_content do
+        body = @file.body
+        assert_equal body_content, body
+        assert_equal body_content, @file.attributes[:body]
+      end
     end
   end
 
-  def test_get_cloud_blob_properties
-    @service.stub :get_blob_properties, @cloud_blob do
-      assert_instance_of Fog::Storage::AzureRM::File, @file.get_properties
+  def test_get_body_method_remote_not_found_success
+    @file.attributes[:body] = nil
+    @file.collection.stub :get, nil do
+      body = @file.body
+      assert_equal '', body
+      assert_equal '', @file.attributes[:body]
     end
   end
 
-  def test_get_blob_properties_http_exception
-    http_exception = -> (_container_name, _blob_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :get_blob_properties, http_exception do
-      assert_raises(RuntimeError) do
-        @file.get_properties
+  def test_set_body_method_success
+    @file.body = 'new_body'
+    assert_equal 'new_body', @file.attributes[:body]
+  end
+
+  def test_copy_method_success
+    copy_id = @raw_cloud_blob.properties[:copy_id]
+    copy_status = 'pending'
+
+    @service.stub :get_blob_properties, @raw_cloud_blob do
+      @service.stub :copy_blob, [copy_id, copy_status] do
+        @service.stub :wait_blob_copy_operation_to_finish, true do
+          target_file = @file.copy('target_container', 'target_blob')
+          assert_instance_of Fog::Storage::AzureRM::File, target_file
+        end
       end
     end
   end
 
-  def test_get_blob_properties_mock
-    assert_instance_of Fog::Storage::AzureRM::File, @mock_file.get_properties
+  def test_copy_from_uri_method_success
+    copy_id = @raw_cloud_blob.properties[:copy_id]
+    copy_status = 'pending'
+
+    @service.stub :get_blob_properties, @raw_cloud_blob do
+      @service.stub :copy_blob_from_uri, [copy_id, copy_status] do
+        @service.stub :wait_blob_copy_operation_to_finish, true do
+          assert @file.copy_from_uri('source_uri')
+        end
+      end
+    end
   end
 
-  def test_set_blob_properties
-    @service.stub :set_blob_properties, true do
-      assert @file.set_properties
+  def test_copy_from_uri_method_without_directory_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:directory)
+      @file.copy_from_uri('source_uri')
     end
   end
 
-  def test_set_blob_properties_http_exception
-    http_exception = -> (_container_name, _blob_name, _properties) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :set_blob_properties, http_exception do
-      assert_raises(RuntimeError) do
-        @file.set_properties
-      end
+  def test_copy_from_uri_method_without_key_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:key)
+      @file.copy_from_uri('source_uri')
     end
   end
 
-  def test_set_blob_properties_mock
-    assert @mock_file.set_properties
+  def test_destroy_method_success
+    @service.stub :delete_blob, true do
+      assert @file.destroy
+      assert @file.attributes[:body].nil?
+    end
   end
 
-  def test_get_blob_metadata
-    @service.stub :get_blob_metadata, @get_metadata_result do
-      file = @file.get_metadata
-      assert_instance_of Fog::Storage::AzureRM::File, file
-      assert_equal @get_metadata_result, file.metadata
+  def test_destroy_method_without_directory_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:directory)
+      @file.destroy
     end
   end
 
-  def test_get_blob_metadata_http_exception
-    http_exception = -> (_container_name, _blob_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :get_blob_metadata, http_exception do
-      assert_raises(RuntimeError) do
-        @file.get_metadata
-      end
+  def test_destroy_method_without_key_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:key)
+      @file.destroy
     end
   end
 
-  def test_get_blob_metadata_mock
-    blob = @mock_file.get_metadata
-    assert_instance_of Fog::Storage::AzureRM::File, blob
-    assert_equal @get_metadata_result, blob.metadata
+  def test_public_method_success
+    @file.directory.acl = 'container'
+    assert @file.public?
+
+    @file.directory.acl = 'blob'
+    assert @file.public?
+
+    @file.directory.acl = nil
+    assert !@file.public?
   end
 
-  def test_set_blob_metadata
-    @service.stub :set_blob_metadata, true do
-      assert @file.set_metadata(@get_metadata_result)
+  def test_public_method_without_directory_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:directory)
+      @file.public?
     end
   end
 
-  def test_set_blob_metadata_http_exception
-    http_exception = -> (_container_name, _blob_name, _metadata, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :set_blob_metadata, http_exception do
-      assert_raises(RuntimeError) do
-        @file.set_metadata @get_metadata_result
+  def test_public_url_method_success
+    @file.stub :public?, false do
+      assert @file.public_url.nil?
+    end
+
+    @file.stub :public?, true do
+      @service.stub :get_blob_url, @blob_https_url do
+        assert @file.public_url, @blob_https_url
+      end
+    end
+
+    http_url = @blob_https_url.gsub('https:', 'http:')
+    options = { scheme: 'https' }
+    @file.stub :public?, true do
+      @service.stub :get_blob_url, http_url do
+        assert @file.public_url(options), http_url
       end
     end
   end
 
-  def test_set_blob_metadata_mock
-    assert @mock_file.set_metadata(@get_metadata_result)
+  def test_public_url_method_without_directory_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:directory)
+      @file.public_url
+    end
   end
 
-  def test_delete_method_true_response
-    @service.stub :delete_blob, true do
-      assert @file.destroy
+  def test_public_url_method_without_key_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:key)
+      @file.public_url
     end
   end
 
-  def test_delete_method_exception
-    exception = -> (_container_name, _blob_name, _option) { raise Azure::Core::Http::HTTPError.new(@mocked_response) }
-    @blob_client.stub :delete_blob, exception do
-      assert_raises(RuntimeError) do
-        assert @file.destroy
-      end
+  def test_url_method_success
+    @file.collection.stub :get_url, @blob_https_url do
+      assert @file.url(Time.now + 3600), @blob_https_url
     end
   end
 
-  def test_delete_method_response_mock
-    assert @mock_file.destroy
+  def test_url_method_without_key_exception
+    assert_raises(ArgumentError) do
+      @file.attributes.delete(:key)
+      @file.url(Time.now + 3600)
+    end
   end
 end