fog-azure-rm 0.0.4 → 0.0.5

data/test/models/{network → traffic_manager}/test_traffic_manager_profile.rb

@@ -3,8 +3,10 @@ require File.expand_path '../../test_helper', __dir__
 # Test class for Traffic Manager Profile Model
 class TestTrafficManagerProfile < Minitest::Test
   def setup
-    @service = Fog::Network::AzureRM.new(credentials)
+    @service = Fog::TrafficManager::AzureRM.new(credentials)
     @traffic_manager_profile = traffic_manager_profile(@service)
+    traffic_manager_client = @service.instance_variable_get(:@traffic_mgmt_client)
+    @traffic_manager_profile_response = ApiStub::Models::TrafficManager::TrafficManagerProfile.traffic_manager_profile_response(traffic_manager_client)
   end
 
   def test_model_methods
@@ -40,9 +42,8 @@ class TestTrafficManagerProfile < Minitest::Test
   end
 
   def test_save_method_response
-    response = ApiStub::Models::Network::TrafficManagerProfile.traffic_manager_profile_response
-    @service.stub :create_traffic_manager_profile, response do
-      assert_instance_of Fog::Network::AzureRM::TrafficManagerProfile, @traffic_manager_profile.save
+    @service.stub :create_traffic_manager_profile, @traffic_manager_profile_response do
+      assert_instance_of Fog::TrafficManager::AzureRM::TrafficManagerProfile, @traffic_manager_profile.save
     end
   end
 

data/test/models/traffic_manager/test_traffic_manager_profiles.rb

@@ -0,0 +1,42 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for Traffic Manager Profile Collection
+class TestTrafficManagerProfiles < Minitest::Test
+  def setup
+    @service = Fog::TrafficManager::AzureRM.new(credentials)
+    @traffic_manager_profiles = Fog::TrafficManager::AzureRM::TrafficManagerProfiles.new(resource_group: 'fog-test-rg', service: @service)
+    traffic_manager_client = @service.instance_variable_get(:@traffic_mgmt_client)
+    @profiles_list = [ApiStub::Models::TrafficManager::TrafficManagerProfile.traffic_manager_profile_response(traffic_manager_client)]
+    @profile = ApiStub::Models::TrafficManager::TrafficManagerProfile.traffic_manager_profile_response(traffic_manager_client)
+  end
+
+  def test_collection_methods
+    methods = [
+      :all,
+      :get
+    ]
+    methods.each do |method|
+      assert @traffic_manager_profiles.respond_to? method
+    end
+  end
+
+  def test_collection_attributes
+    assert @traffic_manager_profiles.respond_to? :resource_group
+  end
+
+  def test_all_method_response
+    @service.stub :list_traffic_manager_profiles, @profiles_list do
+      assert_instance_of Fog::TrafficManager::AzureRM::TrafficManagerProfiles, @traffic_manager_profiles.all
+      assert @traffic_manager_profiles.all.size >= 1
+      @traffic_manager_profiles.all.each do |endpoint|
+        assert_instance_of Fog::TrafficManager::AzureRM::TrafficManagerProfile, endpoint
+      end
+    end
+  end
+
+  def test_get_method_response
+    @service.stub :get_traffic_manager_profile, @profile do
+      assert_instance_of Fog::TrafficManager::AzureRM::TrafficManagerProfile, @traffic_manager_profiles.get('resource-group-name', 'fog-test-profile-name')
+    end
+  end
+end

data/test/requests/application_gateway/test_create_application_gateway.rb

@@ -0,0 +1,51 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for Create Application Gateway Request
+class TestCreateApplicationGateway < Minitest::Test
+  def setup
+    @service = Fog::ApplicationGateway::AzureRM.new(credentials)
+    gateway_client = @service.instance_variable_get(:@network_client)
+    @gateways = gateway_client.application_gateways
+    @response = ApiStub::Requests::ApplicationGateway::Gateway.create_application_gateway_response(gateway_client)
+  end
+
+  def test_create_application_gateway_success
+    gateway_ip_configurations = ApiStub::Requests::ApplicationGateway::Gateway.gateway_ip_configurations
+    frontend_ip_configurations = ApiStub::Requests::ApplicationGateway::Gateway.frontend_ip_configurations
+    frontend_ports = ApiStub::Requests::ApplicationGateway::Gateway.frontend_ports
+    backend_address_pools = ApiStub::Requests::ApplicationGateway::Gateway.backend_address_pools
+    backend_http_settings_list = ApiStub::Requests::ApplicationGateway::Gateway.backend_http_settings_list
+    http_listeners = ApiStub::Requests::ApplicationGateway::Gateway.http_listeners
+    request_routing_rules = ApiStub::Requests::ApplicationGateway::Gateway.request_routing_rules
+    @gateways.stub :create_or_update, @response do
+      assert_equal @service.create_application_gateway('gateway', 'East US', 'fogRM-rg', 'Standard_Medium', 'Standard', 2, gateway_ip_configurations, nil, frontend_ip_configurations, frontend_ports, nil, backend_address_pools, backend_http_settings_list, http_listeners, nil, request_routing_rules), @response
+    end
+  end
+
+  def test_create_application_gateway_argument_error_failure
+    @gateways.stub :create_or_update, @response do
+      assert_raises ArgumentError do
+        @service.create_application_gateway('gateway', 'East US', 'fogRM-rg', 'Standard_Medium', 'Standard', 2)
+      end
+    end
+  end
+
+  def test_create_application_gateway_exception_failure
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    gateway_ip_configurations = ApiStub::Requests::ApplicationGateway::Gateway.gateway_ip_configurations
+    ssl_certificates = ApiStub::Requests::ApplicationGateway::Gateway.ssl_certificates
+    frontend_ip_configurations = ApiStub::Requests::ApplicationGateway::Gateway.frontend_ip_configurations
+    frontend_ports = ApiStub::Requests::ApplicationGateway::Gateway.frontend_ports
+    probes = ApiStub::Requests::ApplicationGateway::Gateway.probes
+    backend_address_pools = ApiStub::Requests::ApplicationGateway::Gateway.backend_address_pools
+    backend_http_settings_list = ApiStub::Requests::ApplicationGateway::Gateway.backend_http_settings_list
+    http_listeners = ApiStub::Requests::ApplicationGateway::Gateway.http_listeners
+    url_path_paths = ApiStub::Requests::ApplicationGateway::Gateway.url_path_maps
+    request_routing_rules = ApiStub::Requests::ApplicationGateway::Gateway.request_routing_rules
+    @gateways.stub :create_or_update, response do
+      assert_raises RuntimeError do
+        @service.create_application_gateway('gateway', 'East US', 'fogRM-rg', 'Standard_Medium', 'Standard', 2, gateway_ip_configurations, ssl_certificates, frontend_ip_configurations, frontend_ports, probes, backend_address_pools, backend_http_settings_list, http_listeners, url_path_paths, request_routing_rules)
+      end
+    end
+  end
+end

data/test/requests/application_gateway/test_delete_application_gateway.rb

@@ -0,0 +1,23 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for Delete Application Gateway Request
+class TestDeleteApplicationGateway < Minitest::Test
+  def setup
+    @service = Fog::ApplicationGateway::AzureRM.new(credentials)
+    gateway_client = @service.instance_variable_get(:@network_client)
+    @gateways = gateway_client.application_gateways
+  end
+
+  def test_delete_application_gateway_success
+    @gateways.stub :delete, true do
+      assert @service.delete_application_gateway('fogRM-rg', 'gateway'), true
+    end
+  end
+
+  def test_delete_application_gateway_failure
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @gateways.stub :delete, response do
+      assert_raises(RuntimeError) { @service.delete_application_gateway('fogRM-rg', 'gateway') }
+    end
+  end
+end

data/test/requests/application_gateway/test_list_application_gateways.rb

@@ -0,0 +1,24 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for List Application Gateway Request
+class TestListApplicationGateways < Minitest::Test
+  def setup
+    @service = Fog::ApplicationGateway::AzureRM.new(credentials)
+    @gateway_client = @service.instance_variable_get(:@network_client)
+    @gateways = @gateway_client.application_gateways
+  end
+
+  def test_list_application_gateways_success
+    mocked_response = ApiStub::Requests::ApplicationGateway::Gateway.list_application_gateway_response(@gateway_client)
+    @gateways.stub :list_as_lazy, mocked_response do
+      assert_equal @service.list_application_gateways('fogRM-rg'), mocked_response.value
+    end
+  end
+
+  def test_list_application_gateways_failure
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @gateways.stub :list_as_lazy, response do
+      assert_raises(RuntimeError) { @service.list_application_gateways('fogRM-rg') }
+    end
+  end
+end

data/test/requests/compute/test_attach_data_disk_to_vm.rb

@@ -4,37 +4,21 @@ require File.expand_path '../../test_helper', __dir__
 class TestAttachDataDiskToVM < Minitest::Test
   def setup
     @service = Fog::Compute::AzureRM.new(credentials)
-    vm_client = @service.instance_variable_get(:@compute_mgmt_client)
+    @compute_client = @service.instance_variable_get(:@compute_mgmt_client)
     storage_client = @service.instance_variable_get(:@storage_mgmt_client)
-    @virtual_machines = vm_client.virtual_machines
+    @virtual_machines = @compute_client.virtual_machines
     @storage_accounts = storage_client.storage_accounts
+    @get_vm_response = ApiStub::Requests::Compute::VirtualMachine.create_virtual_machine_response(@compute_client)
+    @update_vm_response = ApiStub::Requests::Compute::VirtualMachine.update_virtual_machine_response(@compute_client)
+    @storage_access_keys_response = ApiStub::Requests::Storage::StorageAccount.list_keys_response
   end
 
   def test_attach_data_disk_to_vm_success
-    promise_get_vm = Concurrent::Promise.execute do
-    end
-
-    promise_update_vm = Concurrent::Promise.execute do
-    end
-
-    promise_storage_access_keys = Concurrent::Promise.execute do
-    end
-
-    get_vm_response = ApiStub::Requests::Compute::VirtualMachine.create_virtual_machine_response
-    update_vm_response = ApiStub::Requests::Compute::VirtualMachine.update_virtual_machine_response
-    expected_update_vm_response = Azure::ARM::Compute::Models::VirtualMachine.serialize_object(update_vm_response.body)
-    storage_access_keys_response = ApiStub::Requests::Storage::StorageAccount.list_keys_response
-    promise_get_vm.stub :value!, get_vm_response do
-      @virtual_machines.stub :get, promise_get_vm do
-        promise_storage_access_keys.stub :value!, storage_access_keys_response do
-          @storage_accounts.stub :list_keys, promise_storage_access_keys do
-            promise_update_vm.stub :value!, update_vm_response do
-              @virtual_machines.stub :create_or_update, promise_update_vm do
-                @service.stub :check_blob_exist, true do
-                  assert_equal @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1'), expected_update_vm_response
-                end
-              end
-            end
+    @virtual_machines.stub :get, @get_vm_response do
+      @storage_accounts.stub :list_keys, @storage_access_keys_response do
+        @virtual_machines.stub :create_or_update, @update_vm_response do
+          @service.stub :check_blob_exist, true do
+            assert_equal @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1'), @update_vm_response
           end
         end
       end
@@ -42,30 +26,13 @@ class TestAttachDataDiskToVM < Minitest::Test
   end
 
   def test_attach_data_disk_to_vm_failure
-    promise_get_vm = Concurrent::Promise.execute do
-    end
-
-    promise_update_vm = Concurrent::Promise.execute do
-    end
-
-    promise_storage_access_keys = Concurrent::Promise.execute do
-    end
-
-    get_vm_response = ApiStub::Requests::Compute::VirtualMachine.virtual_machine_15_data_disks_response
-    update_vm_response = ApiStub::Requests::Compute::VirtualMachine.update_virtual_machine_response
-    storage_access_keys_response = ApiStub::Requests::Storage::StorageAccount.list_keys_response
-    promise_get_vm.stub :value!, get_vm_response do
-      @virtual_machines.stub :get, promise_get_vm do
-        promise_storage_access_keys.stub :value!, storage_access_keys_response do
-          @storage_accounts.stub :list_keys, promise_storage_access_keys do
-            promise_update_vm.stub :value!, update_vm_response do
-              @virtual_machines.stub :create_or_update, promise_update_vm do
-                @service.stub :check_blob_exist, true do
-                  assert_raises RuntimeError do
-                    @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
-                  end
-                end
-              end
+    get_vm_response = ApiStub::Requests::Compute::VirtualMachine.virtual_machine_15_data_disks_response(@compute_client)
+    @virtual_machines.stub :get, get_vm_response do
+      @storage_accounts.stub :list_keys, @storage_access_keys_response do
+        @virtual_machines.stub :create_or_update, @update_vm_response do
+          @service.stub :check_blob_exist, true do
+            assert_raises RuntimeError do
+              @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
             end
           end
         end
@@ -74,30 +41,13 @@ class TestAttachDataDiskToVM < Minitest::Test
   end
 
   def test_update_vm_failure
-    promise_get_vm = Concurrent::Promise.execute do
-    end
-
-    promise_update_vm = Concurrent::Promise.execute do
-    end
-
-    promise_storage_access_keys = Concurrent::Promise.execute do
-    end
-
-    get_vm_response = ApiStub::Requests::Compute::VirtualMachine.create_virtual_machine_response
-    update_vm_response = -> { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    storage_access_keys_response = ApiStub::Requests::Storage::StorageAccount.list_keys_response
-    promise_get_vm.stub :value!, get_vm_response do
-      @virtual_machines.stub :get, promise_get_vm do
-        promise_storage_access_keys.stub :value!, storage_access_keys_response do
-          @storage_accounts.stub :list_keys, promise_storage_access_keys do
-            promise_update_vm.stub :value!, update_vm_response do
-              @virtual_machines.stub :create_or_update, promise_update_vm do
-                @service.stub :check_blob_exist, true do
-                  assert_raises RuntimeError do
-                    @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
-                  end
-                end
-              end
+    update_vm_response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @virtual_machines.stub :get, @get_vm_response do
+      @storage_accounts.stub :list_keys, @storage_access_keys_response do
+        @virtual_machines.stub :create_or_update, update_vm_response do
+          @service.stub :check_blob_exist, true do
+            assert_raises RuntimeError do
+              @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
             end
           end
         end
@@ -106,30 +56,13 @@ class TestAttachDataDiskToVM < Minitest::Test
   end
 
   def test_update_vm_blob_not_exist_failure
-    promise_get_vm = Concurrent::Promise.execute do
-    end
-
-    promise_update_vm = Concurrent::Promise.execute do
-    end
-
-    promise_storage_access_keys = Concurrent::Promise.execute do
-    end
-
-    get_vm_response = ApiStub::Requests::Compute::VirtualMachine.create_virtual_machine_response
-    update_vm_response = -> { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    storage_access_keys_response = ApiStub::Requests::Storage::StorageAccount.list_keys_response
-    promise_get_vm.stub :value!, get_vm_response do
-      @virtual_machines.stub :get, promise_get_vm do
-        promise_storage_access_keys.stub :value!, storage_access_keys_response do
-          @storage_accounts.stub :list_keys, promise_storage_access_keys do
-            promise_update_vm.stub :value!, update_vm_response do
-              @virtual_machines.stub :create_or_update, promise_update_vm do
-                @service.stub :check_blob_exist, false do
-                  assert_raises RuntimeError do
-                    @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
-                  end
-                end
-              end
+    update_vm_response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @virtual_machines.stub :get, @get_vm_response do
+      @storage_accounts.stub :list_keys, @storage_access_keys_response do
+        @virtual_machines.stub :create_or_update, update_vm_response do
+          @service.stub :check_blob_exist, false do
+            assert_raises RuntimeError do
+              @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
             end
           end
         end
@@ -138,36 +71,20 @@ class TestAttachDataDiskToVM < Minitest::Test
   end
 
   def test_get_vm_failure
-    promise_get_vm = Concurrent::Promise.execute do
-    end
-
-    get_vm_response = -> { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    promise_get_vm.stub :value!, get_vm_response do
-      @virtual_machines.stub :get, promise_get_vm do
-        assert_raises RuntimeError do
-          @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
-        end
+    get_vm_response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @virtual_machines.stub :get, get_vm_response do
+      assert_raises RuntimeError do
+        @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
       end
     end
   end
 
   def test_get_storage_key_failure
-    promise_get_vm = Concurrent::Promise.execute do
-    end
-
-    promise_storage_access_keys = Concurrent::Promise.execute do
-    end
-
-    get_vm_response = ApiStub::Requests::Compute::VirtualMachine.create_virtual_machine_response
-    storage_access_keys_response = -> { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    promise_get_vm.stub :value!, get_vm_response do
-      @virtual_machines.stub :get, promise_get_vm do
-        promise_storage_access_keys.stub :value!, storage_access_keys_response do
-          @storage_accounts.stub :list_keys, promise_storage_access_keys do
-            assert_raises RuntimeError do
-              @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
-            end
-          end
+    storage_access_keys_response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @virtual_machines.stub :get, @get_vm_response do
+      @storage_accounts.stub :list_keys, storage_access_keys_response do
+        assert_raises RuntimeError do
+          @service.attach_data_disk_to_vm('fog-test-rg', 'fog-test-vm', 'disk1', 1, 'mystorage1')
         end
       end
     end

data/test/requests/compute/test_create_availability_set.rb

@@ -4,25 +4,23 @@ require File.expand_path '../../test_helper', __dir__
 class TestCreateAvailabilitySet < Minitest::Test
   def setup
     @service = Fog::Compute::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@compute_mgmt_client)
-    @availability_sets = client.availability_sets
-    @promise = Concurrent::Promise.execute do
-    end
+    @client = @service.instance_variable_get(:@compute_mgmt_client)
+    @availability_sets = @client.availability_sets
   end
 
   def test_create_availability_set_success
-    response = ApiStub::Requests::Compute::AvailabilitySet.create_availability_set_response
-    @promise.stub :value!, response do
-      @availability_sets.stub :create_or_update, @promise do
-        assert_equal @service.create_availability_set('fog-test-rg', 'fog-test-as', 'west us'), Azure::ARM::Compute::Models::AvailabilitySet.serialize_object(response.body)
+    mocked_response = ApiStub::Requests::Compute::AvailabilitySet.create_availability_set_response(@client)
+    @availability_sets.stub :validate_params, true do
+      @availability_sets.stub :create_or_update, mocked_response do
+        assert_equal @service.create_availability_set('fog-test-rg', 'myavset1', 'west us'), mocked_response
       end
     end
   end
 
   def test_create_availability_set_failure
-    response = -> { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    @promise.stub :value!, response do
-      @availability_sets.stub :create_or_update, @promise do
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @availability_sets.stub :validate_params, true do
+      @availability_sets.stub :create_or_update, response do
         assert_raises(RuntimeError) { @service.create_availability_set('fog-test-rg', 'fog-test-as', 'west us') }
       end
     end

data/test/requests/compute/test_create_virtual_machine.rb

@@ -4,46 +4,30 @@ require File.expand_path '../../test_helper', __dir__
 class TestCreateVirtualMachine < Minitest::Test
   def setup
     @service = Fog::Compute::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@compute_mgmt_client)
-    @virtual_machines = client.virtual_machines
-    @promise = Concurrent::Promise.execute do
-    end
+    compute_client = @service.instance_variable_get(:@compute_mgmt_client)
+    @virtual_machines = compute_client.virtual_machines
+    @linux_virtual_machine_hash = ApiStub::Requests::Compute::VirtualMachine.linux_virtual_machine_hash
+    @windows_virtual_machine_hash = ApiStub::Requests::Compute::VirtualMachine.windows_virtual_machine_hash
+    @response = ApiStub::Requests::Compute::VirtualMachine.create_virtual_machine_response(compute_client)
   end
 
   def test_create_linux_virtual_machine_success
-    response = ApiStub::Requests::Compute::VirtualMachine.create_virtual_machine_response
-    @promise.stub :value!, response do
-      @virtual_machines.stub :create_or_update, @promise do
-        assert_equal @service.create_virtual_machine('fog-test-rg', 'fog-test-server', 'westus', 'Basic_A0',
-                                                     'fogstrg', 'fog', 'fog', false, '/home', 'key', 'nic-id',
-                                                     'as-id', 'Canonical', 'UbuntuServer', '14.04.2-LTS', 'latest', 'Linux', nil, nil),
-                     Azure::ARM::Compute::Models::VirtualMachine.serialize_object(response.body)
-      end
+    @virtual_machines.stub :create_or_update, @response do
+      assert_equal @service.create_virtual_machine(@linux_virtual_machine_hash), @response
     end
   end
 
   def test_create_windows_virtual_machine_success
-    response = ApiStub::Requests::Compute::VirtualMachine.create_virtual_machine_response
-    @promise.stub :value!, response do
-      @virtual_machines.stub :create_or_update, @promise do
-        assert_equal @service.create_virtual_machine('fog-test-rg', 'fog-test-server', 'westus', 'Basic_A0',
-                                                     'fogstrg', 'fog', 'fog', nil, '/home', 'key', 'nic-id',
-                                                     'as-id', 'MicrosoftWindowsServerEssentials', 'WindowsServerEssentials',
-                                                     'WindowsServerEssentials', 'latest', 'Windows', true, true),
-                     Azure::ARM::Compute::Models::VirtualMachine.serialize_object(response.body)
-      end
+    @virtual_machines.stub :create_or_update, @response do
+      assert_equal @service.create_virtual_machine(@windows_virtual_machine_hash), @response
     end
   end
 
   def test_create_virtual_machine_failure
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    @promise.stub :value!, response do
-      @virtual_machines.stub :create_or_update, @promise do
-        assert_raises RuntimeError do
-          @service.create_virtual_machine('fog-test-rg', 'fog-test-server', 'westus', 'Basic_A0', 'fogstrg', 'fog',
-                                          'fog', false, '/home', 'key', 'nic-id', 'as-id', 'Canonical',
-                                          'UbuntuServer', '14.04.2-LTS', 'latest', 'Linux', nil, nil)
-        end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @virtual_machines.stub :create_or_update, response do
+      assert_raises RuntimeError do
+        @service.create_virtual_machine(@linux_virtual_machine_hash)
       end
     end
   end