azure 0.6.4 → 0.7.0.pre

data/test/unit/virtual_machine_image_management/serialization_test.rb

@@ -17,19 +17,34 @@ require 'test_helper'
 describe Azure::VirtualMachineImageManagement::Serialization do
   subject { Azure::VirtualMachineImageManagement::Serialization }
 
-  let(:virtual_machine_images_from_xml) { Fixtures['list_images'] }
-
   describe '#virtual_machine_images_from_xml' do
+    let(:os_images_xml) { Fixtures['list_os_images'] }
 
     it 'accepts an XML string' do
-      subject.virtual_machine_images_from_xml Nokogiri::XML(virtual_machine_images_from_xml)
+      subject.virtual_machine_images_from_xml Nokogiri::XML(os_images_xml)
     end
 
     it 'returns an Array of VirtualMachineImageService instances' do
-      results = subject.virtual_machine_images_from_xml Nokogiri::XML(virtual_machine_images_from_xml)
+      results = subject.virtual_machine_images_from_xml Nokogiri::XML(os_images_xml)
       results.must_be_kind_of Array
-      results[0].must_be_kind_of Azure::VirtualMachineImageManagement::VirtualMachineImage
+      results[0].must_be_kind_of VirtualMachineImage
       results.count.must_equal 12
     end
   end
+
+  describe '#virtual_machine_vm_images_from_xml' do
+    let(:vm_images_xml) { Fixtures['list_vm_images'] }
+
+    it 'accepts an XML string' do
+      subject.virtual_machine_vm_images_from_xml Nokogiri::XML(vm_images_xml)
+    end
+
+    it 'returns an Array of VirtualMachineImageService instances' do
+      results = subject.virtual_machine_vm_images_from_xml Nokogiri::XML(vm_images_xml)
+      results.must_be_kind_of Array
+      results[0].must_be_kind_of VirtualMachineImage
+      results.count.must_equal 1
+    end
+  end
+
 end

data/test/unit/virtual_machine_image_management/virtual_machine_image_management_service_test.rb

@@ -18,48 +18,97 @@ describe Azure::VirtualMachineImageManagementService do
 
   subject { Azure::VirtualMachineImageManagementService.new }
 
-  let(:request_path) { '/services/images' }
-  let(:images_xml) { Fixtures['list_images'] }
-  let(:method) { :get }
-  let(:mock_request) { mock }
-  let(:response) do
+  let(:os_image_request_path) { '/services/images' }
+  let(:vm_image_request_path) { '/services/vmimages' }
+  let(:os_images_xml) { Fixtures['list_os_images'] }
+  let(:vm_images_xml) { Fixtures['list_vm_images'] }
+  let(:verb) { :get }
+  let(:os_images_response) do
     response = mock
-    response.stubs(:body).returns(images_xml)
-    response
+    response.stubs(:body).returns(os_images_xml)
+    Nokogiri::XML response.body
   end
-  let(:response_body) { Nokogiri::XML response.body }
-
-  before do
-    Loggerx.expects(:puts).returns(nil).at_least(0)
+  let(:vm_images_response) do
+    response = mock
+    response.stubs(:body).returns(vm_images_xml)
+    Nokogiri::XML response.body
   end
 
-  describe '#list_virtual_machine_images' do
+  before {
+    Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
+  }
 
+  describe '#list_os_images' do
+    let(:verb) { :get }
     before do
-      ManagementHttpRequest.stubs(:new).with(
-        method,
-        request_path,
-        nil
-      ).returns(mock_request)
-      mock_request.expects(:call).returns(response_body)
+      os_images_request = mock
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
+          verb,
+          os_image_request_path,
+          nil
+      ).returns(os_images_request)
+      os_images_request.expects(:call).returns(os_images_response)
     end
 
-    it 'assembles a URI for the request' do
-      subject.list_virtual_machine_images
+    it 'returns a list of os images from server' do
+      os_images = subject.list_os_images
+      os_images.must_be_kind_of Array
+      image_klass = VirtualMachineImage
+      os_images.length.must_equal 12
+      image = os_images.first
+      image.must_be_kind_of image_klass
+      image.image_type.must_equal 'OS'
     end
+  end
 
-    it 'sets the properties of the virtual machine images' do
-      virtual_machine_image = subject.list_virtual_machine_images.first
-      virtual_machine_image.name.must_equal 'RightImage-CentOS-6.2-x64-v5.8.8.1'
+  describe '#list_vm_images' do
+    let(:verb) { :get }
+    before do
+      vm_images_request = mock
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
+          verb,
+          vm_image_request_path,
+          nil
+      ).returns(vm_images_request)
+      vm_images_request.expects(:call).returns(vm_images_response)
     end
 
-    it 'returns a list of virtual machine images from server' do
-      results = subject.list_virtual_machine_images
-      results.must_be_kind_of Array
-      results.length.must_equal 12
-      image_klass = Azure::VirtualMachineImageManagement::VirtualMachineImage
-      results.first.must_be_kind_of image_klass
+    it 'returns a list of vm images from server' do
+      vm_images = subject.list_vm_images
+      vm_images.must_be_kind_of Array
+      vm_images.length.must_equal 1
+      image_klass = VirtualMachineImage
+      image = vm_images.first
+      image.must_be_kind_of image_klass
+      image.image_type.must_equal 'VM'
     end
   end
 
+  describe '#list_images' do
+    let(:verb) { :get }
+    before do
+      vm_images_request = mock
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
+          verb,
+          vm_image_request_path,
+          nil
+      ).returns(vm_images_request)
+      vm_images_request.expects(:call).returns(vm_images_response)
+      os_images_request = mock
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
+          verb,
+          os_image_request_path,
+          nil
+      ).returns(os_images_request)
+      os_images_request.expects(:call).returns(os_images_response)
+    end
+
+    it 'returns a list of virtual machine images' do
+      images = subject.list_virtual_machine_images
+      images.must_be_kind_of Array
+      images.length.must_equal 13
+      images.last.image_type.must_equal 'VM'
+      images.first.image_type.must_equal 'OS'
+    end
+  end
 end

data/test/unit/virtual_machine_management/serialization_test.rb

@@ -15,6 +15,8 @@
 require 'test_helper'
 
 describe Azure::VirtualMachineManagement::Serialization do
+  include Azure::Core::Utility
+
   subject { Azure::VirtualMachineManagement::Serialization }
 
   let(:vm_xml) { Nokogiri::XML(Fixtures['virtual_machine']) }
@@ -46,25 +48,25 @@ describe Azure::VirtualMachineManagement::Serialization do
       virtual_machine = subject.virtual_machines_from_xml(vm_xml, csn).first
       virtual_machine.tcp_endpoints.must_be_kind_of Array
       virtual_machine.tcp_endpoints.must_include(
-        name: 'SSH',
-        vip: '137.116.17.187',
-        public_port: '22',
-        local_port:  '22',
-        protocol: 'tcp'
+          name: 'SSH',
+          vip: '137.116.17.187',
+          public_port: '22',
+          local_port: '22',
+          protocol: 'tcp'
       )
       virtual_machine.tcp_endpoints.must_include(
-        name: 'tcp-port-80',
-        vip: '137.117.17.187',
-        public_port:  '80',
-        local_port:  '80',
-        protocol: 'tcp'
+          name: 'tcp-port-80',
+          vip: '137.117.17.187',
+          public_port: '80',
+          local_port: '80',
+          protocol: 'tcp'
       )
       virtual_machine.tcp_endpoints.must_include(
-        name: 'tcp-port-3889',
-        vip: '137.116.17.187',
-        public_port:  '3889',
-        local_port:  '3889',
-        protocol: 'tcp'
+          name: 'tcp-port-3889',
+          vip: '137.116.17.187',
+          public_port: '3889',
+          local_port: '3889',
+          protocol: 'tcp'
       )
     end
 
@@ -107,30 +109,40 @@ describe Azure::VirtualMachineManagement::Serialization do
   describe '#deployment_to_xml' do
     let(:params) do
       {
-        vm_name: 'virtual-machine-name',
-        vm_user: 'username',
-        image: 'linux_image',
-        password: 'password',
-        location: 'West US'
+          vm_name: 'virtual-machine-name',
+          vm_user: 'username',
+          image: 'linux_image',
+          password: 'password',
+          location: 'West US',
+          certificate: {fingerprint: 'CFB8C256D2986559C630547F2D0'}
       }
     end
 
     let(:options) do
       {
-        storage_account_name: 'storageaccountname',
-        cloud_service_name: 'cloud-service-name',
-        tcp_endpoints: '80,3389:3390,85:85',
-        availability_set_name: 'aval-set',
-        winrm_https_port: '5988',
-        winrm_transport: ['http','https']
+          storage_account_name: 'storageaccountname',
+          cloud_service_name: 'cloud-service-name',
+          tcp_endpoints: '80,3389:3390,85:85',
+          availability_set_name: 'aval-set',
+          winrm_https_port: '5988',
+          winrm_transport: %w(http https),
+          reserved_ip_name: 'AnAwesomeIP'
       }
     end
 
+    let(:image) do
+      Azure::VirtualMachineImageManagement::VirtualMachineImage.new do |i|
+        i.name = 'windows-instance'
+        i.os_type = 'Linux'
+        i.image_type = 'OS'
+      end
+    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
+      result = subject.deployment_to_xml params, image, options
       doc = Nokogiri::XML(result)
       endpoints = doc.css('Deployment RoleList ConfigurationSet InputEndpoints InputEndpoint')
       tcp_endpoints = []
@@ -144,45 +156,65 @@ describe Azure::VirtualMachineManagement::Serialization do
       doc.css('Deployment RoleList AvailabilitySetName').text.must_equal 'aval-set'
       result.must_be_kind_of String
       tcp_endpoints.must_include(
-        name: 'TCP-PORT-80',
-        public_port: '80',
-        local_port: '80'
+          name: 'TCP-PORT-80',
+          public_port: '80',
+          local_port: '80'
       )
       tcp_endpoints.must_include(
-        name: 'TCP-PORT-3390',
-        public_port: '3390',
-        local_port: '3389'
+          name: 'TCP-PORT-3390',
+          public_port: '3390',
+          local_port: '3389'
       )
       tcp_endpoints.must_include(
-        name: 'TCP-PORT-85',
-        public_port: '85',
-        local_port: '85'
+          name: 'TCP-PORT-85',
+          public_port: '85',
+          local_port: '85'
       )
       tcp_endpoints.must_include(
-        name: 'PowerShell',
-        public_port: '5988',
-        local_port: '5986'
+          name: 'PowerShell',
+          public_port: '5988',
+          local_port: '5986'
       )
     end
+
+    it 'returns a VirtualMachine object with it the vhds media_link that includes seconds and milliseconds' do
+      now = Time.now
+      Timecop.freeze(now) do
+        result = subject.deployment_to_xml params, image, options
+        doc = Nokogiri::XML(result)
+        media_link_uri = URI.parse(doc.css('Deployment RoleList OSVirtualHardDisk MediaLink').text)
+        disk_time_name = /disk_(.*?)\.vhd/.match(media_link_uri.path).captures.first
+        disk_time_name.must_equal now.strftime('%Y_%m_%d_%H_%M_%S_%L')
+      end
+    end
+
+    it 'returns a VirtualMachine object with the correct reserved IP' do
+      now = Time.now
+      Timecop.freeze(now) do
+        result = subject.deployment_to_xml params, image, options
+        doc = Nokogiri::XML(result)
+        doc.css('ReservedIPName').text.must_equal "AnAwesomeIP"
+      end
+    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' }
 
     before do
-      Loggerx.expects(:puts).returns(nil).at_least(0)
+      Azure::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      
+    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
@@ -219,7 +251,7 @@ describe Azure::VirtualMachineManagement::Serialization do
     let(:preferred_port) { '22' }
     before do
       subject.class.send(:public, *subject.class.private_instance_methods)
-      Loggerx.expects(:puts).returns(nil).at_least(0)
+      Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
     end
 
     it 'returns random port number when preferred port is in use' do
@@ -244,4 +276,41 @@ describe Azure::VirtualMachineManagement::Serialization do
       assert_operator result.to_i, :<=, 65535
     end
   end
+
+  describe "#role_to_xml" do
+
+    let(:params) do
+      {:certificate => {:fingerprint => "fingerprint"},
+       :vm_name => "aVMName",
+       :vm_user => "nocturnal_flying_echolocating_mammal_man"}
+    end
+
+    let(:image) do
+      Azure::VirtualMachineImageManagement::VirtualMachineImage.new do |i|
+        i.name = 'windows-instance'
+        i.os_type = 'Linux'
+        i.image_type = 'OS'
+      end
+    end
+
+    let(:options) do
+      {:virtual_network_name => "aNetworkName",
+       :subnet_name => "someSubnet",
+       :storage_account_name => "storage",
+       :vm_size => "Small",
+       :os_type => "Linux"}
+    end
+
+    it "should return a valid role containing a static vnet ip address if provided in options" do
+      options[:static_virtual_network_ipaddress] = "1.2.3.4"
+      result = subject.role_to_xml(params, image, options)
+      result.css('StaticVirtualNetworkIPAddress').text.must_equal "1.2.3.4"
+    end
+
+    it "should return a valid role containing a custom data section if provided in params" do
+      params[:custom_data] = 'blahblahblah'
+      result = subject.role_to_xml(params, image, options)
+      result.css('CustomData').text.must_equal "blahblahblah"
+    end
+  end
 end

data/test/unit/virtual_machine_management/virtual_machine_management_service_test.rb

@@ -23,21 +23,21 @@ describe Azure::VirtualMachineManagementService do
 
   let(:params) do
     {
-      vm_name: 'instance1',
-      vm_user: 'root',
-      image: '5112500ae3b842c8b9c604889f8753c3__OpenLogic-CentOS-63APR20130415',
-      password: 'root',
-      location: 'West US'
+        vm_name: 'instance1',
+        vm_user: 'root',
+        image: '5112500ae3b842c8b9c604889f8753c3__OpenLogic-CentOS-63APR20130415',
+        password: 'root',
+        location: 'West US'
     }
   end
 
   let(:windows_params) do
     {
-      vm_name: 'instance1',
-      vm_user: 'administrator',
-      image: 'a699494373c04fc0bc8f2bb1389d6106__Windows-Server-2012-Datacenter-201304.01-en.us-127GB.vhd',
-      password: 'Admin123',
-      location: 'West US'
+        vm_name: 'instance1',
+        vm_user: 'administrator',
+        image: 'a699494373c04fc0bc8f2bb1389d6106__Windows-Server-2012-Datacenter-201304.01-en.us-127GB.vhd',
+        password: 'Admin123',
+        location: 'West US'
     }
   end
 
@@ -50,32 +50,45 @@ describe Azure::VirtualMachineManagementService do
   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
+  let(:os_image_response_body) do
     response = mock
-    response.stubs(:body).returns(windows_images_xml)
+    response.stubs(:body).returns(Fixtures['list_os_images'])
+    Nokogiri::XML response.body
+  end
+  let(:vm_image_response_body) do
+    response = mock
+    response.stubs(:body).returns(Fixtures['list_vm_images'])
     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
+    Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
+        :get,
+        '/services/images',
+        nil
     ).returns(mock_request)
-    mock_request.expects(:call).returns(os_response_body).at_least(0)
+    mock_request.expects(:call).returns(os_image_response_body).at_least(0)
+    vm_request = mock
+    Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
+        :get,
+        '/services/vmimages',
+        nil
+    ).returns(vm_request)
+    vm_request.expects(:call).returns(vm_image_response_body).at_least(0)
   end
 
   describe '#list_virtual_machines' do
+    before do
+      Azure::Loggerx.stubs(:info).returns(nil)
+      Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
+    end
+
     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(:method) { :get }
+    let(:verb) { :get }
     let(:mock_cloud_service_request) { mock }
     let(:cloud_service_response) do
       cloud_service_response = mock
@@ -96,11 +109,11 @@ describe Azure::VirtualMachineManagementService do
     let(:virtual_machine_response_body) { Nokogiri::XML virtual_machine_response.body }
 
     before do
-      ManagementHttpRequest.stubs(:new).with(method, request_path, nil).returns(mock_cloud_service_request)
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(verb, request_path, nil).returns(mock_cloud_service_request)
       mock_cloud_service_request.expects(:call).returns(cloud_service_response_body)
-      ManagementHttpRequest.stubs(:new).with(method, anything).returns(mock_virtual_machine_request)
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(verb, anything).returns(mock_virtual_machine_request)
       mock_virtual_machine_request.stubs(:warn=).returns(true).twice
-      mock_virtual_machine_request.expects(:call).twice.returns(virtual_machine_response_body).returns(Nokogiri::XML  deployment_error_response.body)
+      mock_virtual_machine_request.expects(:call).twice.returns(virtual_machine_response_body).returns(Nokogiri::XML deployment_error_response.body)
     end
 
     it 'assembles a URI for the request' do
@@ -116,6 +129,7 @@ describe Azure::VirtualMachineManagementService do
       virtual_machine.deployment_name.must_equal 'deployment-name'
       virtual_machine.ipaddress.must_equal '137.116.17.187'
       virtual_machine.virtual_network_name.must_equal 'test-virtual-network'
+      virtual_machine.subnet.must_equal 'test-subnet'
     end
 
     it 'returns a list of virtual machines for the subscription' do
@@ -129,25 +143,25 @@ describe Azure::VirtualMachineManagementService do
       virtual_machine = subject.list_virtual_machines.first
       virtual_machine.tcp_endpoints.must_be_kind_of Array
       virtual_machine.tcp_endpoints.must_include(
-        name:  'SSH',
-        vip:  '137.116.17.187',
-        public_port:  '22',
-        local_port: '22',
-        protocol: 'tcp'
+          name: 'SSH',
+          vip: '137.116.17.187',
+          public_port: '22',
+          local_port: '22',
+          protocol: 'tcp'
       )
       virtual_machine.tcp_endpoints.must_include(
-        name: 'tcp-port-80',
-        vip: '137.117.17.187',
-        public_port: '80',
-        local_port: '80',
-        protocol: 'tcp'
+          name: 'tcp-port-80',
+          vip: '137.117.17.187',
+          public_port: '80',
+          local_port: '80',
+          protocol: 'tcp'
       )
       virtual_machine.tcp_endpoints.must_include(
-        name: 'tcp-port-3889',
-        vip: '137.116.17.187',
-        public_port: '3889',
-        local_port: '3889',
-        protocol: 'tcp'
+          name: 'tcp-port-3889',
+          vip: '137.116.17.187',
+          public_port: '3889',
+          local_port: '3889',
+          protocol: 'tcp'
       )
     end
   end
@@ -155,12 +169,14 @@ describe Azure::VirtualMachineManagementService do
   describe '#get_virtual_machine' do
 
     before do
+      Azure::Loggerx.stubs(:info).returns(nil)
+      Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
       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
+          :list_virtual_machines
       ).returns([virtual_machine])
     end
 
@@ -183,24 +199,26 @@ describe Azure::VirtualMachineManagementService do
   end
 
   describe '#create_virtual_machine' do
-    let(:method) { :get }
+    let(:verb) { :get }
 
     before do
+      Azure::Loggerx.stubs(:info).returns(nil)
+      Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
       mock_request = mock
-      ManagementHttpRequest.stubs(:new).with(
-        method,
-        location_request_path,
-        nil
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
+          verb,
+          location_request_path,
+          nil
       ).returns(mock_request)
       mock_request.expects(:call).returns(location_response_body).at_least(0)
       Azure::CloudServiceManagementService.any_instance.stubs(:create_cloud_service)
       Azure::CloudServiceManagementService.any_instance.stubs(:upload_certificate)
       Azure::StorageManagementService.any_instance.stubs(:create_storage_account)
       mock_request = mock
-      ManagementHttpRequest.expects(:new).with(
-        :post,
-        anything,
-        anything
+      Azure::BaseManagement::ManagementHttpRequest.expects(:new).with(
+          :post,
+          anything,
+          anything
       ).returns(mock_request)
       mock_request.expects(:call).returns(nil)
       virtual_machine = VirtualMachine.new do |vm|
@@ -208,7 +226,7 @@ describe Azure::VirtualMachineManagementService do
         vm.ipaddress = '192.168.1.1'
       end
       Azure::VirtualMachineManagementService.stubs(
-        :get_virtual_machine
+          :get_virtual_machine
       ).returns(virtual_machine)
     end
 
@@ -225,9 +243,9 @@ describe Azure::VirtualMachineManagementService do
 
     it 'should set options hash with valid cloud service name.' do
       options = {
-        storage_account_name:  'storage_account_name',
-        deployment_name:  'unique_deployment_name',
-        tcp_endpoints: '80,3889:3889'
+          storage_account_name: 'storage_account_name',
+          deployment_name: 'unique_deployment_name',
+          tcp_endpoints: '80,3889:3889'
       }
       subject.create_virtual_machine(params, options)
       csn = options[:cloud_service_name]
@@ -240,24 +258,25 @@ describe Azure::VirtualMachineManagementService do
 
   describe '#create_virtual_machine with invalid parameters for windows machine' do
     let(:virtual_machine_xml) { Fixtures['virtual_machine'] }
-    let(:method) { :get }
+    let(:verb) { :get }
 
     before do
+      windows_params[:cloud_service_name] = 'cloud-service-1'
       mock_request = mock
-      ManagementHttpRequest.stubs(:new).with(
-        method,
-        location_request_path,
-        nil
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
+          verb,
+          location_request_path,
+          nil
       ).returns(mock_request)
       mock_request.expects(:call).returns(location_response_body).at_least(0)
       Azure::CloudServiceManagementService.any_instance.stubs(:create_cloud_service)
       Azure::CloudServiceManagementService.any_instance.stubs(:upload_certificate)
       Azure::StorageManagementService.any_instance.stubs(:create_storage_account)
       mock_request = mock
-      ManagementHttpRequest.expects(:new).with(
-        :post,
-        anything,
-        anything
+      Azure::BaseManagement::ManagementHttpRequest.expects(:new).with(
+          :post,
+          anything,
+          anything
       ).returns(mock_request).at_least(0)
       mock_request.expects(:call).returns(nil).at_least(0)
       virtual_machine_obj = VirtualMachine.new do |virtual_machine|
@@ -265,7 +284,7 @@ describe Azure::VirtualMachineManagementService do
         virtual_machine.ipaddress = '192.168.1.1'
       end
       Azure::VirtualMachineManagementService.any_instance.stubs(
-        :get_virtual_machine
+          :get_virtual_machine
       ).returns(virtual_machine_obj)
     end
 
@@ -288,16 +307,16 @@ describe Azure::VirtualMachineManagementService do
     end
 
     it 'self-signed certificate is generated by vm and used for the virtual machine when certificate path is not given.' do
-      options = { winrm_transport: %w(https http) }
+      options = {winrm_transport: %w(https http)}
       virtual_machine = subject.create_virtual_machine(windows_params, options)
       virtual_machine.wont_be_nil
     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'
+          winrm_transport: %w(https http),
+          private_key_file: 'f:/invalid_path/private_key',
+          certificate_file: 'f:/invalid_path/certificate.pem'
       }
       virtual_machine = subject.create_virtual_machine(windows_params, options)
       assert_match(/No such file or directory -*/, virtual_machine)
@@ -305,9 +324,9 @@ describe Azure::VirtualMachineManagementService do
 
     it 'should not throws certificate error when wirnm_transport is http' do
       options = {
-        winrm_transport: ['http'],
-        private_key_file: 'f:/invalid_path/private_key' ,
-        certificate_file: 'f:/invalid_path/certificate.pem'
+          winrm_transport: ['http'],
+          private_key_file: 'f:/invalid_path/private_key',
+          certificate_file: 'f:/invalid_path/certificate.pem'
       }
       virtual_machine = subject.create_virtual_machine(windows_params, options)
       virtual_machine.must_be_kind_of VirtualMachine
@@ -344,45 +363,56 @@ describe Azure::VirtualMachineManagementService do
       assert_match(/Persistentvmrole not enabled for "West Europe"*/, msg)
     end
 
-    it 'vm_size should be case sensitive' do
+    it 'warns if vm_size is not in the correct case' do
       options = {
-        vm_size: 'extralarge'
+          vm_size: 'extralarge'
       }
-      msg = subject.create_virtual_machine(params, options)
-      assert_match(/Value 'extralarge' specified for parameter 'vm_size' is invalid/, msg)
+      out, err = capture_io do
+        msg = subject.create_virtual_machine(params, options)
+      end
+      error_msg = "'extralarge' specified for parameter 'vm_size' is not in the list of valid VM role sizes."
+      assert_match(/#{error_msg}*/, out)
     end
 
-    it 'throws error when wrong role size is given' do
+    it 'warns when wrong role size is given' do
       options = {
-        vm_size: 'wrong size'
+          vm_size: 'wrong size'
       }
-      virtual_machine = subject.create_virtual_machine(params, options)
-      error_msg = "'wrong size' specified for parameter 'vm_size' is invalid."
-      assert_match(/#{error_msg}*/, virtual_machine)
+      out, err = capture_io do
+        virtual_machine = subject.create_virtual_machine(params, options)
+      end
+      error_msg = "'wrong size' specified for parameter 'vm_size' is not in the list of valid VM role sizes."
+      assert_match(/#{error_msg}*/, out)
     end
 
-    it 'should not throw any error if role size is empty' do
+    it 'should warn if role size is empty' do
       options = {
-        vm_size: ''
+          vm_size: ''
       }
-      subject.create_virtual_machine(params, options)
+      out, err = capture_io do
+        subject.create_virtual_machine(params, options)
+      end
+      error_msg = "'' specified for parameter 'vm_size' is not in the list of valid VM role sizes."
+      assert_match(/#{error_msg}*/, out)
     end
   end
 
-  describe '#get_os_type' do
+  describe '#get_image' do
 
     before do
+      Azure::Loggerx.stubs(:info).returns(nil)
+      Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
       subject.class.send(:public, *subject.class.private_instance_methods)
     end
 
     it 'returns os type of given virtual machine image' do
-      result = subject.get_os_type 'RightImage-CentOS-6.2-x64-v5.8.8.1'
-      result.must_equal 'Linux'
+      result = subject.get_image 'RightImage-CentOS-6.2-x64-v5.8.8.1'
+      result.os_type.must_equal 'Linux'
     end
 
     it 'errors if the virtual machine image does not exist' do
       exception = assert_raises(RuntimeError) do
-        subject.get_os_type 'invalid-image-name'
+        subject.get_image 'invalid-image-name'
       end
       error_msg = 'The virtual machine image source is not valid'
       assert_match(/#{error_msg}/i, exception.message)
@@ -392,6 +422,8 @@ describe Azure::VirtualMachineManagementService do
   describe '#add_role' do
 
     before do
+      Azure::Loggerx.stubs(:info).returns(nil)
+      Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
       windows_params[:cloud_service_name] = 'cloud-service-1'
     end
 
@@ -415,26 +447,17 @@ describe Azure::VirtualMachineManagementService do
 
     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'
+          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 -'
+      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