fog-azure-rm-temp 0.0.1

data/test/api_stub/requests/compute/virtual_machine_extension.rb

@@ -0,0 +1,46 @@
+module ApiStub
+  module Requests
+    module Compute
+      # Mock class for VirtualMachineExtension Requests
+      class VirtualMachineExtension
+        def self.create_vm_extension_response(compute_client)
+          body = {
+            'id' => '/subscriptions/########-####-####-####-############/resourceGroups/TestRG/providers/Microsoft.Compute/virtualMachines/TestVM/extensions/IaaSAntimalware',
+            'name' => 'IaasAntimalware',
+            'resource_group' => 'fog-test-rg',
+            'location' => 'West US',
+            'properties' => {
+              'publisher' => 'Microsoft.Azure.Security',
+              'type' => 'IaaSAntimalware',
+              'typeHandlerVersion' => '1.3',
+              'autoUpgradeMinorVersion' => 'true',
+              'forceUpdateTag' => 'RerunExtension',
+              'settings' => {
+                'AnitmalwareEnabled' => 'true',
+                'RealtimeProtectionEnabled' => 'false'
+              },
+              'protected_settings' => {}
+            }
+          }
+          extension_mapper = Azure::ARM::Compute::Models::VirtualMachineExtension.mapper
+          compute_client.deserialize(extension_mapper, body, 'result.body')
+        end
+
+        def self.vm_extension_params
+          {
+            resource_group: 'TestRG',
+            location: 'eastus',
+            vm_name: 'TestVM',
+            name: 'IaaSAntimalware',
+            publisher: 'Microsoft.Azure.Security',
+            type: 'IaaSAntimalware',
+            type_handler_version: '1.3',
+            auto_upgrade_minor_version: true,
+            settings: '{"AntimalwareEnabled": "true", "RealtimeProtectionEnabled": "false", "ScheduledScanSettings": {"isEnabled": "false", "day": "7", "time": "120", "scanType": "Quick"}, "Exclusions": {"Extensions": "", "Paths": "", "Processes": ""}}',
+            protected_settings: '{}'
+          }
+        end
+      end
+    end
+  end
+end

data/test/api_stub/requests/dns/record_set.rb

@@ -0,0 +1,75 @@
+module ApiStub
+  module Requests
+    module DNS
+      # Mock class for Record Set
+      class RecordSet
+        def self.list_record_sets_response(dns_client)
+          body = '{
+              "value": [{
+              "id":"\/subscriptions\/########-####-####-####-############\/resourceGroups\/Fog_test_rg\/providers\/Microsoft.Network\/dnszones\/fog-test-zone.com\/CNAME\/fog-test-record_set",
+              "name":"fog-test-record_set",
+              "type":"Microsoft.Network\/dnszones\/A",
+              "etag":"2cce3e93-fc64-43e4-835c-27581c28502b",
+              "location":"global",
+              "tags":{},
+              "properties":
+                          {
+                              "metadata":{},
+                              "fqdn":"fog-test-record_set.fog-test-zone.com.",
+                              "TTL":60,
+                              "ARecords":[{"ipv4Address":"1.2.3.4"},{"ipv4Address":"1.2.3.3"}]
+                          }
+          }]
+          }'
+          record_set_mapper = Azure::ARM::Dns::Models::RecordSetListResult.mapper
+          dns_client.deserialize(record_set_mapper, Fog::JSON.decode(body), 'result.body').value
+        end
+
+        def self.record_set_response_for_a_type_response(dns_client)
+          record_set = '{
+            "id": "/subscriptions/########-####-####-####-############/resourceGroups/EdgeMonitoring2/providers/Microsoft.Network/dnszones/edgemonitoring2.com./A/www",
+            "location": "global",
+            "name": "www",
+            "tags": {},
+            "type": "Microsoft.Network/dnszones/A",
+            "etag": "5b83020b-b59c-44be-8f19-a052ebe80fe7",
+            "properties": {
+              "TTL": 3600,
+              "ARecords": [
+              {
+                "ipv4Address": "4.3.2.1"
+              },
+              {
+                "ipv4Address": "5.3.2.1"
+              }
+              ]
+            }
+          }'
+          record_set_mapper = Azure::ARM::Dns::Models::RecordSet.mapper
+          dns_client.deserialize(record_set_mapper, Fog::JSON.decode(record_set), 'result.body')
+        end
+
+        def self.record_set_response_for_cname_type(dns_client)
+          record_set = '{
+            "id": "/subscriptions/########-####-####-####-############/resourceGroups/EdgeMonitoring2/providers/Microsoft.Network/dnszones/edgemonitoring2.com./CNAME/www",
+            "location": "global",
+            "name": "www",
+            "tags": {},
+            "type": "Microsoft.Network/dnszones/CNAME",
+            "etag": "5b83020b-b59c-44be-8f19-a052ebe80fe7",
+            "properties": {
+              "metadata": [],
+              "fqdn": "fog-test-record_set.fog-test-zone.com.",
+              "TTL": "60",
+              "CNAMERecord": {
+                "cname": "test.fog.com"
+              }
+            }
+          }'
+          record_set_mapper = Azure::ARM::Dns::Models::RecordSet.mapper
+          dns_client.deserialize(record_set_mapper, Fog::JSON.decode(record_set), 'result.body')
+        end
+      end
+    end
+  end
+end

data/test/api_stub/requests/dns/zone.rb

@@ -0,0 +1,52 @@
+module ApiStub
+  module Requests
+    module DNS
+      # Mock class for Zone
+      class Zone
+        def self.list_zones_response(dns_client)
+          body = '{
+            "value": [{
+              "id":"\/subscriptions\/########-####-####-####-############\/resourceGroups\/fog_test_rg\/providers\/Microsoft.Network\/dnszones\/adnaan.com",
+              "name":"adnaan.com",
+              "type":"Microsoft.Network\/dnszones",
+              "etag":"00000011-0000-0000-19f2-3a6c32b0d101",
+              "location":"global",
+              "tags":{},
+              "properties":
+                {
+                  "maxNumberOfRecordSets":5000,
+                  "nameServers":null,
+                  "numberOfRecordSets":2,
+                  "parentResourceGroupName":"fog_test_rg"
+                },
+                "resource_group":"fog-test-rg"
+            }]
+          }'
+          zone_mapper = Azure::ARM::Dns::Models::ZoneListResult.mapper
+          dns_client.deserialize(zone_mapper, Fog::JSON.decode(body), 'result.body').value
+        end
+
+        def self.zone_response(dns_client)
+          zone = '{
+            "id": "/subscriptions/########-####-####-####-############/resourceGroups/fog-test-rg/providers/Microsoft.Network/dnszones/fog-test-zone.com",
+            "name": "fog-test-zone.com",
+            "type": "Microsoft.Network/dnszones",
+            "etag": "00000003-0000-0000-bd66-02b337a4d101",
+            "location": "global",
+            "tags": {},
+            "properties":
+              {
+                "maxNumberOfRecordSets": 100,
+                "nameServers": [],
+                "numberOfRecordSets": 2,
+                "parentResourceGroupName": "fog-test-rg"
+              },
+            "resource_group": "fog-test-rg"
+          }'
+          zone_mapper = Azure::ARM::Dns::Models::Zone.mapper
+          dns_client.deserialize(zone_mapper, Fog::JSON.decode(zone), 'result.body')
+        end
+      end
+    end
+  end
+end

data/test/api_stub/requests/key_vault/vault.rb

@@ -0,0 +1,95 @@
+module ApiStub
+  module Requests
+    module KeyVault
+      # Mock class for Vault Requests
+      class Vault
+        def self.create_vault_response(key_vault_client)
+          response = '{
+            "id" : "/subscriptions/{AZURE_SUBSCRIPTION_ID}/resourceGroups/fog-test-rg/providers/Microsoft.KeyVault/vaults/fog-test-kv",
+            "name" : "fog-test-kv",
+            "type" : "Microsoft.KeyVault/vaults",
+            "location" : "westus",
+            "tags" : {},
+            "properties" : {
+              "sku" : {
+                "family" : "A",
+                "name" : "standard"
+              },
+              "tenantId" : "{AZURE_TENANT_ID}",
+              "accessPolicies" : [
+                {
+                   "tenantId" : "{AZURE_TENANT_ID}",
+                   "objectId" : "{AZURE_OBJECT_ID}",
+                   "permissions" : {
+                     "keys" : ["all"],
+                     "secrets" : ["all"]
+                   }
+                }
+              ],
+              "enabledForDeployment" : false,
+              "vaultUri" : "https://fog-test-kv.vault.azure.net/"
+            }
+          }'
+          vault_mapper = Azure::ARM::KeyVault::Models::Vault.mapper
+          key_vault_client.deserialize(vault_mapper, Fog::JSON.decode(response), 'result.body')
+        end
+
+        def self.vault_params
+          access_policies_arr = [
+            {
+              tenant_id: '{AZURE_TENANT_ID}',
+              object_id: '{AZURE_TENANT_ID}',
+              permissions: {
+                keys: ['all'],
+                secrets: ['all']
+              }
+            }
+          ]
+
+          {
+            name: 'test-tmp',
+            resource_group: 'TestRG-KV',
+            location: 'eastus',
+            tenant_id: '{AZURE_TENANT_ID}',
+            sku_family: 'A',
+            sku_name: 'standard',
+            access_policies: access_policies_arr
+          }
+        end
+
+        def self.list_vault_response(key_vault_client)
+          response = '{
+            "value": [{
+              "id" : "/subscriptions/{AZURE_SUBSCRIPTION_ID}/resourceGroups/fog-test-rg/providers/Microsoft.KeyVault/vaults/fog-test-kv",
+              "name" : "fog-test-kv",
+              "type" : "Microsoft.KeyVault/vaults",
+              "location" : "westus",
+              "tags" : {},
+              "properties" : {
+                "sku" : {
+                  "family" : "A",
+                  "name" : "standard"
+                },
+                "tenantId" : "{AZURE_TENANT_ID}",
+                "accessPolicies" : [
+                  {
+                     "tenantId" : "{AZURE_TENANT_ID}",
+                     "objectId" : "{AZURE_OBJECT_ID}",
+                     "permissions" : {
+                       "keys" : ["all"],
+                       "secrets" : ["all"]
+                     }
+                  }
+                ],
+                "enabledForDeployment" : false,
+                "vaultUri" : "https://fog-test-kv.vault.azure.net/"
+              }
+            }]
+          }'
+          vaults_mapper = Azure::ARM::KeyVault::Models::VaultListResult.mapper
+          key_vault_client.deserialize(vaults_mapper, Fog::JSON.decode(response), 'result.body')
+        end
+      end
+    end
+  end
+end

data/test/api_stub/requests/network/express_route_circuit.rb

@@ -0,0 +1,100 @@
+module ApiStub
+  module Requests
+    module Network
+      # Mock class for Express Route Circuit Requests
+      class ExpressRouteCircuit
+        def self.create_express_route_circuit_response(network_client)
+          body = '{
+            "name": "<circuit name>",
+            "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/testCircuit",
+            "location": "<location>",
+            "tags": {
+              "key1": "value1",
+              "key2": "value2"
+            },
+            "sku": {
+              "name": "Standard_MeteredData",
+              "tier": "Standard",
+              "family": "MeteredData"
+            },
+            "properties": {
+              "serviceProviderProperties": {
+                "serviceProviderName": "serviceProviderName",
+                "peeringLocation": "<peering location>",
+                "bandwidthInMbps": 100
+              },
+              "peerings": [
+                {
+                  "name": "AzurePublicPeering",
+                  "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}",
+                  "properties": {
+                    "peeringType": "AzurePublicPeering",
+                    "peerASN": 100,
+                    "PrimaryPeerAddressPrefix": "192.168.1.0/30",
+                    "SecondaryPeerAddressPrefix": "192.168.2.0/30",
+                    "vlanId": 200
+                  }
+                }
+              ]
+            }
+          }'
+          express_route_circuit_mapper = Azure::ARM::Network::Models::ExpressRouteCircuit.mapper
+          network_client.deserialize(express_route_circuit_mapper, Fog::JSON.decode(body), 'result.body')
+        end
+
+        def self.list_express_route_circuit_response(network_client)
+          body = '{
+            "value": [
+              {
+                "name": "<circuit name>",
+                "id": "/subscriptions/{guid}/resourceGroup/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}",
+                "etag": " W/\"00000000-0000-0000-0000-000000000000\"",
+                "location": "eastus",
+                "tags": {
+                  "key1": "value1",
+                  "key2": "value2"
+                },
+                "sku": {
+                  "name": "Standard_MeteredData",
+                  "tier": "Standard",
+                  "family": "MeteredData"
+                },
+                "properties": {
+                  "provisioningState": "Succeeded",
+                  "circuitProvisioningState": "Enabled",
+                  "serviceProviderProvisioningState": "Provisioned",
+                  "serviceProviderProperties": {
+                    "serviceProviderName": "serviceProviderName",
+                    "peeringLocation": "<peering location",
+                    "bandwidthInMbps": 100
+                  }
+                },
+                "serviceKey": "<unique service key for circuit>",
+                "serviceProviderNotes": "<notes set only by ServiceProvider>"
+              }
+            ]
+          }'
+          express_route_circuit_mapper = Azure::ARM::Network::Models::ExpressRouteCircuitListResult.mapper
+          network_client.deserialize(express_route_circuit_mapper, Fog::JSON.decode(body), 'result.body').value
+        end
+
+        def self.peerings
+          peerings =
+            [
+              {
+                name: 'AzurePrivatePeering',
+                circuit_name: 'Circuit Name',
+                resource_group: 'Fog-rg',
+                peering_type: 'AzurePrivatePeering',
+                peer_asn: 100,
+                primary_peer_address_prefix: '192.168.3.0/30',
+                secondary_peer_address_prefix: '192.168.4.0/30',
+                vlan_id: 200
+              }
+            ]
+          peerings
+        end
+      end
+    end
+  end
+end

data/test/api_stub/requests/network/express_route_circuit_authorization.rb

@@ -0,0 +1,31 @@
+module ApiStub
+  module Requests
+    module Network
+      # Mock class for Express Route Circuit Authorization Requests
+      class ExpressRouteCircuitAuthorization
+        def self.create_express_route_circuit_authorization_response(network_client)
+          authorization = '{
+            "name": "MicrosoftAuthorization",
+            "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/authorizations/{authorizationName}",
+            "properties": {
+              "authorizationKey" : "authorization-key",
+              "authorizationUseStatus" : "Available"
+            }
+          }'
+          circuit_auth_mapper = Azure::ARM::Network::Models::ExpressRouteCircuitAuthorization.mapper
+          network_client.deserialize(circuit_auth_mapper, Fog::JSON.decode(authorization), 'result.body')
+        end
+
+        def self.auth_hash
+          {
+            resource_group: 'rg-name',
+            name: 'auth-unique-name',
+            circuit_name: 'circuit-name',
+            authorization_use_status: 'Available',
+            authorization_name: 'authorization-name'
+          }
+        end
+      end
+    end
+  end
+end

data/test/api_stub/requests/network/express_route_circuit_peering.rb

@@ -0,0 +1,62 @@
+module ApiStub
+  module Requests
+    module Network
+      # Mock class for Express Route Circuit Peering Requests
+      class ExpressRouteCircuitPeering
+        def self.create_express_route_circuit_peering_response(network_client)
+          body = '{
+          "name": "MicrosoftPeering",
+          "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{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>"
+              }
+            }
+          }'
+          express_route_circuit_mapper = Azure::ARM::Network::Models::ExpressRouteCircuitPeering.mapper
+          network_client.deserialize(express_route_circuit_mapper, Fog::JSON.decode(body), 'result.body')
+        end
+
+        def self.list_express_route_circuit_peering_response(network_client)
+          body = '{
+            "value": [
+              {
+                "name": "MicrosoftPeering",
+                "id": "/subscriptions/{guid}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{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>"
+                  }
+                }
+              }
+            ]
+          }'
+          express_route_circuit_mapper = Azure::ARM::Network::Models::ExpressRouteCircuitPeeringListResult.mapper
+          network_client.deserialize(express_route_circuit_mapper, Fog::JSON.decode(body), 'result.body').value
+        end
+      end
+    end
+  end
+end