fog-azure-rm-temp 0.0.1

data/lib/fog/azurerm/models/traffic_manager/traffic_manager_end_points.rb

@@ -0,0 +1,30 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager End Point Collection for TrafficManager Service
+      class TrafficManagerEndPoints < Fog::Collection
+        attribute :resource_group
+        attribute :traffic_manager_profile_name
+        model Fog::TrafficManager::AzureRM::TrafficManagerEndPoint
+
+        def all
+          requires :resource_group, :traffic_manager_profile_name
+
+          end_points = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name).endpoints
+          traffic_manager_endpoints = end_points.map { |endpoint| Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint) }
+          load(traffic_manager_endpoints)
+        end
+
+        def get(resource_group, traffic_manager_profile_name, end_point_name, type)
+          endpoint = service.get_traffic_manager_end_point(resource_group, traffic_manager_profile_name, end_point_name, type)
+          endpoint_fog = Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.new(service: service)
+          endpoint_fog.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+        end
+
+        def check_traffic_manager_endpoint_exists(resource_group, traffic_manager_profile_name, end_point_name, type)
+          service.check_traffic_manager_endpoint_exists(resource_group, traffic_manager_profile_name, end_point_name, type)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/traffic_manager/traffic_manager_profile.rb

@@ -0,0 +1,88 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager Profile model for TrafficManager Service
+      class TrafficManagerProfile < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :location
+        attribute :profile_status
+        attribute :traffic_routing_method
+        attribute :relative_name
+        attribute :fqdn
+        attribute :ttl
+        attribute :profile_monitor_status
+        attribute :protocol
+        attribute :port
+        attribute :path
+        attribute :endpoints
+
+        def self.parse(profile)
+          traffic_manager_profile = get_hash_from_object(profile)
+
+          if profile.dns_config
+            traffic_manager_profile['relative_name'] = profile.dns_config.relative_name
+            traffic_manager_profile['fqdn'] = profile.dns_config.fqdn
+            traffic_manager_profile['ttl'] = profile.dns_config.ttl
+          end
+
+          if profile.monitor_config
+            traffic_manager_profile['profile_monitor_status'] = profile.monitor_config.profile_monitor_status
+            traffic_manager_profile['protocol'] = profile.monitor_config.protocol
+            traffic_manager_profile['port'] = profile.monitor_config.port
+            traffic_manager_profile['path'] = profile.monitor_config.path
+          end
+          traffic_manager_profile['resource_group'] = get_resource_group_from_id(profile.id)
+          traffic_manager_profile['endpoints'] = []
+          profile.endpoints.each do |endpoint|
+            end_point = Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.new
+            traffic_manager_profile['endpoints'] << end_point.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+          end
+          traffic_manager_profile
+        end
+
+        def save
+          requires :name, :resource_group, :traffic_routing_method, :relative_name, :ttl,
+                   :protocol, :port, :path
+          traffic_manager_profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
+          merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(traffic_manager_profile))
+        end
+
+        def destroy
+          service.delete_traffic_manager_profile(resource_group, name)
+        end
+
+        def update(profile_params)
+          validate_input(profile_params)
+          profile_params[:endpoints] = endpoints.map { |endpoint| get_hash_from_object(endpoint)['attributes'] }
+          merge_attributes(profile_params)
+          profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
+          merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))
+        end
+
+        private
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :relative_name, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
+
+        def traffic_manager_profile_hash
+          {
+            resource_group: resource_group,
+            name: name,
+            traffic_routing_method: traffic_routing_method,
+            relative_name: relative_name,
+            ttl: ttl,
+            protocol: protocol,
+            port: port,
+            path: path,
+            endpoints: endpoints
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/traffic_manager/traffic_manager_profiles.rb

@@ -0,0 +1,27 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager Profile Collection for TrafficManager Service
+      class TrafficManagerProfiles < Fog::Collection
+        attribute :resource_group
+        model Fog::TrafficManager::AzureRM::TrafficManagerProfile
+
+        def all
+          requires :resource_group
+          traffic_manager_profiles = service.list_traffic_manager_profiles(resource_group).map { |profile| Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile) }
+          load(traffic_manager_profiles)
+        end
+
+        def get(resource_group, traffic_manager_profile_name)
+          profile = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name)
+          profile_fog = Fog::TrafficManager::AzureRM::TrafficManagerProfile.new(service: service)
+          profile_fog.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))
+        end
+
+        def check_traffic_manager_profile_exists(resource_group, traffic_manager_profile_name)
+          service.check_traffic_manager_profile_exists(resource_group, traffic_manager_profile_name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/network.rb

@@ -0,0 +1,178 @@
+module Fog
+  module Network
+    # Fog Service Class for AzureRM
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+      recognizes :environment
+
+      request_path 'fog/azurerm/requests/network'
+      request :create_or_update_virtual_network
+      request :get_virtual_network
+      request :add_dns_servers_in_virtual_network
+      request :remove_dns_servers_from_virtual_network
+      request :add_address_prefixes_in_virtual_network
+      request :remove_subnets_from_virtual_network
+      request :remove_address_prefixes_from_virtual_network
+      request :add_subnets_in_virtual_network
+      request :delete_virtual_network
+      request :list_virtual_networks
+      request :list_virtual_networks_in_subscription
+      request :check_virtual_network_exists
+      request :create_or_update_public_ip
+      request :delete_public_ip
+      request :get_public_ip
+      request :list_public_ips
+      request :check_public_ip_exists
+      request :create_subnet
+      request :attach_network_security_group_to_subnet
+      request :detach_network_security_group_from_subnet
+      request :attach_route_table_to_subnet
+      request :detach_route_table_from_subnet
+      request :list_subnets
+      request :get_subnet
+      request :get_available_ipaddresses_count
+      request :delete_subnet
+      request :check_subnet_exists
+      request :create_or_update_network_interface
+      request :delete_network_interface
+      request :list_network_interfaces
+      request :get_network_interface
+      request :check_network_interface_exists
+      request :attach_resource_to_nic
+      request :detach_resource_from_nic
+      request :create_load_balancer
+      request :delete_load_balancer
+      request :list_load_balancers
+      request :get_load_balancer
+      request :check_load_balancer_exists
+      request :list_load_balancers_in_subscription
+      request :create_or_update_network_security_group
+      request :delete_network_security_group
+      request :list_network_security_groups
+      request :get_network_security_group
+      request :check_net_sec_group_exists
+      request :add_security_rules
+      request :remove_security_rule
+      request :delete_virtual_network_gateway
+      request :create_or_update_virtual_network_gateway
+      request :list_virtual_network_gateways
+      request :get_virtual_network_gateway
+      request :check_vnet_gateway_exists
+      request :create_or_update_express_route_circuit
+      request :delete_express_route_circuit
+      request :get_express_route_circuit
+      request :list_express_route_circuits
+      request :check_express_route_circuit_exists
+      request :create_or_update_express_route_circuit_peering
+      request :delete_express_route_circuit_peering
+      request :get_express_route_circuit_peering
+      request :list_express_route_circuit_peerings
+      request :create_or_update_express_route_circuit_authorization
+      request :delete_express_route_circuit_authorization
+      request :get_express_route_circuit_authorization
+      request :list_express_route_circuit_authorizations
+      request :check_express_route_cir_auth_exists
+      request :list_express_route_service_providers
+      request :create_or_update_local_network_gateway
+      request :delete_local_network_gateway
+      request :get_local_network_gateway
+      request :list_local_network_gateways
+      request :check_local_net_gateway_exists
+      request :create_or_update_virtual_network_gateway_connection
+      request :delete_virtual_network_gateway_connection
+      request :get_virtual_network_gateway_connection
+      request :list_virtual_network_gateway_connections
+      request :check_vnet_gateway_connection_exists
+      request :get_connection_shared_key
+      request :reset_connection_shared_key
+      request :set_connection_shared_key
+      request :create_or_update_network_security_rule
+      request :delete_network_security_rule
+      request :get_network_security_rule
+      request :list_network_security_rules
+      request :check_net_sec_rule_exists
+
+      model_path 'fog/azurerm/models/network'
+      model :virtual_network
+      collection :virtual_networks
+      model :public_ip
+      collection :public_ips
+      model :subnet
+      collection :subnets
+      model :network_interface
+      collection :network_interfaces
+      model :load_balancer
+      collection :load_balancers
+      model :frontend_ip_configuration
+      model :inbound_nat_pool
+      model :inbound_nat_rule
+      model :load_balancing_rule
+      model :probe
+      model :network_security_group
+      collection :network_security_groups
+      model :network_security_rule
+      collection :network_security_rules
+      model :path_rule
+      model :vpn_client_configuration
+      model :vpn_client_revoked_certificates
+      model :vpn_client_root_certificates
+      model :virtual_network_gateway
+      collection :virtual_network_gateways
+      model :express_route_circuit
+      collection :express_route_circuits
+      model :express_route_circuit_peering
+      collection :express_route_circuit_peerings
+      model :express_route_circuit_authorization
+      collection :express_route_circuit_authorizations
+      model :express_route_service_provider
+      collection :express_route_service_providers
+      model :local_network_gateway
+      collection :local_network_gateways
+      model :virtual_network_gateway_connection
+      collection :virtual_network_gateway_connections
+
+      # Mock class for Network Service
+      class Mock
+        def initialize(_options = {})
+          begin
+            require 'azure_mgmt_network'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+        end
+      end
+
+      # Real class for Network Service
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_network'
+            require 'yaml'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+
+          options[:environment] = 'AzureCloud' if options[:environment].nil?
+
+          credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret], options[:environment])
+          telemetry = "fog-azure-rm/#{Fog::AzureRM::VERSION}"
+          @network_client = ::Azure::ARM::Network::NetworkManagementClient.new(credentials, resource_manager_endpoint_url(options[:environment]))
+          @network_client.subscription_id = options[:subscription_id]
+          @network_client.add_user_agent_information(telemetry)
+          @tenant_id = options[:tenant_id]
+          @client_id = options[:client_id]
+          @client_secret = options[:client_secret]
+          @subscription_id = options[:subscription_id]
+          @environment = options[:environment]
+          current_directory = File.dirname(__FILE__)
+          @logger_messages = YAML.load_file("#{current_directory}/utilities/logger_messages.yml")
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/application_gateway/check_ag_exists.rb

@@ -0,0 +1,31 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # This class provides the actual implementation for service calls.
+      class Real
+        def check_ag_exists(resource_group_name, application_gateway_name)
+          msg = "Checking Application Gateway: #{application_gateway_name}"
+          Fog::Logger.debug msg
+          begin
+            @network_client.application_gateways.get(resource_group_name, application_gateway_name)
+            Fog::Logger.debug "Application Gateway #{application_gateway_name} exists."
+            true
+          rescue MsRestAzure::AzureOperationError => e
+            if e.body['error']['code'] == 'ResourceNotFound'
+              Fog::Logger.debug "Application Gateway #{application_gateway_name} doesn't exist."
+              false
+            else
+              raise_azure_exception(e, msg)
+            end
+          end
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def check_ag_exists(*)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/application_gateway/create_or_update_application_gateway.rb

@@ -0,0 +1,301 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Real class for Application Gateway Request
+      class Real
+        def create_or_update_application_gateway(gateway_params)
+          msg = "Creating/Updated Application Gateway: #{gateway_params[:name]} in Resource Group: #{gateway_params[:resource_group]}."
+          Fog::Logger.debug msg
+          gateway = define_application_gateway(gateway_params)
+          begin
+            gateway_obj = @network_client.application_gateways.create_or_update(gateway_params[:resource_group], gateway_params[:name], gateway)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Application Gateway #{gateway_params[:name]} created/updated successfully."
+          gateway_obj
+        end
+
+        private
+
+        def define_application_gateway(gateway_params)
+          application_gateway = Azure::ARM::Network::Models::ApplicationGateway.new
+          application_gateway.name = gateway_params[:name]
+          application_gateway.location = gateway_params[:location]
+
+          application_gateway.gateway_ipconfigurations = define_gateway_ip_configuration(gateway_params[:gateway_ip_configurations]) if gateway_params[:gateway_ip_configurations]
+          application_gateway.ssl_certificates = define_ssl_certificate(gateway_params[:ssl_certificates]) if gateway_params[:ssl_certificates]
+          application_gateway.frontend_ipconfigurations = define_frontend_ip_configurations(gateway_params[:frontend_ip_configurations]) if gateway_params[:frontend_ip_configurations]
+          application_gateway.frontend_ports = define_frontend_ports(gateway_params[:frontend_ports]) if gateway_params[:frontend_ports]
+          application_gateway.probes = define_probes(gateway_params[:probes]) if gateway_params[:probes]
+          application_gateway.backend_address_pools = define_backend_address_pools(gateway_params[:backend_address_pools]) if gateway_params[:backend_address_pools]
+          application_gateway.backend_http_settings_collection = define_backend_http_settings(gateway_params[:backend_http_settings_list]) if gateway_params[:backend_http_settings_list]
+          application_gateway.http_listeners = define_http_listeners(gateway_params[:http_listeners]) if gateway_params[:http_listeners]
+          application_gateway.url_path_maps = define_url_path_maps(gateway_params[:url_path_maps]) if gateway_params[:url_path_maps]
+          application_gateway.request_routing_rules = define_request_routing_rules(gateway_params[:request_routing_rules]) if gateway_params[:request_routing_rules]
+
+          gateway_sku = Azure::ARM::Network::Models::ApplicationGatewaySku.new
+          gateway_sku.name = gateway_params[:sku_name]
+          gateway_sku.tier = gateway_params[:sku_tier]
+          gateway_sku.capacity = gateway_params[:sku_capacity]
+          application_gateway.sku = gateway_sku
+
+          application_gateway
+        end
+
+        def define_gateway_ip_configuration(gateway_ip_configurations)
+          gateway_ip_configuration_arr = []
+          gateway_ip_configurations.each do |ip_configuration|
+            configuration = Azure::ARM::Network::Models::ApplicationGatewayIPConfiguration.new
+            configuration.provisioning_state = ip_configuration[:provisioning_state]
+            if ip_configuration[:subnet_id]
+              subnet = Azure::ARM::Network::Models::Subnet.new
+              subnet.id = ip_configuration[:subnet_id]
+              configuration.subnet = subnet
+            end
+
+            configuration.name = ip_configuration[:name]
+            gateway_ip_configuration_arr.push(configuration)
+          end
+          gateway_ip_configuration_arr
+        end
+
+        def define_ssl_certificate(ssl_certificates)
+          ssl_certificate_arr = []
+          ssl_certificates.each do |ssl_certificate|
+            certificate = Azure::ARM::Network::Models::ApplicationGatewaySslCertificate.new
+            certificate.data = ssl_certificate[:data]
+            certificate.password = ssl_certificate[:password]
+            certificate.public_cert_data = ssl_certificate[:public_cert_data]
+
+            certificate.name = ssl_certificate[:name]
+            ssl_certificate_arr.push(ssl_certificate)
+          end
+          ssl_certificate_arr
+        end
+
+        def define_frontend_ip_configurations(frontend_ip_configurations)
+          frontend_ip_configuration_arr = []
+          frontend_ip_configurations.each do |fic|
+            frontend_ip_configuration = Azure::ARM::Network::Models::ApplicationGatewayFrontendIPConfiguration.new
+
+            frontend_ip_configuration.private_ipaddress = fic[:private_ip_address]
+            frontend_ip_configuration.private_ipallocation_method = fic[:private_ip_allocation_method]
+
+            if fic[:subnet_id]
+              subnet = Azure::ARM::Network::Models::Subnet.new
+              subnet.id = fic[:subnet_id]
+              frontend_ip_configuration.subnet = subnet
+            end
+
+            unless fic[:public_ip_address_id].nil?
+              pip = Azure::ARM::Network::Models::PublicIPAddress.new
+              pip.id = fic[:public_ip_address_id]
+              frontend_ip_configuration.public_ipaddress = pip
+            end
+
+            frontend_ip_configuration.name = fic[:name]
+
+            frontend_ip_configuration_arr.push(frontend_ip_configuration)
+          end
+          frontend_ip_configuration_arr
+        end
+
+        def define_frontend_ports(frontend_ports)
+          frontend_port_arr = []
+          frontend_ports.each do |port|
+            frontend_port = Azure::ARM::Network::Models::ApplicationGatewayFrontendPort.new
+
+            frontend_port.port = port[:port]
+            frontend_port.name = port[:name]
+
+            frontend_port_arr.push(frontend_port)
+          end
+          frontend_port_arr
+        end
+
+        def define_probes(probes)
+          probe_arr = []
+          probes.each do |probe|
+            ag_probe = Azure::ARM::Network::Models::ApplicationGatewayProbe.new
+            ag_probe.protocol = probe[:protocol]
+            ag_probe.host = probe[:host]
+            ag_probe.path = probe[:path]
+            ag_probe.interval = probe[:interval]
+            ag_probe.timeout = probe[:timeout]
+            ag_probe.unhealthy_threshold = probe[:unhealthy_threshold]
+
+            ag_probe.name = probe[:name]
+            probe_arr.push(ag_probe)
+          end
+          probe_arr
+        end
+
+        def define_backend_address_pools(backend_address_pools)
+          backend_address_pool_arr = []
+
+          backend_address_pools.each do |bap|
+            backend_pool = Azure::ARM::Network::Models::ApplicationGatewayBackendAddressPool.new
+
+            backend_addresses1 = bap[:ip_addresses]
+            addresses = []
+            backend_addresses1.each do |address|
+              backend_add = Azure::ARM::Network::Models::ApplicationGatewayBackendAddress.new
+              backend_add.ip_address = address[:ipAddress]
+              addresses.push(backend_add)
+            end
+            backend_pool.backend_addresses = addresses
+
+            backend_pool.name = bap[:name]
+            backend_address_pool_arr.push(backend_pool)
+          end
+          backend_address_pool_arr
+        end
+
+        def define_backend_http_settings(backend_http_settings_list)
+          backend_http_setting_arr = []
+
+          backend_http_settings_list.each do |http_setting|
+            backend_http_setting = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettings.new
+            backend_http_setting.port = http_setting[:port]
+            backend_http_setting.protocol = http_setting[:protocol]
+            backend_http_setting.cookie_based_affinity = http_setting[:cookie_based_affinity]
+            backend_http_setting.request_timeout = http_setting[:request_timeout]
+            if http_setting[:probe]
+              probe = Azure::ARM::Network::Models::Probe.new
+              probe.id = http_setting[:probe]
+              backend_http_setting.probe = probe
+            end
+
+            backend_http_setting.name = http_setting[:name]
+            backend_http_setting_arr.push(backend_http_setting)
+          end
+          backend_http_setting_arr
+        end
+
+        def define_http_listeners(http_listeners)
+          http_listener_arr = []
+
+          http_listeners.each do |listener|
+            http_listener = Azure::ARM::Network::Models::ApplicationGatewayHttpListener.new
+
+            http_listener.protocol = listener[:protocol]
+            http_listener.host_name = listener[:host_name]
+            http_listener.require_server_name_indication = listener[:require_server_name_indication]
+            if listener[:frontend_ip_config_id]
+              frontend_ip = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+              frontend_ip.id = listener[:frontend_ip_config_id]
+              http_listener.frontend_ipconfiguration = frontend_ip
+            end
+            if listener[:frontend_port_id]
+              frontend_port = Azure::ARM::Network::Models::ApplicationGatewayFrontendPort.new
+              frontend_port.id = listener[:frontend_port_id]
+              http_listener.frontend_port = frontend_port
+            end
+            if listener[:ssl_certificate_id]
+              ssl_cert = Azure::ARM::Network::Models::ApplicationGatewaySslCertificate.new
+              ssl_cert.id = listener[:ssl_certificate_id]
+              http_listener.ssl_certificate = ssl_cert
+            end
+
+            http_listener.name = listener[:name]
+            http_listener_arr.push(http_listener)
+          end
+          http_listener_arr
+        end
+
+        def define_url_path_maps(url_path_maps)
+          url_path_map_arr = []
+
+          url_path_maps.each do |map|
+            url_path_map = Azure::ARM::Network::Models::ApplicationGatewayUrlPathMap.new
+
+            if map[:default_backend_address_pool_id]
+              default_backend_address_pool = Azure::ARM::Network::Models::BackendAddressPool.new
+              default_backend_address_pool.id = map[:default_backend_address_pool_id]
+              url_path_map.default_backend_address_pool = default_backend_address_pool
+            end
+            if map[:default_backend_http_settings_id]
+              default_backend_http_setting = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettings.new
+              default_backend_http_setting.id = map[:default_backend_http_settings_id]
+              url_path_map.default_backend_http_settings = default_backend_http_setting
+            end
+
+            if map[:path_rules]
+              path_rules = map[:path_rules]
+              path_rule_arr = define_path_rules(path_rules)
+              url_path_map.path_rules = path_rule_arr
+            end
+
+            url_path_map.name = map[:name]
+            url_path_map_arr.push(url_path_map)
+          end
+          url_path_map_arr
+        end
+
+        def define_path_rules(path_rules)
+          path_rule_arr = []
+          path_rules.each do |rule|
+            path_rule = Azure::ARM::Network::Models::ApplicationGatewayPathRule.new
+            if rule[:backend_address_pool_id]
+              backend_address_pool = Azure::ARM::Network::Models::BackendAddressPool.new
+              backend_address_pool.id = rule[:backend_address_pool_id]
+              path_rule.backend_address_pool = backend_address_pool
+            end
+            if rule[:backend_http_settings_id]
+              backend_http_setting = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettings.new
+              backend_http_setting.id = rule[:backend_http_settings_id]
+              path_rule.backend_http_settings = backend_http_setting
+            end
+            path_urls = rule[:paths]
+
+            paths = []
+            path_urls.each do |url|
+              paths.push(url)
+            end
+            path_rule.paths = paths
+
+            path_rule.name = rule[:name]
+            path_rule_arr.push(path_rule)
+          end
+          path_rule_arr
+        end
+
+        def define_request_routing_rules(request_routing_rules)
+          request_routing_rule_arr = []
+
+          request_routing_rules.each do |rule|
+            request_routing_rule = Azure::ARM::Network::Models::ApplicationGatewayRequestRoutingRule.new
+
+            request_routing_rule.rule_type = rule[:type]
+            if rule[:http_listener_id]
+              http_listener = Azure::ARM::Network::Models::ApplicationGatewayHttpListener.new
+              http_listener.id = rule[:http_listener_id]
+              request_routing_rule.http_listener = http_listener
+            end
+            if rule[:backend_address_pool_id]
+              backend_address_pool = Azure::ARM::Network::Models::BackendAddressPool.new
+              backend_address_pool.id = rule[:backend_address_pool_id]
+              request_routing_rule.backend_address_pool = backend_address_pool
+            end
+            if rule[:backend_http_settings_id]
+              backend_http_setting = Azure::ARM::Network::Models::ApplicationGatewayBackendHttpSettings.new
+              backend_http_setting.id = rule[:backend_http_settings_id]
+              request_routing_rule.backend_http_settings = backend_http_setting
+            end
+
+            request_routing_rule.name = rule[:name]
+            request_routing_rule_arr.push(request_routing_rule)
+          end
+          request_routing_rule_arr
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def create_or_update_application_gateway(*)
+        end
+      end
+    end
+  end
+end