fog-azure-rm 0.1.2 → 0.2.0

data/test/api_stub/requests/sql/database.rb

@@ -3,8 +3,8 @@ module ApiStub
     module Sql
       # Mock class for Database
       class SqlDatabase
-        def self.create_database_response
-          '{
+        def self.create_database_response(sql_manager_client)
+          body = '{
             "name" : "{database-name}",
             "server_name" : "{server-name}",
             "location" : "{database-location}",
@@ -21,10 +21,12 @@ module ApiStub
               "elasticPoolName" : "{elastic-pool-name}"
             }
           }'
+          database_mapper = Azure::ARM::SQL::Models::Database.mapper
+          sql_manager_client.deserialize(database_mapper, Fog::JSON.decode(body), 'result.body')
         end
 
-        def self.list_database_response
-          '{
+        def self.list_database_response(sql_manager_client)
+          body = '{
             "value": [{
               "name" : "{database-name}",
               "server_name" : "{server-name}",
@@ -43,6 +45,8 @@ module ApiStub
               }
             }]
           }'
+          database_mapper = Azure::ARM::SQL::Models::DatabaseListResult.mapper
+          sql_manager_client.deserialize(database_mapper, Fog::JSON.decode(body), 'result.body')
         end
 
         def self.database_hash
@@ -57,8 +61,6 @@ module ApiStub
             collation: 'collation',
             max_size_bytes: 'max_size_bytes',
             requested_service_objective_name: 'requested_service_objective_name',
-            restore_point_in_time: 'restore_point_in_time',
-            source_database_deletion_date: 'source_database_deletion_date',
             elastic_pool_name: 'elastic_pool_name',
             requested_service_objective_id: 'requested_service_objective_id'
           }

data/test/api_stub/requests/sql/firewall_rule.rb

@@ -3,8 +3,8 @@ module ApiStub
     module Sql
       # Mock class for Firewall Rule
       class FirewallRule
-        def self.create_firewall_rule_response
-          '{
+        def self.create_firewall_rule_response(sql_manager_client)
+          body = '{
             "id": "{uri-of-firewall-rule}",
             "name": "{rule-name}",
             "type": "{rule-type}",
@@ -14,10 +14,12 @@ module ApiStub
               "endIpAddress": "{end-ip-address}"
             }
           }'
+          firewall_mapper = Azure::ARM::SQL::Models::ServerFirewallRule.mapper
+          sql_manager_client.deserialize(firewall_mapper, Fog::JSON.decode(body), 'result.body')
         end
 
-        def self.list_firewall_rule_response
-          '{
+        def self.list_firewall_rule_response(sql_manager_client)
+          body = '{
             "value": [{
               "id": "{uri-of-firewall-rule}",
               "name": "{rule-name}",
@@ -29,6 +31,8 @@ module ApiStub
               }
             }]
           }'
+          firewall_mapper = Azure::ARM::SQL::Models::ServerFirewallRuleListResult.mapper
+          sql_manager_client.deserialize(firewall_mapper, Fog::JSON.decode(body), 'result.body')
         end
 
         def self.firewall_rule_hash

data/test/api_stub/requests/sql/sql_server.rb

@@ -3,8 +3,8 @@ module ApiStub
     module Sql
       # Mock class for Sql Server
       class SqlServer
-        def self.create_sql_server_response
-          '{
+        def self.create_sql_server_response(sql_manager_client)
+          body = '{
             "location" : "{server-location}",
             "properties" : {
               "version" : "{server-version}",
@@ -12,10 +12,12 @@ module ApiStub
               "administratorLoginPassword" : "{admin-password}"
             }
           }'
+          server_mapper = Azure::ARM::SQL::Models::Server.mapper
+          sql_manager_client.deserialize(server_mapper, Fog::JSON.decode(body), 'result.body')
         end
 
-        def self.list_sql_server_response
-          '{
+        def self.list_sql_server_response(sql_manager_client)
+          body = '{
             "value": [{
               "name" : "{database-name}",
               "server_name" : "{server-name}",
@@ -27,6 +29,8 @@ module ApiStub
               }
             }]
           }'
+          server_mapper = Azure::ARM::SQL::Models::ServerListResult.mapper
+          sql_manager_client.deserialize(server_mapper, Fog::JSON.decode(body), 'result.body')
         end
 
         def self.sql_server_hash

data/test/integration/Virtual_network_gateway_connection.rb

@@ -151,6 +151,13 @@ begin
     gateway_default_site: "/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/TestRG-GC/providers/Microsoft.Network/localNetworkGateways/testlocalnetworkgateway"
   )
 
+  ########################################################################################################################
+  ######################            Check Virtual Network Gateway Connection Exists                 ######################
+  ########################################################################################################################
+
+  flag = network.virtual_network_gateway_connections.check_vnet_gateway_connection_exists('TestRG-GC', 'testnetworkgateway2-to-testnetworkgateway')
+  puts "Virtual Network Gateway Connection doesn't exist." unless flag
+
   ########################################################################################################################
   ######################                           Create Virtual Network Gateway Connection                   ###########
   ########################################################################################################################

data/test/integration/application_gateway.rb

@@ -71,6 +71,13 @@ begin
     public_ip_allocation_method: 'Dynamic'
   )
 
+  ########################################################################################################################
+  ######################                            Check for Application Gateway                   ######################
+  ########################################################################################################################
+
+  flag = application_gateway.gateways.check_application_gateway_exists(resource_group_name, app_gateway_name)
+  puts "Application Gateway doesn't exist." unless flag
+
   #######################################################################################################################
   #####################                          Create Application Gateway                        ######################
   #######################################################################################################################
@@ -239,6 +246,7 @@ begin
 
   resource_group = resource.resource_groups.get(resource_group_name)
   resource_group.destroy
+  puts 'Integration Test for application gateway ran successfully'
 rescue
   puts 'Integration Test for application gateway is failing'
   resource_group.destroy unless resource_group.nil?

data/test/integration/availability_set.rb

@@ -12,14 +12,16 @@ rs = Fog::Resources::AzureRM.new(
   tenant_id: azure_credentials['tenant_id'],
   client_id: azure_credentials['client_id'],
   client_secret: azure_credentials['client_secret'],
-  subscription_id: azure_credentials['subscription_id']
+  subscription_id: azure_credentials['subscription_id'],
+  environment: azure_credentials['environment']
 )
 
 compute = Fog::Compute::AzureRM.new(
   tenant_id: azure_credentials['tenant_id'],
   client_id: azure_credentials['client_id'],
   client_secret: azure_credentials['client_secret'],
-  subscription_id: azure_credentials['subscription_id']
+  subscription_id: azure_credentials['subscription_id'],
+  environment: azure_credentials['environment']
 )
 
 ########################################################################################################################
@@ -40,6 +42,14 @@ begin
     location: LOCATION
   )
 
+
+  ########################################################################################################################
+  ######################                            Check for Availability set                       ######################
+  ########################################################################################################################
+
+  flag = compute.availability_sets.check_availability_set_exists(resource_group_name, availability_set_name)
+  puts "Availability set doesn't exist." unless flag
+
   ########################################################################################################################
   ######################                             Create Availability Set                        ######################
   ########################################################################################################################
@@ -73,6 +83,7 @@ begin
 
   rg = rs.resource_groups.get(resource_group_name)
   rg.destroy
+  puts 'Integration Test for availability set ran successfully'
 rescue
   puts 'Integration Test for availability set is failing'
   resource_group.destroy unless resource_group.nil?

data/test/integration/blob.rb

@@ -163,12 +163,6 @@ begin
     File.delete(large_page_blob_file_name) if File.exist?(large_page_blob_file_name)
   end
 
-  ########################################################################################################################
-  ######################                    Blob Exist                                               #####################
-  ########################################################################################################################
-
-  puts 'Blob exist' if container.files.head(small_blob_name)
-
   ########################################################################################################################
   ######################                    Copy Blob                                             ########################
   ########################################################################################################################

data/test/integration/container.rb

@@ -60,6 +60,13 @@ begin
     environment: azure_credentials['environment']
   )
 
+  ########################################################################################################################
+  ######################                             Check Container Exists                         ######################
+  ########################################################################################################################
+
+  flag = storage_data.directories.check_container_exists(container_name)
+  puts "Container doesn't exist." unless flag
+
   ########################################################################################################################
   ######################                                Create Container                            ######################
   ########################################################################################################################

data/test/integration/deployment.rb

@@ -25,6 +25,13 @@ begin
     location: LOCATION
   )
 
+  ########################################################################################################################
+  ######################                            Check Deployment Exists                         ######################
+  ########################################################################################################################
+
+  flag = resources.deployments.check_deployment_exists('TestRG-ZN', 'testdeployment')
+  puts "Deployment doesn't exist." unless flag
+
   ########################################################################################################################
   ######################                                Create Deployment                     ############################
   ########################################################################################################################

data/test/integration/express_route_circuit.rb

@@ -32,6 +32,14 @@ begin
     location: LOCATION
   )
   Fog::Logger.debug 'Resource Group created!'
+
+  ########################################################################################################################
+  ######################                  Check Express Route Circuit Exists?                       ######################
+  ########################################################################################################################
+
+  flag = network.express_route_circuits.check_express_route_circuit_exists('TestRG-ER', 'testERCircuit')
+  puts "Express Route Circuit doesn't exist." unless flag
+
   ########################################################################################################################
   ################                               Create Express Route Circuit                            #################
   ########################################################################################################################
@@ -73,6 +81,13 @@ begin
     puts circuit.name
   end
 
+  ########################################################################################################################
+  ######################             Check Express Route Circuit Authorization Exists?              ######################
+  ########################################################################################################################
+
+  flag = network.express_route_circuit_authorizations.check_express_route_cir_auth_exists('TestRG-ER', 'testERCircuit', 'Test-Auth')
+  puts "Express Route Circuit Authorization doesn't exist." unless flag
+
   ########################################################################################################################
   ######################                Create Express Route Circuit Authorizations                   ####################
   ########################################################################################################################
@@ -117,6 +132,7 @@ begin
   ########################################################################################################################
   resource_group = resources.resource_groups.get('TestRG-ER')
   resource_group.destroy
+  puts 'Integration Test for express route circuit ran successfully'
 rescue
   puts 'Integration Test for express route circuit is failing'
   resource_group.destroy unless resource_group.nil?

data/test/integration/external_load_balancer.rb

@@ -54,6 +54,13 @@ begin
     public_ip_allocation_method: 'Dynamic'
   )
 
+  ########################################################################################################################
+  ######################                      Check Load Balancer Exists?                           ######################
+  ########################################################################################################################
+
+  flag = network.load_balancers.check_load_balancer_exists('TestRG-LB', 'lb')
+  puts "Load Balancer doesn't exist." unless flag
+
   ########################################################################################################################
   ######################                             Create Load Balancer                           ######################
   ########################################################################################################################
@@ -111,6 +118,16 @@ begin
     puts a_load_balancer.name
   end
 
+  ########################################################################################################################
+  ######################                List External Load Balancers in Subscription                ######################
+  ########################################################################################################################
+
+  load_balancers = network.load_balancers
+  puts 'List external load balancers in subscription:'
+  load_balancers.each do |a_load_balancer|
+    puts a_load_balancer.name
+  end
+
   ########################################################################################################################
   ######################                        Get and Destroy Load Balancer                       ######################
   ########################################################################################################################
@@ -131,6 +148,7 @@ begin
 
   resource_group = rs.resource_groups.get('TestRG-LB')
   resource_group.destroy
+  puts 'Integration Test for external load balancer ran successfully'
 rescue
   puts 'Integration Test for external load balancer is failing'
   resource_group.destroy unless resource_group.nil?

data/test/integration/key_vault.rb

@@ -0,0 +1,98 @@
+require 'fog/azurerm'
+require 'yaml'
+
+########################################################################################################################
+######################                   Services object required by all actions                  ######################
+######################                              Keep it Uncommented!                          ######################
+########################################################################################################################
+
+azure_credentials = YAML.load_file('credentials/azure.yml')
+
+resources = Fog::Resources::AzureRM.new(
+  tenant_id: azure_credentials['tenant_id'],
+  client_id: azure_credentials['client_id'],
+  client_secret: azure_credentials['client_secret'],
+  subscription_id: azure_credentials['subscription_id']
+)
+
+key_vault = Fog::KeyVault::AzureRM.new(
+  tenant_id: azure_credentials['tenant_id'],
+  client_id: azure_credentials['client_id'],
+  client_secret: azure_credentials['client_secret'],
+  subscription_id: azure_credentials['subscription_id']
+)
+
+########################################################################################################################
+######################                                 Prerequisites                              ######################
+########################################################################################################################
+
+begin
+  resources.resource_groups.create(
+    name: 'TestRG-KV',
+    location: 'eastus'
+  )
+
+  ########################################################################################################################
+  ######################                      Check Key Vault Exists?                               ######################
+  ########################################################################################################################
+
+  flag = key_vault.vaults.check_vault_exists('TestRG-KV', 'test-tmp')
+  puts "Key vault doesn't exist." unless flag
+
+  ########################################################################################################################
+  ######################                         Create Vault                                       ######################
+  ########################################################################################################################
+
+  access_policies_arr = [
+    {
+      tenant_id: azure_credentials['tenant_id'],
+      object_id: azure_credentials['tenant_id'],
+      permissions: {
+        keys: ['all'],
+        secrets: ['all']
+      }
+    }
+  ]
+
+  key_vault.vaults.create(
+    name: 'test-tmp',
+    resource_group: 'TestRG-KV',
+    location: 'eastus',
+    tenant_id: azure_credentials['tenant_id'],
+    sku_family: 'A',
+    sku_name: 'standard',
+    access_policies: access_policies_arr
+  )
+
+  ########################################################################################################################
+  ######################                            List Vault                                      ######################
+  ########################################################################################################################
+
+  vaults = key_vault.vaults(resource_group: 'TestRG-KV')
+  vaults.each do |vault|
+    puts vault.name.to_s
+  end
+
+  ########################################################################################################################
+  ######################                      Get Single Vault                                      ######################
+  ########################################################################################################################
+
+  vault = key_vault.vaults.get('TestRG-KV', 'test-tmp')
+
+  ########################################################################################################################
+  ######################                            Destroy Vault                                   ######################
+  ########################################################################################################################
+
+  vault.destroy
+
+  ########################################################################################################################
+  ######################                                   CleanUp                                  ######################
+  ########################################################################################################################
+
+  resource_group = resources.resource_groups.get('TestRG-KV')
+  resource_group.destroy
+  puts 'Integration Test for key vault ran successfully'
+rescue
+  puts 'Integration Test for key vault is failing'
+  resource_group.destroy unless resource_group.nil?
+end

data/test/integration/local_network_gateway.rb

@@ -32,6 +32,13 @@ begin
     location: LOCATION
   )
 
+  ########################################################################################################################
+  ######################                   Check Local Network Gateway Exists?                      ######################
+  ########################################################################################################################
+
+  flag = network.local_network_gateways.check_local_net_gateway_exists('TestRG-LNG', 'testlocalnetworkgateway')
+  puts "Local Network Gateway doesn't exist." unless flag
+
   ########################################################################################################################
   ######################                           Create Local Network Gateway                   ######################
   ########################################################################################################################
@@ -77,6 +84,7 @@ begin
 
   resource_group = resource.resource_groups.get('TestRG-LNG')
   resource_group.destroy
+  puts 'Integration Test for local network gateway ran successfully'
 rescue
   puts 'Integration Test for local network gateway is failing'
   resource_group.destroy unless resource_group.nil?

data/test/integration/network_interface.rb

@@ -87,6 +87,13 @@ begin
       ]
   )
 
+  ########################################################################################################################
+  ######################                      Check Network Interface Exists?                       ######################
+  ########################################################################################################################
+
+  flag = network.network_interfaces.check_network_interface_exists('TestRG-NI', 'NetInt')
+  puts "Network Interface doesn't exist." unless flag
+
   ########################################################################################################################
   ######################                           Create Network Interface                         ######################
   ########################################################################################################################
@@ -141,6 +148,7 @@ begin
 
   rg = rs.resource_groups.get('TestRG-NI')
   rg.destroy
+  puts 'Integration Test for network interface ran successfully'
 rescue
   puts 'Integration Test for network interface is failing'
   resource_group.destroy unless resource_group.nil?