fog-azure-rm 0.3.3 → 0.3.4

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

@@ -143,6 +143,81 @@ module ApiStub
           }
         end
 
+        def self.get_managed_disk_response(compute_client)
+          body = {
+            'id' => '/subscriptions/{subscription_id}/resourceGroups/ManagedRG/providers/Microsoft.Compute/disks/ManagedDataDisk1',
+            'name' => 'ManagedDataDisk1',
+            'type' => 'Microsoft.Compute/disks',
+            'location' => 'eastus',
+            'account_type' => 'Premium_LRS',
+
+            'time_created' => {
+              'datetime' => '((2458025j,52461s,709327300n),+0s,2299161j)'
+            },
+
+            'creation_data' => {
+              'create_option' => 'Empty'
+            },
+
+            'disk_size_gb' => 100,
+            'provisioning_state' => 'Succeeded'
+          }
+          vm_mapper = Azure::ARM::Compute::Models::Disk.mapper
+          compute_client.deserialize(vm_mapper, body, 'result.body')
+        end
+
+        def self.get_vm_with_managed_disk_response(compute_client)
+          body = {
+            'id' => '/subscriptions/{subscription_id}/resourceGroups/ManagedRG/providers/Microsoft.Compute/virtualMachines/ManagedVM',
+            'name' => 'ManagedVM',
+            'type' => 'Microsoft.Compute/virtualMachines',
+            'location' => 'eastus',
+            'hardware_profile' => {
+              'vm_size' => 'Standard_D2s_v3'
+            },
+            'storage_profile' => {
+              'image_reference' => {
+                'publisher' => 'Canonical',
+                'offer' => 'UbuntuServer',
+                'sku' => '16.04-LTS',
+                'version' => 'latest'
+              },
+              'os_disk' => {
+                'os_type' => 'Linux',
+                'name' => 'ManagedVM_OsDisk_1_d00cc277b8904c79ae5a777aa3fa5ac3',
+                'caching' => 'ReadWrite',
+                'create_option' => 'FromImage',
+                'disk_size_gb' => 30,
+                'managed_disk' => {
+                  'id' => '/subscriptions/{subscription_id}/resourceGroups/ManagedRG/providers/Microsoft.Compute/disks/ManagedVM_OsDisk_1_d00cc277b8904c79ae5a777aa3fa5ac3',
+                  'storage_account_type' => 'Premium_LRS'
+                }
+              },
+              'data_disks' => [{
+                'lun' => 0,
+                'name' => 'ManagedDataDisk1',
+                'caching' => 'None',
+                'create_option' => 'Attach',
+                'disk_size_gb' => 100,
+                'managed_disk' => {
+                  'id' => '/subscriptions/{subscription_id}/resourceGroups/MANAGEDRG/providers/Microsoft.Compute/disks/ManagedDataDisk1',
+                  'storage_account_type' => 'Premium_LRS'
+                }
+              }]
+            },
+            'network_profile' => {
+              'network_interfaces' => [{
+                'id' => '/subscriptions/{subscription_id}/resourceGroups/ManagedRG/providers/Microsoft.Network/networkInterfaces/managedvm992'
+              }]
+            },
+            'provisioning_state' => 'Succeeded',
+            'vm_id' => '73f38ae6-4767-4325-bd78-9ba4e74337d9'
+          }
+
+          vm_mapper = Azure::ARM::Compute::Models::VirtualMachine.mapper
+          compute_client.deserialize(vm_mapper, body, 'result.body')
+        end
+
         def self.create_virtual_machine_response(compute_client)
           body = '{
             "id":"/subscriptions/{subscription-id}/resourceGroups/fog-test-rg/providers/Microsoft.Compute/virtualMachines/fog-test-server",

data/test/api_stub/requests/resources/resource_group.rb

@@ -9,7 +9,7 @@ module ApiStub
             "name": "fog-test-rg",
             "location": "westus",
             "tags": {
-              "tagname1": "tagvalue1"
+              "tagkey1": "tagvalue1"
             },
             "properties": {
               "provisioning_state": "Succeeded"

data/test/integration/application_gateway.rb

@@ -28,12 +28,13 @@ network = Fog::Network::AzureRM.new(
   client_secret: azure_credentials['client_secret'],
   subscription_id: azure_credentials['subscription_id']
 )
+
 ########################################################################################################################
 ######################                               Resource names                                #####################
 ########################################################################################################################
 
 time = current_time
-resource_group_name = "AG-RG-#{time}"
+resource_group_name = "TestRG-AG-#{time}"
 virtual_network_name = "Vnet#{time}"
 subnet_name = "Sub#{time}"
 public_ip_name = "Pip#{time}"
@@ -82,10 +83,13 @@ begin
   #####################                          Create Application Gateway                        ######################
   #######################################################################################################################
 
+  tags = { key1: 'value1', key2: 'value2' }
+
   app_gateway = application_gateway.gateways.create(
     name: app_gateway_name,
     location: LOCATION,
     resource_group: resource_group_name,
+    tags: tags,
     sku_name: 'Standard_Medium',
     sku_tier: 'Standard',
     sku_capacity: '2',
@@ -151,6 +155,7 @@ begin
     ]
   )
   puts "Created application gateway #{app_gateway.name}"
+
   ########################################################################################################################
   ######################                      Get Application Gateway                   ######################
   ########################################################################################################################
@@ -217,6 +222,7 @@ begin
     unhealthy_threshold: 5
   )
   puts 'Added probe in application gateway'
+
   app_gateway.remove_probe(
     name: 'Probe1',
     protocol: 'http',
@@ -246,6 +252,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'

data/test/integration/availability_set.rb

@@ -29,7 +29,7 @@ compute = Fog::Compute::AzureRM.new(
 ########################################################################################################################
 
 time = current_time
-resource_group_name       = "AS-RG-#{time}"
+resource_group_name       = "TestRG-AS-#{time}"
 unmanaged_as_name_default = "ASUnmanagedDefault#{time}"
 unmanaged_as_name_custom  = "ASUnmanagedCustom#{time}"
 managed_as_name_default   = "ASManagedDefault#{time}"
@@ -71,11 +71,14 @@ begin
   ######################                    Create Unmanaged Availability Set (Default)             ######################
   ########################################################################################################################
 
+  tags = { key1: 'value1', key2: 'value2' }
+
   puts "Create unmanaged default availability set (#{unmanaged_as_name_default}):"
   avail_set = compute.availability_sets.create(
     name: unmanaged_as_name_default,
     location: LOCATION,
-    resource_group: resource_group_name
+    resource_group: resource_group_name,
+    tags: tags
   )
   name = avail_set.name
   fault_domains = avail_set.platform_fault_domain_count
@@ -91,6 +94,7 @@ begin
     name: unmanaged_as_name_custom,
     location: LOCATION,
     resource_group: resource_group_name,
+    tags: tags,
     platform_fault_domain_count: 3,
     platform_update_domain_count: 10
   )
@@ -108,6 +112,7 @@ begin
     name: managed_as_name_default,
     location: LOCATION,
     resource_group: resource_group_name,
+    tags: tags,
     use_managed_disk: true
   )
   name = avail_set.name
@@ -124,6 +129,7 @@ begin
     name: managed_as_name_custom,
     location: LOCATION,
     resource_group: resource_group_name,
+    tags: tags,
     platform_fault_domain_count: 2,
     platform_update_domain_count: 10,
     use_managed_disk: true
@@ -170,6 +176,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!!!'

data/test/integration/external_load_balancer.rb

@@ -104,7 +104,8 @@ begin
         frontend_port: 3389,
         backend_port: 3389
       }
-    ]
+    ],
+    tags: { key: 'value' }
   )
   puts "Created external load balancer: #{load_balancer.name}"
 

data/test/integration/internal_load_balancer.rb

@@ -107,7 +107,8 @@ begin
           interval_in_seconds: 15,
           number_of_probes: 2
         }
-      ]
+      ],
+    tags: { key: 'value' }
   )
   puts "Created internal load balancer: #{load_balancer.name}"
 

data/test/integration/key_vault.rb

@@ -61,7 +61,8 @@ begin
     tenant_id: azure_credentials['tenant_id'],
     sku_family: 'A',
     sku_name: 'standard',
-    access_policies: access_policies_arr
+    access_policies: access_policies_arr,
+    tags: { key: 'value' }
   )
 
   ########################################################################################################################

data/test/integration/managed_disk.rb

@@ -28,9 +28,9 @@ compute = Fog::Compute::AzureRM.new(
 ######################                               Resource names                                #####################
 ########################################################################################################################
 
-time = current_time
-resource_group_name = "MD-RG-#{time}"
-disk_name = "MD#{time}diskunique"
+time                = current_time
+resource_group_name = "TestRG-MD-#{time}"
+disk_name           = "MD#{time}"
 
 ########################################################################################################################
 ######################                                 Prerequisites                              ######################
@@ -53,10 +53,13 @@ begin
   ######################                             Create Managed Disk                            ######################
   ########################################################################################################################
 
+  tags = { key1: 'value1', key2: 'value2' }
+
   disk = compute.managed_disks.create(
     name: disk_name,
     location: LOCATION,
     resource_group_name: resource_group_name,
+    tags: tags,
     account_type: 'Premium_LRS',
     disk_size_gb: 1023,
     creation_data: {
@@ -78,6 +81,7 @@ begin
   ########################################################################################################################
   ######################                       List Managed Disks                                   ######################
   ########################################################################################################################
+
   puts 'List managed disks:'
   compute.managed_disks(resource_group: resource_group_name).each do |managed_disk|
     puts managed_disk.name
@@ -106,8 +110,9 @@ begin
 
   rg = rs.resource_groups.get(resource_group_name)
   rg.destroy
-  puts 'Integration Test for managed disk ran successfully'
+
+  puts 'Integration Test for managed disk ran successfully!'
 rescue
-  puts 'Integration Test for managed disk is failing'
+  puts 'Integration Test for managed disk is failing!'
   resource_group.destroy unless resource_group.nil?
 end

data/test/integration/network_interface.rb

@@ -106,7 +106,8 @@ begin
     subnet_id: "/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/TestRG-NI/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/mysubnet",
     public_ip_address_id: "/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/TestRG-NI/providers/Microsoft.Network/publicIPAddresses/mypubip",
     ip_configuration_name: 'testIpConfiguration',
-    private_ip_allocation_method: 'Dynamic'
+    private_ip_allocation_method: 'Dynamic',
+    tags: { key: 'value' }
   )
   puts "Created network interface: #{network_interface.name}"
 

data/test/integration/network_security_group.rb

@@ -57,7 +57,8 @@ begin
       access: Fog::ARM::Network::Models::SecurityRuleAccess::Allow,
       priority: '100',
       direction: Fog::ARM::Network::Models::SecurityRuleDirection::Inbound
-    }]
+    }],
+    tags: { key: 'value' }
   )
   puts "Created network security group: #{network_security_group.name}"
 

data/test/integration/public_ip.rb

@@ -47,7 +47,8 @@ begin
     name: 'mypubip',
     resource_group: 'TestRG-PB',
     location: LOCATION,
-    public_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic
+    public_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic,
+    tags: { key: 'value' }
   )
   puts "Created public ip: #{public_ip.name}"
 

data/test/integration/resource_group.rb

@@ -29,12 +29,15 @@ begin
   ######################                    Create Resource Group                                   ######################
   ########################################################################################################################
 
+  tags = { key1: 'value1', key2: 'value2' }
+
   resource_group = resource.resource_groups.create(
     name: resource_group_name,
-    location: 'eastus'
+    location: 'eastus',
+    tags: tags
   )
-
   puts "Created resource group #{resource_group.name}"
+
   ########################################################################################################################
   ######################           Get All Resource Groups in a Subscription                        ######################
   ########################################################################################################################

data/test/integration/resource_tag.rb

@@ -53,7 +53,8 @@ begin
   tag_resource = resources.tag_resource(
     resource_id,
     'test-key',
-    'test-value'
+    'test-value',
+    '2016-06-01'
   )
   puts "Tagged resource: #{tag_resource}"
 
@@ -77,7 +78,8 @@ begin
   resource = resources.delete_resource_tag(
     resource_id,
     'test-key',
-    'test-value'
+    'test-value',
+    '2016-06-01'
   )
   puts "Removed tag from a resource: #{resource}"
   ########################################################################################################################

data/test/integration/server.rb

@@ -79,6 +79,16 @@ begin
     private_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic
   )
 
+  # TODO: Create new NIC for managed VM
+  network.network_interfaces.create(
+    name: 'NetInt2',
+    resource_group: 'TestRG-VM',
+    location: LOCATION,
+    subnet_id: "/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/TestRG-VM/providers/Microsoft.Network/virtualNetworks/testVnet/subnets/mysubnet",
+    ip_configuration_name: 'testIpConfiguration',
+    private_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic
+  )
+
   ########################################################################################################################
   ######################                            Check for Virtual Machine                       ######################
   ########################################################################################################################
@@ -87,13 +97,16 @@ begin
   puts "Virtual Machine doesn't exist." unless flag
 
   ########################################################################################################################
-  ######################                                Create Server                               ######################
+  ######################                                  Create Server                             ######################
   ########################################################################################################################
 
+  tags = { key1: 'value1', key2: 'value2' }
+
   virtual_machine = compute.servers.create(
     name: 'TestVM',
     location: LOCATION,
     resource_group: 'TestRG-VM',
+    tags: tags,
     vm_size: 'Basic_A0',
     storage_account_name: storage_account_name,
     username: 'testuser',
@@ -108,7 +121,31 @@ begin
     custom_data: 'echo customData',
     os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None
   )
-  puts "Created virtual machine: #{virtual_machine.name}"
+  puts "Created un-managed virtual machine: #{virtual_machine.name}"
+
+  ########################################################################################################################
+  ######################                            Create Managed Server                           ######################
+  ########################################################################################################################
+  managed_vm = compute.servers.create(
+    name: 'TestVM-Managed',
+    location: LOCATION,
+    resource_group: 'TestRG-VM',
+    vm_size: 'Basic_A0',
+    storage_account_name: nil,
+    username: 'testuser',
+    password: 'Confiz=123',
+    disable_password_authentication: false,
+    network_interface_card_ids: ["/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/TestRG-VM/providers/Microsoft.Network/networkInterfaces/NetInt2"],
+    publisher: 'Canonical',
+    offer: 'UbuntuServer',
+    sku: '14.04.2-LTS',
+    version: 'latest',
+    platform: 'linux',
+    custom_data: 'echo customData',
+    os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None,
+    managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS
+  )
+  puts "Created managed virtual machine: #{managed_vm.name}"
 
   ########################################################################################################################
   ######################                                Create Server Async                           ####################
@@ -118,6 +155,7 @@ begin
     name: 'TestVM',
     location: LOCATION,
     resource_group: 'TestRG-VM',
+    tags: tags,
     vm_size: 'Basic_A0',
     storage_account_name: storage_account_name,
     username: 'testuser',
@@ -132,6 +170,7 @@ begin
     custom_data: 'echo customData',
     os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None
   )
+
   loop do
     puts async_response.state
 
@@ -157,7 +196,7 @@ begin
   puts 'Attached Data Disk to VM'
 
   ########################################################################################################################
-  ######################                          Detach Data Disk from VM                            ######################
+  ######################                          Detach Data Disk from VM                          ######################
   ########################################################################################################################
 
   virtual_machine = compute.servers.get('TestRG-VM', 'TestVM')
@@ -176,6 +215,40 @@ begin
   )
   puts "Deleted data disk: #{storage_data.delete_disk('datadisk1')}"
 
+  ########################################################################################################################
+  ######################                       Create a Managed Data Disk                           ######################
+  ########################################################################################################################
+  managed_disk = compute.managed_disks.create(
+    name: 'ManagedDataDisk',
+    location: LOCATION,
+    resource_group_name: 'TestRG-VM',
+    account_type: 'Standard_LRS',
+    disk_size_gb: 100,
+    creation_data: {
+      create_option: 'Empty'
+    }
+  )
+  puts "Created Managed Disk: #{managed_disk.name}"
+
+  ########################################################################################################################
+  ######################                          Attach Managed Data Disk to VM                    ######################
+  ########################################################################################################################
+  managed_vm.attach_managed_disk('ManagedDataDisk', 'TestRG-VM')
+  puts 'Attached Managed Data Disk to VM'
+
+  ########################################################################################################################
+  ######################                          Detach Data Disk from VM                          ######################
+  ########################################################################################################################
+
+  managed_vm.detach_managed_disk('ManagedDataDisk')
+  puts 'Detached Managed Data Disk from VM'
+
+  ########################################################################################################################
+  ######################                         Delete Managed Data Disk                           ######################
+  ########################################################################################################################
+  managed_disk.destroy
+  puts 'Deleted managed data disk'
+
   ########################################################################################################################
   ######################                      List VM in a resource group                           ######################
   ########################################################################################################################
@@ -243,6 +316,7 @@ begin
   ########################################################################################################################
 
   puts "Deleted virtual machine: #{virtual_machine.destroy}"
+  puts "Deleted virutal machine: #{managed_vm.destroy}"
 
   ########################################################################################################################
   ######################                                   CleanUp                                  ######################
@@ -251,6 +325,9 @@ begin
   nic = network.network_interfaces.get('TestRG-VM', 'NetInt')
   nic.destroy
 
+  nic = network.network_interfaces.get('TestRG-VM', 'NetInt2')
+  nic.destroy
+
   vnet = network.virtual_networks.get('TestRG-VM', 'testVnet')
   vnet.destroy
 
@@ -259,6 +336,7 @@ begin
 
   resource_group = rs.resource_groups.get('TestRG-VM')
   resource_group.destroy
+
   puts 'Integration Test for virtual machine ran successfully'
 rescue
   puts 'Integration Test for virtual machine is failing'