azure 0.6.1 → 0.6.2

data/test/unit/virtual_machine_image_management/virtual_machine_image_management_service_test.rb

@@ -36,7 +36,11 @@ describe Azure::VirtualMachineImageManagementService do
   describe "#list_virtual_machine_images" do
     
     before {
-      ManagementHttpRequest.stubs(:new).with(method, request_path, nil).returns(mock_request)
+      ManagementHttpRequest.stubs(:new).with(
+        method,
+        request_path,
+        nil
+      ).returns(mock_request)
       mock_request.expects(:call).returns(response_body)
     }
   
@@ -46,14 +50,15 @@ describe Azure::VirtualMachineImageManagementService do
   
     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 '0b11de9248dd4d87b18621318e037d37__RightImage-CentOS-6.2-x64-v5.8.8.1'
+      virtual_machine_image.name.must_equal 'RightImage-CentOS-6.2-x64-v5.8.8.1'
     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
-      results.first.must_be_kind_of Azure::VirtualMachineImageManagement::VirtualMachineImage
+      image_klass = Azure::VirtualMachineImageManagement::VirtualMachineImage
+      results.first.must_be_kind_of image_klass
     end
   end
   

data/test/unit/virtual_machine_management/serialization_test.rb

@@ -12,27 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #--------------------------------------------------------------------------
-require "test_helper"
+require 'test_helper'
 
 describe Azure::VirtualMachineManagement::Serialization do
   subject { Azure::VirtualMachineManagement::Serialization }
 
-  let(:virtual_machine_xml) { Nokogiri::XML(Fixtures["virtual_machine"]) }
-  let(:cloud_service_name) { 'cloud-service-1' }
+  let(:vm_xml) { Nokogiri::XML(Fixtures['virtual_machine']) }
+  let(:csn) { 'cloud-service-1' }
 
-  describe "#virtual_machines_from_xml" do
+  describe '#virtual_machines_from_xml' do
 
-    it "accepts an XML string" do
-      subject.virtual_machines_from_xml(virtual_machine_xml,cloud_service_name)
+    it 'accepts an XML string' do
+      subject.virtual_machines_from_xml(vm_xml, csn)
     end
 
-    it "returns an Array of VirtualMachine instances" do
-      result = subject.virtual_machines_from_xml(virtual_machine_xml,cloud_service_name).first
+    it 'returns an Array of VirtualMachine instances' do
+      result = subject.virtual_machines_from_xml(vm_xml, csn).first
       result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
     end
 
     it "returns a virtual_machine, with it's attribute populated" do
-      virtual_machine = subject.virtual_machines_from_xml(virtual_machine_xml,cloud_service_name).first
+      virtual_machine = subject.virtual_machines_from_xml(vm_xml, csn).first
       virtual_machine.vm_name.must_equal 'instance-name'
       virtual_machine.role_size.must_equal 'Small'
       virtual_machine.hostname.must_equal 'host-name'
@@ -43,18 +43,36 @@ describe Azure::VirtualMachineManagement::Serialization do
     end
 
     it "returns a virtual_machine, with it's tcp_endpoints attribute" do
-      virtual_machine = subject.virtual_machines_from_xml(virtual_machine_xml,cloud_service_name).first
+      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", "PublicPort"=>"22", "LocalPort"=>"22"})
-      virtual_machine.tcp_endpoints.must_include({"Name"=>"tcp-port-80", "Vip"=>"137.116.17.187", "PublicPort"=>"80", "LocalPort"=>"80"})
-      virtual_machine.tcp_endpoints.must_include({"Name"=>"tcp-port-3889", "Vip"=>"137.116.17.187", "PublicPort"=>"3889", "LocalPort"=>"3889"})
+      virtual_machine.tcp_endpoints.must_include(
+        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'
+      )
+      virtual_machine.tcp_endpoints.must_include(
+        name: 'tcp-port-3889',
+        vip: '137.116.17.187',
+        public_port:  '3889',
+        local_port:  '3889',
+        protocol: 'tcp'
+      )
     end
 
   end
 
-  describe "#shutdown_virtual_machine_to_xml" do
+  describe '#shutdown_virtual_machine_to_xml' do
 
-    it "returns an xml for virtual machine shutdown" do
+    it 'returns an xml for virtual machine shutdown' do
       result = subject.shutdown_virtual_machine_to_xml
       result.must_be_kind_of String
       doc = Nokogiri::XML(result)
@@ -64,9 +82,9 @@ describe Azure::VirtualMachineManagement::Serialization do
 
   end
 
-  describe "#start_virtual_machine_to_xml" do
+  describe '#start_virtual_machine_to_xml' do
 
-    it "returns an xml for start virtual machine" do
+    it 'returns an xml for start virtual machine' do
       result = subject.start_virtual_machine_to_xml
       result.must_be_kind_of String
       doc = Nokogiri::XML(result)
@@ -75,45 +93,114 @@ describe Azure::VirtualMachineManagement::Serialization do
 
   end
 
-  describe "#deployment_to_xml" do
-    let(:params){
+  describe '#restart_virtual_machine_to_xml' do
+
+    it 'returns an xml for restart virtual machine' do
+      result = subject.restart_virtual_machine_to_xml
+      result.must_be_kind_of String
+      doc = Nokogiri::XML(result)
+      doc.css('OperationType').text.must_equal 'RestartRoleOperation'
+    end
+
+  end
+
+  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'
       }
-    }
+    end
 
-    let(:options) {
+    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'
+        storage_account_name: 'storageaccountname',
+        cloud_service_name: 'cloud-service-name',
+        tcp_endpoints: '80,3389:3390,85:85',
+        availability_set_name: 'aval-set'
       }
-    }
+    end
 
-    it "returns an VirtualMachine object with correct tcp endpoints" do
+    it 'returns an VirtualMachine object with correct tcp endpoints' do
+      params[:certificate] = { fingerprint: 'CFB8C256D2986559C630547F2D0' }
       result = subject.deployment_to_xml params, options
       doc = Nokogiri::XML(result)
       endpoints = doc.css('Deployment RoleList ConfigurationSet InputEndpoints InputEndpoint')
       tcp_endpoints = []
       endpoints.each do |endpoint|
-        hash = Hash.new
-        hash['Name'] = xml_content(endpoint, 'Name')
-        hash['PublicPort'] = xml_content(endpoint, 'Port')
-        hash['LocalPort'] = xml_content(endpoint, 'LocalPort')
-        tcp_endpoints << hash
+        ep = {}
+        ep[:name] = xml_content(endpoint, 'Name')
+        ep[:public_port] = xml_content(endpoint, 'Port')
+        ep[:local_port] = xml_content(endpoint, 'LocalPort')
+        tcp_endpoints << ep
       end
       doc.css('Deployment RoleList AvailabilitySetName').text.must_equal 'aval-set'
       result.must_be_kind_of String
-      tcp_endpoints.must_include({"Name"=>"TCP-PORT-80", "PublicPort"=>"80", "LocalPort"=>"80"})
-      tcp_endpoints.must_include({"Name"=>"TCP-PORT-3390", "PublicPort"=>"3390", "LocalPort"=>"3389"})
-      tcp_endpoints.must_include({"Name"=>"TCP-PORT-85", "PublicPort"=>"85", "LocalPort"=>"85"})
+      tcp_endpoints.must_include(
+        name: 'TCP-PORT-80',
+        public_port: '80',
+        local_port: '80'
+      )
+      tcp_endpoints.must_include(
+        name: 'TCP-PORT-3390',
+        public_port: '3390',
+        local_port: '3389'
+      )
+      tcp_endpoints.must_include(
+        name: 'TCP-PORT-85',
+        public_port: '85',
+        local_port: '85'
+      )
+    end
+  end
+
+  describe '#add_data_disk_to_xml' do
+
+    let(:options) do
+      { 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)
+    end
+
+    it 'returns an xml for newly created data disk' do
+      result = subject.add_data_disk_to_xml(lun, media_link , 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
     end
 
+    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)
+      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
+
+    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)
+      end
+      assert_match(/The data disk name is not valid/i, exception.message)
+    end
   end
 
 end

data/test/unit/virtual_machine_management/virtual_machine_management_service_test.rb

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #--------------------------------------------------------------------------
-require "test_helper"
+require 'test_helper'
 
 describe Azure::VirtualMachineManagementService do
   VirtualMachine = Azure::VirtualMachineManagement::VirtualMachine
@@ -21,91 +21,91 @@ describe Azure::VirtualMachineManagementService do
     Azure::VirtualMachineManagementService.new
   end
 
-  before{
+  before do
     Loggerx.stubs(:info).returns(nil)
-  }
+  end
 
-  let(:params){
+  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){
+  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
 
   let(:location_request_path) { '/locations' }
   let(:locations_xml) { Fixtures['list_locations'] }
-  let(:location_response) {
-    response = mock()
+  let(:location_response) do
+    response = mock
     response.stubs(:body).returns(locations_xml)
     response
-  }
+  end
   let(:location_response_body) { Nokogiri::XML location_response.body }
 
-  describe "#list_virtual_machines" do
+  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(: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(:mock_cloud_service_request) { mock }
+    let(:mock_virtual_machine_request) { mock }
+    let(:mock_virtual_network_request) { mock }
 
-    let(:cloud_service_response) {
-      cloud_service_response = 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) {
-      virtual_machine_response = mock()
+    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) {
-      http_error_response = mock()
+    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) {
-      virtual_networks_response = mock()
+    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 {
+    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, '/services/hostedservices/cloud-service-1/deploymentslots/production').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)
+      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
+    it 'assembles a URI for the request' do
       subject.list_virtual_machines
     end
 
@@ -120,7 +120,7 @@ describe Azure::VirtualMachineManagementService do
       virtual_machine.virtual_network_name.must_equal 'test-virtual-network'
     end
 
-    it "returns a list of virtual machines for the subscription" do
+    it 'returns a list of virtual machines for the subscription' do
       results = subject.list_virtual_machines
       results.must_be_kind_of Array
       results.length.must_equal 1
@@ -130,245 +130,296 @@ describe Azure::VirtualMachineManagementService do
     it "returns a virtual_machine, with it's tcp_endpoints attribute" 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", "PublicPort"=>"22", "LocalPort"=>"22"})
-      virtual_machine.tcp_endpoints.must_include({"Name"=>"tcp-port-80", "Vip"=>"137.116.17.187", "PublicPort"=>"80", "LocalPort"=>"80"})
-      virtual_machine.tcp_endpoints.must_include({"Name"=>"tcp-port-3889", "Vip"=>"137.116.17.187", "PublicPort"=>"3889", "LocalPort"=>"3889"})
+      virtual_machine.tcp_endpoints.must_include(
+        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'
+      )
+      virtual_machine.tcp_endpoints.must_include(
+        name: 'tcp-port-3889',
+        vip: '137.116.17.187',
+        public_port: '3889',
+        local_port: '3889',
+        protocol: 'tcp'
+      )
     end
   end
 
-  describe "#get_virtual_machine" do
+  describe '#get_virtual_machine' do
 
-    before {
+    before do
       virtual_machine = VirtualMachine.new do |virtual_machine|
         virtual_machine.vm_name = 'instance-name'
         virtual_machine.cloud_service_name = 'cloud-service-1'
       end
-      Azure::VirtualMachineManagementService.any_instance.stubs(:list_virtual_machines).returns([virtual_machine])
-    }
+      Azure::VirtualMachineManagementService.any_instance.stubs(
+        :list_virtual_machines
+      ).returns([virtual_machine])
+    end
 
-    it "return nil if virtual machine and cloud server does not exist " do
-      virtual_machine = subject.get_virtual_machine 'name','cloud-service'
+    it 'return nil if virtual machine and cloud server does not exist ' do
+      virtual_machine = subject.get_virtual_machine 'name', 'cloud-service'
       virtual_machine.must_equal nil
     end
 
-    it "return nil if virtual machine or cloud server does not exist " do
-      virtual_machine = subject.get_virtual_machine 'name','cloud-service-1'
+    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 = subject.get_virtual_machine 'instance-name', 'cloud_service_name'
       virtual_machine.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'
+    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
     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"] }
+  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(:mock_request) { mock }
 
-    let(:os_response_body) {
-      response = mock()
+    let(:os_response_body) do
+      response = mock
       response.stubs(:body).returns(images_xml)
       Nokogiri::XML response.body
-    }
+    end
 
-    before {
-      ManagementHttpRequest.stubs(:new).with(method, images_request_path, nil).returns(mock_request)
+    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, location_request_path, nil).returns(mock_request)
+      mock_request = mock
+      ManagementHttpRequest.stubs(:new).with(
+        method,
+        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).returns(mock_request)
+      mock_request = mock
+      ManagementHttpRequest.expects(:new).with(
+        :post,
+        anything,
+        anything
+      ).returns(mock_request)
       mock_request.expects(:call).returns(nil)
-      virtual_machine = VirtualMachine.new do |virtual_machine|
-        virtual_machine.vm_name = 'instance-name'
-        virtual_machine.ipaddress = '192.168.1.1'
+      virtual_machine = VirtualMachine.new do |vm|
+        vm.vm_name = 'instance-name'
+        vm.ipaddress = '192.168.1.1'
       end
-      Azure::VirtualMachineManagementService.stubs(:get_virtual_machine).returns(virtual_machine)
-    }
+      Azure::VirtualMachineManagementService.stubs(
+        :get_virtual_machine
+      ).returns(virtual_machine)
+    end
 
-    it "should set options hash with valid cloud_service_name, deployment_name, storage_account_name." do
+    it 'should set options hash with valid cloud_service_name, deployment_name, storage_account_name.' do
       options = {}
-      virtual_machine = subject.create_virtual_machine(params, options)
-      options[:cloud_service_name].wont_be_nil
+      subject.create_virtual_machine(params, options)
+      csn = options[:cloud_service_name]
+      csn.wont_be_nil
       options[:storage_account_name].wont_be_nil
       options[:deployment_name].wont_be_nil
       options[:os_type].must_equal 'Linux'
-      assert_match(/^#{params[:vm_name]+'-service'}*/, "#{options[:cloud_service_name]}")
+      assert_match(/^#{params[:vm_name] + '-service'}*/, csn)
     end
 
-    it "should set options hash with valid cloud service name." 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'
       }
-      virtual_machine = subject.create_virtual_machine(params, options)
-      options[:cloud_service_name].wont_be_nil
-      assert_match(/^#{params[:vm_name]+'-service-'}*/, "#{options[:cloud_service_name]}")
+      subject.create_virtual_machine(params, options)
+      csn = options[:cloud_service_name]
+      csn.wont_be_nil
+      assert_match(/^#{params[:vm_name] + '-service-'}*/, csn)
       options[:os_type].must_equal 'Linux'
     end
 
   end
 
-  describe "#create_virtual_machine with invalid parameters for windows machine" do
+  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(:windows_images_xml) { Fixtures['list_images'] }
+    let(:virtual_machine_xml) { Fixtures['virtual_machine'] }
     let(:method) { :get }
-    let(:mock_request){ mock() }
-    let(:os_response_body) {
-      response = mock()
+    let(:mock_request) { mock }
+    let(:os_response_body) do
+      response = mock
       response.stubs(:body).returns(windows_images_xml)
       Nokogiri::XML response.body
-    }
+    end
 
-    before {
-      ManagementHttpRequest.stubs(:new).with(method, images_request_path, nil).returns(mock_request)
+    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, location_request_path, nil).returns(mock_request)
+      mock_request = mock
+      ManagementHttpRequest.stubs(:new).with(
+        method,
+        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)
       Loggerx.expects(:puts).returns(nil).at_least(0)
-      mock_request = mock()
-      ManagementHttpRequest.expects(:new).with(:post,anything, anything).returns(mock_request).at_least(0)
+      mock_request = mock
+      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|
         virtual_machine.vm_name = 'windows-instance'
         virtual_machine.ipaddress = '192.168.1.1'
       end
-      Azure::VirtualMachineManagementService.any_instance.stubs(:get_virtual_machine).returns(virtual_machine_obj)
-    }
+      Azure::VirtualMachineManagementService.any_instance.stubs(
+        :get_virtual_machine
+      ).returns(virtual_machine_obj)
+    end
 
-    it "should set options os_type with windows." do
+    it 'should set options os_type with windows.' do
       options = {}
-      virtual_machine = subject.create_virtual_machine(windows_params, options)
-      options[:cloud_service_name].wont_be_nil
+      subject.create_virtual_machine(windows_params, options)
+      csn = options[:cloud_service_name]
+      csn.wont_be_nil
       options[:storage_account_name].wont_be_nil
       options[:deployment_name].wont_be_nil
       options[:os_type].must_equal 'Windows'
-      assert_match(/^#{params[:vm_name]+'-service'}*/, "#{options[:cloud_service_name]}")
+      assert_match(/^#{params[:vm_name] + '-service'}*/, csn)
     end
 
-    it "throws error when vm_user is not given" do
+    it 'throws error when vm_user is not given' do
       windows_params.delete(:vm_user)
       options = {}
       virtual_machine = subject.create_virtual_machine(windows_params, options)
       assert_match(/You did not provide a valid 'vm_user' value*/, virtual_machine)
     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 => ['https','http']
-      }
+    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) }
       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
+    it 'throws error when certificate path is not invalid.' do
       options = {
-        :winrm_transport => ['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)
     end
 
-    it "should not throws certificate error when wirnm_transport is http" 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 Azure::VirtualMachineManagement::VirtualMachine
+      virtual_machine.must_be_kind_of VirtualMachine
       virtual_machine.wont_be_nil
     end
 
-    it "throws error when location is not given" do
+    it 'throws error when location is not given' do
       params.delete(:location)
       virtual_machine = subject.create_virtual_machine(params)
-      assert_match(/You did not provide a valid 'location' value*/, virtual_machine)
+      error_msg = "You did not provide a valid 'location' value"
+      assert_match(/#{error_msg}*/, virtual_machine)
     end
 
-    it "throws error when wrong location is given" do
-      params.merge!(:location => 'wrong location')
+    it 'throws error when wrong location is given' do
+      params.merge!(location: 'wrong location')
       virtual_machine = subject.create_virtual_machine(params)
       assert_match(/Value 'wrong location' specified for parameter 'location' is invalid.*/, virtual_machine)
     end
 
-    it "throws error when empty location is given" do
-      params.merge!(:location => nil)
+    it 'throws error when empty location is given' do
+      params.merge!(location: nil)
       virtual_machine = subject.create_virtual_machine(params)
       assert_match(/You did not provide a valid 'location' value*/, virtual_machine)
     end
 
-    it "location should be case insensitive" do
-      params.merge!(:location => 'west us')
+    it 'location should be case insensitive' do
+      params.merge!(location: 'west us')
       subject.create_virtual_machine(params)
     end
 
-    it "throw error when available_services has not persistentvmrole for given location" do
-      params.merge!(:location => 'West Europe')
+    it 'throw error when available_services has not persistentvmrole for given location' do
+      params.merge!(location: 'West Europe')
       msg = subject.create_virtual_machine(params)
       assert_match(/Persistentvmrole not enabled for "West Europe"*/, msg)
     end
 
-    it "vm_size should be case sensitive" do
+    it 'vm_size should be case sensitive' 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)
+      assert_match(/Value 'extralarge' specified for parameter 'vm_size' is invalid/, msg)
     end
 
-    it "throws error when wrong role size is given" do
+    it 'throws error when wrong role size is given' do
       options = {
-        :vm_size => 'wrong size'
+        vm_size: 'wrong size'
       }
       virtual_machine = subject.create_virtual_machine(params, options)
-      assert_match(/Value 'wrong size' specified for parameter 'vm_size' is invalid.*/, virtual_machine)
+      error_msg = "'wrong size' specified for parameter 'vm_size' is invalid."
+      assert_match(/#{error_msg}*/, virtual_machine)
     end
 
-    it "should not throw any error if role size is empty" do
+    it 'should not throw any error if role size is empty' do
       options = {
-        :vm_size => ''
+        vm_size: ''
       }
       subject.create_virtual_machine(params, options)
     end
   end
 
-  describe "#get_os_type" do
-    let(:images_xml) { Fixtures["list_images"] }
-    let(:mock_request){ mock() }
-    let(:response) {
-      response = mock()
+  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
-    }
-    let(:response_body) {Nokogiri::XML response.body}
+    end
+    let(:response_body) { Nokogiri::XML response.body }
 
-    before {
+    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
-      result = subject.get_os_type '0b11de9248dd4d87b18621318e037d37__RightImage-CentOS-6.2-x64-v5.8.8.1'
+    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'
     end
 
@@ -376,7 +427,8 @@ describe Azure::VirtualMachineManagementService do
       exception = assert_raises(RuntimeError) do
         subject.get_os_type 'invalid-image-name'
       end
-      assert_match(/The virtual machine image source is not valid/i, exception.message)
+      error_msg = 'The virtual machine image source is not valid'
+      assert_match(/#{error_msg}/i, exception.message)
     end
   end