fog-azure-rm 0.0.4 → 0.0.5

data/test/requests/network/test_add_subnets_in_virtual_network.rb

@@ -4,41 +4,25 @@ require File.expand_path '../../test_helper', __dir__
 class TestAddSubnetsInVirtualNetwork < Minitest::Test
   def setup
     @service = Fog::Network::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@network_client)
-    @virtual_networks = client.virtual_networks
+    @network_client = @service.instance_variable_get(:@network_client)
+    @virtual_networks = @network_client.virtual_networks
   end
 
   def test_add_subnets_in_virtual_network_success
-    promise_get = Concurrent::Promise.execute do
-    end
-    promise_create = Concurrent::Promise.execute do
-    end
-
-    mocked_response = ApiStub::Requests::Network::VirtualNetwork.create_virtual_network_response
-    expected_response = ApiStub::Requests::Network::VirtualNetwork.create_virtual_network_response
-    expected_response = Azure::ARM::Network::Models::VirtualNetwork.serialize_object(expected_response.body)
-    expected_response['properties']['subnets'].unshift('properties' => { 'addressPrefix' => '10.0.0.0/16' }, 'name' => 'test-subnet')
-
-    promise_get.stub :value!, mocked_response do
-      promise_create.stub :value!, mocked_response do
-        @virtual_networks.stub :get, promise_get do
-          @virtual_networks.stub :create_or_update, promise_create do
-            assert_equal @service.add_subnets_in_virtual_network('fog-test-rg', 'fog-test-virtual-network', [{ name: 'test-subnet', address_prefix: '10.0.0.0/16' }]), expected_response
-          end
-        end
+    mocked_response = ApiStub::Requests::Network::VirtualNetwork.create_virtual_network_response(@network_client)
+    mocked_response.subnets.unshift('properties' => { 'addressPrefix' => '10.0.0.0/16' }, 'name' => 'test-subnet')
+    @virtual_networks.stub :get, mocked_response do
+      @virtual_networks.stub :create_or_update, mocked_response do
+        assert_equal @service.add_subnets_in_virtual_network('fog-test-rg', 'fog-test-virtual-network', [{ name: 'test-subnet', address_prefix: '10.0.0.0/16' }]), mocked_response
       end
     end
   end
 
   def test_add_subnets_in_virtual_network_failure
-    promise = Concurrent::Promise.execute do
-    end
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    promise.stub :value!, response do
-      @virtual_networks.stub :get, promise do
-        assert_raises RuntimeError do
-          @service.add_subnets_in_virtual_network('fog-test-rg', 'fog-test-virtual-network', @subnets)
-        end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @virtual_networks.stub :get, response do
+      assert_raises RuntimeError do
+        @service.add_subnets_in_virtual_network('fog-test-rg', 'fog-test-virtual-network', @subnets)
       end
     end
   end

data/test/requests/network/test_attach_network_security_group_to_subnet.rb

@@ -4,29 +4,22 @@ require File.expand_path '../../test_helper', __dir__
 class TestAttachNetworkSecurityGroupToSubnet < Minitest::Test
   def setup
     @service = Fog::Network::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@network_client)
-    @subnets = client.subnets
-    @promise = Concurrent::Promise.execute do
-    end
+    @network_client = @service.instance_variable_get(:@network_client)
+    @subnets = @network_client.subnets
   end
 
   def test_attach_network_security_group_to_subnet_success
-    mocked_response = ApiStub::Requests::Network::Subnet.create_subnet_response
-    expected_response = Azure::ARM::Network::Models::Subnet.serialize_object(mocked_response.body)
-    @promise.stub :value!, mocked_response do
-      @subnets.stub :create_or_update, @promise do
-        assert_equal @service.attach_network_security_group_to_subnet('fog-test-rg', 'fog-test-subnet', 'fog-test-virtual-network', '10.1.0.0/24', 'nsg-id', 'table-id'), expected_response
-      end
+    mocked_response = ApiStub::Requests::Network::Subnet.create_subnet_response(@network_client)
+    @subnets.stub :create_or_update, mocked_response do
+      assert_equal @service.attach_network_security_group_to_subnet('fog-test-rg', 'fog-test-subnet', 'fog-test-virtual-network', '10.1.0.0/24', 'myNSG1', 'myRT1'), mocked_response
     end
   end
 
   def test_attach_network_security_group_to_subnet_failure
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    @promise.stub :value!, response do
-      @subnets.stub :create_or_update, @promise do
-        assert_raises RuntimeError do
-          @service.attach_network_security_group_to_subnet('fog-test-rg', 'fog-test-subnet', 'fog-test-virtual-network', '10.1.0.0/24', 'nsg-id', 'table-id')
-        end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @subnets.stub :create_or_update, response do
+      assert_raises RuntimeError do
+        @service.attach_network_security_group_to_subnet('fog-test-rg', 'fog-test-subnet', 'fog-test-virtual-network', '10.1.0.0/24', 'myNSG1', 'myRT1')
       end
     end
   end

data/test/requests/network/test_attach_resource_to_nic.rb

@@ -4,62 +4,40 @@ require File.expand_path '../../test_helper', __dir__
 class TestAttachResourceToNIC < Minitest::Test
   def setup
     @service = Fog::Network::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@network_client)
-    @network_interfaces = client.network_interfaces
+    @network_client = @service.instance_variable_get(:@network_client)
+    @network_interfaces = @network_client.network_interfaces
   end
 
   def test_attach_resources_to_nic_success
-    mocked_response = ApiStub::Requests::Network::NetworkInterface.create_network_interface_response
-    expected_response = Azure::ARM::Network::Models::NetworkInterface.serialize_object(mocked_response.body)
-
-    get_promise = Concurrent::Promise.execute do
-    end
-    create_promise = Concurrent::Promise.execute do
-    end
+    mocked_response = ApiStub::Requests::Network::NetworkInterface.create_network_interface_response(@network_client)
 
     # Attach Subnet
-    get_promise.stub :value!, mocked_response do
-      @network_interfaces.stub :get, get_promise do
-        create_promise.stub :value!, mocked_response do
-          @network_interfaces.stub :create_or_update, create_promise do
-            assert_equal @service.attach_resource_to_nic('fog-test-rg', 'fog-test-network-interface', 'Subnet', '/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/myvnet1/subnets/mysub1'), expected_response
-          end
-        end
+    @network_interfaces.stub :get, mocked_response do
+      @network_interfaces.stub :create_or_update, mocked_response do
+        assert_equal @service.attach_resource_to_nic('fog-test-rg', 'fog-test-network-interface', 'Subnet', '/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/myvnet1/subnets/mysub1'), mocked_response
       end
     end
 
     # Attach Public-IP
-    get_promise.stub :value!, mocked_response do
-      @network_interfaces.stub :get, get_promise do
-        create_promise.stub :value!, mocked_response do
-          @network_interfaces.stub :create_or_update, create_promise do
-            assert_equal @service.attach_resource_to_nic('fog-test-rg', 'fog-test-network-interface', 'Public-IP-Address', '/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/mypip1'), expected_response
-          end
-        end
+    @network_interfaces.stub :get, mocked_response do
+      @network_interfaces.stub :create_or_update, mocked_response do
+        assert_equal @service.attach_resource_to_nic('fog-test-rg', 'fog-test-network-interface', 'Public-IP-Address', '/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/mypip1'), mocked_response
       end
     end
 
     # Attach NSG
-    get_promise.stub :value!, mocked_response do
-      @network_interfaces.stub :get, get_promise do
-        create_promise.stub :value!, mocked_response do
-          @network_interfaces.stub :create_or_update, create_promise do
-            assert_equal @service.attach_resource_to_nic('fog-test-rg', 'fog-test-network-interface', 'Network-Security-Group', '/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/myNSG1'), expected_response
-          end
-        end
+    @network_interfaces.stub :get, mocked_response do
+      @network_interfaces.stub :create_or_update, mocked_response do
+        assert_equal @service.attach_resource_to_nic('fog-test-rg', 'fog-test-network-interface', 'Network-Security-Group', '/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/myNSG1'), mocked_response
       end
     end
   end
 
   def test_attach_resources_to_nic_failure
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceGroupNotFound' }) }
-    promise = Concurrent::Promise.execute do
-    end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceGroupNotFound' }) }
 
-    promise.stub :value!, response do
-      @network_interfaces.stub :get, promise do
-        assert_raises(RuntimeError) { @service.attach_resource_to_nic('fog-test-rg', 'fog-test-network-interface', 'Network-Security-Group', '/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/myNSG1') }
-      end
+    @network_interfaces.stub :get, response do
+      assert_raises(RuntimeError) { @service.attach_resource_to_nic('fog-test-rg', 'fog-test-network-interface', 'Network-Security-Group', '/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/myNSG1') }
     end
   end
 end

data/test/requests/network/test_attach_route_table_to_subnet.rb

@@ -4,29 +4,22 @@ require File.expand_path '../../test_helper', __dir__
 class TestAttachRouteTableToSubnet < Minitest::Test
   def setup
     @service = Fog::Network::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@network_client)
-    @subnets = client.subnets
-    @promise = Concurrent::Promise.execute do
-    end
+    @network_client = @service.instance_variable_get(:@network_client)
+    @subnets = @network_client.subnets
   end
 
   def test_attach_route_table_to_subnet_success
-    mocked_response = ApiStub::Requests::Network::Subnet.create_subnet_response
-    expected_response = Azure::ARM::Network::Models::Subnet.serialize_object(mocked_response.body)
-    @promise.stub :value!, mocked_response do
-      @subnets.stub :create_or_update, @promise do
-        assert_equal @service.attach_route_table_to_subnet('fog-test-rg', 'fog-test-subnet', 'fog-test-virtual-network', '10.1.0.0/24', 'nsg-id', 'table-id'), expected_response
-      end
+    mocked_response = ApiStub::Requests::Network::Subnet.create_subnet_response(@network_client)
+    @subnets.stub :create_or_update, mocked_response do
+      assert_equal @service.attach_route_table_to_subnet('fog-test-rg', 'fog-test-subnet', 'fog-test-virtual-network', '10.1.0.0/24', 'myNSG1', 'myRT1'), mocked_response
     end
   end
 
   def test_attach_route_table_to_subnet_failure
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    @promise.stub :value!, response do
-      @subnets.stub :create_or_update, @promise do
-        assert_raises RuntimeError do
-          @service.attach_route_table_to_subnet('fog-test-rg', 'fog-test-subnet', 'fog-test-virtual-network', '10.1.0.0/24', 'nsg-id', 'table-id')
-        end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @subnets.stub :create_or_update, response do
+      assert_raises RuntimeError do
+        @service.attach_route_table_to_subnet('fog-test-rg', 'fog-test-subnet', 'fog-test-virtual-network', '10.1.0.0/24', 'myNSG1', 'myRT1')
       end
     end
   end

data/test/requests/network/test_check_for_public_ip.rb

@@ -4,35 +4,27 @@ require File.expand_path '../../test_helper', __dir__
 class TestCheckForPublicIp < Minitest::Test
   def setup
     @service = Fog::Network::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@network_client)
-    @public_ips = client.public_ipaddresses
-    @promise = Concurrent::Promise.execute do
-    end
+    network_client = @service.instance_variable_get(:@network_client)
+    @public_ips = network_client.public_ipaddresses
   end
 
   def test_check_for_public_ip_success
-    @promise.stub :value!, true do
-      @public_ips.stub :get, @promise do
-        assert @service.check_for_public_ip('fog-test-rg', 'fog-test-public-ip')
-      end
+    @public_ips.stub :get, true do
+      assert @service.check_for_public_ip('fog-test-rg', 'fog-test-public-ip')
     end
   end
 
   def test_check_for_public_ip_failure
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceNotFound' }) }
-    @promise.stub :value!, response do
-      @public_ips.stub :get, @promise do
-        assert !@service.check_for_public_ip('fog-test-rg', 'fog-test-public-ip')
-      end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceNotFound' }) }
+    @public_ips.stub :get, response do
+      assert !@service.check_for_public_ip('fog-test-rg', 'fog-test-public-ip')
     end
   end
 
   def test_check_for_public_ip_exception
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceGroupNotFound' }) }
-    @promise.stub :value!, response do
-      @public_ips.stub :get, @promise do
-        assert_raises(RuntimeError) { @service.check_for_public_ip('fog-test-rg', 'fog-test-public-ip') }
-      end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceGroupNotFound' }) }
+    @public_ips.stub :get, response do
+      assert_raises(RuntimeError) { @service.check_for_public_ip('fog-test-rg', 'fog-test-public-ip') }
     end
   end
 end

data/test/requests/network/test_check_for_virtual_network.rb

@@ -4,35 +4,27 @@ require File.expand_path '../../test_helper', __dir__
 class TestCheckForVirtualNetwork < Minitest::Test
   def setup
     @service = Fog::Network::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@network_client)
-    @virtual_networks = client.virtual_networks
-    @promise = Concurrent::Promise.execute do
-    end
+    network_client = @service.instance_variable_get(:@network_client)
+    @virtual_networks = network_client.virtual_networks
   end
 
   def test_check_for_virtual_network_success
-    @promise.stub :value!, true do
-      @virtual_networks.stub :get, @promise do
-        assert @service.check_for_virtual_network('fog-test-rg', 'fog-test-virtual-network')
-      end
+    @virtual_networks.stub :get, true do
+      assert @service.check_for_virtual_network('fog-test-rg', 'fog-test-virtual-network')
     end
   end
 
   def test_check_for_virtual_network_failure
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceNotFound' }) }
-    @promise.stub :value!, response do
-      @virtual_networks.stub :get, @promise do
-        assert !@service.check_for_virtual_network('fog-test-rg', 'fog-test-virtual-network')
-      end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceNotFound' }) }
+    @virtual_networks.stub :get, response do
+      assert !@service.check_for_virtual_network('fog-test-rg', 'fog-test-virtual-network')
     end
   end
 
   def test_check_for_virtual_network_exception
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceGroupNotFound' }) }
-    @promise.stub :value!, response do
-      @virtual_networks.stub :get, @promise do
-        assert_raises(RuntimeError) { @service.check_for_virtual_network('fog-test-rg', 'fog-test-virtual-network') }
-      end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceGroupNotFound' }) }
+    @virtual_networks.stub :get, response do
+      assert_raises(RuntimeError) { @service.check_for_virtual_network('fog-test-rg', 'fog-test-virtual-network') }
     end
   end
 end

data/test/requests/network/test_create_express_route_circuit.rb

@@ -0,0 +1,39 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for Create Express Route Circuit Request
+class TestCreateExpressRouteCircuit < Minitest::Test
+  def setup
+    @service = Fog::Network::AzureRM.new(credentials)
+    @network_client = @service.instance_variable_get(:@network_client)
+    @circuit = @network_client.express_route_circuits
+  end
+
+  def test_create_express_route_circuit_success
+    mocked_response = ApiStub::Requests::Network::ExpressRouteCircuit.create_express_route_circuit_response(@network_client)
+    peerings = ApiStub::Requests::Network::ExpressRouteCircuit.peerings
+    express_route_circuit_parameters = { peerings: peerings }
+    @circuit.stub :create_or_update, mocked_response do
+      assert_equal @service.create_or_update_express_route_circuit(express_route_circuit_parameters), mocked_response
+    end
+  end
+
+  def test_create_express_route_circuit_argument_error_failure
+    response = ApiStub::Requests::Network::ExpressRouteCircuit.create_express_route_circuit_response(@network_client)
+    @circuit.stub :create_or_update, response do
+      assert_raises ArgumentError do
+        @service.create_or_update_express_route_circuit('Fog-rg', 'testCircuit', 'eastus', 'value1', 'value2', 'Standard_MeteredData', 'Standard', 'MeteredData', 'Telenor', 'London', 100)
+      end
+    end
+  end
+
+  def test_create_express_route_circuit_exception_failure
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    peerings = ApiStub::Requests::Network::ExpressRouteCircuit.peerings
+    express_route_circuit_parameters = { peerings: peerings }
+    @circuit.stub :create_or_update, response do
+      assert_raises RuntimeError do
+        @service.create_or_update_express_route_circuit(express_route_circuit_parameters)
+      end
+    end
+  end
+end

data/test/requests/network/test_create_express_route_circuit_peering.rb

@@ -0,0 +1,37 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for Create Express Route Circuit Peering Request
+class TestCreateExpressRouteCircuitPeering < Minitest::Test
+  def setup
+    @service = Fog::Network::AzureRM.new(credentials)
+    @network_client = @service.instance_variable_get(:@network_client)
+    @circuit_peerings = @network_client.express_route_circuit_peerings
+  end
+
+  def test_create_express_route_circuit_peering_success
+    circuit_peering_parameters = { peering_type: 'AzurePrivatePeering' }
+    mocked_response = ApiStub::Requests::Network::ExpressRouteCircuitPeering.create_express_route_circuit_peering_response(@network_client)
+    @circuit_peerings.stub :create_or_update, mocked_response do
+      assert_equal @service.create_or_update_express_route_circuit_peering(circuit_peering_parameters), mocked_response
+    end
+  end
+
+  def test_create_express_route_circuit_argument_error_failure
+    response = ApiStub::Requests::Network::ExpressRouteCircuitPeering.create_express_route_circuit_peering_response(@network_client)
+    @circuit_peerings.stub :create_or_update, response do
+      assert_raises ArgumentError do
+        @service.create_or_update_express_route_circuit_peering('Fog-rg', 'AzurePrivatePeering', 'testCircuit', 'AzurePrivatePeering', 100, '192.168.1.0/30', '"192.168.2.0/30"', 'NotConfigured', '200', 'routing_registry_name')
+      end
+    end
+  end
+
+  def test_create_express_route_circuit_exception_failure
+    circuit_peering_parameters = { peering_type: 'AzurePrivatePeering' }
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @circuit_peerings.stub :create_or_update, response do
+      assert_raises RuntimeError do
+        @service.create_or_update_express_route_circuit_peering(circuit_peering_parameters)
+      end
+    end
+  end
+end

data/test/requests/network/test_create_load_balancer.rb

@@ -4,52 +4,45 @@ require File.expand_path '../../test_helper', __dir__
 class TestCreateLoadBalancer < Minitest::Test
   def setup
     @service = Fog::Network::AzureRM.new(credentials)
-    client = @service.instance_variable_get(:@network_client)
-    @load_balancers = client.load_balancers
-    @promise = Concurrent::Promise.execute do
-    end
+    @network_client = @service.instance_variable_get(:@network_client)
+    @load_balancers = @network_client.load_balancers
   end
 
   def test_create_load_balancer_success
-    mocked_response = ApiStub::Requests::Network::LoadBalancer.create_load_balancer_response
-    expected_response = Azure::ARM::Network::Models::LoadBalancer.serialize_object(mocked_response.body)
-    @promise.stub :value!, mocked_response do
-      frontend_ip_config = ApiStub::Requests::Network::LoadBalancer.frontend_ip_config
-      backend_address_pool = ApiStub::Requests::Network::LoadBalancer.backend_address_pool
-      probe = ApiStub::Requests::Network::LoadBalancer.probe
-      load_balancing_rule = ApiStub::Requests::Network::LoadBalancer.load_balancing_rule
-      inbound_nat_rule = ApiStub::Requests::Network::LoadBalancer.inbound_nat_rule
-      inbound_nat_pool = ApiStub::Requests::Network::LoadBalancer.inbound_nat_pool
-      @load_balancers.stub :create_or_update, @promise do
-        assert_equal @service.create_load_balancer('mylb1', 'North US', 'testRG', frontend_ip_config, backend_address_pool, load_balancing_rule, probe, inbound_nat_rule, inbound_nat_pool), expected_response
-      end
+    mocked_response = ApiStub::Requests::Network::LoadBalancer.create_load_balancer_response(@network_client)
+
+    frontend_ip_config = ApiStub::Requests::Network::LoadBalancer.frontend_ip_config
+    backend_address_pool = ApiStub::Requests::Network::LoadBalancer.backend_address_pool
+    probe = ApiStub::Requests::Network::LoadBalancer.probe
+    load_balancing_rule = ApiStub::Requests::Network::LoadBalancer.load_balancing_rule
+    inbound_nat_rule = ApiStub::Requests::Network::LoadBalancer.inbound_nat_rule
+    inbound_nat_pool = ApiStub::Requests::Network::LoadBalancer.inbound_nat_pool
+    @load_balancers.stub :create_or_update, mocked_response do
+      assert_equal @service.create_load_balancer('mylb1', 'North US', 'testRG', frontend_ip_config, backend_address_pool, load_balancing_rule, probe, inbound_nat_rule, inbound_nat_pool), mocked_response
     end
   end
 
   def test_create_load_balancer_argument_error_failure
-    response = ApiStub::Requests::Network::LoadBalancer.create_load_balancer_response
-    @promise.stub :value!, response do
-      @load_balancers.stub :create_or_update, @promise do
-        assert_raises ArgumentError do
-          @service.create_load_balancer('fog-test-lb', 'West US', 'fog-test-rg')
-        end
+    response = ApiStub::Requests::Network::LoadBalancer.create_load_balancer_response(@network_client)
+    @load_balancers.stub :create_or_update, response do
+      assert_raises ArgumentError do
+        @service.create_load_balancer('fog-test-lb', 'West US', 'fog-test-rg')
       end
     end
   end
 
   def test_create_load_balancer_exception_failure
-    response = -> { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    @promise.stub :value!, response do
-      frontend_ip_config = ApiStub::Requests::Network::LoadBalancer.frontend_ip_config
-      backend_address_pool = ApiStub::Requests::Network::LoadBalancer.backend_address_pool
-      probe = ApiStub::Requests::Network::LoadBalancer.probe
-      load_balancing_rule = ApiStub::Requests::Network::LoadBalancer.load_balancing_rule
-      inbound_nat_rule = ApiStub::Requests::Network::LoadBalancer.inbound_nat_rule
-      inbound_nat_pool = ApiStub::Requests::Network::LoadBalancer.inbound_nat_pool
-      @load_balancers.stub :create_or_update, @promise do
-        assert_raises RuntimeError do
-          @service.create_load_balancer('mylb1', 'North US', 'testRG', frontend_ip_config, backend_address_pool, load_balancing_rule, probe, inbound_nat_rule, inbound_nat_pool)
-        end
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+
+    frontend_ip_config = ApiStub::Requests::Network::LoadBalancer.frontend_ip_config
+    backend_address_pool = ApiStub::Requests::Network::LoadBalancer.backend_address_pool
+    probe = ApiStub::Requests::Network::LoadBalancer.probe
+    load_balancing_rule = ApiStub::Requests::Network::LoadBalancer.load_balancing_rule
+    inbound_nat_rule = ApiStub::Requests::Network::LoadBalancer.inbound_nat_rule
+    inbound_nat_pool = ApiStub::Requests::Network::LoadBalancer.inbound_nat_pool
+    @load_balancers.stub :create_or_update, response do
+      assert_raises RuntimeError do
+        @service.create_load_balancer('mylb1', 'North US', 'testRG', frontend_ip_config, backend_address_pool, load_balancing_rule, probe, inbound_nat_rule, inbound_nat_pool)
       end
     end
   end