fog-azure-rm 0.3.3 → 0.3.4

data/test/integration/sql_server.rb

@@ -44,10 +44,13 @@ begin
   ######################                         Create Sql Server                                  ######################
   ########################################################################################################################
 
+  tags = { key1: 'value1', key2: 'value2' }
+
   sql_server = azure_sql_service.sql_servers.create(
     name: server_name,
     resource_group: 'TestRG-SQL',
     location: LOCATION,
+    tags: tags,
     version: '2.0',
     administrator_login: 'testserveradmin',
     administrator_login_password: 'db@admin=123'
@@ -67,10 +70,11 @@ begin
   ########################################################################################################################
 
   sql_database = azure_sql_service.sql_databases.create(
+    name: database_name,
     resource_group: 'TestRG-SQL',
     location: LOCATION,
-    server_name: server_name,
-    name: database_name
+    tags: tags,
+    server_name: server_name
   )
   puts "Created sql database: #{sql_database.name}"
 
@@ -112,6 +116,7 @@ begin
   firewall_rule = azure_sql_service.firewall_rules.create(
     resource_group: 'TestRG-SQL',
     server_name: server_name,
+    tags: tags,
     name: 'test-rule-name',
     start_ip: '10.10.10.10',
     end_ip: '10.10.10.11'
@@ -167,8 +172,11 @@ begin
   ########################################################################################################################
   ######################                                   CleanUp                                  ######################
   ########################################################################################################################
+
   resource_group = resources.resource_groups.get('TestRG-SQL')
   resource_group.destroy
+
+  puts 'Integration test for SQL ran successfully!'
 rescue
   puts 'Integration Test for sql server is failing'
   resource_group.destroy unless resource_group.nil?

data/test/integration/storage_account.rb

@@ -23,13 +23,24 @@ storage = Fog::Storage::AzureRM.new(
   environment: azure_credentials['environment']
 )
 
+########################################################################################################################
+######################                               Resource names                                #####################
+########################################################################################################################
+
+time = current_time
+resource_group_name = "TestRG-SA-#{time}"
+storage_account_name = "teststorage#{time}"
+lrs_storage_account = "lrs#{time}"
+grs_storage_account = "grs#{time}"
+premium_storage_acc = "premsa#{time}"
+
 ########################################################################################################################
 ######################                                 Prerequisites                              ######################
 ########################################################################################################################
 
 begin
   resource_group = rs.resource_groups.create(
-    name: 'TestRG-SA',
+    name: resource_group_name,
     location: LOCATION
   )
 
@@ -37,26 +48,27 @@ begin
   ######################                    Check Storage Account name Availability                 ######################
   ########################################################################################################################
 
-  storage_account_avail = storage.storage_accounts.check_name_availability('teststorage123')
+  storage_account_avail = storage.storage_accounts.check_name_availability(storage_account_name)
   puts storage_account_avail ? 'Storage Account name available' : 'Storage Account name unavailable'
 
   ########################################################################################################################
   ######################                         Check Subnet Exists?                               ######################
   ########################################################################################################################
 
-  lrs_storage_account = "lrs#{current_time}"
-
-  flag = storage.storage_accounts.check_storage_account_exists('TestRG-SA', lrs_storage_account)
+  flag = storage.storage_accounts.check_storage_account_exists(resource_group_name, lrs_storage_account)
   puts "Storage Account doesn't exist." unless flag
 
   ########################################################################################################################
   ###############  Create A Standard Storage Account of Replication: LRS (Locally-redundant storage)       ###############
   ########################################################################################################################
 
+  tags = { key1: 'value1', key2: 'value2' }
+
   storage_account = storage.storage_accounts.create(
     name: lrs_storage_account,
     location: LOCATION,
-    resource_group: 'TestRG-SA'
+    resource_group: resource_group_name,
+    tags: tags
   )
   puts "Created storage account for standard lrs replication: #{storage_account.name}"
 
@@ -64,15 +76,14 @@ begin
   ###############      Create A Standard Storage Account of Replication: GRS (Geo-redundant storage)     #################
   ########################################################################################################################
 
-  grs_storage_account = "grs#{current_time}"
-
   storage_account = storage.storage_accounts.create(
     name: grs_storage_account,
     location: LOCATION,
-    resource_group: 'TestRG-SA',
+    resource_group: resource_group_name,
     sku_name: Fog::ARM::Storage::Models::SkuTier::Standard,
     replication: 'GRS',
-    encryption: true
+    encryption: true,
+    tags: tags
   )
   puts "Created storage account for standard grs replication: #{storage_account.name}"
 
@@ -80,14 +91,13 @@ begin
   ###########   Create A Premium(SSD) Storage Account of its only Replication: LRS (Locally-redundant storage)  ##########
   ########################################################################################################################
 
-  premium_storage_acc = "premsa#{current_time}"
-
   storage_account = storage.storage_accounts.create(
     name: premium_storage_acc,
     location: LOCATION,
-    resource_group: 'TestRG-SA',
+    resource_group: resource_group_name,
     sku_name: Fog::ARM::Storage::Models::SkuTier::Premium,
-    replication: 'LRS'
+    replication: 'LRS',
+    tags: tags
   )
   puts "Created storage account for premium lrs replication: #{storage_account.name}"
 
@@ -95,28 +105,30 @@ begin
   ######################                         Get and Update Storage Account                     ######################
   ########################################################################################################################
 
-  premium_storage_account = storage.storage_accounts.get('TestRG-SA', premium_storage_acc)
+  premium_storage_account = storage.storage_accounts.get(resource_group_name, premium_storage_acc)
   puts "Get storage account: #{premium_storage_account.name}"
   premium_storage_account.update(encryption: true)
-  puts 'Updated encrytion of storage account'
+  puts 'Updated encryption of storage account'
 
   ########################################################################################################################
   ######################                         Get and Delete Storage Account                     ######################
   ########################################################################################################################
 
-  standard_storage_account = storage.storage_accounts.get('TestRG-SA', lrs_storage_account)
+  standard_storage_account = storage.storage_accounts.get(resource_group_name, lrs_storage_account)
   puts "Deleted storage account for standard lrs replication: #{standard_storage_account.destroy}"
-  standard_storage_account = storage.storage_accounts.get('TestRG-SA', grs_storage_account)
+  standard_storage_account = storage.storage_accounts.get(resource_group_name, grs_storage_account)
   puts "Deleted storage account for standard grs replication: #{standard_storage_account.destroy}"
-  premium_storage_account = storage.storage_accounts.get('TestRG-SA', premium_storage_acc)
+  premium_storage_account = storage.storage_accounts.get(resource_group_name, premium_storage_acc)
   puts "Deleted storage account for premium lrs replication: #{premium_storage_account.destroy}"
 
   ########################################################################################################################
   ######################                                   CleanUp                                  ######################
   ########################################################################################################################
 
-  resource_group = rs.resource_groups.get('TestRG-SA')
+  resource_group = rs.resource_groups.get(resource_group_name)
   resource_group.destroy
+
+  puts 'Integration test for storage account ran successfully!'
 rescue
   puts 'Integration Test for storage account is failing'
   resource_group.destroy unless resource_group.nil?

data/test/integration/traffic_manager.rb

@@ -43,9 +43,12 @@ begin
   ######################                         Create Traffic Manager Profile                     ######################
   ########################################################################################################################
 
+  tags = { key1: 'value1', key2: 'value2' }
+
   traffic_manager_profile = traffic_manager.traffic_manager_profiles.create(
     name: 'test-tmp',
     resource_group: 'TestRG-TM',
+    tags: tags,
     traffic_routing_method: 'Performance',
     relative_name: 'testapplication',
     ttl: '30',
@@ -77,8 +80,8 @@ begin
 
   traffic_manager_end_point = traffic_manager.traffic_manager_end_points.create(
     name: 'myendpoint',
-    traffic_manager_profile_name: 'test-tmp',
     resource_group: 'TestRG-TM',
+    traffic_manager_profile_name: 'test-tmp',
     type: 'externalEndpoints',
     target: 'test-app1.com',
     endpoint_location: 'eastus'
@@ -131,6 +134,8 @@ begin
 
   resource_group = resources.resource_groups.get('TestRG-TM')
   resource_group.destroy
+
+  puts 'Integration test for Traffic Manager ran successfully!'
 rescue
   puts 'Integration Test for traffic manager is failing'
   resource_group.destroy unless resource_group.nil?

data/test/integration/virtual_network.rb

@@ -52,7 +52,8 @@ begin
       address_prefix: '10.1.0.0/24'
     }],
     dns_servers:       %w(10.1.0.0 10.2.0.0),
-    address_prefixes:  %w(10.1.0.0/16 10.2.0.0/16)
+    address_prefixes:  %w(10.1.0.0/16 10.2.0.0/16),
+    tags: { key: 'value' }
   )
   puts "Created virtual network: #{virtual_network.name}"
 

data/test/integration/virtual_network_gateway_connection.rb

@@ -174,7 +174,8 @@ begin
       name: 'testnetworkgateway',
       resource_group: 'TestRG-GC'
     },
-    connection_type: 'Vnet2Vnet'
+    connection_type: 'Vnet2Vnet',
+    tags: { key: 'value' }
   )
   puts "Created virtual network gateway connection: #{virtual_network_gateway_connection.name}"
 
@@ -214,8 +215,7 @@ begin
 
   resource_group = resource.resource_groups.get('TestRG-GC')
   resource_group.destroy
-rescue Exception => e
-  raise e
+rescue
   puts 'Integration Test for virtual network gateway connection is failing'
   resource_group.destroy unless resource_group.nil?
 end

data/test/models/application_gateway/test_gateway.rb

@@ -54,7 +54,8 @@ class TestGateway < Minitest::Test
       :backend_http_settings_list,
       :http_listeners,
       :url_path_maps,
-      :request_routing_rules
+      :request_routing_rules,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @gateway, attribute

data/test/models/compute/test_availability_set.rb

@@ -29,7 +29,8 @@ class TestAvailabilitySet < Minitest::Test
       :platform_update_domain_count,
       :platform_fault_domain_count,
       :use_managed_disk,
-      :sku_name
+      :sku_name,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @availability_set, attribute

data/test/models/{storage → compute}/test_data_disk.rb

@@ -3,8 +3,8 @@ require File.expand_path '../../test_helper', __dir__
 # Test class for Data Disk Model
 class TestDataDisk < Minitest::Test
   def setup
-    @service = Fog::Storage::AzureRM.new(credentials)
-    @data_disk = Fog::Storage::AzureRM::DataDisk.new
+    @service = Fog::Compute::AzureRM.new(credentials)
+    @data_disk = Fog::Compute::AzureRM::DataDisk.new
   end
 
   def test_model_attributes

data/test/models/compute/test_managed_disk.rb

@@ -34,7 +34,8 @@ class TestManagedDisk < Minitest::Test
       :provisioning_state,
       :tags,
       :creation_data,
-      :encryption_settings
+      :encryption_settings,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @managed_disk, attribute

data/test/models/compute/test_server.rb

@@ -20,7 +20,9 @@ class TestServer < Minitest::Test
       :redeploy,
       :list_available_sizes,
       :attach_data_disk,
-      :detach_data_disk
+      :detach_data_disk,
+      :attach_managed_disk,
+      :detach_managed_disk
     ]
     methods.each do |method|
       assert_respond_to @server, method
@@ -52,7 +54,10 @@ class TestServer < Minitest::Test
       :provision_vm_agent,
       :enable_automatic_updates,
       :network_interface_card_ids,
-      :availability_set_id
+      :availability_set_id,
+      :managed_disk_storage_type,
+      :os_disk_size,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @server, attribute
@@ -198,4 +203,28 @@ class TestServer < Minitest::Test
       assert_instance_of Fog::AzureRM::AsyncResponse, @server.detach_data_disk('disk1', true)
     end
   end
+
+  def test_attach_managed_disk_response
+    response = ApiStub::Models::Compute::Server.attach_managed_disk_response(@compute_client)
+    @service.stub :attach_data_disk_to_vm, response do
+      assert_instance_of Fog::Compute::AzureRM::Server, @server.attach_managed_disk('disk_name', 'resoure_group')
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :attach_data_disk_to_vm, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.attach_managed_disk('managed_disk_name', 'resoure_group', true)
+    end
+  end
+
+  def test_detach_managed_disk_response
+    response = ApiStub::Models::Compute::Server.create_linux_virtual_machine_response(@compute_client)
+    @service.stub :detach_data_disk_from_vm, response do
+      assert_instance_of Fog::Compute::AzureRM::Server, @server.detach_managed_disk('managed_disk_name')
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :detach_data_disk_from_vm, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.detach_managed_disk('managed_disk_name', true)
+    end
+  end
 end

data/test/models/dns/test_zone.rb

@@ -23,7 +23,8 @@ class TestZone < Minitest::Test
     attributes = [
       :name,
       :id,
-      :resource_group
+      :resource_group,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @zone, attribute

data/test/models/key_vault/test_vault.rb

@@ -20,7 +20,8 @@ class TestVault < Minitest::Test
       :access_policies,
       :enabled_for_deployment,
       :enabled_for_disk_encryption,
-      :enabled_for_template_deployment
+      :enabled_for_template_deployment,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @vault, attribute

data/test/models/network/test_load_balancer.rb

@@ -30,7 +30,8 @@ class TestLoadBalancer < Minitest::Test
       :load_balancing_rules,
       :probes,
       :inbound_nat_rules,
-      :inbound_nat_pools
+      :inbound_nat_pools,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @load_balancer, attribute

data/test/models/network/test_network_interface.rb

@@ -44,7 +44,8 @@ class TestNetworkInterface < Minitest::Test
       :dns_servers,
       :applied_dns_servers,
       :internal_dns_name_label,
-      :internal_fqd
+      :internal_fqd,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @network_interface, attribute

data/test/models/network/test_network_security_group.rb

@@ -31,7 +31,8 @@ class TestNetworkSecurityGroup < Minitest::Test
       :network_interfaces_ids,
       :subnets_ids,
       :security_rules,
-      :default_security_rules
+      :default_security_rules,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @network_security_group, attribute

data/test/models/network/test_public_ip.rb

@@ -31,7 +31,8 @@ class TestPublicIp < Minitest::Test
       :ip_configuration_id,
       :domain_name_label,
       :fqdn,
-      :reverse_fqdn
+      :reverse_fqdn,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @public_ip, attribute

data/test/models/network/test_virtual_network.rb

@@ -34,7 +34,8 @@ class TestVirtualNetwork < Minitest::Test
       :dns_servers,
       :subnets,
       :address_prefixes,
-      :resource_group
+      :resource_group,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @virtual_network, attribute

data/test/models/resources/test_resource_group.rb

@@ -23,7 +23,8 @@ class TestResourceGroup < Minitest::Test
     attributes = [
       :id,
       :name,
-      :location
+      :location,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @resource_group, attribute

data/test/models/sql/test_database.rb

@@ -39,7 +39,8 @@ class TestDatabase < Minitest::Test
       :requested_service_objective_id,
       :requested_service_objective_name,
       :service_level_objective,
-      :source_database_id
+      :source_database_id,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @database, attribute

data/test/models/sql/test_sql_server.rb

@@ -29,7 +29,8 @@ class TestSqlServer < Minitest::Test
       :state,
       :administrator_login,
       :administrator_login_password,
-      :fully_qualified_domain_name
+      :fully_qualified_domain_name,
+      :tags
     ]
     attributes.each do |attribute|
       assert_respond_to @sql_server, attribute