fog-azure-rm 0.3.9 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2518251d501b6a297a475f1cd38f62b83fc87ffbf49ddce2aa8d8340780c1b4
-  data.tar.gz: b88856beb8dd8ddae666b39acedff8b671dd4bdbefd18b2e3cef8d3084349f4e
+  metadata.gz: 7a19921af4507084f3170dd448ce4193f7bcd9075b0fca9376b0270324a70664
+  data.tar.gz: f44723252fdfa0cafb164e416643c04e5b212d6954cec36572408c461add8b5d
 SHA512:
-  metadata.gz: 470b6100a51b5f65a916932a49da01f4bc17fc94fefe38773ff01e99c9b18f5623528efb54906d83992e6e56c14546d2fb1430a7b45b8279a23c4aa18f74458f
-  data.tar.gz: 7c7f7d4288daeb1132735c61e8314f373ca97841156335f358b884d44e9f8e72fd84405f830ac4dc964ff37ac9af1d3cfec3511815f95ee20b05fd3a44aab959
+  metadata.gz: 9102c6cb48c96fa42d47b38ae5d5b73843bc63640e43178e78059fead565569847d65d628a84aefeae61be8a56abd6cf8eee28dbeff5118a90a3a5e3708ec069
+  data.tar.gz: fc2ecb7465efca20e516a19ca555bf97f77aa50eee8bfd2b68a31f8fb59d6cbbb3e8d2031ab06f13cd5268a85243badb799aa30ff791e560c081e6bccc4cf419

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.4.0
+
+**Added**
+- Support added for custom vm image reference 
+
 ## 0.3.9
 
 **Changed**

data/lib/fog/azurerm/compute.rb

@@ -41,8 +41,9 @@ module Fog
       request :list_managed_disks_in_subscription
       request :revoke_access_to_managed_disk
       request :grant_access_to_managed_disk
-      request :create_generalized_image
-      request :delete_generalized_image
+      request :create_image
+      request :delete_image
+      request :get_image
 
       model_path 'fog/azurerm/models/compute'
       model :availability_set

data/lib/fog/azurerm/docs/compute.md

@@ -38,7 +38,6 @@ fog_compute_service.servers.check_vm_exists('<Resource Group Name>', '<VM Name>'
 - To create VM with managed OS disk, use the _managed_disk_storage_type_ argument
 - To create VM with unmanaged OS disk, use the _storage_account_name_ argument
 
-
 ### Virtual Machine (Managed OS Disk)
 
 ```ruby
@@ -66,6 +65,42 @@ fog_compute_service.servers.create(
 )
 ```
 
+**Info:**
+
+- To create VM from Image, pass in the Image ID in `image_ref` attribute
+
+**Limitation:**
+
+- Image should be in the same region
+- ONLY managed VM can be created from image
+
+### Virtual Machine (Managed OS Disk from Image)
+
+```ruby
+fog_compute_service.servers.create(
+        name: '<VM Name>',
+        location: '<Location>',
+        resource_group: '<Resource Group Name>',
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
+        username: '<Username>',
+        disable_password_authentication: <True/False>,
+        network_interface_card_ids: ['/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkInterfaces/<Network Interface Id>'],
+        publisher: '<Publisher Name>',                          # Not required if custom image is being used 
+        offer: '<Offer Name>',                                  # Not required if custom image is being used
+        sku: '<SKU Name>',                                      # Not required if custom image is being used
+        version: '<Version>',                                   # Not required if custom image is being used
+        platform: '<OS Type>',
+        availability_set_id: '<Availability Set Id>',           # [Optional]
+        password: '<Password>',                                 # [Optional], if 'platform' partameter is 'Linux'.
+        image_ref: '<Image ID>',                                # [Optional], if you want to create the VM from a custom image.
+        custom_data: '<Custom Data Value>',                     # [Optional], if you want to add custom data in this VM.
+        os_disk_caching: '<Caching Type>',                      # [Optional], can be one of None, ReadOnly, ReadWrite
+        managed_disk_storage_type: '<Storage Account Type>',    # [Optional], if storage_account_name is passed, can be StandardLRS or PremiumLRS
+        os_disk_size: <Disk Size>                               # [Optional], size of the os disk in GB (upto 1023)
+)
+```
+
 ### Virtual Machine (Unmanaged OS Disk)
 
 ```ruby

data/lib/fog/azurerm/models/compute/server.rb

@@ -35,6 +35,7 @@ module Fog
         attribute :tags
         attribute :platform_update_domain
         attribute :platform_fault_domain
+        attribute :image_ref
 
         def self.parse(vm)
           hash = {}
@@ -92,7 +93,7 @@ module Fog
 
         def save(async = false)
           requires :name, :location, :resource_group, :vm_size, :username, :network_interface_card_ids
-          requires :publisher, :offer, :sku, :version if vhd_path.nil? && managed_disk_storage_type.nil?
+          requires :publisher, :offer, :sku, :version if vhd_path.nil? && image_ref.nil?
           requires :storage_account_name if managed_disk_storage_type.nil?
           requires :managed_disk_storage_type if storage_account_name.nil?
 
@@ -179,7 +180,7 @@ module Fog
 
         def delete_extra_resources
           unless vhd_path.nil? || !managed_disk_storage_type.nil?
-            service.delete_generalized_image(resource_group, name)
+            service.delete_image(resource_group, name)
             delete_storage_account_or_container(resource_group, storage_account_name, name)
           end
         end
@@ -226,7 +227,8 @@ module Fog
             os_disk_caching: os_disk_caching,
             managed_disk_storage_type: managed_disk_storage_type,
             os_disk_size: os_disk_size,
-            tags: tags
+            tags: tags,
+            image_ref: image_ref
           }
         end
 
@@ -242,8 +244,11 @@ module Fog
         end
 
         def delete_storage_account_or_container(resource_group, storage_account_name, vm_name)
-          delete_storage_account(resource_group) if storage_account_name.nil?
-          delete_storage_container(resource_group, storage_account_name, vm_name) unless storage_account_name.nil?
+          if storage_account_name.nil?
+            delete_storage_account(resource_group)
+          else
+            delete_storage_container(resource_group, storage_account_name, vm_name)
+          end
         end
 
         def delete_storage_container(resource_group, storage_account_name, vm_name)

data/lib/fog/azurerm/requests/compute/{create_generalized_image.rb → create_image.rb}

@@ -3,32 +3,32 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def create_generalized_image(image_config)
-          msg = "Creating/Updating Generalized Image: #{image_config[:vm_name]}-osImage"
+        def create_image(image_config)
+          msg = "Creating/Updating Image: #{image_config[:vm_name]}-osImage"
           Fog::Logger.debug msg
           image_name = "#{image_config[:vm_name]}-osImage"
-          image = setup_image_params(image_config)
+          image = setup_params(image_config)
           begin
             image_obj = @compute_mgmt_client.images.create_or_update(image_config[:resource_group], image_name, image)
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Generalized Image #{image_name} created/updated successfully."
+          Fog::Logger.debug "Image #{image_name} created/updated successfully."
           image_obj
         end
 
         private
 
-        def setup_image_params(image_config)
+        def setup_params(image_config)
           storage_profile_image = Azure::ARM::Compute::Models::ImageStorageProfile.new
-          storage_profile_image.os_disk = create_os_disk_image(image_config)
+          storage_profile_image.os_disk = create_generalized_os_disk_image(image_config)
           image = Azure::ARM::Compute::Models::Image.new
           image.storage_profile = storage_profile_image
           image.location = image_config[:location]
           image
         end
 
-        def create_os_disk_image(image_config)
+        def create_generalized_os_disk_image(image_config)
           os_disk_image = Azure::ARM::Compute::Models::ImageOSDisk.new
           os_disk_image.os_type = image_config[:platform]
           os_disk_image.os_state = 'Generalized'
@@ -37,9 +37,10 @@ module Fog
           os_disk_image
         end
       end
+
       # This class provides the mock implementation for unit tests.
       class Mock
-        def create_generalized_image(*)
+        def create_image(*)
           image_obj = {
             'location' => 'West US',
             'tags' => {

data/lib/fog/azurerm/requests/compute/create_virtual_machine.rb

@@ -1,4 +1,5 @@
 require 'base64'
+
 WHITE_SPACE = ' '.freeze
 
 module Fog
@@ -7,122 +8,237 @@ module Fog
       # This class provides the actual implementation for service calls.
       class Real
         def create_virtual_machine(vm_config, async = false)
-          msg = "Creating Virtual Machine #{vm_config[:name]} in Resource Group #{vm_config[:resource_group]}."
+          vm_name = vm_config[:name]
+          rg_name = vm_config[:resource_group]
+
+          msg = "Creating Virtual Machine '#{vm_name}' in Resource Group '#{rg_name}'..."
           Fog::Logger.debug msg
-          virtual_machine = Azure::ARM::Compute::Models::VirtualMachine.new
 
-          unless vm_config[:availability_set_id].nil?
-            sub_resource = MsRestAzure::SubResource.new
-            sub_resource.id = vm_config[:availability_set_id]
-            virtual_machine.availability_set = sub_resource
-          end
+          vm = Azure::ARM::Compute::Models::VirtualMachine.new
+          vm.location = vm_config[:location]
+          vm.tags = vm_config[:tags]
+          vm.availability_set = get_vm_availability_set(vm_config[:availability_set_id])
+          vm.hardware_profile = get_hardware_profile(vm_config[:vm_size])
+          vm.os_profile = get_os_profile(vm_config)
+          vm.network_profile = get_network_profile(vm_config[:network_interface_card_ids])
+          vm.storage_profile = get_storage_profile(vm_config)
 
-          string_data = vm_config[:custom_data]
-          string_data = WHITE_SPACE if string_data.nil?
-          encoded_data = Base64.strict_encode64(string_data)
-          virtual_machine.hardware_profile = define_hardware_profile(vm_config[:vm_size])
-          virtual_machine.storage_profile = define_storage_profile(vm_config[:name],
-                                                                   vm_config[:storage_account_name],
-                                                                   vm_config[:publisher],
-                                                                   vm_config[:offer],
-                                                                   vm_config[:sku],
-                                                                   vm_config[:version],
-                                                                   vm_config[:vhd_path],
-                                                                   vm_config[:os_disk_caching],
-                                                                   vm_config[:platform],
-                                                                   vm_config[:resource_group],
-                                                                   vm_config[:managed_disk_storage_type],
-                                                                   vm_config[:os_disk_size],
-                                                                   vm_config[:location])
-
-          virtual_machine.os_profile = if vm_config[:platform].casecmp(WINDOWS).zero?
-                                         define_windows_os_profile(vm_config[:name],
-                                                                   vm_config[:username],
-                                                                   vm_config[:password],
-                                                                   vm_config[:provision_vm_agent],
-                                                                   vm_config[:enable_automatic_updates],
-                                                                   encoded_data)
-                                       else
-                                         define_linux_os_profile(vm_config[:name],
-                                                                 vm_config[:username],
-                                                                 vm_config[:password],
-                                                                 vm_config[:disable_password_authentication],
-                                                                 vm_config[:ssh_key_path],
-                                                                 vm_config[:ssh_key_data],
-                                                                 encoded_data)
-                                       end
-          virtual_machine.network_profile = define_network_profile(vm_config[:network_interface_card_ids])
-          virtual_machine.location = vm_config[:location]
-          virtual_machine.tags = vm_config[:tags]
           begin
             response = if async
-                         @compute_mgmt_client.virtual_machines.create_or_update_async(vm_config[:resource_group], vm_config[:name], virtual_machine)
+                         @compute_mgmt_client.virtual_machines.create_or_update_async(rg_name, vm_name, vm)
                        else
-                         @compute_mgmt_client.virtual_machines.create_or_update(vm_config[:resource_group], vm_config[:name], virtual_machine)
+                         @compute_mgmt_client.virtual_machines.create_or_update(rg_name, vm_name, vm)
                        end
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
+
           unless async
             unless vm_config[:vhd_path].nil? || vm_config[:managed_disk_storage_type].nil?
-              delete_generalized_image(vm_config[:resource_group], vm_config[:name])
-              delete_storage_account_or_container(vm_config[:resource_group], vm_config[:storage_account_name], vm_config[:name])
+              delete_image(rg_name, vm_name)
+              delete_storage_account_or_container(rg_name, vm_config[:storage_account_name], vm_name)
             end
           end
-          Fog::Logger.debug "Virtual Machine #{vm_config[:name]} Created Successfully." unless async
+
+          Fog::Logger.debug "Virtual Machine #{vm_name} created successfully!" unless async
           response
         end
 
         private
 
-        def define_hardware_profile(vm_size)
+        def get_vm_availability_set(availability_set_id)
+          sub_resource = nil
+          unless availability_set_id.nil?
+            sub_resource = MsRestAzure::SubResource.new
+            sub_resource.id = availability_set_id
+          end
+          sub_resource
+        end
+
+        def get_hardware_profile(vm_size)
           hw_profile = Azure::ARM::Compute::Models::HardwareProfile.new
           hw_profile.vm_size = vm_size
           hw_profile
         end
 
-        def image_reference(publisher, offer, sku, version)
-          image_reference = Azure::ARM::Compute::Models::ImageReference.new
-          image_reference.publisher = publisher
-          image_reference.offer = offer
-          image_reference.sku = sku
-          image_reference.version = version
-          image_reference
+        def get_os_profile(vm_config)
+          # Arguments unpacking
+          platform = vm_config[:platform]
+          vm_name = vm_config[:name]
+          username = vm_config[:username]
+          password = vm_config[:password]
+          custom_data = vm_config[:custom_data]
+          provision_vm_agent = vm_config[:provision_vm_agent]
+          enable_automatic_updates = vm_config[:enable_automatic_updates]
+          disable_password_auth = vm_config[:disable_password_authentication]
+          ssh_key_path = vm_config[:ssh_key_path]
+          ssh_key_data = vm_config[:ssh_key_data]
+
+          # Build and return os profile object
+          os_profile = Azure::ARM::Compute::Models::OSProfile.new
+          os_profile.computer_name = vm_name
+          os_profile.admin_username = username
+          os_profile.admin_password = password
+          os_profile.custom_data = Base64.strict_encode64(custom_data.nil? ? WHITE_SPACE : custom_data)
+
+          if platform.casecmp(WINDOWS).zero?
+            os_profile.windows_configuration = get_windows_config(provision_vm_agent, enable_automatic_updates)
+          else
+            os_profile.linux_configuration = get_linux_config(disable_password_auth, ssh_key_path, ssh_key_data)
+          end
+
+          os_profile
+        end
+
+        def get_windows_config(provision_vm_agent, enable_automatic_updates)
+          windows_config = Azure::ARM::Compute::Models::WindowsConfiguration.new
+          windows_config.provision_vmagent = provision_vm_agent
+          windows_config.enable_automatic_updates = enable_automatic_updates
+          windows_config
         end
 
-        def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version, vhd_path, os_disk_caching, platform, resource_group, managed_disk_storage_type, os_disk_size, location)
+        def get_linux_config(disable_password_auth, ssh_key_path, ssh_key_data)
+          linux_config = Azure::ARM::Compute::Models::LinuxConfiguration.new
+          linux_config.disable_password_authentication = disable_password_auth
+
+          unless ssh_key_path.nil? || ssh_key_data.nil?
+            ssh_config = Azure::ARM::Compute::Models::SshConfiguration.new
+            ssh_public_key = Azure::ARM::Compute::Models::SshPublicKey.new
+            ssh_public_key.path = ssh_key_path
+            ssh_public_key.key_data = ssh_key_data
+            ssh_config.public_keys = [ssh_public_key]
+            linux_config.ssh = ssh_config
+          end
+
+          linux_config
+        end
+
+        def get_network_profile(network_interface_card_ids)
+          network_interface_cards = []
+          network_interface_card_ids.each_with_index do |id, index|
+            nic = Azure::ARM::Compute::Models::NetworkInterfaceReference.new
+            nic.id = id
+            nic.primary = index == PRIMARY_NIC_INDEX
+            network_interface_cards << nic
+          end
+
+          network_profile = Azure::ARM::Compute::Models::NetworkProfile.new
+          network_profile.network_interfaces = network_interface_cards
+          network_profile
+        end
+
+        def get_storage_profile(vm_config)
+          # Arguments unpacking
+          managed_disk_storage_type = vm_config[:managed_disk_storage_type]
+
+          storage_profile = if managed_disk_storage_type.nil?
+                              get_unmanaged_vm_storage_profile(vm_config)
+                            else
+                              get_managed_vm_storage_profile(vm_config)
+                            end
+          storage_profile
+        end
+
+        def get_unmanaged_vm_storage_profile(vm_config)
+          # Arguments unpacking
+          vm_name = vm_config[:name]
+          storage_account_name = vm_config[:storage_account_name]
+          publisher = vm_config[:publisher]
+          offer = vm_config[:offer]
+          sku = vm_config[:sku]
+          version = vm_config[:version]
+          vhd_path = vm_config[:vhd_path]
+          os_disk_caching = vm_config[:os_disk_caching]
+          platform = vm_config[:platform]
+          resource_group = vm_config[:resource_group]
+          os_disk_size = vm_config[:os_disk_size]
+          location = vm_config[:location]
+          image_ref = vm_config[:image_ref]
+
           storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
-          storage_profile.image_reference = image_reference(publisher, offer, sku, version) if vhd_path.nil?
+          # Set OS disk VHD path
           os_disk = Azure::ARM::Compute::Models::OSDisk.new
+          vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
+          vhd.uri = get_blob_endpoint(storage_account_name) + "/vhds/#{vm_name}_os_disk.vhd"
+          os_disk.vhd = vhd
+
+          if vhd_path.nil? && image_ref.nil?
+            # Marketplace
+            storage_profile.image_reference = image_reference(publisher, offer, sku, version)
+          elsif !vhd_path.nil? && image_ref.nil?
+            # VHD
+            new_vhd_path = copy_vhd_to_storage_account(resource_group, storage_account_name, vhd_path, location, vm_name)
+            img_vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
+            img_vhd.uri = new_vhd_path
+            os_disk.image = img_vhd
+          else
+            # Image
+            image_resource_group = get_resource_group_from_id(image_ref)
+            image_name = get_image_name(image_ref)
+            image = get_image(image_resource_group, image_name)
+            storage_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new
+            storage_profile.image_reference.id = image.id
+          end
 
-          new_vhd_path = copy_vhd_to_storage_account(resource_group, storage_account_name, vhd_path, location, vm_name) unless vhd_path.nil?
+          storage_profile.os_disk = configure_os_disk_object(os_disk, os_disk_caching, os_disk_size, platform, vm_name)
+          storage_profile
+        end
 
-          if managed_disk_storage_type.nil?
-            vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
-            vhd.uri = get_blob_endpoint(storage_account_name) + "/vhds/#{vm_name}_os_disk.vhd"
+        def get_managed_vm_storage_profile(vm_config)
+          # Argument unpacking
+          managed_disk_storage_type = vm_config[:managed_disk_storage_type]
+          vhd_path = vm_config[:vhd_path]
+          resource_group = vm_config[:resource_group]
+          storage_account_name = vm_config[:storage_account_name]
+          location = vm_config[:location]
+          publisher = vm_config[:publisher]
+          offer = vm_config[:offer]
+          sku = vm_config[:sku]
+          version = vm_config[:version]
+          os_disk_caching = vm_config[:os_disk_caching]
+          os_disk_size = vm_config[:os_disk_size]
+          platform = vm_config[:platform]
+          vm_name = vm_config[:name]
+          image_ref = vm_config[:image_ref]
 
-            unless vhd_path.nil?
-              img_vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
-              img_vhd.uri = new_vhd_path
-              os_disk.image = img_vhd
-            end
+          # Build storage profile
+          storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
+          os_disk = Azure::ARM::Compute::Models::OSDisk.new
+          managed_disk = Azure::ARM::Compute::Models::ManagedDiskParameters.new
+          managed_disk.storage_account_type = managed_disk_storage_type
+          os_disk.managed_disk = managed_disk
 
-            os_disk.vhd = vhd
+          if vhd_path.nil? && image_ref.nil?
+            # Marketplace
+            storage_profile.image_reference = image_reference(publisher, offer, sku, version)
+          elsif !vhd_path.nil? && image_ref.nil?
+            # VHD
+            new_vhd_path = copy_vhd_to_storage_account(resource_group, storage_account_name, vhd_path, location, vm_name)
+            image = create_image(image_config_params(location, new_vhd_path, platform, resource_group, vm_name))
+            storage_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new
+            storage_profile.image_reference.id = image.id
           else
-            unless vhd_path.nil?
-              image_obj = create_generalized_image(image_config_params(location, new_vhd_path, platform, resource_group, vm_name))
-              storage_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new
-              storage_profile.image_reference.id = image_obj.id
-            end
-
-            managed_disk = Azure::ARM::Compute::Models::ManagedDiskParameters.new
-            managed_disk.storage_account_type = managed_disk_storage_type
-            os_disk.managed_disk = managed_disk
+            # Image
+            image_resource_group = get_resource_group_from_id(image_ref)
+            image_name = get_image_name(image_ref)
+            image = get_image(image_resource_group, image_name)
+            storage_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new
+            storage_profile.image_reference.id = image.id
           end
+
           storage_profile.os_disk = configure_os_disk_object(os_disk, os_disk_caching, os_disk_size, platform, vm_name)
           storage_profile
         end
 
+        def image_reference(publisher, offer, sku, version)
+          image_reference = Azure::ARM::Compute::Models::ImageReference.new
+          image_reference.publisher = publisher
+          image_reference.offer = offer
+          image_reference.sku = sku
+          image_reference.version = version
+          image_reference
+        end
+
         def image_config_params(location, new_vhd_path, platform, resource_group, vm_name)
           {
             location: location,
@@ -151,54 +267,19 @@ module Fog
           os_disk
         end
 
-        def define_windows_os_profile(vm_name, username, password, provision_vm_agent, enable_automatic_updates, encoded_data)
-          os_profile = Azure::ARM::Compute::Models::OSProfile.new
-          windows_config = Azure::ARM::Compute::Models::WindowsConfiguration.new
-          windows_config.provision_vmagent = provision_vm_agent
-          windows_config.enable_automatic_updates = enable_automatic_updates
-          os_profile.windows_configuration = windows_config
-          os_profile.computer_name = vm_name
-          os_profile.admin_username = username
-          os_profile.admin_password = password
-          os_profile.custom_data = encoded_data
-          os_profile
-        end
-
-        def define_linux_os_profile(vm_name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data, encoded_data)
-          os_profile = Azure::ARM::Compute::Models::OSProfile.new
-          linux_config = Azure::ARM::Compute::Models::LinuxConfiguration.new
-
-          unless ssh_key_path.nil? || ssh_key_data.nil?
-            ssh_config = Azure::ARM::Compute::Models::SshConfiguration.new
-            ssh_public_key = Azure::ARM::Compute::Models::SshPublicKey.new
-            ssh_public_key.path = ssh_key_path
-            ssh_public_key.key_data = ssh_key_data
-            ssh_config.public_keys = [ssh_public_key]
-            linux_config.ssh = ssh_config
-          end
-
-          linux_config.disable_password_authentication = disable_password_authentication
-          os_profile.linux_configuration = linux_config
-          os_profile.computer_name = vm_name
-          os_profile.admin_username = username
-          os_profile.admin_password = password
-          os_profile.custom_data = encoded_data
-          os_profile
-        end
-
         def copy_vhd_to_storage_account(resource_group, storage_account_name, vhd_path, location, vm_name)
           # Copy if VHD does not exist belongs to same storage account.
-          vhd_storage_account = (vhd_path.split('/')[2]).split('.')[0]
-          if storage_account_name != vhd_storage_account
+          vhd_storage_account_name = (vhd_path.split('/')[2]).split('.')[0]
+          if storage_account_name != vhd_storage_account_name
             if storage_account_name.nil?
               new_time = current_time
               storage_account_name = "sa#{new_time}"
-              storage_account = @storage_service.storage_accounts.create(
-                storage_account_config_params(location, resource_group, storage_account_name)
-              )
+              storage_account_config = storage_account_config_params(location, resource_group, storage_account_name)
+              storage_account = @storage_service.storage_accounts.create(storage_account_config)
             else
               storage_account = @storage_service.storage_accounts.get(resource_group, storage_account_name)
             end
+
             access_key = storage_account.get_access_keys.first.value
             storage_data = Fog::Storage::AzureRM.new(azure_storage_account_name: storage_account_name, azure_storage_access_key: access_key)
             new_time = current_time
@@ -206,15 +287,18 @@ module Fog
             blob_name = "vhd_image#{new_time}.vhd"
             storage_data.directories.create(key: container_name)
             storage_data.copy_blob_from_uri(container_name, blob_name, vhd_path)
+
             until storage_data.get_blob_properties(container_name, blob_name).properties[:copy_status] == 'success'
               Fog::Logger.debug 'Waiting disk to ready'
               sleep(10)
             end
+
             new_vhd_path = get_blob_endpoint(storage_account_name) + "/#{container_name}/#{blob_name}"
             Fog::Logger.debug "Path:#{new_vhd_path}. | Copy done"
           else
             new_vhd_path = vhd_path
           end
+
           new_vhd_path
         end
 
@@ -232,20 +316,6 @@ module Fog
           }
         end
 
-        def define_network_profile(network_interface_card_ids)
-          network_interface_cards = []
-          network_interface_card_ids.each_with_index do |id, index|
-            nic = Azure::ARM::Compute::Models::NetworkInterfaceReference .new
-            nic.id = id
-            nic.primary = index == PRIMARY_NIC_INDEX
-            network_interface_cards << nic
-          end
-
-          network_profile = Azure::ARM::Compute::Models::NetworkProfile.new
-          network_profile.network_interfaces = network_interface_cards
-          network_profile
-        end
-
         def delete_storage_account_or_container(resource_group, storage_account_name, vm_name)
           delete_storage_account(resource_group) if storage_account_name.nil?
           delete_storage_container(resource_group, storage_account_name, vm_name) unless storage_account_name.nil?
@@ -258,9 +328,12 @@ module Fog
         end
 
         def delete_storage_account(resource_group)
-          @storage_service.storage_accounts.delete_storage_account_from_tag(resource_group, TEMPORARY_STORAGE_ACCOUNT_TAG_KEY, TEMPORARY_STORAGE_ACCOUNT_TAG_VALUE)
+          @storage_service.storage_accounts.delete_storage_account_from_tag(resource_group,
+                                                                            TEMPORARY_STORAGE_ACCOUNT_TAG_KEY,
+                                                                            TEMPORARY_STORAGE_ACCOUNT_TAG_VALUE)
         end
       end
+
       # This class provides the mock implementation for unit tests.
       class Mock
         def create_virtual_machine(*)
@@ -320,6 +393,7 @@ module Fog
               'provisioningState' => 'Succeeded'
             }
           }
+
           vm_mapper = Azure::ARM::Compute::Models::VirtualMachine.mapper
           @compute_mgmt_client.deserialize(vm_mapper, vm, 'result.body')
         end

data/lib/fog/azurerm/requests/compute/{delete_generalized_image.rb → delete_image.rb}

@@ -3,8 +3,8 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def delete_generalized_image(resource_group, vm_name)
-          msg = "Deleting Generalized Image: #{vm_name}-osImage"
+        def delete_image(resource_group, vm_name)
+          msg = "Deleting Image: #{vm_name}-osImage"
           Fog::Logger.debug msg
           image_name = "#{vm_name}-osImage"
           begin
@@ -12,14 +12,14 @@ module Fog
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Generalized Image #{image_name} deleted successfully."
+          Fog::Logger.debug "Image #{image_name} deleted successfully."
           true
         end
       end
 
       # This class provides the mock implementation for unit tests.
       class Mock
-        def delete_generalized_image(*)
+        def delete_image(*)
           Fog::Logger.debug 'Image fog-test-server-osImage from Resource group fog-test-rg deleted successfully.'
           true
         end

data/lib/fog/azurerm/requests/compute/get_image.rb

@@ -0,0 +1,45 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def get_image(resource_group_name, image_name)
+          msg = "Getting Image #{image_name} in Resource Group #{resource_group_name}"
+          Fog::Logger.debug msg
+          begin
+            image = @compute_mgmt_client.images.get(resource_group_name, image_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "#{msg} successful"
+          image
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def get_image(*)
+          body = {
+            'id' => '/subscriptions/########-####-####-####-############/resourceGroups/TestRG/providers/Microsoft.Compute/images/TestImage',
+            'name' => 'TestImage',
+            'resource_group' => 'TestRG',
+            'location' => 'West US',
+            'storage_profile' => {
+              'os_disk' => {
+                'os_type' => 'Linux',
+                'os_state' => 'Generalized',
+                'blob_uri' => 'https://myblob.blob.core.windows.net/images/testimage.vhd',
+                'caching' => 'ReadWrite',
+                'disk_size_gb' => '5'
+              },
+              'data_disks' => []
+            },
+            'provisioning_state' => 'Succeeded'
+          }
+          image_mapper = Azure::ARM::Compute::Models::Image.mapper
+          @compute_mgmt_client.deserialize(image_mapper, body, 'result.body')
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/utilities/general.rb

@@ -166,3 +166,7 @@ def parse_storage_object(object)
   data['etag'].delete!('"')
   data
 end
+
+def get_image_name(id)
+  id.split('/').last
+end

data/lib/fog/azurerm/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module AzureRM
-    VERSION = '0.3.9'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/test/api_stub.rb

@@ -78,7 +78,7 @@ module ApiStub
       autoload :VirtualMachine, File.expand_path('api_stub/requests/compute/virtual_machine', __dir__)
       autoload :VirtualMachineExtension, File.expand_path('api_stub/requests/compute/virtual_machine_extension', __dir__)
       autoload :ManagedDisk, File.expand_path('api_stub/requests/compute/managed_disk', __dir__)
-      autoload :GeneralizedImage, File.expand_path('api_stub/requests/compute/generalized_image', __dir__)
+      autoload :Image, File.expand_path('api_stub/requests/compute/image', __dir__)
     end
 
     # Load test Resources requests

data/test/api_stub/requests/compute/{generalized_image.rb → image.rb}

@@ -2,8 +2,8 @@ module ApiStub
   module Requests
     module Compute
       # Mock class for Virtual Machine Requests
-      class GeneralizedImage
-        def self.generalized_image_params
+      class Image
+        def self.image_params
           {
             resource_group: 'fog-test-rg',
             vm_name: 'fog-test-server',
@@ -13,7 +13,7 @@ module ApiStub
           }
         end
 
-        def self.create_generalized_image(compute_client)
+        def self.create_image(compute_client)
           body = {
             'location' => 'West US',
             'tags' => {

data/test/integration/server.rb

@@ -57,10 +57,10 @@ begin
   )
 
   network.virtual_networks.create(
-    name:             'testVnet',
-    location:         LOCATION,
-    resource_group:   'TestRG-VM',
-    network_address_list:  '10.1.0.0/16,10.2.0.0/16'
+    name: 'testVnet',
+    location: LOCATION,
+    resource_group: 'TestRG-VM',
+    network_address_list: '10.1.0.0/16,10.2.0.0/16'
   )
 
   network.subnets.create(
@@ -79,7 +79,6 @@ 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',
@@ -94,12 +93,14 @@ begin
   ########################################################################################################################
 
   flag = compute.servers.check_vm_exists('TestRG-VM', 'TestVM')
-  puts "Virtual Machine doesn't exist." unless flag
+  puts 'Virtual Machine does NOT exist!' unless flag
 
   ########################################################################################################################
   ######################                                  Create Server                             ######################
   ########################################################################################################################
 
+  puts 'Creating un-managed Virtual Machine...'
+
   tags = { key1: 'value1', key2: 'value2' }
 
   virtual_machine = compute.servers.create(
@@ -126,6 +127,9 @@ begin
   ########################################################################################################################
   ######################                            Create Managed Server                           ######################
   ########################################################################################################################
+
+  puts 'Creating managed Virtual Machine...'
+
   managed_vm = compute.servers.create(
     name: 'TestVM-Managed',
     location: LOCATION,
@@ -151,6 +155,8 @@ begin
   ######################                                Create Server Async                           ####################
   ########################################################################################################################
 
+  print 'Creating Virtual Machine asynchronously...'
+
   async_response = compute.servers.create_async(
     name: 'TestVM',
     location: LOCATION,
@@ -172,17 +178,18 @@ begin
   )
 
   loop do
-    puts async_response.state
-
-    sleep(2) if async_response.pending?
+    if async_response.pending?
+      sleep(2)
+      print '.'
+    end
 
     if async_response.fulfilled?
-      puts async_response.value.inspect
+      puts "\nCreated VM asynchronously! [#{async_response.value.name}]"
       break
     end
 
     if async_response.rejected?
-      puts async_response.reason.inspect
+      puts "\nERROR: Async VM creation failed!\n#{async_response.reason.inspect}"
       break
     end
   end
@@ -193,7 +200,7 @@ begin
 
   virtual_machine = compute.servers.get('TestRG-VM', 'TestVM')
   virtual_machine.attach_data_disk('datadisk1', 10, storage_account_name)
-  puts 'Attached Data Disk to VM'
+  puts 'Attached Data Disk to VM!'
 
   ########################################################################################################################
   ######################                          Detach Data Disk from VM                          ######################
@@ -201,7 +208,7 @@ begin
 
   virtual_machine = compute.servers.get('TestRG-VM', 'TestVM')
   virtual_machine.detach_data_disk('datadisk1')
-  puts 'Detached Data Disk from VM'
+  puts 'Detached Data Disk from VM!'
 
   ########################################################################################################################
   ######################                                Delete Data Disk                            ######################
@@ -218,6 +225,7 @@ begin
   ########################################################################################################################
   ######################                       Create a Managed Data Disk                           ######################
   ########################################################################################################################
+
   managed_disk = compute.managed_disks.create(
     name: 'ManagedDataDisk',
     location: LOCATION,
@@ -233,30 +241,32 @@ begin
   ########################################################################################################################
   ######################                          Attach Managed Data Disk to VM                    ######################
   ########################################################################################################################
+
   managed_vm.attach_managed_disk('ManagedDataDisk', 'TestRG-VM')
-  puts 'Attached Managed Data Disk to 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'
+  puts 'Detached Managed Data Disk from VM!'
 
   ########################################################################################################################
   ######################                         Delete Managed Data Disk                           ######################
   ########################################################################################################################
+
   managed_disk.destroy
-  puts 'Deleted managed data disk'
+  puts 'Deleted managed data disk!'
 
   ########################################################################################################################
   ######################                      List VM in a resource group                           ######################
   ########################################################################################################################
 
   virtual_machines = compute.servers(resource_group: 'TestRG-VM')
-  puts 'List virtual machines ina resource group:'
-  virtual_machines.each do |a_virtual_machine|
-    puts a_virtual_machine.name
+  puts 'List virtual machines in a resource group:'
+  virtual_machines.each do |vm|
+    puts "- #{vm.name}"
   end
 
   #######################################################################################################################
@@ -270,10 +280,10 @@ begin
   ######################                      List available sizes in VM                            ######################
   ########################################################################################################################
 
+  puts 'List of available sizes for Virtual Machine:'
   available_sizes_for_vm = virtual_machine.list_available_sizes
-  puts 'List available sizes in virtual machines:'
   available_sizes_for_vm.each do |available_size|
-    puts available_size.inspect
+    puts "- #{available_size.name}"
   end
 
   ########################################################################################################################
@@ -295,7 +305,7 @@ begin
   ########################################################################################################################
 
   virtual_machine.deallocate
-  puts 'Virtual machine deallocated!'
+  puts 'Virtual machine de-allocated!'
 
   ########################################################################################################################
   ######################                                 Start VM                                   ######################
@@ -316,12 +326,14 @@ begin
   ########################################################################################################################
 
   puts "Deleted virtual machine: #{virtual_machine.destroy}"
-  puts "Deleted virutal machine: #{managed_vm.destroy}"
+  puts "Deleted virtual machine: #{managed_vm.destroy}"
 
   ########################################################################################################################
   ######################                                   CleanUp                                  ######################
   ########################################################################################################################
 
+  puts 'Cleaning up...'
+
   nic = network.network_interfaces.get('TestRG-VM', 'NetInt')
   nic.destroy
 
@@ -337,8 +349,8 @@ begin
   resource_group = rs.resource_groups.get('TestRG-VM')
   resource_group.destroy
 
-  puts 'Integration Test for virtual machine ran successfully'
+  puts 'Integration Test for virtual machine ran successfully!'
 rescue
-  puts 'Integration Test for virtual machine is failing'
+  puts 'Integration Test for virtual machine is failing!'
   resource_group.destroy unless resource_group.nil?
 end

data/test/integration/server_custom_image.rb

@@ -59,10 +59,10 @@ begin
   )
 
   network.virtual_networks.create(
-    name:             'testVnet',
-    location:         LOCATION,
-    resource_group:   RG_NAME,
-    network_address_list:  '10.1.0.0/16,10.2.0.0/16'
+    name: 'testVnet',
+    location: LOCATION,
+    resource_group: RG_NAME,
+    network_address_list: '10.1.0.0/16,10.2.0.0/16'
   )
 
   network.subnets.create(
@@ -103,6 +103,8 @@ begin
   ######################                                Create Server                               ######################
   ########################################################################################################################
 
+  vhd_path = 'https://myblob.blob.core.windows.net/vhds/my_vhd.vhd'.freeze
+
   custom_image_virtual_machine = compute.servers.create(
     name: 'TestVM',
     location: LOCATION,
@@ -114,7 +116,7 @@ begin
     disable_password_authentication: false,
     network_interface_card_ids: ["/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/#{RG_NAME}/providers/Microsoft.Network/networkInterfaces/NetInt"],
     platform: 'linux',
-    vhd_path: 'https://myblob.blob.core.windows.net/vhds/my_vhd.vhd'
+    vhd_path: vhd_path
   )
 
   puts "Created custom image un-managed virtual machine: #{custom_image_virtual_machine.name}"
@@ -134,7 +136,7 @@ begin
     disable_password_authentication: false,
     network_interface_card_ids: ["/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/#{RG_NAME}/providers/Microsoft.Network/networkInterfaces/NetInt2"],
     platform: 'linux',
-    vhd_path: 'https://myblob.blob.core.windows.net/vhds/my_vhd.vhd',
+    vhd_path: vhd_path,
     managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS
   )
 
@@ -144,6 +146,8 @@ begin
   ##############                                Create Managed Server Async                               ################
   ########################################################################################################################
 
+  print 'Creating Virtual Machine asynchronously...'
+
   async_response = compute.servers.create_async(
     name: 'TestVM-ManagedAsync',
     location: LOCATION,
@@ -155,22 +159,23 @@ begin
     disable_password_authentication: false,
     network_interface_card_ids: ["/subscriptions/#{azure_credentials['subscription_id']}/resourceGroups/#{RG_NAME}/providers/Microsoft.Network/networkInterfaces/NetInt3"],
     platform: 'linux',
-    vhd_path: 'https://myblob.blob.core.windows.net/vhds/my_vhd.vhd',
+    vhd_path: vhd_path,
     managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS
   )
 
   loop do
-    puts async_response.state
-
-    sleep(2) if async_response.pending?
+    if async_response.pending?
+      sleep(2)
+      print '.'
+    end
 
     if async_response.fulfilled?
-      puts "Created custom image managed virtual machine: #{async_response.value.name}"
+      puts "\nCreated custom image managed virtual machine: #{async_response.value.name}"
       break
     end
 
     if async_response.rejected?
-      puts async_response.reason.inspect
+      puts "\nERROR: Async VM creation failed!\n#{async_response.reason.inspect}"
       break
     end
   end
@@ -195,6 +200,8 @@ begin
   ######################                                   CleanUp                                  ######################
   ########################################################################################################################
 
+  puts 'Cleaning up...'
+
   nic = network.network_interfaces.get(RG_NAME, 'NetInt')
   nic.destroy
 
@@ -212,6 +219,8 @@ begin
 
   resource_group = rs.resource_groups.get(RG_NAME)
   resource_group.destroy
+
+  puts 'Integration Test for virtual machine ran successfully!'
 rescue
   puts 'Integration Test for custom image virtual machine is failing'
   resource_group.destroy unless resource_group.nil?

data/test/requests/compute/test_create_image.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../test_helper', __dir__)
+
+# Test class for Create Image Request
+class TestCreateImage < Minitest::Test
+  def setup
+    @service = Fog::Compute::AzureRM.new(credentials)
+    compute_client = @service.instance_variable_get(:@compute_mgmt_client)
+    @image = compute_client.images
+    @response = ApiStub::Requests::Compute::Image.create_image(compute_client)
+    @input_params = ApiStub::Requests::Compute::Image.image_params
+  end
+
+  def test_create_image_success
+    @image.stub :create_or_update, @response do
+      assert_equal @service.create_image(@input_params), @response
+    end
+  end
+
+  def test_create_image_failure
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @image.stub :create_or_update, response do
+      assert_raises RuntimeError do
+        @service.create_image(@input_params)
+      end
+    end
+  end
+end

data/test/requests/compute/test_delete_image.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../test_helper', __dir__)
+
+# Test class for Delete Image Request
+class TestDeleteImage < Minitest::Test
+  def setup
+    @service = Fog::Compute::AzureRM.new(credentials)
+    compute_client = @service.instance_variable_get(:@compute_mgmt_client)
+    @image = compute_client.images
+  end
+
+  def test_delete_image_success
+    @image.stub :delete, true do
+      assert @service.delete_image('fog-test-rg', 'fog-test-server-osImage')
+    end
+  end
+
+  def test_delete_image_failure
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @image.stub :delete, response do
+      assert_raises(RuntimeError) { @service.delete_image('fog-test-rg', 'fog-test-server-osImage') }
+    end
+  end
+end

data/test/requests/compute/test_get_image.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../test_helper', __dir__)
+
+# Test class for Get Image Request
+class TestGetImage < Minitest::Test
+  def setup
+    @service = Fog::Compute::AzureRM.new(credentials)
+    compute_client = @service.instance_variable_get(:@compute_mgmt_client)
+    @image = compute_client.images
+  end
+
+  def test_get_image_success
+    @image.stub :get, true do
+      assert @service.get_image('fog-test-rg', 'TestImage')
+    end
+  end
+
+  def test_get_image_failure
+    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
+    @image.stub :get, response do
+      assert_raises(RuntimeError) { @service.get_image('fog-test-rg', 'TestImage') }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fog-azure-rm
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.0
 platform: ruby
 authors:
 - Shaffan Chaudhry
@@ -18,7 +18,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-30 00:00:00.000000000 Z
+date: 2017-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -422,19 +422,20 @@ files:
 - lib/fog/azurerm/requests/compute/check_vm_extension_exists.rb
 - lib/fog/azurerm/requests/compute/check_vm_status.rb
 - lib/fog/azurerm/requests/compute/create_availability_set.rb
-- lib/fog/azurerm/requests/compute/create_generalized_image.rb
+- lib/fog/azurerm/requests/compute/create_image.rb
 - lib/fog/azurerm/requests/compute/create_or_update_managed_disk.rb
 - lib/fog/azurerm/requests/compute/create_or_update_vm_extension.rb
 - lib/fog/azurerm/requests/compute/create_virtual_machine.rb
 - lib/fog/azurerm/requests/compute/deallocate_virtual_machine.rb
 - lib/fog/azurerm/requests/compute/delete_availability_set.rb
-- lib/fog/azurerm/requests/compute/delete_generalized_image.rb
+- lib/fog/azurerm/requests/compute/delete_image.rb
 - lib/fog/azurerm/requests/compute/delete_managed_disk.rb
 - lib/fog/azurerm/requests/compute/delete_virtual_machine.rb
 - lib/fog/azurerm/requests/compute/delete_vm_extension.rb
 - lib/fog/azurerm/requests/compute/detach_data_disk_from_vm.rb
 - lib/fog/azurerm/requests/compute/generalize_virtual_machine.rb
 - lib/fog/azurerm/requests/compute/get_availability_set.rb
+- lib/fog/azurerm/requests/compute/get_image.rb
 - lib/fog/azurerm/requests/compute/get_managed_disk.rb
 - lib/fog/azurerm/requests/compute/get_virtual_machine.rb
 - lib/fog/azurerm/requests/compute/get_vm_extension.rb
@@ -677,7 +678,7 @@ files:
 - test/api_stub/models/traffic_manager/traffic_manager_profile.rb
 - test/api_stub/requests/application_gateway/gateway.rb
 - test/api_stub/requests/compute/availability_set.rb
-- test/api_stub/requests/compute/generalized_image.rb
+- test/api_stub/requests/compute/image.rb
 - test/api_stub/requests/compute/managed_disk.rb
 - test/api_stub/requests/compute/virtual_machine.rb
 - test/api_stub/requests/compute/virtual_machine_extension.rb
@@ -821,18 +822,19 @@ files:
 - test/requests/compute/test_check_vm_exists.rb
 - test/requests/compute/test_check_vm_extension_exists.rb
 - test/requests/compute/test_create_availability_set.rb
-- test/requests/compute/test_create_generalized_image.rb
+- test/requests/compute/test_create_image.rb
 - test/requests/compute/test_create_or_update_managed_disk.rb
 - test/requests/compute/test_create_virtual_machine.rb
 - test/requests/compute/test_create_vm_extension.rb
 - test/requests/compute/test_deallocate_virtual_machine.rb
 - test/requests/compute/test_delete_availability_set.rb
-- test/requests/compute/test_delete_generalized_image.rb
+- test/requests/compute/test_delete_image.rb
 - test/requests/compute/test_delete_managed_disk.rb
 - test/requests/compute/test_delete_virtual_machine.rb
 - test/requests/compute/test_detach_data_disk_from_vm.rb
 - test/requests/compute/test_generalize_virtual_machine.rb
 - test/requests/compute/test_get_availability_set.rb
+- test/requests/compute/test_get_image.rb
 - test/requests/compute/test_get_managed_disk.rb
 - test/requests/compute/test_get_virtual_machine.rb
 - test/requests/compute/test_get_vm_extension.rb

data/test/requests/compute/test_create_generalized_image.rb

@@ -1,27 +0,0 @@
-require File.expand_path '../../test_helper', __dir__
-
-# Test class for Create Virtual Machine Request
-class TestCreateGeneralizedImage < Minitest::Test
-  def setup
-    @service = Fog::Compute::AzureRM.new(credentials)
-    compute_client = @service.instance_variable_get(:@compute_mgmt_client)
-    @image = compute_client.images
-    @response = ApiStub::Requests::Compute::GeneralizedImage.create_generalized_image(compute_client)
-    @input_params = ApiStub::Requests::Compute::GeneralizedImage.generalized_image_params
-  end
-
-  def test_create_generalized_image_success
-    @image.stub :create_or_update, @response do
-      assert_equal @service.create_generalized_image(@input_params), @response
-    end
-  end
-
-  def test_create_generalized_image_failure
-    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    @image.stub :create_or_update, response do
-      assert_raises RuntimeError do
-        @service.create_generalized_image(@input_params)
-      end
-    end
-  end
-end

data/test/requests/compute/test_delete_generalized_image.rb

@@ -1,23 +0,0 @@
-require File.expand_path '../../test_helper', __dir__
-
-# Test class for Delete Virtual Machine Request
-class TestDeleteGeneralizedImage < Minitest::Test
-  def setup
-    @service = Fog::Compute::AzureRM.new(credentials)
-    compute_client = @service.instance_variable_get(:@compute_mgmt_client)
-    @generalized_image = compute_client.images
-  end
-
-  def test_delete_generalized_image_success
-    @generalized_image.stub :delete, true do
-      assert @service.delete_generalized_image('fog-test-rg', 'fog-test-server-osImage')
-    end
-  end
-
-  def test_delete_generalized_image_failure
-    response = proc { raise MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
-    @generalized_image.stub :delete, response do
-      assert_raises(RuntimeError) { @service.delete_generalized_image('fog-test-rg', 'fog-test-server-osImage') }
-    end
-  end
-end