azure 0.6.1 → 0.6.2

data/test/fixtures/list_images.xml

@@ -4,7 +4,7 @@
     <Category>RightScale with Linux</Category>
     <Label>RightImage CentOS 6.2 x64 v5.8.8.1</Label>
     <LogicalSizeInGB>10</LogicalSizeInGB>
-    <Name>0b11de9248dd4d87b18621318e037d37__RightImage-CentOS-6.2-x64-v5.8.8.1</Name>
+    <Name>RightImage-CentOS-6.2-x64-v5.8.8.1</Name>
     <OS>Linux</OS>
     <Eula>http://support.rightscale.com/12-Guides/RightLink/RightLink_End_User_License_Agreeement;http://www.rightscale.com/privacy_policy.php</Eula>
     <Description>CentOS 6.3 with RightLink 5.8.</Description>

data/test/fixtures/virtual_machine.xml

@@ -105,4 +105,9 @@ kZS1mYWNlNSI+DQogICAgPEluc3RhbmNlcyBjb3VudD0iMSIgLz4NCiAgPC9Sb2xlPg0KPC9TZXJ2aWN
     <EndTime>2013-04-13T08:00:00Z</EndTime>
     <Status>PersistentVMUpdateCompleted</Status>
   </PersistentVMDowntime>
+  <VirtualIPs>
+    <VirtualIP>
+      <Address>137.116.17.187</Address>
+    </VirtualIP>
+  </VirtualIPs>
 </Deployment>

data/test/integration/vm/VM_Create_test.rb

@@ -61,106 +61,107 @@ describe Azure::VirtualMachineManagementService do
     }
   end
 
-  
   before do
     Loggerx.expects(:puts).returns(nil).at_least(0)
-    
   end
 
   describe '#deployment' do
 
     it 'should set options hash with valid cloud_service_name, deployment_name, storage_account_name and virtual network' do
-      cloud_name = options[:cloud_service_name]
+      csn = options[:cloud_service_name]
       options[:availability_set_name] = 'aval-set-test'
-      subject.create_virtual_machine(params, options, false)
-      virtual_machine = subject.get_virtual_machine(virtual_machine_name, cloud_name)
-      virtual_machine.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      virtual_machine.cloud_service_name.wont_be_nil
-      virtual_machine.vm_name.must_equal virtual_machine_name
-      virtual_machine.deployment_name.wont_be_nil
-      virtual_machine.deployment_name.must_equal virtual_machine.cloud_service_name
-      virtual_machine.os_type.must_equal 'Linux'
-      virtual_machine.role_size.must_equal 'Small'
-      virtual_machine.availability_set_name.must_equal 'aval-set-test'
+      vm = subject.create_virtual_machine(params, options, false)
+      vm.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
+      vm.cloud_service_name.wont_be_nil
+      vm.vm_name.must_equal virtual_machine_name
+      vm.deployment_name.wont_be_nil
+      vm.deployment_name.must_equal vm.cloud_service_name
+      vm.os_type.must_equal 'Linux'
+      vm.role_size.must_equal 'Small'
+      vm.availability_set_name.must_equal 'aval-set-test'
       options[:storage_account_name].wont_be_nil
-      assert_match(/^#{params[:vm_name] + '-service'}*/, cloud_name)
+      assert_match(/^#{params[:vm_name] + '-service'}*/, csn)
       # Test for add role
       params[:vm_name] = 'test-add-role-vm'
       options[:ssh_port] = 2222
       vm = subject.create_virtual_machine(params, options, true)
-      vm.cloud_service_name.must_equal cloud_name
+      vm.cloud_service_name.must_equal csn
       vm.vm_name.must_equal params[:vm_name]
-      virtual_machine.deployment_name.wont_be_nil
-      virtual_machine.os_type.must_equal 'Linux'
+      vm.deployment_name.wont_be_nil
+      vm.os_type.must_equal 'Linux'
     end
 
     it 'should creates http and https enabled winrm virtual machine without certificate.' do
       default_options.merge!(winrm_transport: %w(https http))
-      subject.create_virtual_machine(windows_params, default_options)
-      result = subject.get_virtual_machine(virtual_machine_name, cloud_service_name)
+      result = subject.create_virtual_machine(windows_params, default_options)
       result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      assert_equal(result.os_type, 'Windows', 'Error in the OS type of VI created')
+      assert_equal(result.os_type, 'Windows')
       tcp_endpoints_names = []
       result.tcp_endpoints.each do |tcp_endpoint|
-        tcp_endpoints_names << tcp_endpoint['Name']
+        tcp_endpoints_names << tcp_endpoint[:name]
       end
-      tcp_endpoints_names.must_include 'WinRm-Https'
+      tcp_endpoints_names.must_include 'PowerShell'
       tcp_endpoints_names.must_include 'WinRm-Http'
       sleep 30
     end
 
     it 'should creates https enabled winrm virtual machine using certificate.' do
-      default_options.merge!(winrm_transport: ['https'], private_key_file: private_key, certificate_file: certificate)
-      subject.create_virtual_machine(windows_params, default_options)
-      result = subject.get_virtual_machine(virtual_machine_name, cloud_service_name)
+      default_options.merge!(
+        winrm_transport: ['https'],
+        private_key_file: private_key,
+        certificate_file: certificate
+      )
+      result = subject.create_virtual_machine(windows_params, default_options)
       result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      assert_equal(result.os_type, 'Windows', 'Error in the OS type of VI created')
+      assert_equal(result.os_type, 'Windows')
       tcp_endpoints_names = []
       result.tcp_endpoints.each do |tcp_endpoint|
-        tcp_endpoints_names << tcp_endpoint['Name']
+        tcp_endpoints_names << tcp_endpoint[:name]
       end
-      tcp_endpoints_names.must_include 'WinRm-Https'
+      tcp_endpoints_names.must_include 'PowerShell'
     end
 
     it 'should creates windows virtual machine without winrm.' do
       default_options.merge!(winrm_transport: ['none'])
-      subject.create_virtual_machine(windows_params, default_options)
-      result = subject.get_virtual_machine(virtual_machine_name, cloud_service_name)
+      result = subject.create_virtual_machine(windows_params, default_options)
       result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      assert_equal(result.os_type, 'Windows', 'Error in the OS type of VI created')
+      assert_equal(result.os_type, 'Windows')
       tcp_endpoints_names = []
       result.tcp_endpoints.each do |tcp_endpoint|
         tcp_endpoints_names << tcp_endpoint['Name']
       end
-      assert (!tcp_endpoints_names.include? 'WinRm-Https')
-      assert (!tcp_endpoints_names.include? 'WinRm-Http')
+      assert !tcp_endpoints_names.include?('PowerShell')
+      assert !tcp_endpoints_names.include?('WinRm-Http')
     end
 
     it 'created linux virtual machine should be accessible using password and certificate' do
-      default_options.merge!(private_key_file: private_key, certificate_file: certificate)
-      subject.create_virtual_machine(params, default_options)
-      result = subject.get_virtual_machine(virtual_machine_name, cloud_service_name)
+      default_options.merge!(
+        private_key_file: private_key,
+        certificate_file: certificate
+      )
+      result = subject.create_virtual_machine(params, default_options)
       result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      assert_equal(result.os_type, 'Linux', 'Error in the OS type of VI created')
+      assert_equal(result.os_type, 'Linux')
       sleep 30
     end
 
-    it 'throws Runtime error as port value is beyond or less than actual range' do
+    it 'throws error as port value is beyond or less than actual range' do
       default_options.merge!(tcp_endpoints: '80,166535:166535')
       msg = subject.create_virtual_machine(params, default_options)
-      assert_match(/invalid. Allowed values are 'a number between 1 to 65535'./i, msg)
+      error_msg = "invalid. Allowed values are 'a number between 1 to 65535'."
+      assert_match(/#{error_msg}/i, msg)
 
       default_options.merge!(tcp_endpoints: '80,0:0')
       msg = subject.create_virtual_machine(params, default_options)
-      assert_match(/invalid. Allowed values are 'a number between 1 to 65535'./i, msg)
-
+      assert_match(/#{error_msg}/i, msg)
       cloud_service.delete_cloud_service(cloud_service_name)
     end
 
     it 'throws error when multiple VMs created under same DNS' do
       subject.create_virtual_machine(params, default_options)
       msg = subject.create_virtual_machine(windows_params, default_options)
-      assert_match(/The specified deployment slot Production is occupied./i, msg)
+      error_msg = 'The specified deployment slot Production is occupied.'
+      assert_match(/#{error_msg}/i, msg)
     end
 
     it 'throws SystemExit error when vm_user not provided' do
@@ -195,10 +196,11 @@ describe Azure::VirtualMachineManagementService do
       cloud_service.delete_cloud_service(cloud_service_name)
     end
 
-    it 'error thrown when invalid Virtual Machine name for Windows OS provided' do
+    it 'error thrown when invalid VM name given for Windows OS' do
       windows_params.merge!(vm_name: 'MSServerInstnce01')
       msg = subject.create_virtual_machine(windows_params, default_options)
-      assert_match(/The computer name cannot be more than 15 characters long, be entirely numeric, or contain the following characters/i, msg)
+      error_msg = 'The computer name cannot be more than 15 characters long'
+      assert_match(/#{error_msg}/i, msg)
       cloud_service.delete_cloud_service(cloud_service_name)
     end
 

data/test/integration/vm/VM_Delete_test.rb

@@ -12,44 +12,44 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #--------------------------------------------------------------------------
-require "integration/test_helper"
+require 'integration/test_helper'
 
 describe Azure::VirtualMachineManagementService do
 
   subject { Azure::VirtualMachineManagementService.new }
   let(:names) { VirtualMachineNameHelper.name }
-  let(:virtual_machine_name) { names.first}
-  let(:cloud_service_name) { names.last }
-  let(:username) {'admin'}
-  before {
+  let(:virtual_machine_name) { names.first }
+  let(:csn) { names.last }
+  let(:username) { 'admin' }
+  before do
     Loggerx.expects(:puts).at_least_once.returns(nil)
     params = {
-      :vm_name => virtual_machine_name,
-      :vm_user => 'user',
-      :image => LinuxImage.name,
-      :password => 'User123',
-      :location => LinuxImageLocation
+      vm_name: virtual_machine_name,
+      vm_user: 'user',
+      image: LinuxImage.name,
+      password: 'User123',
+      location: LinuxImageLocation
     }
     options = {
-      :storage_account_name => StorageAccountName,
-      :cloud_service_name => cloud_service_name,
+      storage_account_name: StorageAccountName,
+      cloud_service_name: csn,
     }
     subject.create_virtual_machine(params, options)
     sleep 60
-  }
+  end
 
-  describe "#delete_virtual_machine" do
+  describe '#delete_virtual_machine' do
 
-    it "delete existing virtual machine and cloud service" do
-      subject.delete_virtual_machine(virtual_machine_name, cloud_service_name)
+    it 'delete existing virtual machine and cloud service' do
+      subject.delete_virtual_machine(virtual_machine_name, csn)
       sleep 60
-      vm = subject.get_virtual_machine(virtual_machine_name, cloud_service_name)
+      vm = subject.get_virtual_machine(virtual_machine_name, csn)
       vm.must_be_nil
-      cloud_presence = Azure::CloudServiceManagementService.new.get_cloud_service(cloud_service_name)
+      cloud_service = Azure::CloudServiceManagementService.new
+      cloud_presence = cloud_service.get_cloud_service(csn)
       cloud_presence.must_equal false
     end
 
   end
 
 end
-

data/test/integration/vm/VM_Operations_test.rb

@@ -0,0 +1,174 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'integration/test_helper'
+
+describe Azure::VirtualMachineManagementService do
+  let(:vm_name) { 'test-operation-vm' }
+  let(:csn) { vm_name + '-service-qwert' }
+  subject { Azure::VirtualMachineManagementService.new }
+
+  before do
+    Loggerx.expects(:puts).returns(nil).at_least(0)
+    params = {
+      vm_name: vm_name,
+      vm_user: 'user',
+      image: LinuxImage.name,
+      password: 'User123',
+      location: LinuxImageLocation
+    }
+    options = {
+      storage_account_name: StorageAccountName,
+      cloud_service_name: csn,
+    }
+    vm = subject.get_virtual_machine(vm_name, csn)
+    if vm.nil?
+      subject.create_virtual_machine(params, options)
+      sleep 60 # Wait to finish provision.
+    end
+  end
+
+  describe 'Operations on virtual machine' do
+
+    describe '#shutdown_virtual_machine' do
+      it 'shuts down virtual machine' do
+        subject.shutdown_virtual_machine(vm_name, csn)
+        vm = subject.get_virtual_machine(vm_name, csn)
+        %w(StoppedVM StoppedDeallocated).must_include  vm.status
+
+        msg = subject.shutdown_virtual_machine(vm_name, csn)
+        emsg = 'Cannot perform the shutdown operation on a stopped virtual machine'
+        assert_match(/#{emsg}/, msg)
+      end
+
+      it 'raises an error if virtual machine doesn\'t exists' do
+        name = 'test-shutdown'
+        msg = subject.shutdown_virtual_machine(name, csn)
+        assert_match(/Cannot find virtual machine \"#{name}\" under cloud service \"#{csn}\"/, msg)
+      end
+
+    end
+
+    describe '#start_virtual_machine' do
+      before do
+        subject.shutdown_virtual_machine(vm_name, csn)
+      end
+      
+      it 'starts virtual machine' do
+        subject.start_virtual_machine(vm_name, csn)
+        vm = subject.get_virtual_machine(vm_name, csn)
+        statuses = %w(ReadyRole Provisioning CreatingVM RoleStateUnknown)
+        statuses.must_include  vm.status
+      end
+
+    end
+
+    describe '#restart_virtual_machine' do
+      before do
+        subject.restart_virtual_machine(vm_name, csn)
+      end
+
+      it 'restarts virtual machine' do
+        vm = subject.get_virtual_machine(vm_name, csn)
+        %w(ReadyRole Provisioning RoleStateUnknown).must_include  vm.status
+      end
+    end
+
+    describe '#get_virtual_machine' do
+      it 'should return virtual machine object' do
+        vm = subject.get_virtual_machine(vm_name, csn)
+        vm.vm_name.must_equal vm_name
+        vm.cloud_service_name.must_equal csn
+      end
+    end
+
+    describe '#list_virtual_machines' do
+      it 'returns a list of virtual machines' do
+        vms = subject.list_virtual_machines
+        vms.wont_be_nil
+        vms.must_be_kind_of Array
+        vm = vms.first
+        vm.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
+        vm_names = vms.map(&:vm_name)
+        vm_names.must_include  vm.vm_name
+      end
+    end
+
+    describe '#add_data_disk' do
+      it 'add data disk to virtual machine' do
+        lun = rand(1..15)
+        others = { disk_size: 100 }
+        subject.add_data_disk(vm_name, csn , lun, others)
+        dms = VirtualMachineDiskManagementService.new
+        disks = dms.list_virtual_machine_disks
+        disks = disks.select { |x| (/#{csn}/ =~ x.name) && x.os_type.empty? }
+        assert_operator disks.size, :>=, 1
+        disks.first.size.must_equal others[:disk_size].to_s
+      end
+    end
+
+    describe 'Add, Update, Delete endpoints' do
+      
+      it 'should add endpoints to virtual machine.' do
+        ep1 =  {
+          name: 'endpoint-1',
+          public_port: 777,
+          local_port: 777,
+          protocol: 'UDP',
+        }
+        ep2 =  {
+          name: 'endpoint-2',
+          public_port: 888,
+          local_port: 889,
+          protocol: 'UDP',
+          load_balancer_name: 'lb',
+          load_balancer: { protocol: 'http', path: 'mypath' }
+        }
+        subject.update_endpoints(vm_name, csn,  ep1, ep2)
+        vm = subject.get_virtual_machine(vm_name, csn)
+        vm.udp_endpoints.size.must_equal 2
+        vm.udp_endpoints.first[:name].must_equal 'endpoint-1'
+        vm.udp_endpoints.last[:name].must_equal 'endpoint-2'
+      end
+
+      it 'should update existing endpoints of virtual machine.' do
+        ep1 =  {
+          name: 'SSH',
+          public_port: 2222,
+          local_port: 22,
+          protocol: 'TCP',
+        }
+        subject.update_endpoints(vm_name, csn,  ep1)
+        vm = subject.get_virtual_machine(vm_name, csn)
+        vm.tcp_endpoints.size.must_equal 1
+        vm.tcp_endpoints.first[:name].must_equal 'SSH'
+        vm.tcp_endpoints.first[:public_port].must_equal '2222'
+      end
+
+      it 'should delete endpoint of virtual machine.' do
+        subject.delete_endpoint(vm_name, csn,  'SSH')
+        vm = subject.get_virtual_machine(vm_name, csn)
+        vm.tcp_endpoints.size.must_equal 0
+        ep1 =  {
+          name: 'SSH',
+          public_port: 22,
+          local_port: 22,
+          protocol: 'TCP',
+        }
+        subject.update_endpoints(vm_name, csn,  ep1)
+      end
+    end
+
+  end
+end # end

data/test/support/virtual_machine_name_generator.rb

@@ -28,7 +28,7 @@ class VirtualMachineNameGenerator
     vm_name = random_text('test-')
     cloud_name = random_text(vm_name + '-service-')
     @names << [vm_name, cloud_name]
-    return vm_name, cloud_name
+    [vm_name, cloud_name]
   end
 
   def clean
@@ -44,43 +44,31 @@ class VirtualMachineNameGenerator
     virtual_machine_service = Azure::VirtualMachineManagementService.new
     virtualmachines = virtual_machine_service.list_virtual_machines
     azure_cloud_service = Azure::CloudServiceManagementService.new
-    virtualmachines.each do |virtualmachine|
-      if virtualmachine.vm_name.include?('test-') &&\
-          virtualmachine.cloud_service_name.include?(
-            virtualmachine.vm_name + '-service-'
-          )
-        begin
-          azure_cloud_service.delete_cloud_service_deployment(
-            virtualmachine.cloud_service_name
-          )
-          azure_cloud_service.delete_cloud_service(
-            virtualmachine.cloud_service_name
-          )
-        rescue
-        end
+    virtualmachines.each do |vm|
+      vm_name = vm.vm_name + '-service-'
+      csn = vm.cloud_service_name
+      if vm.vm_name.include?('test-') && csn.include?(vm_name)
+        azure_cloud_service.delete_cloud_service_deployment(csn) rescue nil
       end
     end
+
     # Delete cloud services
-    Azure::BaseManagementService.new
     cloud_services = azure_cloud_service.list_cloud_services
     cloud_services.each do |cloud_service|
-      if cloud_service.name.include?('test-') &&\
-         cloud_service.name.include?('-service-')
-        azure_cloud_service.delete_cloud_service(
-          cloud_service.name
-        )  rescue nil
+      csn = cloud_service.name
+      if csn.include?('test-') && csn.include?('-service-')
+        azure_cloud_service.delete_cloud_service(csn)  rescue nil
       end
     end
 
     # Delete disks
-    disk_management_service = Azure::VirtualMachineImageManagement::VirtualMachineDiskManagementService.new
-    disks = disk_management_service.list_virtual_machine_disks
+    disk_service = VirtualMachineDiskManagementService.new
+    sleep 60
+    disks = disk_service.list_virtual_machine_disks
     disks.each do |disk|
-      if disk.name.include?('-service-') &&\
-         disk.name.include?('test-') && !disk.attached
-        disk_management_service.delete_virtual_machine_disk(
-          disk.name
-        ) rescue nil
+      name = disk.name
+      if name.include?('-service-') && name.include?('test-') && !disk.attached
+        disk_service.delete_virtual_machine_disk(name) rescue nil
       end
     end
 
@@ -94,16 +82,13 @@ class VirtualMachineNameGenerator
     end
 
     # Delete affinity groups
-    affinity_group_service = Azure::BaseManagementService.new
-    affinity_groups = affinity_group_service.list_affinity_groups
+    ag_service = Azure::BaseManagementService.new
+    affinity_groups = ag_service.list_affinity_groups
     affinity_groups.each do |affinity_group|
       if affinity_group.name.include?('affinity-group-')
-        affinity_group_service.delete_affinity_group(
-          affinity_group.name
-        ) rescue nil
+        ag_service.delete_affinity_group(affinity_group.name) rescue nil
       end
     end
-
   end
 end