azure 0.7.1 → 0.7.3

data/test/unit/storage_management/storage_management_service_test.rb

@@ -1,247 +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 'test_helper'
-
-describe Azure::StorageManagementService do
-
-  subject { Azure::StorageManagementService.new }
-  let(:request_path) { '/services/storageservices' }
-  let(:storage_accounts_xml) { Fixtures['list_storage_accounts'] }
-  let(:one_storage_account_xml) { Fixtures['list_storage_account_single'] }
-  let(:verb) { :get }
-  let(:mock_request) { mock() }
-
-  let(:response) {
-    response = mock()
-    response.stubs(:body).returns(storage_accounts_xml)
-    response
-  }
-
-  let(:single_response) {
-    single_response = mock()
-    single_response.stubs(:body).returns(one_storage_account_xml)
-    single_response
-  }
-
-  let(:response_body) { Nokogiri::XML response.body }
-  let(:single_response_body) { Nokogiri::XML single_response.body }
-
-  before {
-    Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
-  }
-
-  describe '#list_storage_accounts' do
-    before {
-      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(verb, request_path, anything).returns(mock_request)
-      mock_request.expects(:call).returns(response_body)
-    }
-
-    it 'assembles a URI for the request' do
-      subject.list_storage_accounts
-    end
-
-    it 'sets the properties of the storage accounts' do
-      storage_account = subject.list_storage_accounts.first
-      storage_account.name.must_equal 'storage1'
-    end
-
-    it 'returns a list of storage accounts for the subscription' do
-      results = subject.list_storage_accounts
-      results.must_be_kind_of Array
-      results.length.must_equal 2
-      results.first.must_be_kind_of Azure::StorageManagement::StorageAccount
-    end
-  end
-
-  describe '#list_storage_accounts_single' do
-    before {
-      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
-          verb, request_path, anything
-      ).returns(mock_request)
-      mock_request.expects(:call).returns(single_response_body)
-    }
-
-    it 'returns an array even if single account exists' do
-      results = subject.list_storage_accounts
-      results.must_be_kind_of Array
-      results.length.must_equal 1
-      results.first.must_be_kind_of Azure::StorageManagement::StorageAccount
-      results.first.name.must_equal 'storage1'
-    end
-  end
-
-  describe '#get_storage_account' do
-    before {
-      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(verb, request_path, anything).returns(mock_request)
-      mock_request.expects(:call).returns(response_body)
-    }
-
-    it 'assembles a URI for the request' do
-      subject.get_storage_account 'storage1'
-    end
-
-    it 'returns storage account instance' do
-      storage_account_name = 'storage1'
-      result = subject.get_storage_account storage_account_name
-      result.must_be_kind_of Azure::StorageManagement::StorageAccount
-      result.name.must_equal storage_account_name
-    end
-
-    it "returns false if storage account with given name doesn't exists" do
-      result = subject.get_storage_account 'storage3'
-      result.must_equal nil
-    end
-  end
-
-  describe '#create_storage_account' do
-    let(:options) {
-      {
-          location: 'East Asia',
-          description: 'Test Storage Description'
-      }
-    }
-
-    it 'Checks if name is provided' do
-      exception = assert_raises(RuntimeError) do
-        subject.create_storage_account(options)
-      end
-      assert_match('Name not specified', exception.message)
-    end
-
-    it 'Checks if name is not nil' do
-      exception = assert_raises(RuntimeError) do
-        subject.create_storage_account('', options)
-      end
-      assert_match('Name not specified', exception.message)
-    end
-
-    it 'Checks if name is not empty' do
-      exception = assert_raises(RuntimeError) do
-        subject.create_storage_account('', options)
-      end
-      assert_match('Name not specified', exception.message)
-    end
-
-    it 'Create storage account return message if storage account exists of given name.' do
-      Azure::BaseManagement::ManagementHttpRequest.any_instance.expects(:call).returns response_body
-      msg = subject.create_storage_account 'storage1'
-      assert_match(/^Storage Account storage1 already exist.*/, msg)
-    end
-
-    it "Create storage account if storage account doesn't exists of given name." do
-      Azure::StorageManagementService.any_instance.stubs(:get_storage_account).with('storage3').returns(false)
-      Azure::BaseManagement::ManagementHttpRequest.any_instance.expects(:call).returns nil
-      subject.create_storage_account 'storage3'
-    end
-
-  end
-
-  describe '#update_storage_account' do
-    let(:updated_accounts_xml) { Fixtures['updated_storage_accounts'] }
-    let(:no_options_specified) { 'No options specified' }
-    let(:sa_response) {
-      res = mock()
-      res.stubs(:body).returns(updated_accounts_xml)
-      res
-      Nokogiri::XML res.body
-    }
-
-    let(:update_request) {
-      update_request = mock()
-      update_request.stubs(:body).returns('')
-      update_request
-    }
-
-    before {
-      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(verb, request_path, anything).returns(mock_request)
-      mock_request.expects(:call).returns(response_body)
-    }
-
-    let(:options) { {
-        description: 'Test Description',
-        label: 'Test Label',
-        geo_replication_enabled: false,
-        extended_properties: {
-            prop_1_name: 'prop_1_value',
-            prop_2_name: 'prop_2_value'
-        }
-    }
-    }
-
-    it 'checks if empty options is provided' do
-      exception = assert_raises RuntimeError do
-        subject.update_storage_account 'storage2', Hash.new
-      end
-      assert_match no_options_specified, exception.message
-    end
-
-    it 'checks if account exists before updating' do
-      ret_val = subject.update_storage_account 'storage3', Hash.new
-      ret_val.must_equal "Storage Account 'storage3' does not exist. Skipped..."
-    end
-
-    it 'updates the specified account' do
-      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
-        :put,
-        "#{request_path}/storage2",
-        has_entries(body: Fixtures['update_storage_account'])
-      ).returns(update_request)
-      update_request.expects(:call)
-      subject.update_storage_account 'storage2', options
-      mock_request.expects(:call).returns(sa_response)
-      storage_account = subject.list_storage_accounts.last
-      storage_account.name.must_equal 'storage2'
-      storage_account.label.must_equal options[:label]
-      storage_account.geo_replication_enabled.must_equal "#{options[:geo_replication_enabled]}"
-      storage_account.extended_properties.each { |prop|
-        prop[:value].must_equal "#{options[:extended_properties][:"#{prop[:name]}"]}"
-      }
-    end
-  end
-
-  describe '#get_storage_account_properties' do
-    let(:account_name) { 'storage2' }
-    let(:label) { 'ValidLabel' }
-    let(:request_path) { "/services/storageservices/#{account_name}" }
-    let(:account_xml) { Fixtures['get_storage_account_properties'] }
-
-    let(:get_account_mock_request) { mock() }
-    let(:get_account_response) {
-      get_account_response = mock()
-      get_account_response.stubs(:body).returns(account_xml)
-      get_account_response
-    }
-    let(:get_account_response_body) {
-      Nokogiri::XML(get_account_response.body)
-    }
-
-    before {
-      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(
-          :get, request_path, anything
-      ).returns(get_account_mock_request)
-      get_account_mock_request.expects(:call).returns(
-          get_account_response_body
-      )
-    }
-
-    it 'returns the label as a Base64 decoded string' do
-      storage_account = subject.get_storage_account_properties(account_name)
-      storage_account.label.must_be_kind_of(String)
-      storage_account.label.must_equal(label)
-      storage_account.account_type.must_equal 'Standard_GRS'
-      storage_account.geo_primary_region.must_equal 'West US'
-    end
-  end
-end

data/test/unit/table/edmtype_test.rb

@@ -1,108 +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/table/edmtype"
-
-require "azure/table/guid"
-
-describe Azure::Table::EdmType do
-  describe "#serialize_query_value" do
-    it "correctly serializes int64 query values" do
-      value = 2**128 + 1256231
-      serializedValue = Azure::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal value.to_s + "L"
-    end
-
-    it "correctly serializes int32 query values" do
-      value = 2
-      serializedValue = Azure::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "2"
-    end
-
-    it "correctly serializes datetime query values" do
-      value = DateTime.new(2001,2,3,4,5,6)
-      serializedValue = Azure::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "datetime'2001-02-03T04:05:06+00:00'"
-    end
-
-    it "correctly serializes guid query values" do
-      value = Azure::Table::GUID.new("81425519-6394-43e4-ac6e-28d91f5c3921")
-      serializedValue = Azure::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "guid'81425519-6394-43e4-ac6e-28d91f5c3921'"
-    end
-
-    it "correctly serializes float query values" do
-      value = 1.2
-      serializedValue = Azure::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "1.2"
-    end
-
-    it "correctly serializes string query values" do
-      value = "string"
-      serializedValue = Azure::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "string"
-    end
-
-    it "correctly serializes binary query values" do
-      value = "1".force_encoding("BINARY")
-      serializedValue = Azure::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "X'31'"
-    end
-  end
-
-  describe "#unserialize_query_value" do
-    it "correctly unserializes int64 query values" do
-      value = "340282366920938463463374607431769467687"
-      unserializedValue = Azure::Table::EdmType.unserialize_query_value(value, "Edm.Int64")
-      unserializedValue.must_equal (2**128 + 1256231)
-    end
-
-    it "correctly unserializes int32 query values" do
-      value = "2"
-      unserializedValue = Azure::Table::EdmType.unserialize_query_value(value, "Edm.Int32")
-      unserializedValue.must_equal 2
-    end
-
-    it "correctly unserializes datetime query values" do
-      value = "2001-02-03T04:05:06+00:00"
-      unserializedValue = Azure::Table::EdmType.unserialize_query_value(value, "Edm.DateTime")
-      unserializedValue.must_equal Time.new(2001, 2, 3, 4, 5, 6, "+00:00")
-    end
-
-    it "correctly unserializes guid query values" do
-      value = "81425519-6394-43e4-ac6e-28d91f5c3921"
-      unserializedValue = Azure::Table::EdmType.unserialize_query_value(value, "Edm.Guid")
-      unserializedValue.must_equal Azure::Table::GUID.new("81425519-6394-43e4-ac6e-28d91f5c3921")
-    end
-
-    it "correctly unserializes float query values" do
-      value = "1.2"
-      unserializedValue = Azure::Table::EdmType.unserialize_query_value(value, "Edm.Double")
-      unserializedValue.must_equal 1.2
-    end
-
-    it "correctly unserializes string query values" do
-      value = "string"
-      unserializedValue = Azure::Table::EdmType.unserialize_query_value(value, "Edm.String")
-      unserializedValue.must_equal "string"
-    end
-
-    it "correctly unserializes binary query values" do
-      value = "MTIzNDU=".force_encoding("BINARY")
-      unserializedValue = Azure::Table::EdmType.unserialize_query_value(value, "Edm.Binary")
-      unserializedValue.must_equal "12345"
-    end
-  end
-end

data/test/unit/virtual_machine_image_management/serialization_test.rb

@@ -1,50 +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 'test_helper'
-
-describe Azure::VirtualMachineImageManagement::Serialization do
-  subject { Azure::VirtualMachineImageManagement::Serialization }
-
-  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(os_images_xml)
-    end
-
-    it 'returns an Array of VirtualMachineImageService instances' do
-      results = subject.virtual_machine_images_from_xml Nokogiri::XML(os_images_xml)
-      results.must_be_kind_of Array
-      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

@@ -1,114 +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 'test_helper'
-
-describe Azure::VirtualMachineImageManagementService do
-
-  subject { Azure::VirtualMachineImageManagementService.new }
-
-  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(os_images_xml)
-    Nokogiri::XML response.body
-  end
-  let(:vm_images_response) do
-    response = mock
-    response.stubs(:body).returns(vm_images_xml)
-    Nokogiri::XML response.body
-  end
-
-  before {
-    Azure::Loggerx.expects(:puts).returns(nil).at_least(0)
-  }
-
-  describe '#list_os_images' do
-    let(:verb) { :get }
-    before do
-      os_images_request = mock
-      subject.client.stubs(:management_request).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 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
-
-  describe '#list_vm_images' do
-    let(:verb) { :get }
-    before do
-      vm_images_request = mock
-      subject.client.stubs(:management_request).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 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
-      subject.client.stubs(:management_request).with(
-          verb,
-          vm_image_request_path,
-          nil
-      ).returns(vm_images_request)
-      vm_images_request.expects(:call).returns(vm_images_response)
-      os_images_request = mock
-      subject.client.stubs(:management_request).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