fog-azure-rm 0.2.7 → 0.3.0

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

@@ -15,7 +15,7 @@ module ApiStub
             disable_password_authentication: false,
             ssh_key_path: '/home',
             ssh_key_data: 'key',
-            network_interface_card_id: 'nic-id',
+            network_interface_card_ids: ['nic-id'],
             availability_set_id: 'as-id',
             publisher: 'Canonical',
             offer: 'UbuntuServer',
@@ -39,7 +39,7 @@ module ApiStub
             disable_password_authentication: nil,
             ssh_key_path: '/home',
             ssh_key_data: 'key',
-            network_interface_card_id: 'nic-id',
+            network_interface_card_ids: ['nic-id'],
             availability_set_id: 'as-id',
             publisher: 'MicrosoftWindowsServerEssentials',
             offer: 'WindowsServerEssentials',
@@ -63,7 +63,7 @@ module ApiStub
             disable_password_authentication: false,
             ssh_key_path: '/home',
             ssh_key_data: 'key',
-            network_interface_card_id: 'nic-id',
+            network_interface_card_ids: ['nic-id'],
             availability_set_id: 'as-id',
             publisher: 'Canonical',
             offer: 'UbuntuServer',
@@ -88,7 +88,7 @@ module ApiStub
             disable_password_authentication: nil,
             ssh_key_path: '/home',
             ssh_key_data: 'key',
-            network_interface_card_id: 'nic-id',
+            network_interface_card_ids: ['nic-id'],
             availability_set_id: 'as-id',
             publisher: 'MicrosoftWindowsServerEssentials',
             offer: 'WindowsServerEssentials',
@@ -113,7 +113,7 @@ module ApiStub
             disable_password_authentication: false,
             ssh_key_path: '/home',
             ssh_key_data: 'key',
-            network_interface_card_id: 'nic-id',
+            network_interface_card_ids: ['nic-id'],
             availability_set_id: 'as-id',
             platform: 'Linux',
             provision_vm_agent: nil,
@@ -134,7 +134,7 @@ module ApiStub
             disable_password_authentication: nil,
             ssh_key_path: '/home',
             ssh_key_data: 'key',
-            network_interface_card_id: 'nic-id',
+            network_interface_card_ids: ['nic-id'],
             availability_set_id: 'as-id',
             platform: 'Windows',
             provision_vm_agent: true,

data/test/integration/Virtual_network_gateway_connection.rb

@@ -212,12 +212,6 @@ begin
   pubip = network.public_ips.get('TestRG-GC', 'mypubip2')
   pubip.destroy
 
-  vnet = network.virtual_networks.get('TestRG-GC', 'testVnet')
-  vnet.destroy
-
-  vnet = network.virtual_networks.get('TestRG-GC', 'testVnet2')
-  vnet.destroy
-
   resource_group = resource.resource_groups.get('TestRG-GC')
   resource_group.destroy
 rescue

data/test/integration/application_gateway.rb

@@ -106,7 +106,7 @@ begin
     frontend_ports: [
       {
         name: 'frontendPort',
-        port: 443
+        port: 65_502
       }
     ],
     backend_address_pools: [

data/test/integration/credentials/azure.yml

@@ -2,4 +2,4 @@ client_id: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 client_secret: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 subscription_id: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 tenant_id: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
-environment: XXXXXXXX
+environment: XXXXXXXX

data/test/integration/managed_disk.rb

@@ -0,0 +1,113 @@
+require 'fog/azurerm'
+require 'yaml'
+
+########################################################################################################################
+######################                   Services object required by all actions                  ######################
+######################                              Keep it Uncommented!                          ######################
+########################################################################################################################
+
+azure_credentials = YAML.load_file('credentials/azure.yml')
+
+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'],
+  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'],
+  environment: azure_credentials['environment']
+)
+
+########################################################################################################################
+######################                               Resource names                                #####################
+########################################################################################################################
+
+time = current_time
+resource_group_name = "MD-RG-#{time}"
+disk_name = "MD#{time}diskunique"
+
+########################################################################################################################
+######################                                 Prerequisites                              ######################
+########################################################################################################################
+
+begin
+  rs.resource_groups.create(
+    name: resource_group_name,
+    location: LOCATION
+  )
+
+  ########################################################################################################################
+  ######################                            Check for Managed Disk                          ######################
+  ########################################################################################################################
+
+  flag = compute.managed_disks.check_managed_disk_exists(resource_group_name, disk_name)
+  puts "Managed Disk doesn't exist." unless flag
+
+  ########################################################################################################################
+  ######################                             Create Managed Disk                            ######################
+  ########################################################################################################################
+
+  disk = compute.managed_disks.create(
+    name: disk_name,
+    location: LOCATION,
+    resource_group_name: resource_group_name,
+    account_type: 'Premium_LRS',
+    disk_size_gb: 1023,
+    creation_data: {
+      create_option: 'Empty'
+    }
+  )
+  puts "Created managed disk: #{disk.name}"
+
+  ########################################################################################################################
+  ######################                         Grant and revoke access                            ######################
+  ########################################################################################################################
+
+  access_sas = compute.managed_disks.grant_access(resource_group_name, disk_name, 'Read', 1000)
+  puts "Access SAS: #{access_sas}"
+
+  response = compute.managed_disks.revoke_access(resource_group_name, disk_name)
+  puts "Revoke Access response: #{response.inspect}"
+
+  ########################################################################################################################
+  ######################                       List Managed Disks                                   ######################
+  ########################################################################################################################
+  puts 'List managed disks:'
+  compute.managed_disks(resource_group: resource_group_name).each do |managed_disk|
+    puts managed_disk.name
+  end
+
+  ########################################################################################################################
+  ######################                    List all Managed Disks in a subscription                ######################
+  ########################################################################################################################
+
+  puts 'List managed disks in Subscription:'
+  compute.managed_disks.each do |m_disk|
+    puts m_disk.name
+  end
+
+  ########################################################################################################################
+  ######################                       Get and Delete Managed Disk                          ######################
+  ########################################################################################################################
+
+  disk = compute.managed_disks.get(resource_group_name, disk_name)
+  puts "Get managed disk: #{disk.inspect}"
+  puts "Deleted managed disk: #{disk.destroy}"
+
+  ########################################################################################################################
+  ######################                                   CleanUp                                  ######################
+  ########################################################################################################################
+
+  rg = rs.resource_groups.get(resource_group_name)
+  rg.destroy
+  puts 'Integration Test for managed disk ran successfully'
+rescue
+  puts 'Integration Test for managed disk is failing'
+  resource_group.destroy unless resource_group.nil?
+end

data/test/integration/server.rb

@@ -99,7 +99,7 @@ begin
     username: 'testuser',
     password: 'Confiz=123',
     disable_password_authentication: false,
-    network_interface_card_id: "/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/TestRG-VM/providers/Microsoft.Network/networkInterfaces/NetInt",
+    network_interface_card_ids: ["/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/TestRG-VM/providers/Microsoft.Network/networkInterfaces/NetInt"],
     publisher: 'Canonical',
     offer: 'UbuntuServer',
     sku: '14.04.2-LTS',
@@ -110,6 +110,44 @@ begin
   )
   puts "Created virtual machine: #{virtual_machine.name}"
 
+  ########################################################################################################################
+  ######################                                Create Server Async                           ####################
+  ########################################################################################################################
+
+  async_response = compute.servers.create_async(
+    name: 'TestVM',
+    location: LOCATION,
+    resource_group: 'TestRG-VM',
+    vm_size: 'Basic_A0',
+    storage_account_name: storage_account_name,
+    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/NetInt"],
+    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
+  )
+  loop do
+    puts async_response.state
+
+    sleep(2) if async_response.pending?
+
+    if async_response.fulfilled?
+      puts async_response.value.inspect
+      break
+    end
+
+    if async_response.rejected?
+      puts async_response.reason.inspect
+      break
+    end
+  end
+
   ########################################################################################################################
   ######################                          Attach Data Disk to VM                            ######################
   ########################################################################################################################

data/test/integration/traffic_manager.rb

@@ -80,7 +80,7 @@ begin
     traffic_manager_profile_name: 'test-tmp',
     resource_group: 'TestRG-TM',
     type: 'externalEndpoints',
-    target: 'test-app.com',
+    target: 'test-app1.com',
     endpoint_location: 'eastus'
   )
   puts "Created traffic manager endpoint: #{traffic_manager_end_point.name}"
@@ -93,7 +93,7 @@ begin
   puts "Get traffic manager endpoint: #{end_point.name}"
   end_point.update(
     type: 'externalEndpoints',
-    target: 'test-app1.com',
+    target: 'test-app2.com',
     endpoint_location: 'centralus'
   )
   puts 'Updated traffic manager endpoint'

data/test/models/compute/test_managed_disk.rb

@@ -0,0 +1,61 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for Managed Disk Model
+class TestManagedDisk < Minitest::Test
+  def setup
+    @service = Fog::Compute::AzureRM.new(credentials)
+    @managed_disk = managed_disk(@service)
+    compute_client = @service.instance_variable_get(:@compute_mgmt_client)
+    @response = ApiStub::Models::Compute::ManagedDisk.create_managed_disk_response(compute_client)
+  end
+
+  def test_model_methods
+    methods = [
+      :save,
+      :destroy
+    ]
+    methods.each do |method|
+      assert_respond_to @managed_disk, method
+    end
+  end
+
+  def test_model_attributes
+    attributes = [
+      :id,
+      :name,
+      :type,
+      :location,
+      :resource_group_name,
+      :account_type,
+      :time_created,
+      :os_type,
+      :disk_size_gb,
+      :owner_id,
+      :provisioning_state,
+      :tags,
+      :creation_data,
+      :encryption_settings
+    ]
+    attributes.each do |attribute|
+      assert_respond_to @managed_disk, attribute
+    end
+  end
+
+  def test_save_method_response
+    @service.stub :create_or_update_managed_disk, @response do
+      assert_instance_of Fog::Compute::AzureRM::ManagedDisk, @managed_disk.save
+    end
+  end
+
+  def test_destroy_method_true_response
+    @service.stub :delete_managed_disk, true do
+      assert @managed_disk.destroy
+    end
+  end
+
+  def test_destroy_method_false_response
+    @service.stub :delete_managed_disk, false do
+      assert !@managed_disk.destroy
+    end
+  end
+end

data/test/models/compute/test_managed_disks.rb

@@ -0,0 +1,68 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for Managed Disk Collection
+class TestManagedDisks < Minitest::Test
+  def setup
+    @service = Fog::Compute::AzureRM.new(credentials)
+    @managed_disks = Fog::Compute::AzureRM::ManagedDisks.new(resource_group: 'fog-test-rg', service: @service)
+    @client = @service.instance_variable_get(:@compute_mgmt_client)
+    @managed_disk_list = [ApiStub::Models::Compute::ManagedDisk.create_managed_disk_response(@client)]
+    @managed_disk = ApiStub::Models::Compute::ManagedDisk.create_managed_disk_response(@client)
+  end
+
+  def test_collection_methods
+    methods = [
+      :all,
+      :get,
+      :check_managed_disk_exists
+    ]
+    methods.each do |method|
+      assert_respond_to @managed_disks, method
+    end
+  end
+
+  def test_collection_attributes
+    assert_respond_to @managed_disks, :resource_group
+  end
+
+  def test_all_method_response
+    @service.stub :list_managed_disks_by_rg, @managed_disk_list do
+      assert_instance_of Fog::Compute::AzureRM::ManagedDisks, @managed_disks.all
+      assert @managed_disks.all.size >= 1
+      @managed_disks.all.each do |disk|
+        assert_instance_of Fog::Compute::AzureRM::ManagedDisk, disk
+      end
+    end
+  end
+
+  def test_get_method_response
+    @service.stub :get_managed_disk, @managed_disk do
+      assert_instance_of Fog::Compute::AzureRM::ManagedDisk, @managed_disks.get('fog-test-rg', 'fog-test-managed_disk')
+    end
+  end
+
+  def test_check_managed_disk_exists_true_case
+    @service.stub :check_managed_disk_exists, true do
+      assert @managed_disks.check_managed_disk_exists('fog-test-rg', 'fog-test-managed_disk')
+    end
+  end
+
+  def test_check_managed_disk_exists_false_case
+    @service.stub :check_managed_disk_exists, false do
+      assert !@managed_disks.check_managed_disk_exists('fog-test-rg', 'fog-test-managed_disk')
+    end
+  end
+
+  def test_grant_access_response
+    @service.stub :grant_access_to_managed_disk, 'DUMMY-URI' do
+      assert_equal(@managed_disks.grant_access('fog-test-rg', 'fog-test-managed_disk', 'Read', 100), 'DUMMY-URI')
+    end
+  end
+
+  def test_revoke_access_response
+    response = ApiStub::Models::Compute::ManagedDisk.operation_status_response(@client)
+    @service.stub :revoke_access_to_managed_disk, response do
+      assert_equal(@managed_disks.revoke_access('fog-test-rg', 'fog-test-managed_disk').status, 'success')
+    end
+  end
+end

data/test/models/compute/test_server.rb

@@ -51,7 +51,7 @@ class TestServer < Minitest::Test
       :platform,
       :provision_vm_agent,
       :enable_automatic_updates,
-      :network_interface_card_id,
+      :network_interface_card_ids,
       :availability_set_id
     ]
     attributes.each do |attribute|
@@ -64,6 +64,12 @@ class TestServer < Minitest::Test
     @service.stub :create_virtual_machine, response do
       assert_instance_of Fog::Compute::AzureRM::Server, @server.save
     end
+
+    # Async
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :create_virtual_machine, async_response do
+      assert_instance_of Concurrent::Promise, @server.save(true)
+    end
   end
 
   def test_save_method_response_for_windows_vm

data/test/models/compute/test_servers.rb

@@ -12,6 +12,7 @@ class TestServers < Minitest::Test
   def test_collection_methods
     methods = [
       :all,
+      :create_async,
       :get,
       :check_vm_exists
     ]

data/test/requests/compute/test_check_managed_disk_exists.rb

@@ -0,0 +1,31 @@
+require File.expand_path '../../test_helper', __dir__
+
+# Test class for Check Managed Disk Exists Request
+class TestCheckManagedDiskExists < Minitest::Test
+  def setup
+    @service = Fog::Compute::AzureRM.new(credentials)
+    @client = @service.instance_variable_get(:@compute_mgmt_client)
+    @managed_disks = @client.disks
+  end
+
+  def test_check_managed_disk_exists_success
+    mocked_response = ApiStub::Requests::Compute::ManagedDisk.get_managed_disk_response(@client)
+    @managed_disks.stub :get, mocked_response do
+      assert @service.check_managed_disk_exists('myrg1', 'mydisk1')
+    end
+  end
+
+  def test_check_managed_disk_exists_failure
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceNotFound' }) }
+    @managed_disks.stub :get, response do
+      assert !@service.check_managed_disk_exists('myrg1', 'mydisk1')
+    end
+  end
+
+  def test_check_managed_disk_exists_exception
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception', 'code' => 'ResourceGroupNotFound' }) }
+    @managed_disks.stub :get, response do
+      assert_raises(RuntimeError) { @service.check_managed_disk_exists('myrg1', 'mydisk1') }
+    end
+  end
+end