azure 0.7.1 → 0.7.3

data/test/integration/table/update_entity_test.rb

@@ -1,131 +0,0 @@
-#-------------------------------------------------------------------------
-# # Copyright (c) Microsoft and contributors. All rights reserved.
-#
-# 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"
-require "azure/table/table_service"
-require "azure/core/http/http_error"
-
-describe Azure::Table::TableService do
-  describe "#update_entity" do
-    subject { Azure::Table::TableService.new }
-    let(:table_name){ TableNameHelper.name }
-
-    let(:entity_properties){
-      {
-        "PartitionKey" => "testingpartition",
-        "RowKey" => "abcd1234_existing",
-        "CustomStringProperty" => "CustomPropertyValue",
-        "CustomIntegerProperty" => 37,
-        "CustomBooleanProperty" => true,
-        "CustomDateProperty" => Time.now
-      }
-    }
-
-    before {
-      subject.create_table table_name
-      subject.insert_entity table_name, entity_properties
-      @existing_etag = ""
-
-      exists = false
-      begin
-        existing = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
-        @existing_etag = existing.etag
-        exists = true
-      rescue
-      end
-
-      assert exists, "cannot verify existing record"
-    }
-
-    after { TableNameHelper.clean }
-
-    it "updates an existing entity, removing any properties not included in the update operation" do
-      etag = subject.update_entity table_name, {
-        "PartitionKey" => entity_properties["PartitionKey"],
-        "RowKey" => entity_properties["RowKey"],
-        "NewCustomProperty" => "NewCustomValue"
-      }
-
-      etag.must_be_kind_of String
-      etag.wont_equal @existing_etag
-
-      result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
-
-      result.must_be_kind_of Azure::Table::Entity
-      result.table.must_equal table_name
-
-      # removed all existing props
-      entity_properties.each { |k,v|
-        result.properties.wont_include k unless k == "PartitionKey" || k == "RowKey"
-      }
-
-      # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
-    end
-
-    it "updates an existing entity, removing any properties not included in the update operation and adding nil one" do
-      etag = subject.update_entity table_name, {
-        "PartitionKey" => entity_properties["PartitionKey"],
-        "RowKey" => entity_properties["RowKey"],
-        "NewCustomProperty" => nil
-      }
-
-      etag.must_be_kind_of String
-      etag.wont_equal @existing_etag
-
-      result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
-
-      result.must_be_kind_of Azure::Table::Entity
-      result.table.must_equal table_name
-
-      # removed all existing props
-      entity_properties.each { |k,v|
-        result.properties.wont_include k unless k == "PartitionKey" || k == "RowKey"
-      }
-
-      # and has the new one
-      result.properties["NewCustomProperty"].must_equal nil
-    end
-
-    it "errors on a non-existing row key" do
-      assert_raises(Azure::Core::Http::HTTPError) do
-        entity = entity_properties.dup
-        entity["RowKey"] = "this-row-key-does-not-exist"
-        subject.update_entity table_name, entity
-      end
-    end
-
-    it "errors on an invalid table name" do
-      assert_raises(Azure::Core::Http::HTTPError) do
-        subject.update_entity "this_table.cannot-exist!", entity_properties
-      end
-    end
-
-    it "errors on an invalid partition key" do
-      assert_raises(Azure::Core::Http::HTTPError) do
-        entity = entity_properties.dup
-        entity["PartitionKey"] = "this/partition_key#is?invalid"
-        subject.update_entity table_name, entity
-      end
-    end
-
-    it "errors on an invalid row key" do
-      assert_raises(Azure::Core::Http::HTTPError) do
-        entity = entity_properties.dup
-        entity["RowKey"] = "this/row_key#is?invalid"
-        subject.update_entity table_name, entity
-      end
-    end
-  end
-end

data/test/integration/test_helper.rb

@@ -1,40 +0,0 @@
-#-------------------------------------------------------------------------
-# # Copyright (c) Microsoft and contributors. All rights reserved.
-#
-# 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 'test_helper'
-require 'azure'
-
-Azure.configure do |config|
-  config.storage_access_key       = ENV.fetch('AZURE_STORAGE_ACCESS_KEY')
-  config.storage_account_name     = ENV.fetch('AZURE_STORAGE_ACCOUNT')
-  config.sb_namespace             = ENV.fetch('AZURE_SERVICEBUS_NAMESPACE')
-  config.sb_access_key            = ENV.fetch('AZURE_SERVICEBUS_ACCESS_KEY')
-  config.management_certificate   = ENV.fetch('AZURE_MANAGEMENT_CERTIFICATE')
-  config.subscription_id          = ENV.fetch('AZURE_SUBSCRIPTION_ID')
-end
-
-util = Class.new.extend(Azure::Core::Utility)
-
-StorageAccountName = util.random_string('storagetest',10)
-Images = Azure::VirtualMachineImageManagementService.new.list_virtual_machine_images
-LinuxImage = Images.select{|image| image.os_type == 'Linux'}.first
-WindowsImage = Images.select{|image| image.os_type == 'Windows'}.first
-locations = WindowsImage.locations.split(';')
-WindowsImageLocation = locations.include?('West US') ? 'West US' : locations.first
-locations = LinuxImage.locations.split(';')
-LinuxImageLocation = locations.include?('West US') ? 'West US' : locations.first
-
-MiniTest.after_run {
-  VirtualMachineNameGenerator.cleanup
-}

data/test/integration/vm/VM_Create_test.rb

@@ -1,262 +0,0 @@
-#-------------------------------------------------------------------------
-# 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
-  include Azure::Core::Utility
-
-  subject { Azure::VirtualMachineManagementService.new }
-  let(:cloud_service) { Azure::CloudServiceManagementService.new }
-  let(:names) { VirtualMachineNameHelper.name }
-  let(:virtual_machine_name) { names.first }
-  let(:cloud_service_name) { names.last }
-  let(:storage_account_name) { StorageAccountName }
-  let(:username) { 'adminuser' }
-  let(:password) { 'Admin123' }
-  let(:private_key) { Fixtures['privatekey.key'] }
-
-  let(:params)do
-    {
-      vm_name: virtual_machine_name,
-      vm_user: username,
-      image: LinuxImage.name,
-      password: password,
-      location: LinuxImageLocation
-    }
-  end
-
-  let(:windows_params)do
-    {
-      vm_name: virtual_machine_name,
-      vm_user: username,
-      image: WindowsImage.name,
-      password: password,
-      location: WindowsImageLocation
-    }
-  end
-
-  let(:options)do
-    {
-      storage_account_name: storage_account_name,
-      cloud_service_name: cloud_service_name,
-      vm_size: 'Basic_A0'
-    }
-  end
-
-  let(:default_options) do
-    {
-      storage_account_name: storage_account_name,
-      cloud_service_name: cloud_service_name
-    }
-  end
-
-  before do
-    Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
-  end
-
-  describe '#deployment' do
-
-    describe '#add_role' do
-      before do
-        @vm_obj = subject.create_virtual_machine(params, options)
-        params[:cloud_service_name] = options[:cloud_service_name]
-        options.delete(:cloud_service_name)
-        params.delete(:location)
-        params[:vm_name] = "add-#{virtual_machine_name}"
-      end
-
-      it 'should add role to existing storage account and cloud service' do
-        vm = subject.add_role(params, options)
-        vm.cloud_service_name.must_equal params[:cloud_service_name]
-        vm.vm_name.must_equal params[:vm_name]
-        vm.deployment_name.must_equal @vm_obj.deployment_name
-        vm.os_type.must_equal 'Linux'
-      end
-
-      it 'should add role and create new storage account' do
-        params[:vm_name] = "Add-storage-#{virtual_machine_name}"
-        vm = subject.add_role(params)
-        vm.cloud_service_name.must_equal params[:cloud_service_name]
-        vm.vm_name.must_equal params[:vm_name]
-        vm.deployment_name.must_equal @vm_obj.deployment_name
-      end
-    end
-
-    describe '#virtual_network' do
-      let(:subnet_name) { 'Subnet-1' }
-      let(:geo_location) { LinuxImageLocation }
-      let(:static_virtual_network_ipaddress){'172.16.0.10'}
-      before do
-        options[:virtual_network_name] = 'v-net'
-        inputoptions = {
-          subnet: [{ name: subnet_name, ip_address: '172.16.0.0', cidr: 12 }],
-          dns: [{ name: 'DNS', ip_address: '1.2.3.4' }]
-        }
-        vnet_service = Azure::VirtualNetworkManagementService
-        vnet_service.new.set_network_configuration(
-          options[:virtual_network_name],
-          geo_location,
-          ['172.16.0.0/12'],
-          inputoptions
-        ) rescue nil
-        options[:subnet_name] = subnet_name
-        options[:static_virtual_network_ipaddress] = '172.16.0.10'
-        subject.create_virtual_machine(params, options)
-      end
-
-      it 'should provision virtual machine in a existing virtual network' do
-        virtual_machine = subject.get_virtual_machine(virtual_machine_name, cloud_service_name)
-        virtual_machine.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-        virtual_machine.vm_name.must_equal virtual_machine_name
-        virtual_machine.virtual_network_name.must_equal options[:virtual_network_name]
-        virtual_machine.subnet.must_equal subnet_name
-        virtual_machine.static_virtual_network_ipaddress.must_equal static_virtual_network_ipaddress
-      end
-    end
-
-    it 'should set options hash with valid cloud_service_name, deployment_name, storage_account_name and virtual network' do
-      csn = options[:cloud_service_name]
-      options[:availability_set_name] = 'aval-set-test'
-      vm = subject.create_virtual_machine(params, options)
-      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 'Basic_A0'
-      vm.availability_set_name.must_equal 'aval-set-test'
-      options[:storage_account_name].wont_be_nil
-      assert_match(/^#{params[:vm_name] + '-service'}*/, csn)
-    end
-
-    it 'should creates http and https enabled winrm virtual machine without certificate.' do
-      default_options.merge!(winrm_transport: %w(https http))
-      result = subject.create_virtual_machine(windows_params, default_options)
-      result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      assert_equal(result.os_type, 'Windows')
-      tcp_endpoints_names = []
-      result.tcp_endpoints.each do |tcp_endpoint|
-        tcp_endpoints_names << tcp_endpoint[:name]
-      end
-      tcp_endpoints_names.must_include 'PowerShell'
-      tcp_endpoints_names.must_include 'WinRm-Http'
-    end
-
-    it 'should creates https enabled winrm virtual machine using certificate.' do
-      default_options.merge!(
-        winrm_transport: ['https'],
-        private_key_file: private_key
-      )
-      result = subject.create_virtual_machine(windows_params, default_options)
-      result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      assert_equal(result.os_type, 'Windows')
-      tcp_endpoints_names = []
-      result.tcp_endpoints.each do |tcp_endpoint|
-        tcp_endpoints_names << tcp_endpoint[:name]
-      end
-      tcp_endpoints_names.must_include 'PowerShell'
-    end
-
-    it 'should creates windows virtual machine without winrm.' do
-      default_options.merge!(winrm_transport: ['none'])
-      result = subject.create_virtual_machine(windows_params, default_options)
-      result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      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?('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
-      )
-      result = subject.create_virtual_machine(params, default_options)
-      result.must_be_kind_of Azure::VirtualMachineManagement::VirtualMachine
-      assert_equal(result.os_type, 'Linux')
-    end
-
-    it 'throws error as port value is beyond or less than actual range' do
-      default_options.merge!(tcp_endpoints: '80,166535:166535')
-      ex = assert_raises(RuntimeError){subject.create_virtual_machine(params, default_options)}
-      error_msg = "invalid. Allowed values are 'a number between 1 to 65535'."
-      assert_match(/#{error_msg}/i, ex.message)
-
-      default_options.merge!(tcp_endpoints: '80,0:0')
-      ex = assert_raises(RuntimeError){subject.create_virtual_machine(params, default_options)}
-      assert_match(/#{error_msg}/i,ex.message)
-      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)
-      ex = assert_raises(RuntimeError){subject.create_virtual_machine(windows_params, default_options)}
-      error_msg = 'The specified deployment slot Production is occupied.'
-      assert_match(/#{error_msg}/i, ex.message)
-    end
-
-    it 'throws SystemExit error when vm_user not provided' do
-      params.delete(:vm_user)
-      ex = assert_raises(RuntimeError){subject.create_virtual_machine(params)}
-      assert_match(/You did not provide a valid 'vm_user' value./i, ex.message)
-    end
-
-    it 'throws Runtime error when image not provide' do
-      params.delete(:image)
-      ex = assert_raises(RuntimeError){ subject.create_virtual_machine(params)}
-      assert_match(/The virtual machine image source is not valid/i, ex.message)
-    end
-
-    it 'error thrown when invalid storage account name is given' do
-      default_options.merge!(storage_account_name: 'storageuse_91')
-      ex = assert_raises(RuntimeError){subject.create_virtual_machine(params, default_options)}
-      assert_match(/The name is not a valid storage account name./i, ex.message)
-      cloud_service.delete_cloud_service(cloud_service_name)
-    end
-
-    it 'error thrown when invalid cloud name is given' do
-      default_options.merge!(cloud_service_name: 'cloud-server-test_91')
-      ex = assert_raises(RuntimeError){ subject.create_virtual_machine(params, default_options)}
-      assert_match(/The hosted service name is invalid/i, ex.message)
-    end
-
-    it 'error thrown when invalid deployment name provided' do
-      default_options.merge!(deployment_name: 'instance_B')
-      ex = assert_raises(RuntimeError){subject.create_virtual_machine(params, default_options)}
-      assert_match(/The deployment name is invalid/i,ex.message)
-      cloud_service.delete_cloud_service(cloud_service_name)
-    end
-
-    it 'error thrown when invalid VM name given for Windows OS' do
-      windows_params.merge!(vm_name: 'MSServerInstnce01')
-      ex = assert_raises(RuntimeError) {subject.create_virtual_machine(windows_params, default_options)}
-      error_msg = 'The computer name cannot be more than 15 characters long'
-      assert_match(/#{error_msg}/i, ex.message)
-      cloud_service.delete_cloud_service(cloud_service_name)
-    end
-
-    it 'error thrown when blank password for Windows OS provided' do
-      windows_params.delete(:password)
-      ex = assert_raises(RuntimeError){ subject.create_virtual_machine(windows_params, default_options)}
-      assert_match(/You did not provide a valid 'password' value./i, ex.message)
-    end
-
-  end # deployment
-
-end

data/test/integration/vm/VM_Delete_test.rb

@@ -1,53 +0,0 @@
-#-------------------------------------------------------------------------
-# 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
-
-  subject { Azure::VirtualMachineManagementService.new }
-  let(:names) { VirtualMachineNameHelper.name }
-  let(:virtual_machine_name) { names.first }
-  let(:csn) { names.last }
-  let(:username) { 'admin' }
-  before do
-    Azure::Loggerx.expects(:puts).at_least_once.returns(nil)
-    params = {
-      vm_name: virtual_machine_name,
-      vm_user: 'user',
-      image: LinuxImage.name,
-      password: 'User123',
-      location: LinuxImageLocation
-    }
-    options = {
-      storage_account_name: StorageAccountName,
-      cloud_service_name: csn,
-    }
-    subject.create_virtual_machine(params, options)
-  end
-
-  describe '#delete_virtual_machine' do
-
-    it 'delete existing virtual machine and cloud service' do
-      subject.delete_virtual_machine(virtual_machine_name, csn)
-      vm = subject.get_virtual_machine(virtual_machine_name, csn)
-      vm.must_be_nil
-      cloud_service = Azure::CloudServiceManagementService.new
-      cloud_presence = cloud_service.get_cloud_service(csn)
-      cloud_presence.must_equal nil
-    end
-
-  end
-
-end