azure 0.6.3 → 0.6.4

data/test/unit/virtual_machine_management/serialization_test.rb

@@ -120,12 +120,16 @@ describe Azure::VirtualMachineManagement::Serialization do
         storage_account_name: 'storageaccountname',
         cloud_service_name: 'cloud-service-name',
         tcp_endpoints: '80,3389:3390,85:85',
-        availability_set_name: 'aval-set'
+        availability_set_name: 'aval-set',
+        winrm_https_port: '5988',
+        winrm_transport: ['http','https']
       }
     end
 
     it 'returns an VirtualMachine object with correct tcp endpoints' do
       params[:certificate] = {fingerprint: 'CFB8C256D2986559C630547F2D0'}
+      options[:os_type] = 'Windows'
+      options[:existing_ports] = ['5985']
       result = subject.deployment_to_xml params, options
       doc = Nokogiri::XML(result)
       endpoints = doc.css('Deployment RoleList ConfigurationSet InputEndpoints InputEndpoint')
@@ -154,28 +158,37 @@ describe Azure::VirtualMachineManagement::Serialization do
         public_port: '85',
         local_port: '85'
       )
+      tcp_endpoints.must_include(
+        name: 'PowerShell',
+        public_port: '5988',
+        local_port: '5986'
+      )
     end
   end
 
   describe '#add_data_disk_to_xml' do
 
     let(:options) do
-      {disk_size: 100}
+      {
+        disk_size: 100,
+      }
     end
     let(:media_link) { 'https://sta.blob.managment.core.net/vhds/1234.vhd' }
-    let(:lun) { 5 }
+
     before do
       Loggerx.expects(:puts).returns(nil).at_least(0)
+      @vm = Azure::VirtualMachineManagement::VirtualMachine.new
+      @vm.data_disks = []
+      @vm.media_link = media_link
     end
 
-    it 'returns an xml for newly created data disk' do
-      result = subject.add_data_disk_to_xml(lun, media_link, options)
+    it 'returns an xml for newly created data disk' do      
+      result = subject.add_data_disk_to_xml(@vm, options)
       doc = Nokogiri::XML(result)
       disk_size = doc.css('DataVirtualHardDisk LogicalDiskSizeInGB').text
       media_link = doc.css('DataVirtualHardDisk MediaLink').text
       disk_name = doc.css('DataVirtualHardDisk DiskName').text
       result.must_be_kind_of String
-      doc.css('DataVirtualHardDisk Lun').text.must_equal lun.to_s
       disk_size.must_equal options[:disk_size].to_s
       media_link.wont_be_empty
       disk_name.must_be_empty
@@ -184,12 +197,11 @@ describe Azure::VirtualMachineManagement::Serialization do
     it 'returns an xml for existing data disk' do
       options[:import] = true
       options[:disk_name] = 'disk_name'
-      result = subject.add_data_disk_to_xml(lun, media_link, options)
+      result = subject.add_data_disk_to_xml(@vm, options)
       doc = Nokogiri::XML(result)
       media_link = doc.css('DataVirtualHardDisk MediaLink').text
       disk_name = doc.css('DataVirtualHardDisk DiskName').text
       result.must_be_kind_of String
-      doc.css('DataVirtualHardDisk Lun').text.must_equal lun.to_s
       media_link.must_be_empty
       disk_name.wont_be_empty
     end
@@ -197,36 +209,36 @@ describe Azure::VirtualMachineManagement::Serialization do
     it 'raise error when disk name is empty' do
       options[:import] = true
       exception = assert_raises(RuntimeError) do
-        subject.add_data_disk_to_xml(lun, media_link, options)
+        subject.add_data_disk_to_xml(@vm, options)
       end
       assert_match(/The data disk name is not valid/i, exception.message)
     end
   end
 
-  describe '#add_data_disk_to_xml' do
+  describe '#assign_random_port' do
     let(:preferred_port) { '22' }
     before do
       subject.class.send(:public, *subject.class.private_instance_methods)
       Loggerx.expects(:puts).returns(nil).at_least(0)
     end
 
-    it 'returns an xml for newly created data disk' do
+    it 'returns random port number when preferred port is in use' do
       result = subject.assign_random_port(preferred_port, [preferred_port])
       assert_operator result.to_i, :>=, 10000
       assert_operator result.to_i, :<=, 65535
     end
 
-    it 'returns an xml for newly created data disk' do
+    it 'returns preferred port number when used ports is nil' do
       result = subject.assign_random_port(preferred_port, nil)
       result.must_equal preferred_port
     end
 
-    it 'returns an xml for newly created data disk' do
+    it 'returns preferred port number when used ports is empty' do
       result = subject.assign_random_port(preferred_port, [])
       result.must_equal preferred_port
     end
 
-    it 'returns an xml for newly created data disk' do
+    it 'returns random port number when preferred port is in use' do
       result = subject.assign_random_port(preferred_port, ['1', preferred_port])
       assert_operator result.to_i, :>=, 10000
       assert_operator result.to_i, :<=, 65535

data/test/unit/virtual_machine_management/virtual_machine_management_service_test.rb

@@ -21,11 +21,7 @@ describe Azure::VirtualMachineManagementService do
     Azure::VirtualMachineManagementService.new
   end
 
-  before do
-    Loggerx.stubs(:info).returns(nil)
-  end
-
-  let(:params)do
+  let(:params) do
     {
       vm_name: 'instance1',
       vm_user: 'root',
@@ -35,7 +31,7 @@ describe Azure::VirtualMachineManagementService do
     }
   end
 
-  let(:windows_params)do
+  let(:windows_params) do
     {
       vm_name: 'instance1',
       vm_user: 'administrator',
@@ -53,56 +49,58 @@ describe Azure::VirtualMachineManagementService do
     response
   end
   let(:location_response_body) { Nokogiri::XML location_response.body }
+  let(:mock_virtual_machine_request) { mock }
+  let(:windows_images_xml) { Fixtures['list_images'] }
+  let(:images_request_path) { '/services/images' }
+  let(:mock_request) { mock }
+  let(:os_response_body) do
+    response = mock
+    response.stubs(:body).returns(windows_images_xml)
+    Nokogiri::XML response.body
+  end
+
+  before do
+    Loggerx.stubs(:info).returns(nil)
+    Loggerx.expects(:puts).returns(nil).at_least(0)
+    ManagementHttpRequest.stubs(:new).with(
+      :get,
+      images_request_path,
+      nil
+    ).returns(mock_request)
+    mock_request.expects(:call).returns(os_response_body).at_least(0)
+  end
 
   describe '#list_virtual_machines' do
     let(:request_path) { '/services/hostedservices' }
     let(:cloud_services_xml) { Fixtures['list_cloud_services'] }
     let(:virtual_machine_xml) { Fixtures['virtual_machine'] }
     let(:deployment_error_xml) { Fixtures['deployment_error'] }
-    let(:virtual_networks_xml) { Fixtures['list_virtual_networks'] }
-
     let(:method) { :get }
-
     let(:mock_cloud_service_request) { mock }
-    let(:mock_virtual_machine_request) { mock }
-    let(:mock_virtual_network_request) { mock }
-
     let(:cloud_service_response) do
       cloud_service_response = mock
       cloud_service_response.stubs(:body).returns(cloud_services_xml)
       cloud_service_response
     end
-
     let(:virtual_machine_response) do
       virtual_machine_response = mock
       virtual_machine_response.stubs(:body).returns(virtual_machine_xml)
       virtual_machine_response
     end
-
     let(:deployment_error_response) do
       http_error_response = mock
       http_error_response.stubs(:body).returns(deployment_error_xml)
       http_error_response
     end
-
-    let(:virtual_networks_response) do
-      virtual_networks_response = mock
-      virtual_networks_response.stubs(:body).returns(virtual_networks_xml)
-      virtual_networks_response
-    end
-
     let(:cloud_service_response_body) { Nokogiri::XML cloud_service_response.body }
     let(:virtual_machine_response_body) { Nokogiri::XML virtual_machine_response.body }
-    let(:virtual_networks_response_body) { Nokogiri::XML virtual_networks_response.body }
 
     before do
       ManagementHttpRequest.stubs(:new).with(method, request_path, nil).returns(mock_cloud_service_request)
       mock_cloud_service_request.expects(:call).returns(cloud_service_response_body)
-      ManagementHttpRequest.stubs(:new).with(method, '/services/hostedservices/cloud-service-1/deploymentslots/production').returns(mock_virtual_machine_request)
+      ManagementHttpRequest.stubs(:new).with(method, anything).returns(mock_virtual_machine_request)
       mock_virtual_machine_request.stubs(:warn=).returns(true).twice
-      ManagementHttpRequest.stubs(:new).with(method, '/services/hostedservices/cloud-service-2/deploymentslots/production').returns(mock_virtual_machine_request)
       mock_virtual_machine_request.expects(:call).twice.returns(virtual_machine_response_body).returns(Nokogiri::XML  deployment_error_response.body)
-      ManagementHttpRequest.stubs(:new).with(method, '/services/networking/virtualnetwork', nil).returns(mock_virtual_network_request)
     end
 
     it 'assembles a URI for the request' do
@@ -157,9 +155,9 @@ describe Azure::VirtualMachineManagementService do
   describe '#get_virtual_machine' do
 
     before do
-      virtual_machine = VirtualMachine.new do |virtual_machine|
-        virtual_machine.vm_name = 'instance-name'
-        virtual_machine.cloud_service_name = 'cloud-service-1'
+      virtual_machine = VirtualMachine.new do |vm|
+        vm.vm_name = 'instance-name'
+        vm.cloud_service_name = 'cloud-service-1'
       end
       Azure::VirtualMachineManagementService.any_instance.stubs(
         :list_virtual_machines
@@ -172,38 +170,22 @@ describe Azure::VirtualMachineManagementService do
     end
 
     it 'return nil if virtual machine or cloud server does not exist ' do
-      virtual_machine = subject.get_virtual_machine 'name', 'cloud-service-1'
-      virtual_machine.must_equal nil
-      virtual_machine = subject.get_virtual_machine 'instance-name', 'cloud_service_name'
-      virtual_machine.must_equal nil
+      vm = subject.get_virtual_machine 'name', 'cloud-service-1'
+      vm.must_equal nil
+      vm = subject.get_virtual_machine 'name2', 'cloud_service_name'
+      vm.must_equal nil
     end
 
     it 'return virtual machine instance if virtual machine name and cloud server name are valid ' do
-      virtual_machine = subject.get_virtual_machine 'instance-name', 'cloud-service-1'
-      virtual_machine.must_be_kind_of VirtualMachine
+      vm = subject.get_virtual_machine 'instance-name', 'cloud-service-1'
+      vm.must_be_kind_of VirtualMachine
     end
   end
 
   describe '#create_virtual_machine' do
-    let(:images_request_path) { '/services/images' }
-    let(:images_xml) { Fixtures['list_images'] }
-    let(:virtual_machine_xml) { Fixtures['virtual_machine'] }
     let(:method) { :get }
-    let(:mock_request) { mock }
-
-    let(:os_response_body) do
-      response = mock
-      response.stubs(:body).returns(images_xml)
-      Nokogiri::XML response.body
-    end
 
     before do
-      ManagementHttpRequest.stubs(:new).with(
-        method,
-        images_request_path,
-        nil
-      ).returns(mock_request)
-      mock_request.expects(:call).returns(os_response_body)
       mock_request = mock
       ManagementHttpRequest.stubs(:new).with(
         method,
@@ -257,24 +239,10 @@ describe Azure::VirtualMachineManagementService do
   end
 
   describe '#create_virtual_machine with invalid parameters for windows machine' do
-    let(:images_request_path) { '/services/images' }
-    let(:windows_images_xml) { Fixtures['list_images'] }
     let(:virtual_machine_xml) { Fixtures['virtual_machine'] }
     let(:method) { :get }
-    let(:mock_request) { mock }
-    let(:os_response_body) do
-      response = mock
-      response.stubs(:body).returns(windows_images_xml)
-      Nokogiri::XML response.body
-    end
 
     before do
-      ManagementHttpRequest.stubs(:new).with(
-        method,
-        images_request_path,
-        nil
-      ).returns(mock_request)
-      mock_request.expects(:call).returns(os_response_body)
       mock_request = mock
       ManagementHttpRequest.stubs(:new).with(
         method,
@@ -285,7 +253,6 @@ describe Azure::VirtualMachineManagementService do
       Azure::CloudServiceManagementService.any_instance.stubs(:create_cloud_service)
       Azure::CloudServiceManagementService.any_instance.stubs(:upload_certificate)
       Azure::StorageManagementService.any_instance.stubs(:create_storage_account)
-      Loggerx.expects(:puts).returns(nil).at_least(0)
       mock_request = mock
       ManagementHttpRequest.expects(:new).with(
         :post,
@@ -403,19 +370,9 @@ describe Azure::VirtualMachineManagementService do
   end
 
   describe '#get_os_type' do
-    let(:images_xml) { Fixtures['list_images'] }
-    let(:mock_request) { mock }
-    let(:response) do
-      response = mock
-      response.stubs(:body).returns(images_xml)
-      response
-    end
-    let(:response_body) { Nokogiri::XML response.body }
 
     before do
-      ManagementHttpRequest.any_instance.expects(:call).returns response_body
       subject.class.send(:public, *subject.class.private_instance_methods)
-      Loggerx.expects(:puts).returns(nil).at_least(0)
     end
 
     it 'returns os type of given virtual machine image' do
@@ -432,4 +389,52 @@ describe Azure::VirtualMachineManagementService do
     end
   end
 
+  describe '#add_role' do
+
+    before do
+      windows_params[:cloud_service_name] = 'cloud-service-1'
+    end
+
+    it 'should throws error when cloud service name is empty' do
+      windows_params.delete(:cloud_service_name)
+      exception = assert_raises(RuntimeError) do
+        subject.add_role(params)
+      end
+      error_msg = 'You did not provide a valid \'cloud_service_name\' value'
+      assert_match(/#{error_msg}/i, exception.message)
+    end
+
+    it 'throws error when vm_user is not given' do
+      windows_params.delete(:vm_user)
+      exception = assert_raises(RuntimeError) do
+        subject.add_role(windows_params)
+      end
+      error_msg = 'You did not provide a valid \'vm_user\' value'
+      assert_match(/#{error_msg}/i, exception.message)
+    end
+
+    it 'throws error when certificate path is not invalid.' do
+      options = {
+        winrm_transport: %w(https http),
+        private_key_file: 'f:/invalid_path/private_key' ,
+        certificate_file: 'f:/invalid_path/certificate.pem'
+      }
+      exception = assert_raises(RuntimeError) do
+        subject.add_role(windows_params, options)
+      end
+      error_msg = 'No such file or directory -'
+      assert_match(/#{error_msg}/i, exception.message)
+    end
+
+    it 'throws error when wrong role size is given' do
+      options = { vm_size: 'wrong size' }
+      exception = assert_raises(RuntimeError) do
+        subject.add_role(windows_params, options)
+      end
+      error_msg = "wrong size' specified for parameter 'vm_size' is invalid."
+      assert_match(/#{error_msg}*/, exception.message)
+    end
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: azure
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - Microsoft Corporation
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-29 00:00:00.000000000 Z
+date: 2014-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -333,6 +333,8 @@ files:
 - test/integration/blob/lease/release_lease_test.rb
 - test/integration/blob/lease/renew_lease_test.rb
 - test/integration/blob/list_blobs_test.rb
+- test/integration/cloud_service/Cloud_Create_test.rb
+- test/integration/cloud_service/Cloud_Delete_test.rb
 - test/integration/database/create_sql_server_firewall_test.rb
 - test/integration/database/create_sql_server_test.rb
 - test/integration/database/delete_sql_server_firewall_test.rb