fog-azure-rm 0.0.4 → 0.0.5

data/lib/fog/azurerm/requests/network/create_or_update_express_route_circuit.rb

@@ -0,0 +1,98 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def create_or_update_express_route_circuit(circuit_parameters)
+          msg = "Exception creating/updating Express Route Circuit #{circuit_parameters[:circuit_name]} in Resource Group: #{circuit_parameters[:resource_group_name]}."
+          Fog::Logger.debug msg
+          circuit = get_express_route_circuit_object(circuit_parameters)
+          begin
+            circuit = @network_client.express_route_circuits.create_or_update(circuit_parameters[:resource_group_name], circuit_parameters[:circuit_name], circuit)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Express Route Circuit #{circuit_parameters[:circuit_name]} created/updated successfully."
+          circuit
+        end
+
+        private
+
+        def get_express_route_circuit_object(circuit_parameters)
+          sku = Azure::ARM::Network::Models::ExpressRouteCircuitSku.new
+          sku.name = circuit_parameters[:sku_name]
+          sku.family = circuit_parameters[:sku_family]
+          sku.tier = circuit_parameters[:sku_tier]
+
+          service_provider_prop = Azure::ARM::Network::Models::ExpressRouteCircuitServiceProviderProperties.new
+          service_provider_prop.service_provider_name = circuit_parameters[:service_provider_name]
+          service_provider_prop.peering_location = circuit_parameters[:peering_location]
+          service_provider_prop.bandwidth_in_mbps = circuit_parameters[:bandwidth_in_mbps]
+
+          express_route_circuit = Azure::ARM::Network::Models::ExpressRouteCircuit.new
+          express_route_circuit.service_provider_properties = service_provider_prop
+          if circuit_parameters[:peerings]
+            circuit_peerings = get_circuit_peerings(circuit_parameters[:peerings])
+            express_route_circuit.peerings = circuit_peerings
+          end
+          express_route_circuit.name = circuit_parameters[:circuit_name]
+          express_route_circuit.location = circuit_parameters[:location]
+          express_route_circuit.sku = sku
+          express_route_circuit.tags = circuit_parameters[:tags] if express_route_circuit.tags.nil?
+
+          express_route_circuit
+        end
+
+        def get_circuit_peerings(peerings)
+          circuit_peerings = []
+          peerings.each do |peering|
+            circuit_peering = Azure::ARM::Network::Models::ExpressRouteCircuitPeering.new
+            circuit_peering.peering_type = peering[:peering_type]
+            circuit_peering.peer_asn = peering[:peer_asn]
+            circuit_peering.primary_peer_address_prefix = peering[:primary_peer_address_prefix]
+            circuit_peering.secondary_peer_address_prefix = peering[:secondary_peer_address_prefix]
+            circuit_peering.vlan_id = peering[:vlan_id]
+            if peering[:peering_type].casecmp(MICROSOFT_PEERING) == 0
+              peering_config = Azure::ARM::Network::Models::ExpressRouteCircuitPeeringConfig.new
+              peering_config.advertised_public_prefixes = peering[:advertised_public_prefixes]
+              peering_config.advertised_public_prefixes_state = peering[:advertised_public_prefix_state]
+              peering_config.customer_asn = peering[:customer_asn]
+              peering_config.routing_registry_name = peering[:routing_registry_name]
+              circuit_peering.microsoft_peering_config = peering_config
+            end
+
+            circuit_peering.name = peering[:name]
+            circuit_peerings.push(circuit_peering)
+          end
+          circuit_peerings
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def create_or_update_express_route_circuit(*)
+          {
+            'name' => 'CircuitName',
+            'location' => 'eastus',
+            'tags' => {
+              'key1' => 'value1',
+              'key2' => 'value2'
+            },
+            'sku' => {
+              'name' => 'Standard_MeteredData',
+              'tier' => 'Standard',
+              'family' => 'MeteredData'
+            },
+            'properties' => {
+              'serviceProviderProperties' => {
+                'serviceProviderName' => 'Telenor',
+                'peeringLocation' => 'London',
+                'bandwidthInMbps' => 100
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/create_or_update_express_route_circuit_peering.rb

@@ -0,0 +1,69 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def create_or_update_express_route_circuit_peering(circuit_peering_params)
+          msg = "Exception creating/updating Express Route Circuit Peering #{circuit_peering_params[:peering_name]} in Resource Group: #{circuit_peering_params[:resource_group_name]}."
+          Fog::Logger.debug msg
+          circuit_peering = get_circuit_peering_object(circuit_peering_params)
+          begin
+            peering = @network_client.express_route_circuit_peerings.create_or_update(circuit_peering_params[:resource_group_name], circuit_peering_params[:circuit_name], circuit_peering_params[:peering_name], circuit_peering)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Express Route Circuit Peering #{circuit_peering_params[:peering_name]} created/updated successfully."
+          peering
+        end
+
+        private
+
+        def get_circuit_peering_object(circuit_peering_params)
+          circuit_peering = Azure::ARM::Network::Models::ExpressRouteCircuitPeering.new
+          circuit_peering.name = circuit_peering_params[:peering_name]
+          circuit_peering.peering_type = circuit_peering_params[:peering_type]
+          circuit_peering.peer_asn = circuit_peering_params[:peer_asn]
+          circuit_peering.primary_peer_address_prefix = circuit_peering_params[:primary_peer_address_prefix]
+          circuit_peering.secondary_peer_address_prefix = circuit_peering_params[:secondary_peer_address_prefix]
+          circuit_peering.vlan_id = circuit_peering_params[:vlan_id]
+
+          if circuit_peering_params[:peering_type].casecmp(MICROSOFT_PEERING) == 0
+            peering_config = Azure::ARM::Network::Models::ExpressRouteCircuitPeeringConfig.new
+            peering_config.advertised_public_prefixes = circuit_peering_params[:advertised_public_prefixes]
+            peering_config.advertised_public_prefixes_state = circuit_peering_params[:advertised_public_prefix_state]
+            peering_config.customer_asn = circuit_peering_params[:customer_asn]
+            peering_config.routing_registry_name = circuit_peering_params[:routing_registry_name]
+            circuit_peering.microsoft_peering_config = peering_config
+          end
+
+          circuit_peering
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def create_or_update_express_route_circuit_peering(*)
+          {
+            'name' => 'PeeringName',
+            'properties' => {
+              'peeringType' => 'MicrosoftPeering',
+              'peerASN' => 100,
+              'primaryPeerAddressPrefix' => '192.168.1.0/30',
+              'secondaryPeerAddressPrefix' => '192.168.2.0/30',
+              'vlanId' => 200,
+              'microsoftPeeringConfig' => {
+                'advertisedpublicprefixes' => [
+                  '11.2.3.4/30',
+                  '12.2.3.4/30'
+                ],
+                'advertisedPublicPrefixState' => 'NotConfigured',
+                'customerAsn' => 200,
+                'routingRegistryName' => '<name>'
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/create_or_update_network_interface.rb

@@ -5,17 +5,16 @@ module Fog
       # Real class for Network Request
       class Real
         def create_or_update_network_interface(resource_group_name, name, location, subnet_id, public_ip_address_id, ip_config_name, private_ip_allocation_method, private_ip_address)
-          Fog::Logger.debug "Creating/Updating Network Interface Card: #{name}..."
+          msg = "Creating/Updating Network Interface Card: #{name}"
+          Fog::Logger.debug msg
           network_interface = get_network_interface_object(name, location, subnet_id, public_ip_address_id, ip_config_name, private_ip_allocation_method, private_ip_address)
           begin
-            promise = @network_client.network_interfaces.create_or_update(resource_group_name, name, network_interface)
-            result = promise.value!
-            Fog::Logger.debug "Network Interface #{name} created/updated successfully."
-            Azure::ARM::Network::Models::NetworkInterface.serialize_object(result.body)
+            network_interface_obj = @network_client.network_interfaces.create_or_update(resource_group_name, name, network_interface)
           rescue MsRestAzure::AzureOperationError => e
-            msg = "Exception creating/updating Network Interface #{name} in Resource Group: #{resource_group_name}. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Network Interface #{name} created/updated successfully."
+          network_interface_obj
         end
 
         private
@@ -29,23 +28,17 @@ module Fog
             public_ipaddress.id = public_ip_address_id
           end
 
-          ip_configs_props = Azure::ARM::Network::Models::NetworkInterfaceIPConfigurationPropertiesFormat.new
-          ip_configs_props.private_ipallocation_method = private_ip_allocation_method
-          ip_configs_props.private_ipaddress = private_ip_address
-          ip_configs_props.public_ipaddress = public_ipaddress
-          ip_configs_props.subnet = subnet
-
           ip_configs = Azure::ARM::Network::Models::NetworkInterfaceIPConfiguration.new
           ip_configs.name = ip_config_name
-          ip_configs.properties = ip_configs_props
-
-          nic_props = Azure::ARM::Network::Models::NetworkInterfacePropertiesFormat.new
-          nic_props.ip_configurations = [ip_configs]
+          ip_configs.private_ipallocation_method = private_ip_allocation_method
+          ip_configs.private_ipaddress = private_ip_address
+          ip_configs.public_ipaddress = public_ipaddress unless public_ip_address_id.nil?
+          ip_configs.subnet = subnet
 
           network_interface = Azure::ARM::Network::Models::NetworkInterface.new
           network_interface.name = name
           network_interface.location = location
-          network_interface.properties = nic_props
+          network_interface.ip_configurations = [ip_configs]
 
           network_interface
         end
@@ -54,7 +47,7 @@ module Fog
       # Mock class for Network Request
       class Mock
         def create_or_update_network_interface(resource_group_name, name, location, subnet_id, public_ip_address_id, ip_configs_name, private_ip_allocation_method, private_ip_address)
-          {
+          nic = {
             'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{resource_group_name}/providers/Microsoft.Network/networkInterfaces/#{name}",
             'name' => name,
             'type' => 'Microsoft.Network/networkInterfaces',
@@ -92,6 +85,8 @@ module Fog
                 'provisioningState' => 'Succeeded'
               }
           }
+          network_interface_mapper = Azure::ARM::Network::Models::NetworkInterface.mapper
+          @network_client.deserialize(network_interface_mapper, nic, 'result.body')
         end
       end
     end

data/lib/fog/azurerm/requests/network/create_or_update_network_security_group.rb

@@ -4,43 +4,44 @@ module Fog
       # Real class for Network Request
       class Real
         def create_or_update_network_security_group(resource_group_name, security_group_name, location, security_rules)
-          Fog::Logger.debug "Creating/Updating Network Security Group #{security_group_name} in Resource Group #{resource_group_name}."
-          properties = Azure::ARM::Network::Models::NetworkSecurityGroupPropertiesFormat.new
-          properties.security_rules = create_security_rule_objects(security_rules)
+          msg = "Creating/Updating Network Security Group #{security_group_name} in Resource Group #{resource_group_name}."
+          Fog::Logger.debug msg
+
+          security_group = get_security_group_object(security_rules, location)
 
-          params = Azure::ARM::Network::Models::NetworkSecurityGroup.new
-          params.location = location
-          params.properties = properties
           begin
-            promise = @network_client.network_security_groups.begin_create_or_update(resource_group_name, security_group_name, params)
-            result = promise.value!
-            Fog::Logger.debug "Network Security Group #{security_group_name} Created/Updated Successfully!"
-            Azure::ARM::Network::Models::NetworkSecurityGroup.serialize_object(result.body)
+            security_group = @network_client.network_security_groups.begin_create_or_update(resource_group_name, security_group_name, security_group)
           rescue MsRestAzure::AzureOperationError => e
-            msg = "Exception creating/updating Network Security Group #{security_group_name} in Resource Group: #{resource_group_name}. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+
+          Fog::Logger.debug "Network Security Group #{security_group_name} Created/Updated Successfully!"
+          security_group
         end
 
         private
 
-        def create_security_rule_objects(security_rules)
+        def get_security_group_object(security_rules, location)
+          security_group = Azure::ARM::Network::Models::NetworkSecurityGroup.new
+          security_group.security_rules = get_security_rule_objects(security_rules)
+          security_group.location = location
+          security_group
+        end
+
+        def get_security_rule_objects(security_rules)
           rules = []
           security_rules.each do |sr|
-            properties = Azure::ARM::Network::Models::SecurityRulePropertiesFormat.new
-            properties.description = sr[:description] unless sr[:description].nil?
-            properties.protocol = sr[:protocol]
-            properties.source_port_range = sr[:source_port_range]
-            properties.destination_port_range = sr[:destination_port_range]
-            properties.source_address_prefix = sr[:source_address_prefix]
-            properties.destination_address_prefix = sr[:destination_address_prefix]
-            properties.access = sr[:access]
-            properties.priority = sr[:priority]
-            properties.direction = sr[:direction]
-
             security_rule = Azure::ARM::Network::Models::SecurityRule.new
+            security_rule.description = sr[:description] unless sr[:description].nil?
+            security_rule.protocol = sr[:protocol]
+            security_rule.source_port_range = sr[:source_port_range]
+            security_rule.destination_port_range = sr[:destination_port_range]
+            security_rule.source_address_prefix = sr[:source_address_prefix]
+            security_rule.destination_address_prefix = sr[:destination_address_prefix]
+            security_rule.access = sr[:access]
+            security_rule.priority = sr[:priority]
+            security_rule.direction = sr[:direction]
             security_rule.name = sr[:name]
-            security_rule.properties = properties
             rules << security_rule
           end unless security_rules.nil?
           rules
@@ -50,7 +51,7 @@ module Fog
       # Mock class for Network Request
       class Mock
         def create_or_update_network_security_group(resource_group_name, security_group_name, location, security_rules)
-          {
+          network_security_group = {
             'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{resource_group_name}/providers/Microsoft.Network/networkSecurityGroups/#{security_group_name}",
             'name' => security_group_name,
             'type' => 'Microsoft.Network/networkSecurityGroups',
@@ -167,6 +168,8 @@ module Fog
                 'provisioningState' => 'Updating'
               }
           }
+          nsg_mapper = Azure::ARM::Network::Models::NetworkSecurityGroup.mapper
+          @network_client.deserialize(nsg_mapper, network_security_group, 'result.body')
         end
       end
     end

data/lib/fog/azurerm/requests/network/create_or_update_virtual_network.rb

@@ -5,28 +5,26 @@ module Fog
       class Real
         def create_or_update_virtual_network(resource_group_name, virtual_network_name, location, dns_servers, subnets, address_prefixes)
           virtual_network = define_vnet_object(location, address_prefixes, dns_servers, subnets)
-          vnet = create_or_update_vnet(resource_group_name, virtual_network_name, virtual_network)
-          Azure::ARM::Network::Models::VirtualNetwork.serialize_object(vnet)
+          create_or_update_vnet(resource_group_name, virtual_network_name, virtual_network)
         end
 
         private
 
         def create_or_update_vnet(resource_group_name, virtual_network_name, virtual_network)
-          Fog::Logger.debug "Creating/Updating Virtual Network: #{virtual_network_name}"
+          msg = "Creating/Updating Virtual Network: #{virtual_network_name}"
+          Fog::Logger.debug msg
           begin
-            response = @network_client.virtual_networks.create_or_update(resource_group_name, virtual_network_name, virtual_network).value!
-            Fog::Logger.debug "Virtual Network #{virtual_network_name} created/updated successfully."
-            response.body
-          rescue  MsRestAzure::AzureOperationError => e
-            msg = "Exception creating/updating Virtual Network #{virtual_network_name} in Resource Group: #{resource_group_name}. #{e.body['error']['message']}"
-            raise msg
+            virtual_network = @network_client.virtual_networks.create_or_update(resource_group_name, virtual_network_name, virtual_network)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Virtual Network #{virtual_network_name} created/updated successfully."
+          virtual_network
         end
 
         def define_vnet_object(location, address_prefixes, dns_servers, subnets)
           virtual_network = Azure::ARM::Network::Models::VirtualNetwork.new
           virtual_network.location = location
-          virtual_network_properties = Azure::ARM::Network::Models::VirtualNetworkPropertiesFormat.new
 
           if address_prefixes.nil? || !address_prefixes.any?
             address_space = Azure::ARM::Network::Models::AddressSpace.new
@@ -35,20 +33,19 @@ module Fog
             address_space = Azure::ARM::Network::Models::AddressSpace.new
             address_space.address_prefixes = address_prefixes
           end
-          virtual_network_properties.address_space = address_space
+          virtual_network.address_space = address_space
 
           if !dns_servers.nil? && dns_servers.any?
             dhcp_options = Azure::ARM::Network::Models::DhcpOptions.new
             dhcp_options.dns_servers = dns_servers
-            virtual_network_properties.dhcp_options = dhcp_options
+            virtual_network.dhcp_options = dhcp_options
           end
 
           if !subnets.nil? && subnets.any?
             subnet_objects = define_subnet_objects(subnets)
-            virtual_network_properties.subnets = subnet_objects
+            virtual_network.subnets = subnet_objects
           end
 
-          virtual_network.properties = virtual_network_properties
           virtual_network
         end
 
@@ -61,14 +58,12 @@ module Fog
             route_table = Azure::ARM::Network::Models::RouteTable.new
             route_table.id = subnet[:route_table_id]
 
-            subnet_properties = Azure::ARM::Network::Models::SubnetPropertiesFormat.new
-            subnet_properties.address_prefix = subnet[:address_prefix]
-            subnet_properties.network_security_group = network_security_group unless subnet[:network_security_group_id].nil?
-            subnet_properties.route_table = route_table unless subnet[:route_table_id].nil?
-
             subnet_object = Azure::ARM::Network::Models::Subnet.new
             subnet_object.name = subnet[:name]
-            subnet_object.properties = subnet_properties
+            subnet_object.address_prefix = subnet[:address_prefix]
+            subnet_object.network_security_group = network_security_group unless subnet[:network_security_group_id].nil?
+            subnet_object.route_table = route_table unless subnet[:route_table_id].nil?
+
             subnet_objects << subnet_object
           end
           subnet_objects
@@ -78,7 +73,7 @@ module Fog
       # Mock class for Network Request
       class Mock
         def create_or_update__virtual_network(*)
-          {
+          virtual_network = {
             'id' => '/subscriptions/########-####-####-####-############/resourceGroups/fog-rg/providers/Microsoft.Network/virtualNetworks/fog-vnet',
             'name' => 'fog-vnet',
             'type' => 'Microsoft.Network/virtualNetworks',
@@ -88,10 +83,7 @@ module Fog
                 'addressSpace' =>
                   {
                     'addressPrefixes' =>
-                      [
-                        '10.1.0.0/16',
-                        '10.2.0.0/16'
-                      ]
+                      %w(10.1.0.0/16 10.2.0.0/16)
                   },
                 'subnets' =>
                   [
@@ -109,6 +101,8 @@ module Fog
                 'provisioningState' => 'Succeeded'
               }
           }
+          vnet_mapper = Azure::ARM::Network::Models::VirtualNetwork.mapper
+          @network_client.deserialize(vnet_mapper, virtual_network, 'result.body')
         end
       end
     end

data/lib/fog/azurerm/requests/network/create_or_update_virtual_network_gateway.rb

@@ -0,0 +1,151 @@
+
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def create_or_update_virtual_network_gateway(virtual_network_params)
+          msg = "Creating/Updating Virtual Network Gateway: #{virtual_network_params[:name]} in Resource Group: #{virtual_network_params[:resource_group_name]}."
+          Fog::Logger.debug msg
+          network_gateway = get_network_gateway_object(virtual_network_params)
+          begin
+            virtual_network_gateway = @network_client.virtual_network_gateways.create_or_update(virtual_network_params[:resource_group_name], virtual_network_params[:name], network_gateway)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Virtual Network Gateway #{virtual_network_params[:name]} created/updated successfully."
+          virtual_network_gateway
+        end
+
+        private
+
+        def get_network_gateway_object(virtual_network_params)
+          network_gateway = Azure::ARM::Network::Models::VirtualNetworkGateway.new
+
+          default_site = MsRestAzure::SubResource.new
+          default_site.id = virtual_network_params[:gateway_default_site]
+
+          sku = Azure::ARM::Network::Models::VirtualNetworkGatewaySku.new
+          sku.name = virtual_network_params[:sku_name]
+          sku.capacity = virtual_network_params[:sku_capacity]
+          sku.tier = virtual_network_params[:sku_tier]
+
+          network_gateway.enable_bgp = virtual_network_params[:enable_bgp]
+          network_gateway.gateway_type = virtual_network_params[:gateway_type]
+          network_gateway.provisioning_state = virtual_network_params[:provisioning_state]
+          network_gateway.vpn_type = virtual_network_params[:vpn_type]
+          network_gateway.sku = sku
+          network_gateway.gateway_default_site = default_site
+          if virtual_network_params[:ip_configurations]
+            ip_configurations = get_ip_configurations(virtual_network_params[:ip_configurations])
+            network_gateway.ip_configurations = ip_configurations
+          end
+
+          if virtual_network_params[:enable_bgp]
+            bgp_settings = Azure::ARM::Network::Models::BgpSettings.new
+            bgp_settings.asn = virtual_network_params[:asn]
+            bgp_settings.bgp_peering_address = virtual_network_params[:bgp_peering_address]
+            bgp_settings.peer_weight = virtual_network_params[:peer_weight]
+            network_gateway.bgp_settings = bgp_settings
+          end
+
+          if virtual_network_params[:vpn_client_configuration]
+            vpn_client_config = get_vpn_client_config(virtual_network_params[:vpn_client_configuration])
+            network_gateway.vpn_client_configuration = vpn_client_config
+          end
+
+          network_gateway.name = virtual_network_params[:name]
+          network_gateway.location = virtual_network_params[:location]
+          network_gateway.tags = virtual_network_params[:tags] if network_gateway.tags.nil?
+
+          network_gateway
+        end
+
+        def get_vpn_client_config(vpn_client_config)
+          client_config = Azure::ARM::Network::Models::VpnClientConfiguration.new
+
+          address_pool = Azure::ARM::Network::Models::AddressSpace.new
+          address_pool.address_prefixes = vpn_client_config[:address_pool]
+          client_config.vpn_client_address_pool = address_pool
+
+          if vpn_client_config[:root_certificates]
+            root_certificates = get_root_certificates(vpn_client_config[:root_certificates])
+            client_config.vpn_client_root_certificates = root_certificates
+          end
+
+          if vpn_client_config[:revoked_certificates]
+            revoked_certificates = get_revoked_certificates(vpn_client_config[:revoked_certificates])
+            client_config.vpn_client_revoked_certificates = revoked_certificates
+          end
+          client_config
+        end
+
+        def get_root_certificates(root_certificates)
+          root_certs = []
+          root_certificates.each do |root_cert|
+            root_certificate = Azure::ARM::Network::Models::VpnClientRootCertificate.new
+            root_certificate.public_cert_data = root_cert[:public_cert_data]
+            root_certificate.provisioning_state = root_cert[:provisioning_state]
+            root_certificate.name = root_cert[:name]
+            root_certs.push(root_certificate)
+          end
+          root_certs
+        end
+
+        def get_revoked_certificates(revoked_certificates)
+          revoked_certs = []
+          revoked_certificates.each do |revoked_cert|
+            revoked_certificate = Azure::ARM::Network::Models::VpnClientRevokedCertificate.new
+            revoked_certificate.thumbprint = revoked_cert[:thumbprint]
+            revoked_certificate.provisioning_state = revoked_cert[:provisioning_state]
+            revoked_certificate.name = revoked_cert[:name]
+            revoked_certs.push(revoked_certificate)
+          end
+          revoked_certs
+        end
+
+        def get_ip_configurations(ip_configurations)
+          ip_configs = []
+          ip_configurations.each do |ip_config|
+            ip_configuration = Azure::ARM::Network::Models::VirtualNetworkGatewayIPConfiguration.new
+            ip_configuration.private_ipallocation_method = ip_config[:private_ipallocation_method]
+            unless ip_config[:subnet_id].nil?
+              subnet = Azure::ARM::Network::Models::Subnet.new
+              subnet.id = ip_config[:subnet_id]
+              ip_configuration.subnet = subnet
+            end
+            unless ip_config[:public_ipaddress_id].nil?
+              pip = Azure::ARM::Network::Models::PublicIPAddress.new
+              pip.id = ip_config[:public_ipaddress_id]
+              ip_configuration.public_ipaddress = pip
+            end
+
+            ip_configuration.name = ip_config[:name]
+            ip_configs.push(ip_configuration)
+          end
+          ip_configs
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def create_or_update_virtual_network_gateway(*)
+          gateway = {
+            'name' => 'myvirtualgateway1',
+            'location' => 'West US',
+            'tags' => { 'key1' => 'value1' },
+            'properties' => {
+              'gatewayType' => 'DynamicRouting',
+              'gatewaySize' => 'Default',
+              'bgpEnabled' => true,
+              'vpnClientAddressPool' => ['{vpnClientAddressPoolPrefix}'],
+              'defaultSites' => ['mysite1']
+            }
+          }
+          gateway_mapper = Azure::ARM::Network::Models::VirtualNetworkGateway.mapper
+          @network_client.deserialize(gateway_mapper, gateway, 'result.body')
+        end
+      end
+    end
+  end
+end