fog-rackspace-0.1.6/ 0000755 0000041 0000041 00000000000 13411315054 014250 5 ustar www-data www-data fog-rackspace-0.1.6/.travis.yml 0000644 0000041 0000041 00000001151 13411315054 016357 0 ustar www-data www-data language: ruby sudo: false script: bundle exec rake test matrix: fast_finish: true include: - rvm: 1.8.7 gemfile: gemfiles/Gemfile-ruby-1.8.7 - rvm: 1.9.3 gemfile: Gemfile - rvm: 2.0.0 gemfile: Gemfile - rvm: 2.1.0 gemfile: Gemfile - rvm: 2.1.1 gemfile: Gemfile - rvm: 2.1.1 gemfile: gemfiles/Gemfile-edge - rvm: 2.2.0 gemfile: Gemfile - rvm: 2.2.0 gemfile: gemfiles/Gemfile-edge - rvm: jruby-18mode gemfile: gemfiles/Gemfile-ruby-1.8.7 - rvm: jruby-19mode gemfile: Gemfile - rvm: jruby-head gemfile: Gemfile allow_failures: - rvm: jruby-head fog-rackspace-0.1.6/.rspec 0000644 0000041 0000041 00000000037 13411315054 015365 0 ustar www-data www-data --format documentation --color fog-rackspace-0.1.6/README.md 0000644 0000041 0000041 00000000756 13411315054 015537 0 ustar www-data www-data # Fog::Rackspace [](https://circleci.com/gh/fog/fog-rackspace) [](https://travis-ci.org/fog/fog-rackspace) ## Installation Add this line to your application's Gemfile: ```ruby gem 'fog-rackspace' ``` And then execute: $ bundle Or install it yourself as: $ gem install fog-rackspace ## Usage See https://github.com/fog/fog for usage. fog-rackspace-0.1.6/tests/ 0000755 0000041 0000041 00000000000 13411315054 015412 5 ustar www-data www-data fog-rackspace-0.1.6/tests/helper.rb 0000644 0000041 0000041 00000001435 13411315054 017221 0 ustar www-data www-data begin require "codeclimate-test-reporter" CodeClimate::TestReporter.start rescue LoadError => e $stderr.puts "not recording test coverage: #{e.inspect}" end require File.expand_path('../../lib/fog/rackspace', __FILE__) Bundler.require(:test) Excon.defaults.merge!(:debug_request => true, :debug_response => true) require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper')) # This overrides the default 600 seconds timeout during live test runs unless Fog.mocking? Fog.timeout = ENV['FOG_TEST_TIMEOUT'] || 2_000 Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds" end def lorem_file File.open(File.dirname(__FILE__) + '/lorem.txt', 'r') end def array_differences(array_a, array_b) (array_a - array_b) | (array_b - array_a) end fog-rackspace-0.1.6/tests/helpers/ 0000755 0000041 0000041 00000000000 13411315054 017054 5 ustar www-data www-data fog-rackspace-0.1.6/tests/helpers/collection_helper.rb 0000644 0000041 0000041 00000005027 13411315054 023077 0 ustar www-data www-data def collection_tests(collection, params = {}, mocks_implemented = true) tests('success') do tests("#new(#{params.inspect})").succeeds do pending if Fog.mocking? && !mocks_implemented collection.new(params) end tests("#create(#{params.inspect})").succeeds do pending if Fog.mocking? && !mocks_implemented @instance = collection.create(params) end # FIXME: work around for timing issue on AWS describe_instances mocks if Fog.mocking? && @instance.respond_to?(:ready?) @instance.wait_for { ready? } end tests("#all").succeeds do pending if Fog.mocking? && !mocks_implemented collection.all end if !Fog.mocking? || mocks_implemented @identity = @instance.identity end tests("#get(#{@identity})").succeeds do pending if Fog.mocking? && !mocks_implemented collection.get(@identity) end tests('Enumerable') do pending if Fog.mocking? && !mocks_implemented methods = [ 'all?', 'any?', 'find', 'detect', 'collect', 'map', 'find_index', 'flat_map', 'collect_concat', 'group_by', 'none?', 'one?' ] # JRuby 1.7.5+ issue causes a SystemStackError: stack level too deep # https://github.com/jruby/jruby/issues/1265 if RUBY_PLATFORM == "java" and JRUBY_VERSION =~ /1\.7\.[5-8]/ methods.delete('all?') end methods.each do |enum_method| if collection.respond_to?(enum_method) tests("##{enum_method}").succeeds do block_called = false collection.send(enum_method) {|x| block_called = true } block_called end end end [ 'max_by','min_by' ].each do |enum_method| if collection.respond_to?(enum_method) tests("##{enum_method}").succeeds do block_called = false collection.send(enum_method) {|x| block_called = true; 0 } block_called end end end end if block_given? yield(@instance) end if !Fog.mocking? || mocks_implemented @instance.destroy end end tests('failure') do if !Fog.mocking? || mocks_implemented @identity = @identity.to_s @identity = @identity.gsub(/[a-zA-Z]/) { Fog::Mock.random_letters(1) } @identity = @identity.gsub(/\d/) { Fog::Mock.random_numbers(1) } @identity end tests("#get('#{@identity}')").returns(nil) do pending if Fog.mocking? && !mocks_implemented collection.get(@identity) end end end fog-rackspace-0.1.6/tests/helpers/formats_helper_tests.rb 0000644 0000041 0000041 00000007020 13411315054 023634 0 ustar www-data www-data Shindo.tests('test_helper', 'meta') do tests('comparing welcome data against schema') do data = {:welcome => "Hello" } data_matches_schema(:welcome => String) { data } end tests('#data_matches_schema') do tests('when value matches schema expectation') do data_matches_schema({"key" => String}) { {"key" => "Value"} } end tests('when values within an array all match schema expectation') do data_matches_schema({"key" => [Integer]}) { {"key" => [1, 2]} } end tests('when nested values match schema expectation') do data_matches_schema({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} } end tests('when collection of values all match schema expectation') do data_matches_schema([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] } end tests('when collection is empty although schema covers optional members') do data_matches_schema([{"key" => String}], {:allow_optional_rules => true}) { [] } end tests('when additional keys are passed and not strict') do data_matches_schema({"key" => String}, {:allow_extra_keys => true}) { {"key" => "Value", :extra => "Bonus"} } end tests('when value is nil and schema expects NilClass') do data_matches_schema({"key" => NilClass}) { {"key" => nil} } end tests('when value and schema match as hashes') do data_matches_schema({}) { {} } end tests('when value and schema match as arrays') do data_matches_schema([]) { [] } end tests('when value is a Time') do data_matches_schema({"time" => Time}) { {"time" => Time.now} } end tests('when key is missing but value should be NilClass (#1477)') do data_matches_schema({"key" => NilClass}, {:allow_optional_rules => true}) { {} } end tests('when key is missing but value is nullable (#1477)') do data_matches_schema({"key" => Fog::Nullable::String}, {:allow_optional_rules => true}) { {} } end end tests('#formats backwards compatible changes') do tests('when value matches schema expectation') do formats({"key" => String}) { {"key" => "Value"} } end tests('when values within an array all match schema expectation') do formats({"key" => [Integer]}) { {"key" => [1, 2]} } end tests('when nested values match schema expectation') do formats({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} } end tests('when collection of values all match schema expectation') do formats([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] } end tests('when collection is empty although schema covers optional members') do formats([{"key" => String}]) { [] } end tests('when additional keys are passed and not strict') do formats({"key" => String}, false) { {"key" => "Value", :extra => "Bonus"} } end tests('when value is nil and schema expects NilClass') do formats({"key" => NilClass}) { {"key" => nil} } end tests('when value and schema match as hashes') do formats({}) { {} } end tests('when value and schema match as arrays') do formats([]) { [] } end tests('when value is a Time') do formats({"time" => Time}) { {"time" => Time.now} } end tests('when key is missing but value should be NilClass (#1477)') do formats({"key" => NilClass}) { {} } end tests('when key is missing but value is nullable (#1477)') do formats({"key" => Fog::Nullable::String}) { {} } end end end fog-rackspace-0.1.6/tests/helpers/mock_helper.rb 0000644 0000041 0000041 00000000645 13411315054 021676 0 ustar www-data www-data # Use so you can run in mock mode from the command line # # FOG_MOCK=true fog if ENV["FOG_MOCK"] == "true" Fog.mock! end # if in mocked mode, fill in some fake credentials for us if Fog.mock? Fog.credentials = { :rackspace_api_key => 'rackspace_api_key', :rackspace_region => 'dfw', :rackspace_username => 'rackspace_username' }.merge(Fog.credentials) end fog-rackspace-0.1.6/tests/helpers/model_helper.rb 0000644 0000041 0000041 00000001414 13411315054 022040 0 ustar www-data www-data def model_tests(collection, params = {}, mocks_implemented = true) tests('success') do @instance = collection.new(params) tests("#save").succeeds do pending if Fog.mocking? && !mocks_implemented @instance.save end if block_given? yield(@instance) end tests("#destroy").succeeds do pending if Fog.mocking? && !mocks_implemented @instance.destroy end end end # Generates a unique identifier with a random differentiator. # Useful when rapidly re-running tests, so we don't have to wait # serveral minutes for deleted objects to disappear from the API # E.g. 'fog-test-1234' def uniq_id(base_name = 'fog-test') # random_differentiator suffix = rand(65536).to_s(16).rjust(4, '0') [base_name, suffix] * '-' end fog-rackspace-0.1.6/tests/helpers/formats_helper.rb 0000644 0000041 0000041 00000007056 13411315054 022423 0 ustar www-data www-data require "fog/schema/data_validator" # format related hackery # allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean) # allows both nil.is_a?(Fog::Nullable::String) and ''.is_a?(Fog::Nullable::String) module Fog module Boolean; end module Nullable module Boolean; end module Integer; end module String; end module Time; end module Float; end module Hash; end module Array; end end end [FalseClass, TrueClass].each {|klass| klass.send(:include, Fog::Boolean)} [FalseClass, TrueClass, NilClass, Fog::Boolean].each {|klass| klass.send(:include, Fog::Nullable::Boolean)} [NilClass, String].each {|klass| klass.send(:include, Fog::Nullable::String)} [NilClass, Time].each {|klass| klass.send(:include, Fog::Nullable::Time)} [Integer, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Integer)} [Float, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Float)} [Hash, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Hash)} [Array, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Array)} module Shindo class Tests # Generates a Shindo test that compares a hash schema to the result # of the passed in block returning true if they match. # # The schema that is passed in is a Hash or Array of hashes that # have Classes in place of values. When checking the schema the # value should match the Class. # # Strict mode will fail if the data has additional keys. Setting # +strict+ to +false+ will allow additional keys to appear. # # @param [Hash] schema A Hash schema # @param [Hash] options Options to change validation rules # @option options [Boolean] :allow_extra_keys # If +true+ does not fail when keys are in the data that are # not specified in the schema. This allows new values to # appear in API output without breaking the check. # @option options [Boolean] :allow_optional_rules # If +true+ does not fail if extra keys are in the schema # that do not match the data. Not recommended! # @yield Data to check with schema # # @example Using in a test # Shindo.tests("comparing welcome data against schema") do # data = {:welcome => "Hello" } # data_matches_schema(:welcome => String) { data } # end # # comparing welcome data against schema # + data matches schema # # @example Example schema # { # "id" => String, # "ram" => Integer, # "disks" => [ # { # "size" => Float # } # ], # "dns_name" => Fog::Nullable::String, # "active" => Fog::Boolean, # "created" => DateTime # } # # @return [Boolean] def data_matches_schema(schema, options = {}) test('data matches schema') do validator = Fog::Schema::DataValidator.new valid = validator.validate(yield, schema, options) @message = validator.message unless valid valid end end # @deprecated #formats is deprecated. Use #data_matches_schema instead def formats(format, strict = true) test('has proper format') do if strict options = {:allow_extra_keys => false, :allow_optional_rules => true} else options = {:allow_extra_keys => true, :allow_optional_rules => true} end validator = Fog::Schema::DataValidator.new valid = validator.validate(yield, format, options) @message = validator.message unless valid valid end end end end fog-rackspace-0.1.6/tests/helpers/compute/ 0000755 0000041 0000041 00000000000 13411315054 020530 5 ustar www-data www-data fog-rackspace-0.1.6/tests/helpers/compute/flavors_helper.rb 0000644 0000041 0000041 00000001463 13411315054 024074 0 ustar www-data www-data def flavors_tests(connection, params = {}, mocks_implemented = true) tests('success') do tests("#all").succeeds do pending if Fog.mocking? && !mocks_implemented connection.flavors.all end if !Fog.mocking? || mocks_implemented @identity = connection.flavors.first.identity end tests("#get('#{@identity}')").succeeds do pending if Fog.mocking? && !mocks_implemented connection.flavors.get(@identity) end end tests('failure') do if !Fog.mocking? || mocks_implemented invalid_flavor_identity = connection.flavors.first.identity.to_s.gsub(/\w/, '0') end tests("#get('#{invalid_flavor_identity}')").returns(nil) do pending if Fog.mocking? && !mocks_implemented connection.flavors.get(invalid_flavor_identity) end end end fog-rackspace-0.1.6/tests/helpers/compute/servers_helper.rb 0000644 0000041 0000041 00000000410 13411315054 024100 0 ustar www-data www-data def servers_tests(connection, params = {}, mocks_implemented = true) collection_tests(connection.servers, params, mocks_implemented) do if !Fog.mocking? || mocks_implemented @instance.wait_for { ready? } yield if block_given? end end end fog-rackspace-0.1.6/tests/helpers/compute/server_helper.rb 0000644 0000041 0000041 00000001246 13411315054 023725 0 ustar www-data www-data def server_tests(connection, params = {}, mocks_implemented = true) model_tests(connection.servers, params, mocks_implemented) do tests('#reload').returns(true) do pending if Fog.mocking? && !mocks_implemented @instance.wait_for { ready? } identity = @instance.identity !identity.nil? && identity == @instance.reload.identity end responds_to([:ready?, :state]) yield if block_given? tests('#reboot').succeeds do pending if Fog.mocking? && !mocks_implemented @instance.wait_for { ready? } @instance.reboot end if !Fog.mocking? || mocks_implemented @instance.wait_for { ready? } end end end fog-rackspace-0.1.6/tests/helpers/succeeds_helper.rb 0000644 0000041 0000041 00000000206 13411315054 022534 0 ustar www-data www-data module Shindo class Tests def succeeds test('succeeds') do !!instance_eval(&Proc.new) end end end end fog-rackspace-0.1.6/tests/helpers/responds_to_helper.rb 0000644 0000041 0000041 00000000374 13411315054 023303 0 ustar www-data www-data module Shindo class Tests def responds_to(method_names) for method_name in [*method_names] tests("#respond_to?(:#{method_name})").returns(true) do @instance.respond_to?(method_name) end end end end end fog-rackspace-0.1.6/tests/helpers/schema_validator_tests.rb 0000644 0000041 0000041 00000007231 13411315054 024133 0 ustar www-data www-data Shindo.tests('Fog::Schema::DataValidator', 'meta') do validator = Fog::Schema::DataValidator.new tests('#validate') do tests('returns true') do returns(true, 'when value matches schema expectation') do validator.validate({"key" => "Value"}, {"key" => String}) end returns(true, 'when values within an array all match schema expectation') do validator.validate({"key" => [1, 2]}, {"key" => [Integer]}) end returns(true, 'when nested values match schema expectation') do validator.validate({"key" => {:nested_key => "Value"}}, {"key" => {:nested_key => String}}) end returns(true, 'when collection of values all match schema expectation') do validator.validate([{"key" => "Value"}, {"key" => "Value"}], [{"key" => String}]) end returns(true, 'when collection is empty although schema covers optional members') do validator.validate([], [{"key" => String}]) end returns(true, 'when additional keys are passed and not strict') do validator.validate({"key" => "Value", :extra => "Bonus"}, {"key" => String}, {:allow_extra_keys => true}) end returns(true, 'when value is nil and schema expects NilClass') do validator.validate({"key" => nil}, {"key" => NilClass}) end returns(true, 'when value and schema match as hashes') do validator.validate({}, {}) end returns(true, 'when value and schema match as arrays') do validator.validate([], []) end returns(true, 'when value is a Time') do validator.validate({"time" => Time.now}, {"time" => Time}) end returns(true, 'when key is missing but value should be NilClass (#1477)') do validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => true}) end returns(true, 'when key is missing but value is nullable (#1477)') do validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => true}) end end tests('returns false') do returns(false, 'when value does not match schema expectation') do validator.validate({"key" => nil}, {"key" => String}) end returns(false, 'when key formats do not match') do validator.validate({"key" => "Value"}, {:key => String}) end returns(false, 'when additional keys are passed and strict') do validator.validate({"key" => "Missing"}, {}) end returns(false, 'when some keys do not appear') do validator.validate({}, {"key" => String}) end returns(false, 'when collection contains a member that does not match schema') do validator.validate([{"key" => "Value"}, {"key" => 5}], [{"key" => String}]) end returns(false, 'when collection has multiple schema patterns') do validator.validate([{"key" => "Value"}], [{"key" => Integer}, {"key" => String}]) end returns(false, 'when hash and array are compared') do validator.validate({}, []) end returns(false, 'when array and hash are compared') do validator.validate([], {}) end returns(false, 'when a hash is expected but another data type is found') do validator.validate({"key" => {:nested_key => []}}, {"key" => {:nested_key => {}}}) end returns(false, 'when key is missing but value should be NilClass (#1477)') do validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => false}) end returns(false, 'when key is missing but value is nullable (#1477)') do validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => false}) end end end end fog-rackspace-0.1.6/tests/rackspace/ 0000755 0000041 0000041 00000000000 13411315054 017346 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/ 0000755 0000041 0000041 00000000000 13411315054 021221 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/identity/ 0000755 0000041 0000041 00000000000 13411315054 023052 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/identity/token_tests.rb 0000644 0000041 0000041 00000003473 13411315054 025750 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity | tokens', ['rackspace']) do ROLE_FORMAT = { 'id' => String, 'name' => String, 'description' => String } ENDPOINT_FORMAT = { 'tenantId' => String, 'publicURL' => Fog::Nullable::String, 'internalURL' => Fog::Nullable::String, 'region' => Fog::Nullable::String, 'versionId' => Fog::Nullable::String, 'versionInfo' => Fog::Nullable::String, 'versionList' => Fog::Nullable::String } SERVICE_FORMAT = { 'name' => String, 'type' => String, 'endpoints' => [ENDPOINT_FORMAT] } ACCESS_FORMAT = { 'access' => { 'token' => { 'id' => String, 'expires' => String, 'tenant' => { 'id' => String, 'name' => String } }, 'user' => { 'id' => String, 'name' => String, 'roles' => [ROLE_FORMAT] }, 'serviceCatalog' => [SERVICE_FORMAT] } } service = Fog::Rackspace::Identity.new tests('success') do credentials = Fog.credentials username = credentials[:rackspace_username] api_key = credentials[:rackspace_api_key] tests('#create_token').formats(ACCESS_FORMAT) do service.create_token(username, api_key).body end tests('uses connection options').returns(true) do pending if Fog.mocking? identity_service = Fog::Rackspace::Identity.new(:connection_options => { :ssl_verify_peer => true }) connection = identity_service.instance_variable_get("@connection") excon = connection.instance_variable_get("@excon") data = excon.instance_variable_get("@data") data.key?(:ssl_verify_peer) end end tests('failure') do tests('#create_token(invalidname, invalidkey').raises(Excon::Errors::HTTPStatusError) do service.create_token('baduser', 'badkey') end end end fog-rackspace-0.1.6/tests/rackspace/requests/identity/tenants_tests.rb 0000644 0000041 0000041 00000000705 13411315054 026277 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity | tenants', ['rackspace']) do pending if Fog.mock? TENANTS_FORMATS = { 'tenants' => [{ 'id' => String, 'name' => String, 'description' => Fog::Nullable::String, 'enabled' => Fog::Nullable::Boolean }] } service = Fog::Rackspace::Identity.new tests('success') do tests('#list_tenants').formats(TENANTS_FORMATS) do service.list_tenants().body end end end fog-rackspace-0.1.6/tests/rackspace/requests/identity/user_tests.rb 0000644 0000041 0000041 00000005263 13411315054 025605 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity | users', ['rackspace']) do pending if Fog.mock? USER_INFO = { 'id' => String, 'username' => String, 'email' => Fog::Nullable::String, 'enabled' => Fog::Boolean, 'OS-KSADM:password' => Fog::Nullable::String, 'created' => Fog::Nullable::String, 'updated' => Fog::Nullable::String } USER_FORMAT = { 'user' => USER_INFO } USERS_FORMAT = { 'users' => [USER_INFO] } CREDENTIAL_FORMAT = { 'RAX-KSKEY:apiKeyCredentials' => { 'username' => String, 'apiKey' => String } } CREDENTIALS_FORMAT = { 'credentials' => [CREDENTIAL_FORMAT] } ROLES_FORMAT = { 'roles' => [{ 'id' => String, 'name' => String, 'description' => String }] } service = Fog::Rackspace::Identity.new id = nil username = "fog#{Time.now.to_i.to_s}" email = 'fog_user@example.com' enabled = true password = 'Fog_password1' tests('success') do tests('#create_user').formats(USER_FORMAT) do data = service.create_user(username, email, enabled).body id = data['user']['id'] data end tests('#delete_user').succeeds do service.delete_user(id) end # there appears to be a werid caching issue. It's just easier to create a new username and continue on username = "fog#{Time.now.to_i.to_s}" tests('#create_user with password').succeeds do data = service.create_user(username, email, enabled, :password => password ).body id = data['user']['id'] data end tests('#get_user_by_name').formats(USER_FORMAT) do data = service.get_user_by_name(username).body id = data['user']['id'] data end tests('#get_user_by_id').formats(USER_FORMAT) do service.get_user_by_id(id).body end tests('#list_users').formats(USERS_FORMAT) do service.list_users().body end tests('#update_user').formats(USER_FORMAT) do service.update_user(id, username, 'updated_user@example.com', enabled).body end tests('#update_user with password').succeeds do service.update_user(id, username, email, enabled, :password => password).body end tests('#list_user_roles').formats(ROLES_FORMAT) do service.list_user_roles(id).body end service.delete_user(id) # Users are only authorized to request their own credentials, # so perform credential tests with the ID of the user running tests. credential_username = Fog.credentials[:rackspace_username] credential_id = service.get_user_by_name(credential_username).body['user']['id'] tests('#list_credentials').formats(CREDENTIALS_FORMAT) do service.list_credentials(credential_id).body end end end fog-rackspace-0.1.6/tests/rackspace/requests/cdn/ 0000755 0000041 0000041 00000000000 13411315054 021765 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/cdn/cdn_tests.rb 0000644 0000041 0000041 00000004364 13411315054 024307 0 ustar www-data www-data Shindo.tests('Fog::CDN[:rackspace] | CDN requests', ['rackspace']) do @container_format = [String] @containers_format = [{ "cdn_ios_uri" => String, "log_retention" => Fog::Boolean, "ttl" => Fixnum, "cdn_streaming_uri" => String, "cdn_enabled" => Fog::Boolean, "name" => String, "cdn_ssl_uri" => String, "cdn_uri" => String }] @container_headers = { "Content-Length" => String, "X-Cdn-Enabled" => String, "X-Log-Retention" => String, "X-Cdn-Ios-Uri" => String, "X-Ttl" => String, "X-Cdn-Uri" => String, "X-Cdn-Ssl-Uri" => String, "X-Cdn-Streaming-Uri" => String, "X-Trans-Id" => String, "Date" => String } begin unless Fog.mocking? @directory = Fog::Storage[:rackspace].directories.create(:key => 'fogcontainertests') @file = @directory.files.create(:key => 'fog_object', :body => lorem_file) end tests('success') do tests("#put_container('fogcontainertests')").succeeds do Fog::CDN[:rackspace].put_container('fogcontainertests', {'X-CDN-Enabled' => true }) end tests("#get_containers").formats(@containers_format) do Fog::CDN[:rackspace].get_containers.body end tests("#head_container('fogcontainertests')").formats(@container_headers) do Fog::CDN[:rackspace].head_container('fogcontainertests').headers end tests("#post_container('fogcontainertests')").succeeds do Fog::CDN[:rackspace].post_container('fogcontainertests', 'X-TTL' => 5000) end #NOTE: you are only allow 25 object purges per day. If this fails, you may be over the limit tests("#delete_object('fog_object')").succeeds do Fog::CDN[:rackspace].delete_object('fogcontainertests', 'fog_object') end end ensure unless Fog.mocking? @file.destroy if @file @directory.destroy if @directory end end tests('failure') do tests("#head_container('missing_container')").raises(Fog::Storage::Rackspace::NotFound) do Fog::CDN[:rackspace].head_container('missing_container') end tests("#post_container('missing_container')").raises(Fog::Storage::Rackspace::NotFound) do Fog::CDN[:rackspace].post_container('missing_container', 'X-TTL' => 5000) end end end fog-rackspace-0.1.6/tests/rackspace/requests/dns/ 0000755 0000041 0000041 00000000000 13411315054 022005 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/dns/helper.rb 0000644 0000041 0000041 00000005620 13411315054 023614 0 ustar www-data www-data SUBDOMAIN_FORMAT = { 'name' => String, 'id' => Integer, 'created' => String, 'updated' => String, 'emailAddress' => String } DOMAIN_FORMAT = SUBDOMAIN_FORMAT.merge({ 'accountId' => Integer }) LIST_SUBDOMAINS_FORMAT = { 'domains' => [SUBDOMAIN_FORMAT], 'totalEntries' => Integer } LIST_DOMAIN_FORMAT = { 'domains' => [DOMAIN_FORMAT], 'totalEntries' => Integer, 'links' => [ { 'rel' => String, 'href' => String } ] } RECORD_FORMAT = { 'name' => String, 'id' => String, 'type' => String, 'data' => String, 'updated' => String, 'created' => String, 'ttl' => Integer, 'priority' => Fog::Nullable::Integer } RECORD_LIST_FORMAT = { 'records' => [RECORD_FORMAT], #In some cases this is returned (domain details) and in some cases it isn't (create domain). Marking as nullable. 'totalEntries' => Fog::Nullable::Integer } NAME_SERVERS_FORMAT = [{ 'name' => String }] BASIC_DOMAIN_DETAIL_FORMAT = DOMAIN_FORMAT.merge({ 'nameservers' => NAME_SERVERS_FORMAT, 'ttl' => Integer }) LIST_DOMAIN_DETAILS_WITH_RECORDS = BASIC_DOMAIN_DETAIL_FORMAT.merge({ 'recordsList' => RECORD_LIST_FORMAT }) LIST_DOMAIN_DETAILS_WITH_RECORDS_AND_SUBDOMAINS_FORMAT = BASIC_DOMAIN_DETAIL_FORMAT.merge({ 'recordsList' => RECORD_LIST_FORMAT, 'subdomains' => { 'domains' => [SUBDOMAIN_FORMAT], 'totalEntries' => Integer } }) LIST_DOMAIN_DETAILS_WITHOUT_RECORDS_AND_SUBDOMAINS_FORMAT = BASIC_DOMAIN_DETAIL_FORMAT CREATE_DOMAINS_FORMAT = { 'domains' => [ BASIC_DOMAIN_DETAIL_FORMAT.merge({ 'recordsList' => RECORD_LIST_FORMAT }) ] } def wait_for(service, response) job_id = response.body['jobId'] Fog.wait_for do response = service.callback(job_id) response.body['status'] != 'RUNNING' end response end def domain_tests(service, domain_attributes) tests("create_domains([#{domain_attributes}])").formats(CREATE_DOMAINS_FORMAT) do response = wait_for service, service.create_domains([domain_attributes]) @domain_details = response.body['response']['domains'] @domain_id = @domain_details[0]['id'] response.body['response'] end begin if block_given? yield end ensure tests("remove_domain('#{@domain_id}')").succeeds do wait_for service, service.remove_domain(@domain_id) end end end def domains_tests(service, domains_attributes, custom_delete = false) tests("create_domains(#{domains_attributes})").formats(CREATE_DOMAINS_FORMAT) do response = wait_for service, service.create_domains(domains_attributes) @domain_details = response.body['response']['domains'] @domain_ids = @domain_details.map { |domain| domain['id'] } response.body['response'] end begin if block_given? yield end ensure if !custom_delete tests("remove_domains(#{@domain_ids})").succeeds do wait_for service, service.remove_domains(@domain_ids) end end end end fog-rackspace-0.1.6/tests/rackspace/requests/dns/dns_tests.rb 0000644 0000041 0000041 00000012564 13411315054 024350 0 ustar www-data www-data Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do pending if Fog.mocking? domain_name = uniq_id + '.com' tests('success on simple domain') do domain_tests(Fog::DNS[:rackspace], {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]}) do tests('list_domains').formats(LIST_DOMAIN_FORMAT.reject {|key,value| key == 'links'}) do Fog::DNS[:rackspace].list_domains.body end tests("list_domains :limit => 5, :offset => 10, :domain => #{@domain_details.first['name']} --> All possible attributes").formats(LIST_DOMAIN_FORMAT) do Fog::DNS[:rackspace].list_domains(:limit => 5, :offset => 10, :domain => @domain_details.first['name']).body end tests("list_domain_details('#{@domain_id}')").formats(LIST_DOMAIN_DETAILS_WITH_RECORDS) do Fog::DNS[:rackspace].list_domain_details(@domain_id).body end tests("modify_domain('#{@domain_id}', :ttl => 500, :comment => 'woot', :email => 'randomemail@randomhost.com')").succeeds do response = Fog::DNS[:rackspace].modify_domain @domain_id, :ttl => 500, :comment => 'woot', :email => 'randomemail@randomhost.com' wait_for Fog::DNS[:rackspace], response end end end tests('success for domain with multiple records') do domain_tests(Fog::DNS[:rackspace], { :name => domain_name, :email => 'hostmaster@' + domain_name, :records => [ { :ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1' }, { :ttl => 3600, :name => domain_name, :type => 'MX', :data => 'mx.' + domain_name, :priority => 10 } ] }) end tests('success for multiple domains') do domain1_name = uniq_id + '-1.com' domain2_name = uniq_id + '-2.com' domains_tests(Fog::DNS[:rackspace], [ {:name => domain1_name, :email => 'hostmaster@' + domain1_name, :records => [{:ttl => 300, :name => domain1_name, :type => 'A', :data => '192.168.1.1'}]}, {:name => domain2_name, :email => 'hostmaster@' + domain2_name, :records => [{:ttl => 300, :name => domain2_name, :type => 'A', :data => '192.168.1.1'}]} ]) end tests('success for domain with subdomain') do domains_tests(Fog::DNS[:rackspace], [ {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]}, {:name => 'subdomain.' + domain_name, :email => 'hostmaster@subdomain.' + domain_name, :records => [{:ttl => 300, :name =>'subdomain.' + domain_name, :type => 'A', :data => '192.168.1.1'}]} ], true) do @root_domain_id = @domain_details.find { |domain| domain['name'] == domain_name }['id'] tests("list_domain_details('#{@root_domain_id}', :show_records => false, :show_subdomains => false)") do response = Fog::DNS[:rackspace].list_domain_details(@root_domain_id, :show_records => false, :show_subdomains => false) formats(LIST_DOMAIN_DETAILS_WITHOUT_RECORDS_AND_SUBDOMAINS_FORMAT) { response.body } returns(nil) { response.body['recordsList'] } returns(nil) { response.body['subdomains'] } end tests("list_domain_details('#{@root_domain_id}', :show_records => true, :show_subdomains => true)") do response = Fog::DNS[:rackspace].list_domain_details(@root_domain_id, :show_records => true, :show_subdomains => true) formats(LIST_DOMAIN_DETAILS_WITH_RECORDS_AND_SUBDOMAINS_FORMAT) { response.body } returns(false) { response.body['recordsList'].nil? } returns(false) { response.body['subdomains'].nil? } end tests("list_subdomains('#{@root_domain_id}')").formats(LIST_SUBDOMAINS_FORMAT) do Fog::DNS[:rackspace].list_subdomains(@root_domain_id).body end tests("remove_domain('#{@root_domain_id}', :delete_subdomains => true)") do wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_domain(@root_domain_id, :delete_subdomains => true) test('domain and subdomains were really deleted') do (Fog::DNS[:rackspace].list_domains.body['domains'].map { |domain| domain['name'] } & [domain_name, 'subdomain.' + domain_name]).empty? end end end end tests( 'failure') do tests('create_domain(invalid)').returns('ERROR') do response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].create_domains([{:name => 'badtestdomain.com', :email => '', :records => [{:ttl => 300, :name => 'badtestdomain.com', :type => 'A', :data => '192.168.1.1'}]}]) response.body['status'] end tests('list_domains :limit => 5, :offset => 8').raises(Fog::Rackspace::Errors::BadRequest) do Fog::DNS[:rackspace].list_domains :limit => 5, :offset => 8 end tests('list_domain_details 34335353').raises(Fog::DNS::Rackspace::NotFound) do Fog::DNS[:rackspace].list_domain_details 34335353 end #tests('create_domains(#{domains})').raises(Fog::Rackspace::Errors::Conflict) do # wait_for Fog::DNS[:rackspace].create_domains(domains) #end #tests('remove_domain(34343435)').raises(Fog::DNS::Rackspace::DeleteFault) do # Fog::DNS[:rackspace].remove_domain 34343435 #end end end fog-rackspace-0.1.6/tests/rackspace/requests/dns/records_tests.rb 0000644 0000041 0000041 00000007120 13411315054 025215 0 ustar www-data www-data Shindo.tests('Fog::DNS[:rackspace] | dns records requests', ['rackspace', 'dns']) do pending if Fog.mocking? domain_name = uniq_id + '.com' domain_tests(Fog::DNS[:rackspace], {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]}) do tests('success on single record') do tests("list_records(#{@domain_id})").formats(RECORD_LIST_FORMAT) do Fog::DNS[:rackspace].list_records(@domain_id).body end tests("add_records(#{@domain_id}, [{ :name => 'test1.#{domain_name}', :type => 'A', :data => '192.168.2.1', :ttl => 550}])").formats(RECORD_LIST_FORMAT) do response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => 'test1.' + domain_name, :type => 'A', :data => '192.168.2.1', :ttl => 550}]) @record_id = response.body['response']['records'].first['id'] response.body['response'] end tests("list_record_details(#{@domain_id}, #{@record_id})").formats(RECORD_FORMAT) do Fog::DNS[:rackspace].list_record_details(@domain_id, @record_id).body end tests("modify_record(#{@domain_id}, #{@record_id}, { :ttl => 500, :name => 'test2.#{domain_name}', :data => '192.168.3.1' })").succeeds do wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].modify_record(@domain_id, @record_id, { :ttl => 500, :name => 'test2.' + domain_name, :data => '192.168.3.1' }) end tests("remove_record(#{@domain_id}, #{@record_id})").succeeds do wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_record(@domain_id, @record_id) end end tests('success on multiple records') do records_attributes = [ { :name => 'test1.' + domain_name, :type => 'A', :data => '192.168.2.1'}, { :name => domain_name, :type => 'MX', :priority => 10, :data => 'mx.' + domain_name} ] tests("add_records(#{@domain_id}, #{records_attributes})").formats(RECORD_LIST_FORMAT) do response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, records_attributes) @record_ids = response.body['response']['records'].map { |record| record['id'] } response.body['response'] end tests("remove_records(#{@domain_id}, #{@record_ids})").succeeds do wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_records(@domain_id, @record_ids) end end tests( 'failure') do tests("list_records('')").raises(ArgumentError) do Fog::DNS[:rackspace].list_records('') end tests("list_records('abc')").raises(Fog::DNS::Rackspace::NotFound) do Fog::DNS[:rackspace].list_records('abc') end tests("list_record_details(#{@domain_id}, '')").raises(ArgumentError) do Fog::DNS[:rackspace].list_record_details(@domain_id, '') end tests("list_record_details(#{@domain_id}, 'abc')").raises(Fog::DNS::Rackspace::NotFound) do Fog::DNS[:rackspace].list_record_details(@domain_id, 'abc') end tests("remove_record(#{@domain_id}, '')").raises(ArgumentError) do Fog::DNS[:rackspace].remove_record(@domain_id, '') end tests("remove_record(#{@domain_id}, 'abc')").raises(Fog::DNS::Rackspace::NotFound) do Fog::DNS[:rackspace].remove_record(@domain_id, 'abc') end tests("add_record(#{@domain_id}, [{ :name => '', :type => '', :data => ''}])").raises(Fog::Rackspace::Errors::BadRequest) do Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => '', :type => '', :data => ''}]) end end end end fog-rackspace-0.1.6/tests/rackspace/requests/databases/ 0000755 0000041 0000041 00000000000 13411315054 023150 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/databases/database_tests.rb 0000644 0000041 0000041 00000002411 13411315054 026461 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Database | database_tests', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new instance_name = 'fog' + Time.now.to_i.to_s begin @instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id'] wait_for_request("waiting for database to be created") do service.get_instance(@instance_id).body["instance"]["status"] == 'ACTIVE' end tests('success') do database_name = 'fogdb' + Time.now.to_i.to_s tests("#create_database(#{@instance_id}, #{database_name})").returns(202) do service.create_database(@instance_id, database_name).status end tests("#list_databases{#{@instance_id})").formats(LIST_DATABASES_FORMAT) do service.list_databases(@instance_id).body end tests("#delete_database(#{@instance_id}, #{database_name})").returns(202) do service.delete_database(@instance_id, database_name).status end end tests('failure') do tests("#create_database(#{@instance_id}, '') => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do service.create_database(@instance_id, '') end end ensure service.delete_instance(@instance_id) if @instance_id end end fog-rackspace-0.1.6/tests/rackspace/requests/databases/helper.rb 0000644 0000041 0000041 00000002267 13411315054 024763 0 ustar www-data www-data FLAVOR_FORMAT = { 'id' => Integer, 'name' => String, 'ram' => Integer, 'links' => LINKS_FORMAT } GET_FLAVOR_FORMAT = { 'flavor' => FLAVOR_FORMAT } LIST_FLAVORS_FORMAT = { 'flavors' => [FLAVOR_FORMAT] } INSTANCE_FORMAT = { 'id' => String, 'name' => String, 'status' => String, 'links' => LINKS_FORMAT, 'flavor' => { 'id' => String, 'links' => LINKS_FORMAT }, 'volume' => { 'size' => Integer } } INSTANCE_DETAILS_FORMAT = INSTANCE_FORMAT.merge({ 'created' => String, 'updated' => String, 'hostname' => String, }) CREATE_INSTANCE_FORMAT = { 'instance' => INSTANCE_DETAILS_FORMAT } GET_INSTANCE_FORMAT = { 'instance' => INSTANCE_DETAILS_FORMAT.merge({ 'volume' => { 'size' => Integer, 'used' => Float } }) } LIST_INSTANCES_FORMAT = { 'instances' => [ INSTANCE_FORMAT ] } CHECK_ROOT_USER_FORMAT = { 'rootEnabled' => Fog::Boolean } ENABLE_ROOT_USER_FORMAT = { 'user' => { 'name' => String, 'password' => String } } LIST_DATABASES_FORMAT = { 'databases' => [{ 'name' => String }] } LIST_USERS_FORMAT = { 'users' => [{ 'name' => String, 'databases' => [{ 'name' => String }] }] } fog-rackspace-0.1.6/tests/rackspace/requests/databases/instance_tests.rb 0000644 0000041 0000041 00000004233 13411315054 026525 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Database | instance_tests', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new tests('success') do instance_id = nil instance_name = 'fog' + Time.now.to_i.to_s tests("#list_instances").formats(LIST_INSTANCES_FORMAT) do service.list_instances.body end tests("#create_instance(#{instance_name}, 1, 1)").formats(CREATE_INSTANCE_FORMAT) do data = service.create_instance(instance_name, 1, 1).body instance_id = data['instance']['id'] data end until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE' sleep 10 end tests("#get_instance(#{instance_id})").formats(GET_INSTANCE_FORMAT) do service.get_instance(instance_id).body end tests("#check_root_user(#{instance_id})").formats(CHECK_ROOT_USER_FORMAT) do service.check_root_user(instance_id).body end tests("#enable_root_user(#{instance_id})").formats(ENABLE_ROOT_USER_FORMAT) do service.enable_root_user(instance_id).body end tests("#restart_instance(#{instance_id})").succeeds do service.restart_instance(instance_id) end until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE' sleep 10 end tests("#resize_instance(#{instance_id}, 2)").succeeds do service.resize_instance(instance_id, 2) end until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE' sleep 10 end tests("#resize_instance_volume(#{instance_id}, 2)").succeeds do service.resize_instance_volume(instance_id, 2) end until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE' sleep 10 end tests("#delete_instance(#{instance_id})").succeeds do service.delete_instance(instance_id) end end tests('failure') do tests("#create_instance('', 0, 0) => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do service.create_instance('', 0, 0) end tests("#get_instance('') => Does not exist").raises(Fog::Rackspace::Databases::NotFound) do service.get_instance('') end end end fog-rackspace-0.1.6/tests/rackspace/requests/databases/flavor_tests.rb 0000644 0000041 0000041 00000000602 13411315054 026206 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Database | flavor_tests', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new tests('success') do tests('#list_flavors_details').formats(LIST_FLAVORS_FORMAT) do service.list_flavors().body end tests('#get_flavor(1)').formats(GET_FLAVOR_FORMAT) do service.get_flavor(1).body end end end fog-rackspace-0.1.6/tests/rackspace/requests/databases/user_tests.rb 0000644 0000041 0000041 00000002246 13411315054 025701 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Database | user_tests', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new instance_name = 'fog' + Time.now.to_i.to_s instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id'] wait_for_request("Waiting for database to be created") do service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE' end tests('success') do user_name = 'fog' + Time.now.to_i.to_s password = 'password1' tests("#create_user(#{instance_id}, #{user_name}, #{password})").returns(202) do service.create_user(instance_id, user_name, password).status end tests("#list_users{#{instance_id})").formats(LIST_USERS_FORMAT) do service.list_users(instance_id).body end tests("#delete_user(#{instance_id}, #{user_name})").returns(202) do service.delete_user(instance_id, user_name).status end end tests('failure') do tests("#create_user(#{instance_id}, '', '') => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do service.create_user(instance_id, '', '') end end service.delete_instance(instance_id) end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/ 0000755 0000041 0000041 00000000000 13411315054 023304 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/image_tests.rb 0000644 0000041 0000041 00000004312 13411315054 026135 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | image_tests', ['rackspace']) do service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2') image_format = { 'id' => String, 'name' => String, 'created' => Fog::Nullable::String, 'updated' => Fog::Nullable::String, 'status' => Fog::Nullable::String, 'user_id' => Fog::Nullable::String, 'tenant_id' => Fog::Nullable::String, 'progress' => Fog::Nullable::Integer, 'minDisk' => Fog::Nullable::Integer, 'minRam' => Fog::Nullable::Integer, 'metadata' => Fog::Nullable::Hash, 'OS-DCF:diskConfig' => Fog::Nullable::String, 'links' => [{ 'rel' => String, 'href' => String, 'type' => Fog::Nullable::String }] } list_image_format = { 'images' => [image_format] } get_image_format = { 'image' => image_format } begin test_time = Time.now.to_i.to_s @server = service.servers.create(:name => "fog-image-tests_#{test_time}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service)) @server.wait_for { ready? } @image_id = nil tests('success') do tests("#create_image(#{@server.id}, 'fog-test-image')").succeeds do response = service.create_image(@server.id, "fog-test-image_#{test_time}") @image_id = response.headers["Location"].match(/\/([^\/]+$)/)[1] end tests('#list_images').formats(list_image_format) do service.list_images.body end tests('#list_images_detail').formats(list_image_format) do service.list_images_detail.body end tests('#get_image').formats(get_image_format, false) do service.get_image(@image_id).body end tests('#delete_image').succeeds do service.delete_image(@image_id) end end tests('failure') do tests('#delete_image').raises(Fog::Compute::RackspaceV2::NotFound) do service.delete_image(Fog::Rackspace::MockData::NOT_FOUND_ID) end tests('#get_image').raises(Fog::Compute::RackspaceV2::NotFound) do service.get_image(Fog::Rackspace::MockData::NOT_FOUND_ID) end end ensure @image.destroy if @image @server.destroy if @server end end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/server_tests.rb 0000644 0000041 0000041 00000014037 13411315054 026366 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | server_tests', ['rackspace']) do service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2') link_format = { 'href' => String, 'rel' => String } server_format = { 'id' => String, 'name' => String, 'hostId' => Fog::Nullable::String, 'created' => Fog::Nullable::String, 'updated' => Fog::Nullable::String, 'status' => Fog::Nullable::String, 'progress' => Fog::Nullable::Integer, 'user_id' => Fog::Nullable::String, 'tenant_id' => Fog::Nullable::String, 'links' => [link_format], 'metadata' => Fog::Nullable::Hash } list_servers_format = { 'servers' => [server_format] } get_server_format = { 'server' => server_format.merge({ 'accessIPv4' => String, 'accessIPv6' => String, 'OS-DCF:diskConfig' => String, 'rax-bandwidth:bandwidth' => Fog::Nullable::Array, 'addresses' => Fog::Nullable::Hash, 'flavor' => { 'id' => String, 'links' => [link_format] }, 'image' => { 'id' => String, 'links' => [link_format] } }) } create_server_format = { 'server' => { 'id' => String, 'adminPass' => String, 'links' => [link_format], 'OS-DCF:diskConfig' => String } } rescue_server_format = { 'adminPass' => Fog::Nullable::String } tests('success') do server_id = nil server_name = "fog#{Time.now.to_i.to_s}" image_id = rackspace_test_image_id(service) flavor_id = rackspace_test_flavor_id(service) bootable_flavor_id = if Fog.mocking? flavor_id else service.flavors.find { |f| f.name =~ /Performance/ }.id end tests("#create_server(#{server_name}, #{image_id}, #{flavor_id}, 1, 1)").formats(create_server_format) do body = service.create_server(server_name, image_id, flavor_id, 1, 1).body server_id = body['server']['id'] body end wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR') tests("#create_server(#{server_name}_bfv_1, '', #{flavor_id}, 1, 1, :boot_volume_id => bootable_volume_id)").succeeds do # First, create a bootable volume. volume_service = Fog::Rackspace::BlockStorage.new bootable_volume_id = volume_service.create_volume(100, :image_id => image_id).body['volume']['id'] wait_for_volume_state(volume_service, bootable_volume_id, 'available') body = service.create_server(server_name + "_bfv_1", '', bootable_flavor_id, 1, 1, :boot_volume_id => bootable_volume_id).body bfv_server_id = body['server']['id'] wait_for_server_state(service, bfv_server_id, 'ACTIVE', 'ERROR') service.delete_server(bfv_server_id) wait_for_volume_state(volume_service, bootable_volume_id, 'available') volume_service.delete_volume(bootable_volume_id) end tests("#create_server(#{server_name}_bfv_2, '', #{flavor_id}, 1, 1, :boot_image_id => #{image_id})").succeeds do body = service.create_server(server_name + "_bfv_2", '', bootable_flavor_id, 1, 1, :boot_image_id => image_id).body bfv_server_id = body['server']['id'] wait_for_server_state(service, bfv_server_id, 'ACTIVE', 'ERROR') service.delete_server(bfv_server_id) end tests('#list_servers').formats(list_servers_format, false) do service.list_servers.body end tests('#get_server').formats(get_server_format, false) do service.get_server(server_id).body end tests("#update_server(#{server_id}, #{server_name}_update) LEGACY").formats(get_server_format) do service.update_server(server_id, "#{server_name}_update").body end tests("#update_server(#{server_id}, { 'name' => #{server_name}_update)} ").formats(get_server_format) do service.update_server(server_id, 'name' => "#{server_name}_update").body end tests('#change_server_password').succeeds do service.change_server_password(server_id, 'some_server_password') end wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR') tests('#reboot_server').succeeds do service.reboot_server(server_id, 'SOFT') end wait_for_server_state(service, server_id, 'ACTIVE') tests('#rebuild_server').succeeds do rebuild_image_id = image_id service.rebuild_server(server_id, rebuild_image_id) end wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR') sleep 120 unless Fog.mocking? tests('#resize_server').succeeds do resize_flavor_id = Fog.mocking? ? flavor_id : service.flavors[1].id service.resize_server(server_id, resize_flavor_id) end wait_for_server_state(service, server_id, 'VERIFY_RESIZE', 'ACTIVE') tests('#confirm_resize_server').succeeds do service.confirm_resize_server(server_id) end wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR') tests('#resize_server').succeeds do resize_flavor_id = Fog.mocking? ? flavor_id : service.flavors[2].id service.resize_server(server_id, resize_flavor_id) end wait_for_server_state(service, server_id, 'VERIFY_RESIZE', 'ACTIVE') tests('#revert_resize_server').succeeds do service.revert_resize_server(server_id) end wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR') tests('#rescue_server').formats(rescue_server_format, false) do service.rescue_server(server_id) end wait_for_server_state(service, server_id, 'RESCUE', 'ACTIVE') tests('#start_server').formats(rescue_server_format, false) do service.start_server(server_id) end wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR') tests('#stop_server').formats(rescue_server_format, false) do service.stop_server(server_id) end wait_for_server_state(service, server_id, 'SHUTOFF') tests('#unrescue_server').succeeds do service.unrescue_server(server_id) end wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR') tests('#delete_server').succeeds do service.delete_server(server_id) end tests('#get_vnc_console').succeeds do service.get_vnc_console(server_id, 'novnc') end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/attachment_tests.rb 0000644 0000041 0000041 00000004524 13411315054 027210 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | attachment_tests', ['rackspace']) do compute_service = Fog::Compute::RackspaceV2.new block_storage_service = Fog::Rackspace::BlockStorage.new image_id = rackspace_test_image_id(compute_service) flavor_id = rackspace_test_flavor_id(compute_service) attachment_format = { 'volumeAttachment' => { 'id' => String, 'serverId' => String, 'volumeId' => String, 'device' => Fog::Nullable::String } } list_attachments_format = { 'volumeAttachments' => [attachment_format['volumeAttachment']] } name = 'fog' + Time.now.to_i.to_s image_id = image_id flavor_id = flavor_id server_id = compute_service.create_server(name, image_id, flavor_id, 1, 1).body['server']['id'] volume_id = block_storage_service.create_volume(100).body['volume']['id'] device_id = '/dev/xvde' tests('success') do wait_for_request("Waiting for server to become ready") do compute_service.get_server(server_id).body['server']['status'] == 'ACTIVE' end wait_for_request("Waiting for Volume to be ready") do block_storage_service.get_volume(volume_id).body['volume']['status'] == 'available' end tests("#attach_volume(#{server_id}, #{volume_id}, #{device_id})").formats(attachment_format) do compute_service.attach_volume(server_id, volume_id, device_id).body end tests("#list_attachments(#{server_id})").formats(list_attachments_format) do compute_service.list_attachments(server_id).body end wait_for_request("Waiting for Volume to be ready") do block_storage_service.get_volume(volume_id).body['volume']['status'] == 'in-use' end tests("#get_attachment(#{server_id}, #{volume_id})").formats(attachment_format) do compute_service.get_attachment(server_id, volume_id).body end tests("#delete_attachment(#{server_id}, #{volume_id})").succeeds do compute_service.delete_attachment(server_id, volume_id) end end tests('failure') do tests("#attach_volume('', #{volume_id}, #{device_id})").raises(Fog::Compute::RackspaceV2::NotFound) do compute_service.attach_volume('', volume_id, device_id) end tests("#delete_attachment('', #{volume_id})").raises(Fog::Compute::RackspaceV2::NotFound) do compute_service.delete_attachment('', volume_id) end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/network_tests.rb 0000644 0000041 0000041 00000002270 13411315054 026545 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | network_tests', ['rackspace']) do service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2') network_format = { 'id' => String, 'label' => String, 'cidr' => Fog::Nullable::String } get_network_format = { 'network' => network_format } list_networks_format = { 'networks' => [network_format] } tests('success') do network_id = nil tests('#create_network').formats(get_network_format) do service.create_network("fog_#{Time.now.to_i.to_s}", '192.168.0.0/24').body.tap do |r| network_id = r['network']['id'] end end tests('#list_networks').formats(list_networks_format) do service.list_networks.body end tests('#get_network').formats(get_network_format) do service.get_network(network_id).body end tests('#delete_network').succeeds do service.delete_network(network_id) end end test('failure') do tests('#get_network').raises(Fog::Compute::RackspaceV2::NotFound) do service.get_network(0) end tests('#delete_network').raises(Fog::Compute::RackspaceV2::NotFound) do service.delete_network(0) end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/flavor_tests.rb 0000644 0000041 0000041 00000002147 13411315054 026350 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | flavor_tests', ['rackspace']) do flavor_format = { 'id' => String, 'name' => String, 'ram' => Fog::Nullable::Integer, 'disk' => Fog::Nullable::Integer, 'vcpus' => Fog::Nullable::Integer, 'links' => [{ 'rel' => String, 'href' => String }] } list_flavor_format = { 'flavors' => [flavor_format] } get_flavor_format = { 'flavor' => flavor_format.merge({ 'OS-FLV-EXT-DATA:ephemeral' => Integer, 'rxtx_factor' => Float, 'swap' => Integer }) } service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2') flavor_id = nil tests('success') do tests('#list_flavors').formats(list_flavor_format) do body = service.list_flavors.body flavor_id = body['flavors'][0]['id'] body end tests('#list_flavors_detail').formats(list_flavor_format) do body = service.list_flavors_detail.body flavor_id = body['flavors'][0]['id'] body end tests('#get_flavor').formats(get_flavor_format) do service.get_flavor(flavor_id).body end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/keypair_tests.rb 0000644 0000041 0000041 00000002621 13411315054 026520 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | keypair_tests', ['rackspace']) do keypair_format = { 'name' => String, 'public_key' => String, 'fingerprint' => String, } create_keypair_format = { 'keypair' => keypair_format.merge({ 'user_id' => String, 'private_key' => String }) } list_keypair_format = { 'keypairs' => [ 'keypair' => keypair_format ] } get_keypair_format = { 'keypair' => keypair_format } service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2') keypair_name = Fog::Mock.random_letters(32) tests('success') do tests('#create_keypair').formats(create_keypair_format) do service.create_keypair(keypair_name).body end tests('#list_keypairs').formats(list_keypair_format) do service.list_keypairs.body end tests('#get_keypair').formats(get_keypair_format) do service.get_keypair(keypair_name).body end tests('#delete_keypair') do service.delete_keypair(keypair_name).body end end unknown_keypair_name = Fog::Mock.random_letters(32) tests('failure') do tests('#get_unknown_keypair').raises(Fog::Compute::RackspaceV2::NotFound) do service.get_keypair(unknown_keypair_name).body end tests('#delete_unknown_keypair').raises(Fog::Compute::RackspaceV2::NotFound) do service.delete_keypair(unknown_keypair_name).body end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/metadata_tests.rb 0000644 0000041 0000041 00000011147 13411315054 026637 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | metadata_tests', ['rackspace']) do @service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2') image_id = rackspace_test_image_id(@service) flavor_id = rackspace_test_flavor_id(@service) tests('success') do begin metadata = {"tag" => "database"} unless Fog.mocking? name = "fog-server-metadata-#{Time.now.to_i}" @server = @service.servers.create(:name => name, :flavor_id => flavor_id, :image_id => image_id, :metadata => metadata) @server.wait_for { ready? } @server_id = @server.id @image = @server.create_image(name, :metadata => metadata) @image_id = @image.id else @image_id = 1 @server_id = 1 end tests("servers") do tests('list_metadata').returns("metadata" => metadata) do @service.list_metadata("servers", @server_id).body end tests('set_metadata').returns("metadata" => {"environment" => "dev"}) do @service.set_metadata("servers", @server_id, {"environment" => "dev"}).body end tests('update_metadata').returns("metadata" => {"environment" => "dev", "tag" => "database"}) do @service.update_metadata("servers", @server_id, {"environment" => "dev", "tag" => "database"}).body end tests('get_metadata_item').returns("meta" => {"environment" => "dev"}) do @service.get_metadata_item("servers", @server_id, "environment").body end tests('set_metadata_item').returns("meta" => {"environment" => "test"}) do @service.set_metadata_item("servers", @server_id, "environment", "test").body end tests('delete_metadata_item').succeeds do @service.delete_metadata_item("servers", @server_id, "environment") end end tests("images") do @image.wait_for { ready? } unless Fog.mocking? tests('list_metadata').returns(metadata) do h = @service.list_metadata("images", @image_id).body h["metadata"].reject {|k,v| k.downcase != "tag"} #only look at the metadata we created end tests('set_metadata').returns({"environment" => "dev"}) do h = @service.set_metadata("images", @image_id, {"environment" => "dev"}).body h["metadata"].reject {|k,v| k.downcase != "environment"} #only look at the metadata we created end tests('update_metadata').returns({"environment" => "dev", "tag" => "database"}) do h = @service.update_metadata("images", @image_id, {"environment" => "dev", "tag" => "database"}).body h["metadata"].reject {|k,v| !['environment', 'tag'].include?(k.downcase)} #only look at the metadata we created end tests('get_metadata_item').returns("meta" => {"environment" => "dev"}) do @service.get_metadata_item("images", @image_id, "environment").body end tests('set_metadata_item').returns("meta" => {"environment" => "test"}) do @service.set_metadata_item("images", @image_id, "environment", "test").body end tests('delete_metadata_item').succeeds do @service.delete_metadata_item("images", @image_id, "environment") end end ensure @image.destroy if @image @server.destroy if @server end end tests('failure') do ['server', 'image'].each do |collection| tests(collection) do tests('list_metadata').raises(Fog::Compute::RackspaceV2::NotFound) do @service.list_metadata(collection, 0) end tests('set_server_metadata').raises(Fog::Compute::RackspaceV2::NotFound) do @service.set_metadata(collection, 0, {"environment" => "dev"}) end tests('update_server_metadata').raises(Fog::Compute::RackspaceV2::NotFound) do @service.update_metadata(collection, 0, {"environment" => "dev", "tag" => "database"}) end tests('get_server_metadata_item').raises(Fog::Compute::RackspaceV2::NotFound) do @service.get_metadata_item(collection, 0, "environment") end tests('set_server_metadata_item').raises(Fog::Compute::RackspaceV2::NotFound) do @service.set_metadata_item(collection, 0, "environment", "test") end tests('delete_server_metadata_item').raises(Fog::Compute::RackspaceV2::NotFound) do @service.delete_metadata_item(collection, 0, "environment") end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/virtual_interface_tests.rb 0000644 0000041 0000041 00000003152 13411315054 030562 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | virtual_interface_tests', ['rackspace']) do @service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2') virtual_interface_format = { "virtual_interfaces"=> [{ "ip_addresses"=> [{ "network_id"=> String, "network_label"=> String, "address"=> String }], "id"=> String, "mac_address"=> String }] } begin unless Fog.mocking? network_id = nil @server = @service.servers.create(:name => "fog_virtual_interface_test_#{Time.now.to_i.to_s}", :flavor_id => rackspace_test_flavor_id(@service), :image_id => rackspace_test_image_id(@service)) @server.wait_for { ready? } @network = @service.networks.create(:label => "fog_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24') end tests('success') do pending if Fog.mocking? tests('#create_virtual_interface').formats(virtual_interface_format) do response = @service.create_virtual_interface @server.id, @network.id body = response.body @virtual_network_interface_id = body["virtual_interfaces"].first["id"] body end tests('#list_virtual_interfaces').formats(virtual_interface_format) do @service.list_virtual_interfaces(@server.id).body end tests('#delete_virtual_interfaces').succeeds do @service.delete_virtual_interface(@server.id, @virtual_network_interface_id) end end ensure @server.destroy if @server delete_test_network @network end end fog-rackspace-0.1.6/tests/rackspace/requests/compute_v2/address_tests.rb 0000644 0000041 0000041 00000002721 13411315054 026502 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | address requests', ['rackspace']) do @service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2') image_id = rackspace_test_image_id(@service) flavor_id = rackspace_test_flavor_id(@service) tests('success') do unless Fog.mocking? @server = @service.servers.create(:flavor_id => flavor_id, :image_id => image_id, :name => "address-tests-#{Time.now.to_i}") @server.wait_for { ready? } @server_id = @server.id else @server_id = 42 end address_format = { "addresses"=> { "private" => [{"addr" => String, "version" => Integer}], "public" => [{"addr" => String, "version" => Integer }, {"addr"=> String, "version" => Integer}]} } begin tests("#list_addresses(#{@server_id})").formats(address_format) do @service.list_addresses(@server_id).body end tests("#list_addresses_by_network(#{@server_id}, 'private')").formats(address_format["addresses"].reject {|k,v| k != "private"}) do @service.list_addresses_by_network(@server_id, "private").body end ensure @server.destroy if @server end end tests('failure') do tests('#list_addresses(0)').raises(Fog::Compute::RackspaceV2::NotFound) do @service.list_addresses(0) end tests("#list_addresses_by_network(0, 'private')").raises(Fog::Compute::RackspaceV2::NotFound) do @service.list_addresses_by_network(0, 'private') end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/ 0000755 0000041 0000041 00000000000 13411315054 024152 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/content_caching_tests.rb 0000644 0000041 0000041 00000001372 13411315054 031052 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | content_caching', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do tests("#get_content_caching(#{@lb.id})").formats(CONTENT_CACHING_FORMAT) do @service.get_content_caching(@lb.id).body end @lb.wait_for { ready? } tests("#set_content_caching(#{@lb.id}, true)").succeeds do @service.set_content_caching(@lb.id, true) end end tests('failure') do tests("#set_content_caching(#{@lb.id}, 'aaa')").raises(Fog::Rackspace::LoadBalancers::InternalServerError) do @service.set_content_caching(@lb.id, 'aaa') end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/virtual_ip_tests.rb 0000644 0000041 0000041 00000002405 13411315054 030100 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | virtual_ip_tests', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests('#create_virtual_ip').formats(VIRTUAL_IP_FORMAT) do data = @service.create_virtual_ip(@lb.id, 'PUBLIC').body @virtual_ip_id = data['id'] data end @lb.wait_for { ready? } tests("list_virtual_ips").formats(VIRTUAL_IPS_FORMAT) do @service.list_virtual_ips(@lb.id).body end end tests('failure') do #TODO - I feel like this should really be a BadRequest, need to dig in tests('create_virtual_ip(invalid type)').raises(Fog::Rackspace::LoadBalancers::InternalServerError) do @service.create_virtual_ip(@lb.id, 'badtype') end tests('delete_virtual_ip(0)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.delete_virtual_ip(@lb.id, 0) end end tests('success') do @lb.wait_for { ready? } tests("#delete_virtual_ip(#{@lb.id}, #{@virtual_ip_id})").succeeds do @service.delete_virtual_ip(@lb.id, @virtual_ip_id) end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/usage_tests.rb 0000644 0000041 0000041 00000001003 13411315054 027017 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | usage', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do tests('success') do tests("#get_usage()").formats(USAGE_FORMAT) do pending # @service.get_usage.body end tests("#get_usage(:start_time => '2010-05-10', :end_time => '2010-05-11')").formats(USAGE_FORMAT) do pending # @service.get_usage(:start_time => '2010-05-10', :end_time => '2010-05-11').body end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/helper.rb 0000644 0000041 0000041 00000017540 13411315054 025765 0 ustar www-data www-data SINGLE_NODE_FORMAT = {'address' => String, 'id' => Integer, 'status' => String, 'weight' => Fog::Nullable::Integer, 'port' => Integer, 'condition' => String, 'type' => String} NODE_FORMAT = {'node' => SINGLE_NODE_FORMAT.merge({ 'metadata' => []})} NODES_FORMAT = {'nodes' => [SINGLE_NODE_FORMAT]} VIRTUAL_IP_FORMAT = {'type' => String, 'id' => Integer, 'type' => String, 'ipVersion' => String, 'address' => String} VIRTUAL_IPS_FORMAT = { 'virtualIps' => [VIRTUAL_IP_FORMAT] } SOURCE_ADDRESSES = { 'ipv4Servicenet' => String, 'ipv4Public' => String, 'ipv6Public' => String, } LOAD_BALANCER_USAGE_FORMAT = { 'links' => [ { 'otherAttributes' => [], 'href' => Fog::Nullable::String, 'rel' => Fog::Nullable::String } ], 'loadBalancerUsageRecords' => [ { 'id' => Fog::Nullable::Integer, 'eventType' => Fog::Nullable::String, 'averageNumConnections' => Fog::Nullable::Float, 'incomingTransfer' => Fog::Nullable::Integer, 'outgoingTransfer' => Fog::Nullable::Integer, 'numVips' => Fog::Nullable::Integer, 'numPolls' => Fog::Nullable::Integer, 'startTime' => Fog::Nullable::String, 'endTime' => Fog::Nullable::String, 'vipType' => Fog::Nullable::String, } ] } LOAD_BALANCER_STATS_FORMAT = { 'connectTimeOut' => Integer, 'connectError' => Integer, 'connectFailure' => Integer, 'dataTimedOut' => Integer, 'keepAliveTimedOut' => Integer, 'maxConn' => Integer } SSL_TERMINATION_FORMAT = { 'sslTermination' => { 'certificate' => String, 'privatekey' => String, 'enabled' => Fog::Boolean, 'securePort' => Integer, 'secureTrafficOnly' => Fog::Boolean, 'intermediateCertificate' => Fog::Nullable::String } } USAGE_FORMAT = { 'accountId' => Integer, 'loadBalancerUsages' => [ { 'loadBalancerId' => Fog::Nullable::Integer, 'loadBalancerName' => Fog::Nullable::String }.merge(LOAD_BALANCER_USAGE_FORMAT) ], 'accountUsage' => [ { 'startTime' => Fog::Nullable::String, 'numLoadBalancers' => Fog::Nullable::Integer, 'numPublicVips' => Fog::Nullable::Integer, 'numServicenetVips' => Fog::Nullable::Integer } ] } CONNECTION_LOGGING_FORMAT = { 'connectionLogging' => { 'enabled' => Fog::Boolean } } CONNECTION_THROTTLING_FORMAT = { 'connectionThrottle' => { 'maxConnections' => Fog::Nullable::Integer, 'minConnections' => Fog::Nullable::Integer, 'maxConnectionRate' => Fog::Nullable::Integer, 'rateInterval' => Fog::Nullable::Integer } } SESSION_PERSISTENCE_FORMAT = { 'sessionPersistence' => { 'persistenceType' => Fog::Nullable::String } } CONTENT_CACHING_FORMAT = { 'contentCaching' => { 'enabled' => Fog::Boolean } } ACCESS_LIST_FORMAT = { 'accessList' => [ { 'address' => String, 'id' => Integer, 'type' => String } ] } HEALTH_MONITOR_FORMAT = { 'healthMonitor' => { 'type' => Fog::Nullable::String, 'delay' => Fog::Nullable::Integer, 'timeout' => Fog::Nullable::Integer, 'attemptsBeforeDeactivation' => Fog::Nullable::Integer, 'path' => Fog::Nullable::String, 'bodyRegex' => Fog::Nullable::String, 'statusRegex' => Fog::Nullable::String } } STATUS_ACTIVE = 'ACTIVE' LOAD_BALANCERS_FORMAT = { 'loadBalancers' => [ { 'name' => String, 'id' => Integer, 'port' => Integer, 'protocol' => String, 'algorithm' => String, 'status' => String, 'virtualIps' => [VIRTUAL_IP_FORMAT], 'created' => { 'time' => String }, 'updated' => { 'time' => String }, 'nodeCount' => Integer }] } LOAD_BALANCERS_DETAIL_FORMAT = { 'loadBalancers' => [ { 'name' => String, 'id' => Integer, 'port' => Integer, 'protocol' => String, 'algorithm' => String, 'sourceAddresses' => SOURCE_ADDRESSES, 'status' => String, 'timeout' => Integer, 'virtualIps' => [VIRTUAL_IP_FORMAT], 'nodes' => [SINGLE_NODE_FORMAT], 'created' => { 'time' => String }, 'updated' => { 'time' => String } }] } LOAD_BALANCER_FORMAT = { 'loadBalancer' => { 'name' => String, 'id' => Integer, 'port' => Integer, 'protocol' => String, 'algorithm' => String, 'sourceAddresses' => SOURCE_ADDRESSES, 'status' => String, 'timeout' => Integer, 'cluster' => { 'name' => String }, 'virtualIps' => [VIRTUAL_IP_FORMAT], 'nodes' => Fog::Nullable::Array, 'created' => { 'time' => String }, 'updated' => { 'time' => String }, 'contentCaching' => { 'enabled' => Fog::Boolean } }.merge(CONNECTION_LOGGING_FORMAT) } ERROR_PAGE_FORMAT = { 'errorpage' => { 'content' => String } } PRIVATE_KEY = '-----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEAqSXePu8qLmniU7jNxoWq3SLkR8txMsl1gFYftpq7NIFaGfzV f4ZswYdEYDVWWRepQjS0TvsB0d5+usEUy/pcdZAlQLnn+540iLkvxKPVMzojUbG6 yOAmjC/xAZuExJHtfCrRHUQ4WQCwqyqANfP81y1inAb0zJGbtWUreV+nv8Ue77qX 77fOuqI6zOHinGZU7l25XGLcVUphgt8UtHZBzz2ahoftZ97DhUyQiSJQCaHXJd3Q eIHAq9qc7hu+usiYZWz34A0lw/gAl+RYcdvVc8kIwWxpiSieqqBPOwNzN5B0+9uu 5sDzMGMFnnSWcNKIPumX0rke3xFUl3UD6GJwvwIDAQABAoIBABQ7alT+yH3avm6j OUHYtTJUPRf1VqnrfPmH061E3sWN/1gCbQse6h1P77bOSnDHqsA3i6Wy0mnnAiOW esVXQf3x6vLOCdiH+OKtu+/6ZMMG3jikWKI0ZYf5KAu4LW5RwiVK/c5RXagPtBIV OFa7w299h0EAeAGMHSLaYhPXhDokyJa6yDkAQL3n+9L3V8kNWeCELfrqXnXF4X0K CJp622tS/fW6kzppJyLJ4GPkK9HNMpu02/n2Z7swWypfF+7set+9/aNTooDYWzCu dbnRgqEIG1IP8+t6HG6x9VujJVJLIW/WLITnQ/WTRXOQHBGhazgmwe1GPdxsQgXu /wIcsIkCgYEA8Si0q+QhmJyoAm8vTHjo6+DD06YYTvSODLJOpOqr1ncGGDJ/evBw x+9QsK3veXMbAK5G7Xss32IuXbBfjqQ89+/q/YT4BnS3T0OQa2WlR8tURNphCDr5 B3yD212kJTTehC+p7BI9zhnWXD9kImh4vm4XcOsC9iqOSCZkGfvRPRsCgYEAs46t Y85v2Pk235r1BPbgKwqYR+jElH4VWKu+EguUeQ4BlS47KktlLhvHtwrTv/UZ+lPx 8gSJTgyy7iEmzcGwPf1/MI5xg+DPgGhbr2G8EvrThmdHy+rPF2YSp1iBmJ4xq/1r 6XYKvf6ST3iujxTPU5xPEDUSLsH2ejJD/ddqSS0CgYEAkIdxyDa//8ObWWIjObSY +4zIMBcyKFeernNKeMH/3FeW+neBOT/Sh7CgblK/28ylWUIZVghlOzePTC0BB+7c b0eFUQ0YzF204rc+XW8coCt2xJEQaCtXxinUqGq1jmriFNyv/MBt9BA+DSkcrRZp js9SEyV1r+yPOyRvB7eIjhMCgYEAkd5yG+fkU1c6bfNb4/mPaUgFKD4AHUZEnzF+ ivhfWOy4+nGBXT285/VnjNs95O8AeK3jmyJ2TTLh1bSW6obUX7flsRO3QlTLHd0p xtPWT3D3kHOtDwslzDN/KfYr6klxvvB0z0e3OFxsjiVTYiecuqb8UAVdTSED1Ier Vre+v80CgYB86OqcAlR3diNaIwHgwK5kP2NAH1DaSwZXoobYpdkjsUQfJN5jwJbD 4/6HVydoc5xe0z8B+O1VUzC+QA0gdXgHbmLZBIUeQU8sE4hGELoe/eWULXGwI91M FyEWg03jZj8FkFh2954zwU6BOcbeL+9GrTdTPu1vuHoTitmNEye4iw== -----END RSA PRIVATE KEY-----' CERTIFICATE = '-----BEGIN CERTIFICATE----- MIIEWjCCA0KgAwIBAgIGATTTGu/tMA0GCSqGSIb3DQEBBQUAMHkxCzAJBgNVBAYT AlVTMQ4wDAYDVQQIEwVUZXhhczEOMAwGA1UEBxMFVGV4YXMxGjAYBgNVBAoTEVJh Y2tTcGFjZSBIb3N0aW5nMRQwEgYDVQQLEwtSYWNrRXhwIENBNTEYMBYGA1UEAxMP Y2E1LnJhY2tleHAub3JnMB4XDTEyMDExMjE4MDgwNVoXDTM5MDUzMDE4MDgwNVow gZcxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIEwVUZXhhczEUMBIGA1UEBxMLU2FuIEFu dG9uaW8xEDAOBgNVBAoTB1JhY2tFeHAxEDAOBgNVBAsTB1JhY2tEZXYxPjA8BgNV BAMMNW15c2l0ZS5jb20vZW1haWxBZGRyZXNzPXBoaWxsaXAudG9vaGlsbEByYWNr c3BhY2UuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqSXePu8q LmniU7jNxoWq3SLkR8txMsl1gFYftpq7NIFaGfzVf4ZswYdEYDVWWRepQjS0TvsB 0d5+usEUy/pcdZAlQLnn+540iLkvxKPVMzojUbG6yOAmjC/xAZuExJHtfCrRHUQ4 WQCwqyqANfP81y1inAb0zJGbtWUreV+nv8Ue77qX77fOuqI6zOHinGZU7l25XGLc VUphgt8UtHZBzz2ahoftZ97DhUyQiSJQCaHXJd3QeIHAq9qc7hu+usiYZWz34A0l w/gAl+RYcdvVc8kIwWxpiSieqqBPOwNzN5B0+9uu5sDzMGMFnnSWcNKIPumX0rke 3xFUl3UD6GJwvwIDAQABo4HIMIHFMIGjBgNVHSMEgZswgZiAFIkXQizRaftxVDaL P/Fb/F2ht017oX2kezB5MQswCQYDVQQGEwJVUzEOMAwGA1UECBMFVGV4YXMxDjAM BgNVBAcTBVRleGFzMRowGAYDVQQKExFSYWNrU3BhY2UgSG9zdGluZzEUMBIGA1UE CxMLUmFja0V4cCBDQTQxGDAWBgNVBAMTD2NhNC5yYWNrZXhwLm9yZ4IBAjAdBgNV HQ4EFgQUQUXHjce1JhjJDA4nhYcbebMrIGYwDQYJKoZIhvcNAQEFBQADggEBACLe vxcDSx91uQoc1uancb+vfkaNpvfAxOkUtrdRSHGXxvUkf/EJpIyG/M0jt5CLmEpE UedeCFlRN+Qnsqt589ZemWWJwth/Jbu0wQodfSo1cP0J2GFZDyTd5cWgm0IxD8A/ ZRGzNnTx3xskv6/lOh7so9ULppEbOsZTNqQ4ahbxbiaR2iDTQGF3XKSHha8O93RB YlnFahKZ2j0CpYvg0lJjfN0Lvj7Sm6GBA74n2OrGuB14H27wklD+PtIEFniyxKbq 5TDO0l4yDgkR7PsckmZqK22GP9c3fQkmXodtpV1wRjcSAxxVWYm+S24XvMFERs3j yXEf+VJ0H+voAvxgbAk= -----END CERTIFICATE-----' fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/connection_logging_tests.rb 0000644 0000041 0000041 00000001422 13411315054 031565 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | connection_logging', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do tests("#get_connection_logging(#{@lb.id})").formats(CONNECTION_LOGGING_FORMAT) do @service.get_connection_logging(@lb.id).body end @lb.wait_for { ready? } tests("#set_connection_logging(#{@lb.id}, true)").succeeds do @service.set_connection_logging(@lb.id, true) end end tests('failure') do tests("#set_connection_logging(#{@lb.id}, 'aaa')").raises(Fog::Rackspace::LoadBalancers::InternalServerError) do @service.set_connection_logging(@lb.id, 'aaa') end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/algorithm_tests.rb 0000644 0000041 0000041 00000000603 13411315054 027706 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | algorithm_tests', ['rackspace']) do pending if Fog.mocking? ALGORITHMS_FORMAT = { 'algorithms' => [ { 'name' => String } ]} @service = Fog::Rackspace::LoadBalancers.new tests('success') do tests('#list_algorithms').formats(ALGORITHMS_FORMAT) do @service.list_algorithms.body end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/error_page_tests.rb 0000644 0000041 0000041 00000001631 13411315054 030047 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | error_page', ['rackspace', 'loadbalancers']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests("#get_error_page(#{@lb.id})").formats(ERROR_PAGE_FORMAT) do @service.get_error_page(@lb.id).body end @lb.wait_for { ready? } tests("#set_error_page(#{@lb.id}, '
hi!')").succeeds do @service.set_error_page(@lb.id, 'hi!') end @lb.wait_for { ready? } tests("#get_error_page(#{@lb.id})").formats(ERROR_PAGE_FORMAT) do @service.get_error_page(@lb.id).body end @lb.wait_for { ready? } tests("#remove_error_page()").succeeds do @service.remove_error_page(@lb.id) end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/access_list_tests.rb 0000644 0000041 0000041 00000004054 13411315054 030220 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | access_lists_tests', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests("#create_access_rule(#{@lb.id}, '67.0.0.1','ALLOW')").succeeds do @service.create_access_rule(@lb.id, '67.0.0.1', 'ALLOW').body end @lb.wait_for { ready? } tests("list_access_rules").formats(ACCESS_LIST_FORMAT) do data = @service.list_access_rules(@lb.id).body returns(1) { data.size } @access_list_id = data['accessList'].first['id'] data end @lb.wait_for {ready? } tests("delete_access_rule(#{@lb.id}, #{@access_list_id}").succeeds do @service.delete_access_rule(@lb.id, @access_list_id) end @lb.wait_for {ready? } tests("delete_all_access_rules(#{@lb.id})").succeeds do #This could be refactored once we can add multiple access rules at once @service.create_access_rule(@lb.id, '67.0.0.2', 'ALLOW') @lb.wait_for {ready? } @service.create_access_rule(@lb.id, '67.0.0.3', 'ALLOW') @lb.wait_for {ready? } returns(2) { @service.list_access_rules(@lb.id).body['accessList'].size } @service.delete_all_access_rules(@lb.id) @lb.wait_for {ready? } returns(0) { @service.list_access_rules(@lb.id).body['accessList'].size } end end tests('failure') do tests('create_access_rule(invalid ip)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.create_access_rule(@lb.id, '', 'ALLOW') end tests('create_access_rule(invalid type)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.create_access_rule(@lb.id, '10.10.10.10', 'ENABLED') end tests("delete_access_rule(#{@lb.id}, 0)").raises(Fog::Rackspace::LoadBalancers::NotFound) do @service.delete_access_rule(@lb.id, 0) end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/connection_throttling_tests.rb 0000644 0000041 0000041 00000002321 13411315054 032334 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | connection_throttling', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests("#get_connection_throttling(#{@lb.id})").formats(CONNECTION_THROTTLING_FORMAT) do @service.get_connection_throttling(@lb.id).body end @lb.wait_for { ready? } tests("#set_connection_throttling(#{@lb.id}, 10, 10, 10, 30)").succeeds do @service.set_connection_throttling(@lb.id, 10, 10, 10, 30) end @lb.wait_for { ready? } tests("#get_connection_throttling(#{@lb.id})").formats(CONNECTION_THROTTLING_FORMAT) do @service.get_connection_throttling(@lb.id).body end @lb.wait_for { ready? } tests("#remove_connection_throttling()").succeeds do @service.remove_connection_throttling(@lb.id) end end tests('failure') do tests("#set_connection_throttling(#{@lb.id}, -1, -1, -1, -1)").raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.set_connection_throttling(@lb.id, -1, -1, -1, -1) end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/protocol_tests.rb 0000644 0000041 0000041 00000000631 13411315054 027562 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | protocol_tests', ['rackspace']) do pending if Fog.mocking? PROTOCOLS_FORMAT = { 'protocols' => [ { 'name' => String, 'port' => Integer } ]} @service = Fog::Rackspace::LoadBalancers.new tests('success') do tests('#list_protocols').formats(PROTOCOLS_FORMAT) do @service.list_protocols.body end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/load_balancer_tests.rb 0000644 0000041 0000041 00000006535 13411315054 030500 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer_tests', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do tests('success') do @lb_id = nil @lb_ids = [] @lb_name = 'fog' + Time.now.to_i.to_s tests("#create_load_balancer(#{@lb_name}, 'HTTP')").formats(LOAD_BALANCER_FORMAT) do data = @service.create_load_balancer(@lb_name, 'HTTP').body @lb_id = data['loadBalancer']['id'] @lb_ids << @lb_id data end tests("#create_load_balancer(#{@lb_name}, 'HTTP', 80,...)").formats(LOAD_BALANCER_FORMAT) do data = @service.create_load_balancer(@lb_name, 'HTTP', 80, [{ :type => 'PUBLIC' }], [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED' }]).body @lb_ids << data['loadBalancer']['id'] data end tests("#create_load_balancer(#{@lb_name}, 'HTTP', 80,...with algorithm)").formats(LOAD_BALANCER_FORMAT) do data = @service.create_load_balancer(@lb_name, 'HTTP', 80, [{ :type => 'PUBLIC'}], [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}], { :algorithm => 'LEAST_CONNECTIONS', :timeout => 30 }).body @lb_ids << data['loadBalancer']['id'] returns('LEAST_CONNECTIONS') { data['loadBalancer']['algorithm'] } returns(30) { data['loadBalancer']['timeout'] } data end tests("#update_load_balancer(#{@lb_id}) while immutable").raises(Fog::Rackspace::LoadBalancers::ServiceError) do @service.update_load_balancer(@lb_id, { :port => 80 }).body end tests("#get_load_balancer(#{@lb_id})").formats(LOAD_BALANCER_FORMAT) do @service.get_load_balancer(@lb_id).body end tests("#list_load_balancers()").formats(LOAD_BALANCERS_FORMAT) do @service.list_load_balancers.body end until @service.get_load_balancer(@lb_id).body["loadBalancer"]["status"] == STATUS_ACTIVE sleep 10 end tests("#list_load_balancers({:node_address => '1.1.1.1'})").formats(LOAD_BALANCERS_FORMAT) do @service.list_load_balancers({:node_address => '1.1.1.1'}).body end tests("#update_load_balancer(#{@lb_id}, { :port => 80 })").succeeds do @service.update_load_balancer(@lb_id, { :port => 80 }).body end until @service.get_load_balancer(@lb_id).body["loadBalancer"]["status"] == STATUS_ACTIVE sleep 10 end @lb_ids.each do |id| tests("#delete_load_balancer(#{id})").succeeds do @service.delete_load_balancer(id).body end end end tests('failure') do tests('#create_load_balancer(invalid name)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.create_load_balancer('', 'HTTP', 80, [{ :type => 'PUBLIC'}], [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}]) end tests('#get_load_balancer(0)').raises(Fog::Rackspace::LoadBalancers::NotFound) do @service.get_load_balancer(0) end tests('#delete_load_balancer(0)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.delete_load_balancer(0) end tests('#update_load_balancer(0)').raises(Fog::Rackspace::LoadBalancers::NotFound) do @service.update_load_balancer(0, { :name => 'newname' }) end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/node_tests.rb 0000644 0000041 0000041 00000007017 13411315054 026653 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | node_tests', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do @nodes_created = [] tests('success') do @lb.wait_for { ready? } tests("#create_node(#{@lb.id}, '1.1.1.2', 80, 'ENABLED')").formats(NODES_FORMAT) do data = @service.create_node(@lb.id, '1.1.1.2', 80, 'ENABLED').body @nodes_created << data['nodes'][0]['id'] data end @lb.wait_for { ready? } tests('#create_node with weight').formats(NODES_FORMAT) do data = @service.create_node(@lb.id, '1.1.1.3', 80, 'ENABLED', { :weight => 10 }).body @nodes_created << data['nodes'][0]['id'] data end @lb.wait_for { ready? } tests('#create_node with type').formats(NODES_FORMAT) do data = @service.create_node(@lb.id, '1.1.1.4', 80, 'ENABLED', { :type => 'PRIMARY' }).body @nodes_created << data['nodes'][0]['id'] data end @lb.wait_for { ready? } tests("#list_nodes(#{@lb.id})").formats(NODES_FORMAT) do @service.list_nodes(@lb.id).body end @lb.wait_for { ready? } tests("#get_node(#{@lb.id})").formats(NODE_FORMAT) do @service.get_node(@lb.id, @nodes_created[0]).body end @lb.wait_for { ready? } tests("#update_node(#{@lb.id}, #{@nodes_created[0]}, { :condition => 'DISABLED' })").succeeds do @service.update_node(@lb.id, @nodes_created[0], { :condition => 'DISABLED' }) end @lb.wait_for { ready? } tests("#update_node(#{@lb.id}, #{@nodes_created[0]}, { :weight => 20})").succeeds do @service.update_node(@lb.id, @nodes_created[0], { :weight => 20 }) end @lb.wait_for { ready? } tests("#update_node(#{@lb.id}, #{@nodes_created[0]}, { :condition => 'DISABLED', :weight => 20 })").succeeds do @service.update_node(@lb.id, @nodes_created[0], { :condition => 'DISABLED', :weight => 20 }) end end tests('failure') do tests('#create_node(invalid ip)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.create_node(@lb.id, '', 80, 'ENABLED') end tests('#create_node(invalid condition)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.create_node(@lb.id, '1.1.1.2', 80, 'EABLED') end tests("#get_node(#{@lb.id}, 0)").raises(Fog::Rackspace::LoadBalancers::NotFound) do @service.get_node(@lb.id, 0) end tests("#delete_node(#{@lb.id}, 0)").raises(Fog::Rackspace::LoadBalancers::NotFound) do @service.delete_node(@lb.id, 0) end tests("#delete_nodes('a', 'b')").raises(Fog::Rackspace::LoadBalancers::NotFound) do @service.delete_nodes(@lb.id, 'a', 'b') end tests("#update_node(#{@lb.id}, 0, { :weight => 20 })").raises(Fog::Rackspace::LoadBalancers::NotFound) do @service.update_node(@lb.id, 0, { :weight => 20 }) end end tests('success') do @lb.wait_for { ready? } tests("#delete_nodes(multiple node)").succeeds do @service.delete_nodes(@lb.id, *@nodes_created) end @lb.wait_for { ready? } tests("#delete_node()").succeeds do node_id = @service.create_node(@lb.id, '1.1.1.3', 80, 'ENABLED').body['nodes'][0]['id'] @lb.wait_for { ready? } @service.delete_node(@lb.id, node_id) end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/session_persistence_tests.rb 0000644 0000041 0000041 00000002110 13411315054 032002 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | session_persistence', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests("#set_session_persistence(#{@lb.id}, 'HTTP_COOKIE')").succeeds do @service.set_session_persistence(@lb.id, 'HTTP_COOKIE') end @lb.wait_for { ready? } tests("#get_session_persistence{@lb.id})").formats(SESSION_PERSISTENCE_FORMAT) do data = @service.get_session_persistence(@lb.id).body returns('HTTP_COOKIE') { data['sessionPersistence']['persistenceType'] } data end @lb.wait_for { ready? } tests("#remove_session_persistence()").succeeds do @service.remove_session_persistence(@lb.id) end end tests('failure') do tests("#set_session_persistence(#{@lb.id}, 'aaa')").raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.set_session_persistence(@lb.id, 'aaa') end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/get_stats_tests.rb 0000644 0000041 0000041 00000000565 13411315054 027724 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer_get_stats', ['rackspace']) do given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests("#get_stats(#{@lb.id})").formats(LOAD_BALANCER_STATS_FORMAT) do @service.get_stats(@lb.id).body end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/ssl_termination_tests.rb 0000644 0000041 0000041 00000002314 13411315054 031133 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | ssl_termination', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests("#set_ssl_termination(#{@lb.id}, 443, PRIVATE_KEY, CERTIFICATE)").succeeds do @service.set_ssl_termination(@lb.id, 443, PRIVATE_KEY, CERTIFICATE) end @lb.wait_for { ready? } tests("#get_ssl_termination(#{@lb.id})").formats(SSL_TERMINATION_FORMAT) do @service.get_ssl_termination(@lb.id).body end @lb.wait_for { ready? } tests("#remove_ssl_termination(#{@lb.id})").succeeds do @service.remove_ssl_termination(@lb.id).body end end tests('failure') do @lb.wait_for { ready? } tests("#get_ssl_termination(#{@lb.id})").raises(Fog::Rackspace::LoadBalancers::NotFound) do @service.get_ssl_termination(@lb.id).body end tests("#set_ssl_termination(#{@lb.id}, 443, '', CERTIFICATE)").raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.set_ssl_termination(@lb.id, 443, '', CERTIFICATE) end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/load_balancer_usage_tests.rb 0000644 0000041 0000041 00000001222 13411315054 031650 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer_usage', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests("#get_usage(#{@lb.id})").formats(LOAD_BALANCER_USAGE_FORMAT) do @service.get_load_balancer_usage(@lb.id).body end tests("#get_usage(:start_time => '2010-05-10', :end_time => '2010-05-11')").formats(LOAD_BALANCER_USAGE_FORMAT) do @service.get_load_balancer_usage(@lb.id, :start_time => '2010-05-10', :end_time => '2010-05-11').body end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/load_balancers/monitor_tests.rb 0000644 0000041 0000041 00000003022 13411315054 027405 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | monitor', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do tests('success') do @lb.wait_for { ready? } tests("#get_monitor(#{@lb.id})").formats(HEALTH_MONITOR_FORMAT) do @service.get_monitor(@lb.id).body end @lb.wait_for { ready? } tests("#set_monitor(#{@lb.id}, 'CONNECT', 5, 5, 5)").succeeds do @service.set_monitor(@lb.id, 'CONNECT', 5, 5, 5) end @lb.wait_for { ready? } tests("#set_monitor(#{@lb.id}, 'HTTP', 5, 5, 5, :path => '/', :body_regex => '^200$', :status_regex => '^2[0-9][0-9]$')").succeeds do @service.set_monitor(@lb.id, 'HTTP', 5, 5, 5, :path => '/', :body_regex => '^200$', :status_regex => '2[0-9][0-9]$') end @lb.wait_for { ready? } tests("#get_monitor(#{@lb.id})").formats(HEALTH_MONITOR_FORMAT) do @service.get_monitor(@lb.id).body end @lb.wait_for { ready? } tests("#remove_monitor()").succeeds do @service.remove_monitor(@lb.id) end end tests('failure') do tests("#set_monitor(#{@lb.id}, 'HTP', 5, 5, 5, 5)").raises(Fog::Rackspace::LoadBalancers::BadRequest) do @service.set_monitor(@lb.id, 5, 5, 5, 5) end tests("#remove_monitor(#{@lb.id}) => No Monitor").raises(Fog::Rackspace::LoadBalancers::ServiceError) do @service.remove_monitor(@lb.id) end end end end end fog-rackspace-0.1.6/tests/rackspace/requests/block_storage/ 0000755 0000041 0000041 00000000000 13411315054 024037 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/block_storage/volume_type_tests.rb 0000644 0000041 0000041 00000001124 13411315054 030154 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage | volume_type_tests', ['rackspace']) do volume_type_format = { 'name' => String, 'extra_specs' => Hash, 'id' => String } service = Fog::Rackspace::BlockStorage.new tests('success') do volume_type_id = service.volume_types.first.id tests("#list_volume_types").formats('volume_types' => [volume_type_format]) do service.list_volume_types.body end tests("#get_volume_type(#{volume_type_id})").formats('volume_type' => volume_type_format) do service.get_volume_type(volume_type_id).body end end end fog-rackspace-0.1.6/tests/rackspace/requests/block_storage/volume_tests.rb 0000644 0000041 0000041 00000003674 13411315054 027127 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage | volume_tests', ['rackspace']) do volume_format = { 'id' => String, 'status' => String, 'display_name' => Fog::Nullable::String, 'display_description' => Fog::Nullable::String, 'size' => Integer, 'created_at' => String, 'volume_type' => String, 'availability_zone' => String, 'snapshot_id' => Fog::Nullable::String, 'image_id' => Fog::Nullable::String, 'attachments' => Array, 'metadata' => Hash } get_volume_format = { 'volume' => volume_format } list_volume_format = { 'volumes' => [volume_format] } service = Fog::Rackspace::BlockStorage.new tests('success') do ids = [] size = 100 tests("#create_volume(#{size})").formats(get_volume_format) do data = service.create_volume(size).body ids << data['volume']['id'] data end tests("#create_volume for a bootable volume").formats(get_volume_format) do # Find a suitable image. image_id = rackspace_test_image_id(Fog::Compute.new(:provider => 'rackspace')) data = service.create_volume(size, :image_id => image_id).body tests("assigned an image id").returns(image_id) do data['volume']['image_id'] end ids << data['volume']['id'] data end tests("#list_volumes").formats(list_volume_format) do service.list_volumes.body end tests("#get_volume(#{ids.first})").formats(get_volume_format) do service.get_volume(ids.first).body end ids.each do |id| tests("#delete_volume(#{id})").succeeds do wait_for_volume_state(service, id, 'available') service.delete_volume(id) end end end tests('failure') do tests("#create_volume(-1)").raises(Fog::Rackspace::BlockStorage::BadRequest) do service.create_volume(-1) end tests("#get_volume(-1)").raises(Fog::Rackspace::BlockStorage::NotFound) do service.get_volume(-1) end end end fog-rackspace-0.1.6/tests/rackspace/requests/block_storage/snapshot_tests.rb 0000644 0000041 0000041 00000003733 13411315054 027453 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage | snapshot_tests', ['rackspace']) do timeout = Fog.mocking? ? 1 : 10 snapshot_format = { 'id' => String, 'status' => String, 'display_name' => Fog::Nullable::String, 'display_description' => Fog::Nullable::String, 'volume_id' => String, 'size' => Integer, 'created_at' => String } get_snapshot_format = { 'snapshot' => snapshot_format } list_snapshot_format = { 'snapshots' => [snapshot_format] } def snapshot_deleted?(service, snapshot_id) begin service.get_snapshot(snapshot_id) false rescue true end end service = Fog::Rackspace::BlockStorage.new tests('success') do volume = service.create_volume(100).body['volume'] volume_id = volume['id'] snapshot_id = nil until service.get_volume(volume_id).body['volume']['status'] == 'available' sleep timeout end tests("#create_snapshot(#{volume_id})").formats(get_snapshot_format) do service.create_snapshot(volume_id).body.tap do |b| snapshot_id = b['snapshot']['id'] end end tests("#list_snapshots").formats(list_snapshot_format) do service.list_snapshots.body end tests("#get_snapshot(#{snapshot_id})").formats(get_snapshot_format) do service.get_snapshot(snapshot_id).body end until service.get_snapshot(snapshot_id).body['snapshot']['status'] == 'available' do sleep timeout end tests("#delete_snapshot(#{snapshot_id})").succeeds do service.delete_snapshot(snapshot_id) end until snapshot_deleted?(service, snapshot_id) sleep timeout end service.delete_volume(volume_id) end tests('failure') do tests("#create_snapshot('invalid')").raises(Fog::Rackspace::BlockStorage::NotFound) do service.create_snapshot('invalid') end tests("#get_snapshot('invalid')").raises(Fog::Rackspace::BlockStorage::NotFound) do service.get_snapshot('invalid') end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute/ 0000755 0000041 0000041 00000000000 13411315054 022675 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/compute/helper.rb 0000644 0000041 0000041 00000000226 13411315054 024501 0 ustar www-data www-data class Rackspace module Compute module Formats SUMMARY = { 'id' => Integer, 'name' => String } end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute/image_tests.rb 0000644 0000041 0000041 00000003652 13411315054 025534 0 ustar www-data www-data Shindo.tests('Fog::Compute[:rackspace] | image requests', ['rackspace']) do @image_format = { 'created' => Fog::Nullable::String, 'id' => Integer, 'name' => String, 'progress' => Fog::Nullable::Integer, 'serverId' => Fog::Nullable::Integer, 'status' => String, 'updated' => String } @service = Fog::Compute.new(:provider => :rackspace, :version => :v1) tests('success') do @server = @service.servers.create(:flavor_id => 1, :image_id => 19) @server.wait_for { ready? } @image_id = nil tests("#create_image(#{@server.id})").formats(@image_format) do data = @service.create_image(@server.id).body['image'] @image_id = data['id'] data end unless Fog.mocking? @service.images.get(@image_id).wait_for { ready? } end tests("#get_image_details(#{@image_id})").formats(@image_format) do pending if Fog.mocking? @service.get_image_details(@image_id).body['image'] end tests('#list_images').formats({'images' => [Rackspace::Compute::Formats::SUMMARY]}) do @service.list_images.body end tests('#list_images_detail').formats({'images' => [@image_format]}) do @service.list_images_detail.body end unless Fog.mocking? @service.images.get(@image_id).wait_for { ready? } end tests("#delete_image(#{@image_id})").succeeds do pending if Fog.mocking? # because it will fail without the wait just above here, which won't work @service.delete_image(@image_id) end @server.destroy end tests('failure') do tests('#delete_image(0)').raises(Fog::Compute::Rackspace::NotFound) do @service.delete_image(Fog::Rackspace::MockData::NOT_FOUND_ID) end tests('#get_image_details(0)').raises(Fog::Compute::Rackspace::NotFound) do pending if Fog.mocking? @service.get_image_details(Fog::Rackspace::MockData::NOT_FOUND_ID) end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute/resize_tests.rb 0000644 0000041 0000041 00000002264 13411315054 025751 0 ustar www-data www-data Shindo.tests('Fog::Compute[:rackspace] | resize request', ['rackspace']) do @service = Fog::Compute.new(:provider => :rackspace, :version => :v1) @confirm_server = @service.servers.create(:flavor_id => 1, :image_id => 19) @revert_server = @service.servers.create(:flavor_id => 1, :image_id => 19) @confirm_server.wait_for { ready? } tests("#resize_server(#{@confirm_server.id}, 2) # to confirm").succeeds do @service.resize_server(@confirm_server.id, 2) end @revert_server.wait_for { ready? } tests("#resize_server(#{@revert_server.id}, 2) # to revert").succeeds do @service.resize_server(@revert_server.id, 2) end @confirm_server.wait_for { state == 'VERIFY_RESIZE' } tests("#confirm_resized_server(#{@confirm_server.id})").succeeds do @service.confirm_resized_server(@confirm_server.id) end @revert_server.wait_for { state == 'VERIFY_RESIZE' } tests("#revert_resized_server(#{@revert_server.id})").succeeds do @service.revert_resized_server(@revert_server.id) end @confirm_server.wait_for { ready? } @confirm_server.destroy @revert_server.wait_for { ready? } @revert_server.destroy end fog-rackspace-0.1.6/tests/rackspace/requests/compute/server_tests.rb 0000644 0000041 0000041 00000005335 13411315054 025760 0 ustar www-data www-data Shindo.tests('Fog::Compute[:rackspace] | server requests', ['rackspace']) do @server_format = { 'addresses' => { 'private' => [String], 'public' => [String] }, 'flavorId' => Integer, 'hostId' => String, 'id' => Integer, 'imageId' => Integer, 'metadata' => {}, 'name' => String, 'progress' => Integer, 'status' => String } @service = Fog::Compute.new(:provider => :rackspace, :version => :v1) tests('success') do @server_id = nil tests('#create_server(1, 19)').formats(@server_format.merge('adminPass' => String)) do # 1 => 256MB, 19 => Gentoo data = @service.create_server(1, 19).body['server'] @server_id = data['id'] data end @service.servers.get(@server_id).wait_for { ready? } tests("#get_server_details(#{@server_id})").formats(@server_format) do @service.get_server_details(@server_id).body['server'] end tests('#list_servers').formats({'servers' => [Rackspace::Compute::Formats::SUMMARY]}) do @service.list_servers.body end tests('#list_servers_detail').formats({'servers' => [@server_format]}) do @service.list_servers_detail.body end @service.servers.get(@server_id).wait_for { ready? } tests("#update_server(#{@server_id}, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')").succeeds do @service.update_server(@server_id, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver') end @service.servers.get(@server_id).wait_for { ready? } tests("#reboot_server(#{@server_id}, 'HARD')").succeeds do pending if Fog.mocking? @service.reboot_server(@server_id, 'HARD') end @service.servers.get(@server_id).wait_for { ready? } tests("#reboot_server(#{@server_id}, 'SOFT')").succeeds do pending if Fog.mocking? @service.reboot_server(@server_id, 'SOFT') end @service.servers.get(@server_id).wait_for { ready? } tests("#delete_server(#{@server_id})").succeeds do @service.delete_server(@server_id) end end tests('failure') do tests('#delete_server(0)').raises(Fog::Compute::Rackspace::NotFound) do @service.delete_server(0) end tests('#get_server_details(0)').raises(Fog::Compute::Rackspace::NotFound) do @service.get_server_details(0) end tests("#update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')").raises(Fog::Compute::Rackspace::NotFound) do @service.update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver') end tests('#reboot_server(0)').raises(Fog::Compute::Rackspace::NotFound) do pending if Fog.mocking? @service.reboot_server(0) end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute/flavor_tests.rb 0000644 0000041 0000041 00000001713 13411315054 025737 0 ustar www-data www-data Shindo.tests('Fog::Compute[:rackspace] | flavor requests', ['rackspace']) do @flavor_format = { 'disk' => Integer, 'id' => Integer, 'name' => String, 'ram' => Integer } @service = Fog::Compute.new(:provider => :rackspace, :version => :v1) tests('success') do tests('#get_flavor_details(1)').formats(@flavor_format) do pending if Fog.mocking? @service.get_flavor_details(1).body['flavor'] end tests('#list_flavors').formats({'flavors' => [Rackspace::Compute::Formats::SUMMARY]}) do pending if Fog.mocking? @service.list_flavors.body end tests('#list_flavors_detail').formats({'flavors' => [@flavor_format]}) do pending if Fog.mocking? @service.list_flavors_detail.body end end tests('failure') do tests('#get_flavor_details(0)').raises(Fog::Compute::Rackspace::NotFound) do pending if Fog.mocking? @service.get_flavor_details(0) end end end fog-rackspace-0.1.6/tests/rackspace/requests/compute/address_tests.rb 0000644 0000041 0000041 00000002265 13411315054 026076 0 ustar www-data www-data Shindo.tests('Fog::Compute[:rackspace] | address requests', ['rackspace']) do @service = Fog::Compute.new(:provider => :rackspace, :version => :v1) tests('success') do @server = @service.servers.create(:flavor_id => 1, :image_id => 19) tests("#list_addresses(#{@server.id})").formats({'addresses' => {'private' => [String], 'public' => [String]}}) do @service.list_addresses(@server.id).body end tests("#list_private_addresses(#{@server.id})").formats({'private' => [String]}) do @service.list_private_addresses(@server.id).body end tests("#list_public_addresses(#{@server.id})").formats({'public' => [String]}) do @service.list_public_addresses(@server.id).body end @server.wait_for { ready? } @server.destroy end tests('failure') do tests('#list_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do @service.list_addresses(0) end tests('#list_private_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do @service.list_private_addresses(0) end tests('#list_public_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do @service.list_public_addresses(0) end end end fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/ 0000755 0000041 0000041 00000000000 13411315054 023406 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/helper.rb 0000644 0000041 0000041 00000006065 13411315054 025221 0 ustar www-data www-data MINIMAL_HEADERS_FORMAT = { 'X-RateLimit-Window' => String, 'X-RateLimit-Limit' => String, 'X-RateLimit-Type' => String, 'Content-Type' => String, 'Date' => String, } DELETE_HEADERS_FORMAT = MINIMAL_HEADERS_FORMAT.merge({ 'Content-Length' => String }) HEADERS_FORMAT = MINIMAL_HEADERS_FORMAT.merge({ 'Content-Length' => String, 'X-Object-ID' => String, 'Location' => String }) LIST_HEADERS_FORMAT = MINIMAL_HEADERS_FORMAT.merge({ 'X-RateLimit-Remaining' => String, 'X-Response-Id' => String, 'Transfer-Encoding' => String, 'X-LB' => String, 'Vary' => String }) DATA_FORMAT = { :status => Integer, :body => String, :headers => HEADERS_FORMAT, :remote_ip => String } DELETE_DATA_FORMAT = { :status => Integer, :body => String, :headers => DELETE_HEADERS_FORMAT, :remote_ip => String } LIST_MONITORING_ZONE = { "values"=> [{"id"=>String, "label"=> Fog::Nullable::String, "country_code"=> String, "source_ips"=>[String, String]}], "metadata"=> {"count"=>Integer, "limit"=>Integer, "marker"=>Fog::Nullable::String, "next_marker"=>Fog::Nullable::String, "next_href"=>Fog::Nullable::String } } GET_MONITORING_ZONE = { "id" => String, "label" => String, "country_code" => String, "source_ips" => [String] } # {"values"=> # [{"id"=>"ch4GimHQsQ", # "label"=>nil, # "type"=>"remote.http", # "details"=> # {"url"=>"http://www.rackspace.com", # "method"=>"GET", # "follow_redirects"=>true, # "include_body"=>false}, # "monitoring_zones_poll"=>["mzdfw"], # "timeout"=>30, # "period"=>100, # "target_alias"=>nil, # "target_hostname"=>"rackspace.com", # "target_resolver"=>"IPv4", # "disabled"=>false, # "collectors"=>["coeT7x1iF3"], # "metadata"=>nil, # "created_at"=>1377803830760, # "updated_at"=>1377803830760}], # "metadata"=> # {"count"=>1, # "limit"=>100, # "marker"=>nil, # "next_marker"=>nil, # "next_href"=>nil}} # {"values"=> # [{"id"=>String, # "label"=>String, # "country_code"=>String, # "source_ips"=>[String, String]}], # "metadata"=> # {"count"=>Integer, # "limit"=>Integer, # "marker"=>nil, # "next_marker"=>nil, # "next_href"=>nil}} CHECK_CREATE_OPTIONS = { :details => { :url => 'http://www.rackspace.com', :method => 'GET', }, :type => 'remote.http', :monitoring_zones_poll => ['mzdfw'], :target_hostname => 'rackspace.com', :timeout => 30, :period => 100 } OVERVIEW_FORMAT = { :status => Integer, :body=> { :values => [ { :entity => { :id => String, :label => String, :ip_addresses => { }, :metadata => String }, :checks => [ ], :alarms => [ ], :latest_alarm_states => [ ] } ], :metadata => { :count => Integer, :limit => Integer, :marker => String, :next_marker => String, :next_href => String } }, :headers => LIST_HEADERS_FORMAT, :remote_ip => String } fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/alarm_tests.rb 0000644 0000041 0000041 00000004243 13411315054 026254 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | alarm_tests', ['rackspace','rackspace_monitoring']) do account = Fog::Rackspace::Monitoring.new entity_id = account.create_entity(:label => "Foo").data[:headers]["X-Object-ID"] check_id = account.create_check(entity_id, CHECK_CREATE_OPTIONS).data[:headers]["X-Object-ID"] alarm_id = nil np = "npTechnicalContactsEmail" tests('success') do tests('#create new alarm').formats(DATA_FORMAT) do alarm_criteria = "if (metric['code'] == '404') { return new AlarmStatus(CRITICAL, 'Page not found');}" options = { :check_id => check_id, :notification_plan_id => np, :criteria => alarm_criteria } response = account.create_alarm(entity_id,options).data alarm_id = response[:headers]["X-Object-ID"] response end tests('#update alarm').formats(DATA_FORMAT) do options = { :label => "Bar"} account.update_alarm(entity_id,alarm_id,options).data end tests('#list alarms').formats(LIST_HEADERS_FORMAT) do account.list_alarms(entity_id).data[:headers] end tests('#get alarm').formats(LIST_HEADERS_FORMAT) do account.get_alarm(entity_id,alarm_id).data[:headers] end tests('#delete alarm').formats(DELETE_DATA_FORMAT) do account.delete_alarm(entity_id,alarm_id).data end end tests('failure') do tests('#fail to create new alarm(-1)').raises(Fog::Rackspace::Monitoring::BadRequest) do account.create_alarm(entity_id, {:type => ""}) end tests('#fail to update invalid alarm(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do options = { :testing => "Bar" } response = account.update_alarm(-1,-1,options) end tests('#fail to list alarms').raises(Fog::Rackspace::Monitoring::NotFound) do account.list_alarms(-1) end tests('#fail to get alarm').raises(Fog::Rackspace::Monitoring::NotFound) do account.get_alarm(-1,-1) end tests('#fail to delete alarm(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do account.delete_alarm(-1,-1) end end account.delete_check(entity_id,check_id) unless Fog.mocking? account.delete_entity(entity_id) unless Fog.mocking? end fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/entity_tests.rb 0000644 0000041 0000041 00000002542 13411315054 026474 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | entity_tests', ['rackspace','rackspace_monitoring']) do account = Fog::Rackspace::Monitoring.new entity_id = nil tests('success') do tests('#create new entity').formats(DATA_FORMAT) do response = account.create_entity(:label => "Foo").data @entity_id = response[:headers]["X-Object-ID"] response end tests('#get entity').formats(LIST_HEADERS_FORMAT) do account.get_entity(@entity_id).data[:headers] end tests('#update entity').formats(DATA_FORMAT) do options = { :metadata => {:testing => "Bar" }} account.update_entity(@entity_id,options).data end tests('#delete entity').formats(DELETE_DATA_FORMAT) do account.delete_entity(@entity_id).data end end tests('failure') do tests('#create new entity(-1)').raises(Fog::Rackspace::Monitoring::BadRequest) do account.create_entity(:label => "") end tests('#get entity(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do account.get_entity(-1) end tests('#update invalid entity(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do options = { :metadata => {:testing => "Bar" }} response = account.update_entity(-1,options) end tests('#delete entity(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do account.delete_entity(-1) end end end fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/notification_tests.rb 0000644 0000041 0000041 00000003324 13411315054 027645 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | notification_tests', ['rackspace','rackspace_monitoring']) do account = Fog::Rackspace::Monitoring.new notification_id = nil tests('success') do tests('#create new notification').formats(DATA_FORMAT) do pending if Fog.mocking? response = account.create_notification(:label => "Foo", :type => "email", :details => {:address => "test@test.com"}).data notification_id = response[:headers]["X-Object-ID"] response end tests('#get notification').formats(LIST_HEADERS_FORMAT) do account.get_notification(notification_id).data[:headers] end tests('#update notification').formats(DATA_FORMAT) do pending if Fog.mocking? options = {:testing => "Bar"} account.update_notification(notification_id,options).data end tests('#delete notification').formats(DELETE_DATA_FORMAT) do pending if Fog.mocking? account.delete_notification(notification_id).data end end tests('failure') do tests('#create new notification(-1)').raises(Fog::Rackspace::Monitoring::BadRequest) do pending if Fog.mocking? account.create_notification(:label => "") end tests('#get notification(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do pending if Fog.mocking? account.get_notification(-1) end tests('#update invalid notification(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do pending if Fog.mocking? options = { :testing => "Bar" } response = account.update_notification(-1,options) end tests('#delete notification(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do pending if Fog.mocking? account.delete_notification(-1) end end end fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/agent_tests.rb 0000644 0000041 0000041 00000005742 13411315054 026263 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | agent_tests', ['rackspace','rackspace_monitoring']) do account = Fog::Rackspace::Monitoring.new agent_token = nil options = { "label" => "Bar" } values_format = Hash tests('success') do tests('#create new agent token').formats(DATA_FORMAT) do response = account.create_agent_token(options).data agent_token = response[:headers]["X-Object-ID"] response end tests('#list agent tokens').formats(LIST_HEADERS_FORMAT) do account.list_agent_tokens().data[:headers] end tests("#list_agents") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.list_agents.body } end tests("#get_agent") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_agent("agent_id").body } end tests('#get agent token').formats(LIST_HEADERS_FORMAT) do account.get_agent_token(agent_token).data[:headers] end tests('#delete agent token').formats(DELETE_HEADERS_FORMAT) do account.delete_agent_token(agent_token).data[:headers] end tests("#get_cpus_info") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_cpus_info("agent_id").body } end tests("#get_disks_info") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_disks_info("agent_id").body } end tests("#get_filesystems_info") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_filesystems_info("agent_id").body } end tests("#get_logged_in_user_info") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_logged_in_user_info("agent_id").body } end tests("#get_memory_info") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_memory_info("agent_id").body } end tests("#get_network_interfaces_info") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_network_interfaces_info("agent_id").body } end tests("#get_processes_info") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_processes_info("agent_id").body } end tests("#get_system_info") do data_matches_schema(values_format, {:allow_extra_keys => true}) { account.get_system_info("agent_id").body } end end tests('failure') do tests('#fail to create agent token(-1)').raises(TypeError) do account.create_agent_token(-1) end tests('#fail to get agent token(-1)').raises(TypeError) do account.create_agent_token(-1) end tests('#fail to delete agent token(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do account.delete_agent_token(-1) end tests('#fail to connect to agent(-1)').raises(Fog::Rackspace::Monitoring::BadRequest) do account.get_cpus_info(-1) end tests('#fail to get agent (-1)').raises(Fog::Rackspace::Monitoring::NotFound) do account.get_agent(-1) end end end fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/check_tests.rb 0000644 0000041 0000041 00000002743 13411315054 026240 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | check_tests', ['rackspace', 'rackspace_monitoring']) do account = Fog::Rackspace::Monitoring.new entity_id = account.create_entity(:label => "Foo").data[:headers]["X-Object-ID"] check_id = nil tests('success') do tests('#create new check').formats(DATA_FORMAT) do response = account.create_check(entity_id, CHECK_CREATE_OPTIONS).data check_id = response[:headers]['X-Object-ID'] response end tests('#get check').formats(LIST_HEADERS_FORMAT) do account.get_check(entity_id,check_id).data[:headers] end tests('#update check').formats(DATA_FORMAT) do options = { :label => "Bar"} account.update_check(entity_id,check_id,options).data end tests('#delete check').formats(DELETE_DATA_FORMAT) do account.delete_check(entity_id,check_id).data end end tests('failure') do tests('#create new check(-1)').raises(Fog::Rackspace::Monitoring::BadRequest) do account.create_check(entity_id, {:type => ""}) end tests('#get check(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do account.get_check(-1, -1) end tests('#update invalid check(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do options = { :testing => "Bar" } response = account.update_check(-1,-1,options) end tests('#delete check(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do account.delete_check(-1,-1) end end account.delete_entity(entity_id) end fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/list_tests.rb 0000644 0000041 0000041 00000006116 13411315054 026134 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | list_tests', ['rackspace','rackspace_monitoring']) do account = Fog::Rackspace::Monitoring.new if Fog.mocking? entity_id = "peoigne93" check_id = "2090wgn93" else entity_id = account.create_entity(:label => "Foo").data[:headers]["X-Object-ID"] check_id = account.create_check(entity_id,CHECK_CREATE_OPTIONS).data[:headers]["X-Object-ID"] end metric_name = "idle_percent_average" now = Time.now.to_i SLEEP_TIME= 2 sleep(SLEEP_TIME) unless Fog.mocking? tests('success') do tests('#get list of monitoring zones').formats(LIST_MONITORING_ZONE) do pending if Fog.mocking? account.list_monitoring_zones.body end tests('#get a monitoring zone').formats(GET_MONITORING_ZONE) do pending if Fog.mocking? account.get_monitoring_zone('mzdfw').body end tests('#get list of checks').formats(LIST_HEADERS_FORMAT) do account.list_checks(entity_id).data[:headers] end tests('#get list of check types').formats(LIST_HEADERS_FORMAT) do account.list_check_types().data[:headers] end tests('#get list of entities').formats(LIST_HEADERS_FORMAT) do account.list_entities().data[:headers] end tests('#get list of metrics').formats(LIST_HEADERS_FORMAT) do account.list_metrics(entity_id,check_id).data[:headers] end tests('#get overview list').formats(LIST_HEADERS_FORMAT) do account.list_overview().data[:headers] end tests('#list notification plans').formats(LIST_HEADERS_FORMAT) do account.list_notification_plans().data[:headers] end tests('#list notifications').formats(LIST_HEADERS_FORMAT) do account.list_notifications().data[:headers] end tests('#get list of data points').formats(LIST_HEADERS_FORMAT) do options = { :points => 1, :from => now * 1000, :to => (now+SLEEP_TIME) * 1000 } account.list_data_points(entity_id,check_id,metric_name,options).data[:headers] end end tests('failure') do tests('#fail to list checks').raises(Fog::Rackspace::Monitoring::NotFound) do account.list_checks(-1) end tests('#fail to list check types').raises(ArgumentError) do account.list_check_types(-1) end # This test has been put on hold due to a bug that incorrectly returns 200 OK to this request # tests('#fail to list notifications').raises(ArgumentError) do # account.list_notifications(-1) # end # This test has been put on hold due to a bug that incorrectly returns 200 OK to this request #tests('#fail to list metrics').raises(Fog::Rackspace::Monitoring::NotFound) do #account.list_metrics(-1,-1) #end tests('#fail: 1 argument instead of 0 for list_notification_plans').raises(ArgumentError) do account.list_notification_plans('fail') end tests('#fail to get list of data points').raises(Fog::Rackspace::Monitoring::BadRequest) do account.list_data_points(-1,-1,-1,-1).data end end account.delete_check(entity_id,check_id) unless Fog.mocking? account.delete_entity(entity_id) unless Fog.mocking? end fog-rackspace-0.1.6/tests/rackspace/requests/monitoring/alarm_example_tests.rb 0000644 0000041 0000041 00000002255 13411315054 027770 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | alarm_example_tests', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? account = Fog::Rackspace::Monitoring.new example_id = "remote.http_body_match_1" tests('success') do tests('#list alarm examples').formats(LIST_HEADERS_FORMAT) do account.list_alarm_examples().data[:headers] end tests('#get alarm example').formats(LIST_HEADERS_FORMAT) do account.get_alarm_example(example_id).data[:headers] end tests('#evaluate alarm example').formats(LIST_HEADERS_FORMAT) do options = { :string => "Foo"} account.evaluate_alarm_example(example_id,options).data[:headers] end end tests('failure') do tests('#fail to list alarm examples(-1)').raises(ArgumentError) do account.list_alarm_examples(-1).data[:headers] end tests('#fail to get alarm example(-1)').raises(Fog::Rackspace::Monitoring::NotFound) do account.get_alarm_example(-1).data[:headers] end tests('#fail to evaluate alarm example').raises(Fog::Rackspace::Monitoring::BadRequest) do options = { } account.evaluate_alarm_example(example_id,options).data[:headers] end end end fog-rackspace-0.1.6/tests/rackspace/requests/storage/ 0000755 0000041 0000041 00000000000 13411315054 022665 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/storage/container_tests.rb 0000644 0000041 0000041 00000004014 13411315054 026415 0 ustar www-data www-data Shindo.tests('Fog::Storage[:rackspace] | container requests', ["rackspace"]) do @container_format = [{ 'hash' => String, 'last_modified' => String, 'bytes' => Integer, 'name' => String, 'content_type' => String }] @containers_format = [{ 'bytes' => Integer, 'count' => Integer, 'name' => String }] tests('success') do tests("#put_container('fogcontainertests', {})").succeeds do Fog::Storage[:rackspace].put_container('fogcontainertests') end tests("#put_container('fogcontainertests', 'X-Container-Meta-Color'=>'green')").succeeds do Fog::Storage[:rackspace].put_container('fogcontainertests', 'X-Container-Meta-Color'=>'green') response = Fog::Storage[:rackspace].head_container('fogcontainertests') returns('green') { response.headers['X-Container-Meta-Color'] } end tests("#get_container('fogcontainertests')").formats(@container_format) do Fog::Storage[:rackspace].get_container('fogcontainertests').body end tests("#get_containers").formats(@containers_format) do Fog::Storage[:rackspace].get_containers.body end tests("#head_container('fogcontainertests')").succeeds do Fog::Storage[:rackspace].head_container('fogcontainertests') end tests("#head_containers").succeeds do Fog::Storage[:rackspace].head_containers end tests("#delete_container('fogcontainertests')").succeeds do Fog::Storage[:rackspace].delete_container('fogcontainertests') end end tests('failure') do tests("#get_container('fognoncontainer')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].get_container('fognoncontainer') end tests("#head_container('fognoncontainer')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].head_container('fognoncontainer') end tests("#delete_container('fognoncontainer')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].delete_container('fognoncontainer') end end end fog-rackspace-0.1.6/tests/rackspace/requests/storage/large_object_tests.rb 0000644 0000041 0000041 00000033637 13411315054 027070 0 ustar www-data www-data Shindo.tests('Fog::Storage[:rackspace] | large object requests', ['rackspace']) do @directory = Fog::Storage[:rackspace].directories.create(:key => 'foglargeobjecttests') @directory2 = Fog::Storage[:rackspace].directories.create(:key => 'foglargeobjecttests2') @segments = { :a => { :container => @directory.identity, :name => 'fog_large_object/a', :data => 'a' * (1024**2 + 10), :size => 1024**2 + 10, :etag => 'c2e97007d59f0c19b850debdcb80cca5' }, :b => { :container => @directory.identity, :name => 'fog_large_object/b', :data => 'b' * (1024**2 + 20), :size => 1024**2 + 20, :etag => 'd35f50622a1259daad75ff7d5512c7ef' }, :c => { :container => @directory.identity, :name => 'fog_large_object2/a', :data => 'c' * (1024**2 + 30), :size => 1024**2 + 30, :etag => '901d3531a87d188041d4d5b43cb464c1' }, :d => { :container => @directory2.identity, :name => 'fog_large_object2/b', :data => 'd' * (1024**2 + 40), :size => 1024**2 + 40, :etag => '350c0e00525198813920a157df185c8d' } } tests('success') do tests('upload test segments').succeeds do @segments.each_value do |segment| Fog::Storage[:rackspace].put_object(segment[:container], segment[:name], segment[:data]) end end tests('dynamic large object requests') do tests('#put_object_manifest alias').succeeds do Fog::Storage[:rackspace].put_object_manifest(@directory.identity, 'fog_large_object') end tests('using default X-Object-Manifest header') do tests('#put_dynamic_obj_manifest').succeeds do Fog::Storage[:rackspace].put_dynamic_obj_manifest(@directory.identity, 'fog_large_object') end tests('#get_object streams all segments matching the default prefix').succeeds do expected = @segments[:a][:data] + @segments[:b][:data] + @segments[:c][:data] Fog::Storage[:rackspace].get_object(@directory.identity, 'fog_large_object').body == expected end # When the manifest object name is equal to the segment prefix, OpenStack treats it as if it's the first segment. # So you must prepend the manifest object's Etag - Digest::MD5.hexdigest('') tests('#head_object returns Etag that includes manifest object in calculation').succeeds do etags = ['d41d8cd98f00b204e9800998ecf8427e', @segments[:a][:etag], @segments[:b][:etag], @segments[:c][:etag]] expected = "\"#{ Digest::MD5.hexdigest(etags.join) }\"" # returned in quotes "\"2577f38428e895c50de6ea78ccc7da2a"\" Fog::Storage[:rackspace].head_object(@directory.identity, 'fog_large_object').headers['Etag'] == expected end end tests('specifying X-Object-Manifest segment prefix') do tests('#put_dynamic_obj_manifest').succeeds do options = { 'X-Object-Manifest' => "#{ @directory.identity }/fog_large_object/" } Fog::Storage[:rackspace].put_dynamic_obj_manifest(@directory.identity, 'fog_large_object', options) end tests('#get_object streams segments only matching the specified prefix').succeeds do expected = @segments[:a][:data] + @segments[:b][:data] Fog::Storage[:rackspace].get_object(@directory.identity, 'fog_large_object').body == expected end tests('#head_object returns Etag that does not include manifest object in calculation').succeeds do etags = [@segments[:a][:etag], @segments[:b][:etag]] expected = "\"#{ Digest::MD5.hexdigest(etags.join) }\"" # returned in quotes "\"0f035ed3cc38aa0ef46dda3478fad44d"\" Fog::Storage[:rackspace].head_object(@directory.identity, 'fog_large_object').headers['Etag'] == expected end end tests('storing manifest in a different container than the segments') do tests('#put_dynamic_obj_manifest').succeeds do options = { 'X-Object-Manifest' => "#{ @directory.identity }/fog_large_object/" } Fog::Storage[:rackspace].put_dynamic_obj_manifest(@directory2.identity, 'fog_large_object', options) end tests('#get_object').succeeds do expected = @segments[:a][:data] + @segments[:b][:data] Fog::Storage[:rackspace].get_object(@directory2.identity, 'fog_large_object').body == expected end end end tests('static large object requests') do tests('single container') do tests('#put_static_obj_manifest').succeeds do segments = [ { :path => "#{ @segments[:a][:container] }/#{ @segments[:a][:name] }", :etag => @segments[:a][:etag], :size_bytes => @segments[:a][:size] }, { :path => "#{ @segments[:c][:container] }/#{ @segments[:c][:name] }", :etag => @segments[:c][:etag], :size_bytes => @segments[:c][:size] } ] Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments) end tests('#head_object') do etags = [@segments[:a][:etag], @segments[:c][:etag]] etag = "\"#{ Digest::MD5.hexdigest(etags.join) }\"" # "\"ad7e633a12e8a4915b45e6dd1d4b0b4b\"" content_length = (@segments[:a][:size] + @segments[:c][:size]).to_s response = Fog::Storage[:rackspace].head_object(@directory.identity, 'fog_large_object') returns(etag, 'returns ETag computed from segments') { response.headers['Etag'] } returns(content_length , 'returns Content-Length for all segments') { response.headers['Content-Length'] } returns('True', 'returns X-Static-Large-Object header') { response.headers['X-Static-Large-Object'] } end tests('#get_object').succeeds do expected = @segments[:a][:data] + @segments[:c][:data] Fog::Storage[:rackspace].get_object(@directory.identity, 'fog_large_object').body == expected end tests('#delete_static_large_object') do expected = { 'Number Not Found' => 0, 'Response Status' => '200 OK', 'Errors' => [], 'Number Deleted' => 3, 'Response Body' => '' } returns(expected, 'deletes manifest and segments') do Fog::Storage[:rackspace].delete_static_large_object(@directory.identity, 'fog_large_object').body end end end tests('multiple containers') do tests('#put_static_obj_manifest').succeeds do segments = [ { :path => "#{ @segments[:b][:container] }/#{ @segments[:b][:name] }", :etag => @segments[:b][:etag], :size_bytes => @segments[:b][:size] }, { :path => "#{ @segments[:d][:container] }/#{ @segments[:d][:name] }", :etag => @segments[:d][:etag], :size_bytes => @segments[:d][:size] } ] Fog::Storage[:rackspace].put_static_obj_manifest(@directory2.identity, 'fog_large_object', segments) end tests('#head_object') do etags = [@segments[:b][:etag], @segments[:d][:etag]] etag = "\"#{ Digest::MD5.hexdigest(etags.join) }\"" # "\"9801a4cc4472896a1e975d03f0d2c3f8\"" content_length = (@segments[:b][:size] + @segments[:d][:size]).to_s response = Fog::Storage[:rackspace].head_object(@directory2.identity, 'fog_large_object') returns(etag, 'returns ETag computed from segments') { response.headers['Etag'] } returns(content_length , 'returns Content-Length for all segments') { response.headers['Content-Length'] } returns('True', 'returns X-Static-Large-Object header') { response.headers['X-Static-Large-Object'] } end tests('#get_object').succeeds do expected = @segments[:b][:data] + @segments[:d][:data] Fog::Storage[:rackspace].get_object(@directory2.identity, 'fog_large_object').body == expected end tests('#delete_static_large_object') do expected = { 'Number Not Found' => 0, 'Response Status' => '200 OK', 'Errors' => [], 'Number Deleted' => 3, 'Response Body' => '' } returns(expected, 'deletes manifest and segments') do Fog::Storage[:rackspace].delete_static_large_object(@directory2.identity, 'fog_large_object').body end end end end end tests('failure') do tests('dynamic large object requests') do tests('#put_dynamic_obj_manifest with missing container').raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].put_dynamic_obj_manifest('fognoncontainer', 'fog_large_object') end end tests('static large object requests') do tests('upload test segments').succeeds do Fog::Storage[:rackspace].put_object(@segments[:a][:container], @segments[:a][:name], @segments[:a][:data]) Fog::Storage[:rackspace].put_object(@segments[:b][:container], @segments[:b][:name], @segments[:b][:data]) end tests('#put_static_obj_manifest with missing container').raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].put_static_obj_manifest('fognoncontainer', 'fog_large_object', []) end tests('#put_static_obj_manifest with missing object') do segments = [ { :path => "#{ @segments[:c][:container] }/#{ @segments[:c][:name] }", :etag => @segments[:c][:etag], :size_bytes => @segments[:c][:size] } ] expected = { 'Errors' => [[segments[0][:path], '404 Not Found']] } error = nil begin Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments) rescue => err error = err end raises(Fog::Storage::Rackspace::BadRequest) do raise error if error end expected['Errors'][0][0] = error.response_data['Errors'][0][0] rescue nil returns(expected, 'returns error information') do error.response_data end end tests('#put_static_obj_manifest with invalid etag') do segments = [ { :path => "#{ @segments[:a][:container] }/#{ @segments[:a][:name] }", :etag => @segments[:b][:etag], :size_bytes => @segments[:a][:size] } ] expected = { 'Errors' => [[segments[0][:path], 'Etag Mismatch']] } error = nil begin Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments) rescue => err error = err end raises(Fog::Storage::Rackspace::BadRequest) do raise error if error end expected['Errors'][0][0] = error.response_data['Errors'][0][0] rescue nil returns(expected, 'returns error information') do error.response_data end end tests('#put_static_obj_manifest with invalid byte_size') do segments = [ { :path => "#{ @segments[:a][:container] }/#{ @segments[:a][:name] }", :etag => @segments[:a][:etag], :size_bytes => @segments[:b][:size] } ] expected = { 'Errors' => [[segments[0][:path], 'Size Mismatch']] } error = nil begin Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments) rescue => err error = err end raises(Fog::Storage::Rackspace::BadRequest) do raise error if error end expected['Errors'][0][0] = error.response_data['Errors'][0][0] rescue nil returns(expected, 'returns error information') do error.response_data end end tests('#delete_static_large_object with missing container') do response = Fog::Storage[:rackspace].delete_static_large_object('fognoncontainer', 'fog_large_object') returns(200) { response.status } returns(1) { response.body["Number Not Found"] } returns("200 OK") { response.body["Response Status"]} returns("") { response.body["Response Body"]} end tests('#delete_static_large_object with missing manifest') do response = Fog::Storage[:rackspace].delete_static_large_object(@directory.identity, 'fog_non_object') returns(200) { response.status } returns(1) { response.body["Number Not Found"] } returns("200 OK") { response.body["Response Status"]} returns("") { response.body["Response Body"]} end tests('#delete_static_large_object with missing segment') do tests('#put_static_obj_manifest for segments :a and :b').succeeds do segments = [ { :path => "#{ @segments[:a][:container] }/#{ @segments[:a][:name] }", :etag => @segments[:a][:etag], :size_bytes => @segments[:a][:size] }, { :path => "#{ @segments[:b][:container] }/#{ @segments[:b][:name] }", :etag => @segments[:b][:etag], :size_bytes => @segments[:b][:size] } ] Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments) end tests('#delete_object segment :b').succeeds do Fog::Storage[:rackspace].delete_object(@segments[:b][:container], @segments[:b][:name]) end tests('#delete_static_large_object') do expected = { 'Number Not Found' => 1, 'Response Status' => '200 OK', 'Errors' => [], 'Number Deleted' => 2, 'Response Body' => '' } returns(expected, 'deletes manifest and segment :a, and reports missing segment :b') do Fog::Storage[:rackspace].delete_static_large_object(@directory.identity, 'fog_large_object').body end end end end end @directory.destroy @directory2.destroy end fog-rackspace-0.1.6/tests/rackspace/requests/storage/account_tests.rb 0000644 0000041 0000041 00000000457 13411315054 026076 0 ustar www-data www-data Shindo.tests('Fog::Storage[:rackspace] | account requests', ["rackspace"]) do tests('success') do tests("#post_set_meta_temp_url_key('super_secret_key')").succeeds do Fog::Storage[:rackspace].post_set_meta_temp_url_key('super_secret_key') end end tests('failure') do end end fog-rackspace-0.1.6/tests/rackspace/requests/storage/object_tests.rb 0000644 0000041 0000041 00000021520 13411315054 025702 0 ustar www-data www-data require 'uri' require 'cgi' Shindo.tests('Fog::Storage[:rackspace] | object requests', ["rackspace"]) do @directory = Fog::Storage[:rackspace].directories.create(:key => 'fogobjecttests') module RackspaceStorageHelpers def override_path(path) @uri.path = path end end def parse_url(url_string) uri = URI.parse(url_string) query_hash = CGI.parse(uri.query) query_hash.each do |k, v| query_hash[k] = v[0] if query_hash[k].is_a?(Array) and query_hash[k].count == 1 end { :scheme => uri.scheme, :host => uri.host, :port => uri.port, :path => uri.path, :query => query_hash } end tests('success') do tests("#put_object('fogobjecttests', 'fog_object')").succeeds do Fog::Storage[:rackspace].put_object('fogobjecttests', 'fog_object', lorem_file) end tests("#get_object('fogobjectests', 'fog_object')").succeeds do Fog::Storage[:rackspace].get_object('fogobjecttests', 'fog_object').body == lorem_file.read end tests("#get_object('fogobjecttests', 'fog_object', &block)").succeeds do data = '' Fog::Storage[:rackspace].get_object('fogobjecttests', 'fog_object') do |chunk, remaining_bytes, total_bytes| data << chunk end data == lorem_file.read end tests("#head_object('fogobjectests', 'fog_object')").succeeds do Fog::Storage[:rackspace].head_object('fogobjecttests', 'fog_object') end tests("#delete_object('fogobjecttests', 'fog_object')").succeeds do Fog::Storage[:rackspace].delete_object('fogobjecttests', 'fog_object') end # an object key with no special characters tests("#get_object_http_url('fogobjecttests', 'fog_object','expiration timestamp')").succeeds do expires_at = 1344149532 # 2012-08-05 16:52:12 +1000 storage = Fog::Storage::Rackspace.new(:rackspace_temp_url_key => "super_secret") storage.extend RackspaceStorageHelpers storage.override_path('/fake_version/fake_tenant') object_url = storage.get_object_http_url('fogobjecttests', 'fog_object', expires_at) url = parse_url(object_url) [ url[:host] =~ /.*clouddrive\.com$/, url[:path] =~ /\/fogobjecttests\/fog_object$/, url[:query]['temp_url_sig'] == '7e69a73092e333095a70b3be826a7350fcbede86', url[:query]['temp_url_expires'] == '1344149532' ].all? end # an object key with no special characters tests("#get_object_https_url('fogobjecttests', 'fog_object','expiration timestamp')").succeeds do expires_at = 1344149532 # 2012-08-05 16:52:12 +1000 storage = Fog::Storage::Rackspace.new(:rackspace_temp_url_key => "super_secret") storage.extend RackspaceStorageHelpers storage.override_path('/fake_version/fake_tenant') object_url = storage.get_object_https_url('fogobjecttests', 'fog_object', expires_at) url = parse_url(object_url) [ url[:host] =~ /.*clouddrive\.com$/, url[:path] =~ /\/fogobjecttests\/fog_object$/, url[:query]['temp_url_sig'] == '7e69a73092e333095a70b3be826a7350fcbede86', url[:query]['temp_url_expires'] == '1344149532' ].all? end # an object key nested under a / tests("#get_object_https_url('fogobjecttests', 'fog/object','expiration timestamp')").succeeds do expires_at = 1344149532 # 2012-08-05 16:52:12 +1000 storage = Fog::Storage::Rackspace.new(:rackspace_temp_url_key => "super_secret") storage.extend RackspaceStorageHelpers storage.override_path('/fake_version/fake_tenant') object_url = storage.get_object_https_url('fogobjecttests', 'fog/object', expires_at) url = parse_url(object_url) [ url[:host] =~ /.*clouddrive\.com$/, url[:path] =~ /\/fogobjecttests\/fog\/object$/, url[:query]['temp_url_sig'] == '3e99892828804e3d0fdadd18c543b688591ca8b8', url[:query]['temp_url_expires'] == '1344149532' ].all? end # an object key containing a - tests("#get_object_https_url('fogobjecttests', 'fog-object','expiration timestamp')").succeeds do expires_at = 1344149532 # 2012-08-05 16:52:12 +1000 storage = Fog::Storage::Rackspace.new(:rackspace_temp_url_key => "super_secret") storage.extend RackspaceStorageHelpers storage.override_path('/fake_version/fake_tenant') object_url = storage.get_object_https_url('fogobjecttests', 'fog-object', expires_at) url = parse_url(object_url) [ url[:host] =~ /.*clouddrive\.com$/, url[:path] =~ /\/fogobjecttests\/fog-object$/, url[:query]['temp_url_sig'] == 'a24dd5fc955a57adce7d1b5bc4ec2c7660ab8396', url[:query]['temp_url_expires'] == '1344149532' ].all? end tests("put_object with block") do tests("#put_object('fogobjecttests', 'fog_object', &block)").succeeds do begin file = lorem_file buffer_size = file.stat.size / 2 # chop it up into two buffers Fog::Storage[:rackspace].put_object('fogobjecttests', 'fog_block_object', nil) do file.read(buffer_size).to_s end ensure file.close end end tests('#get_object').succeeds do Fog::Storage[:rackspace].get_object('fogobjecttests', 'fog_block_object').body == lorem_file.read end tests('#delete_object').succeeds do Fog::Storage[:rackspace].delete_object('fogobjecttests', 'fog_block_object') end end tests('#delete_multiple_objects') do Fog::Storage[:rackspace].put_object('fogobjecttests', 'fog_object', lorem_file) Fog::Storage[:rackspace].put_object('fogobjecttests', 'fog_object2', lorem_file) Fog::Storage[:rackspace].directories.create(:key => 'fogobjecttests2') Fog::Storage[:rackspace].put_object('fogobjecttests2', 'fog_object', lorem_file) expected = { "Number Not Found" => 0, "Response Status" => "200 OK", "Errors" => [], "Number Deleted" => 2, "Response Body" => "" } returns(expected, 'deletes multiple objects') do Fog::Storage[:rackspace].delete_multiple_objects('fogobjecttests', ['fog_object', 'fog_object2']).body end returns(expected, 'deletes object and container') do Fog::Storage[:rackspace].delete_multiple_objects(nil, ['fogobjecttests2/fog_object', 'fogobjecttests2']).body end end end tests('failure') do tests("#get_object('fogobjecttests', 'fog_non_object')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].get_object('fogobjecttests', 'fog_non_object') end tests("#get_object('fognoncontainer', 'fog_non_object')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].get_object('fognoncontainer', 'fog_non_object') end tests("#head_object('fogobjecttests', 'fog_non_object')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].head_object('fogobjecttests', 'fog_non_object') end tests("#head_object('fognoncontainer', 'fog_non_object')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].head_object('fognoncontainer', 'fog_non_object') end tests("#delete_object('fogobjecttests', 'fog_non_object')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].delete_object('fogobjecttests', 'fog_non_object') end tests("#delete_object('fognoncontainer', 'fog_non_object')").raises(Fog::Storage::Rackspace::NotFound) do Fog::Storage[:rackspace].delete_object('fognoncontainer', 'fog_non_object') end tests('#delete_multiple_objects') do expected = { "Number Not Found" => 2, "Response Status" => "200 OK", "Errors" => [], "Number Deleted" => 0, "Response Body" => "" } returns(expected, 'reports missing objects') do Fog::Storage[:rackspace].delete_multiple_objects('fogobjecttests', ['fog_non_object', 'fog_non_object2']).body end returns(expected, 'reports missing container') do Fog::Storage[:rackspace].delete_multiple_objects('fognoncontainer', ['fog_non_object', 'fog_non_object2']).body end tests('deleting non-empty container') do Fog::Storage[:rackspace].put_object('fogobjecttests', 'fog_object', lorem_file) expected = { "Number Not Found" => 0, "Response Status" => "400 Bad Request", "Errors" => [['fogobjecttests', '409 Conflict']], "Number Deleted" => 1, "Response Body" => "" } body = Fog::Storage[:rackspace].delete_multiple_objects(nil, ['fogobjecttests', 'fogobjecttests/fog_object']).body expected['Errors'][0][0] = body['Errors'][0][0] rescue nil returns(expected, 'deletes object but not container') { body } end end end @directory.destroy end fog-rackspace-0.1.6/tests/rackspace/requests/queues/ 0000755 0000041 0000041 00000000000 13411315054 022530 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/queues/claim_tests.rb 0000644 0000041 0000041 00000003604 13411315054 025367 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | claim_tests', ['rackspace']) do service = Fog::Rackspace::Queues.new queue_name = 'fog' + Time.now.to_i.to_s client_id = service.client_id claim_id = nil service.create_queue(queue_name) tests('success') do tests("#create_claim(#{queue_name}, #{VALID_TTL}, #{VALID_GRACE}) => No Messages").returns(204) do service.create_claim(queue_name, VALID_TTL, VALID_GRACE).status end tests('with messages in the queue') do before do service.create_message(client_id, queue_name, { :message => "message-body"}, 300) end #TODO - Fix it so simple text bodies pass validation tests("#create_claim(#{queue_name}, #{VALID_TTL}, #{VALID_GRACE})").formats(CREATE_CLAIM_FORMAT) do response = service.create_claim(queue_name, VALID_TTL, VALID_GRACE) claim_id = response.headers['Location'].split('/').last response.body end tests("#get_claim(#{queue_name}, #{claim_id})").formats(CLAIM_FORMAT) do service.get_claim(queue_name, claim_id).body end tests("#update_claim(#{queue_name}, #{claim_id}, 500)").succeeds do service.update_claim(queue_name, claim_id, 500) end tests("#delete_claim(#{queue_name}, #{claim_id})").succeeds do service.delete_claim(queue_name, claim_id) end tests("#create_claim(#{queue_name}, #{VALID_TTL}, #{VALID_GRACE}, { :limit => 1})") do response = service.create_claim(queue_name, VALID_TTL, VALID_GRACE, { :limit => 1}) formats(CREATE_CLAIM_FORMAT) { response.body } returns(1) { response.body.length } end end end tests('failure') do tests("#get_claim('queue_name', 'nonexistentclaim') => Does not exist").raises(Fog::Rackspace::Queues::NotFound) do service.get_claim(queue_name, 'nonexistentclaim') end end service.delete_queue(queue_name) end fog-rackspace-0.1.6/tests/rackspace/requests/queues/helper.rb 0000644 0000041 0000041 00000001260 13411315054 024333 0 ustar www-data www-data VALID_TTL = 300 VALID_GRACE = 300 METADATA_FORMAT = { } QUEUE_FORMAT = { 'metadata' => METADATA_FORMAT } LIST_QUEUES_FORMAT = { 'queues' => [ QUEUE_FORMAT.merge({ 'name' => String, 'href' => String, }) ], 'links' => LINKS_FORMAT } MESSAGE_FORMAT = { 'href' => String, 'ttl' => Integer, 'age' => Integer, 'body' => Hash } LIST_MESSAGES_FORMAT = { 'messages' => [MESSAGE_FORMAT], 'links' => LINKS_FORMAT } CREATE_CLAIM_FORMAT = [ MESSAGE_FORMAT ] CLAIM_FORMAT = { 'ttl' => Integer, 'age' => Integer, 'messages' => [ MESSAGE_FORMAT ] } QUEUE_STATS_FORMAT = { 'messages' => { 'free' => Integer, 'claimed' => Integer } } fog-rackspace-0.1.6/tests/rackspace/requests/queues/queues_tests.rb 0000644 0000041 0000041 00000002110 13411315054 025600 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | queue_tests', ['rackspace']) do service = Fog::Rackspace::Queues.new tests('success') do queue_name = 'fog' + Time.now.to_i.to_s tests("#create_queue(#{queue_name})").succeeds do service.create_queue(queue_name) end tests("#list_queues").formats(LIST_QUEUES_FORMAT) do response = service.list_queues response.body end tests("#get_queue(#{queue_name})").formats(QUEUE_FORMAT) do service.get_queue(queue_name).body end tests("#get_queue_stats(#{queue_name})").formats(QUEUE_STATS_FORMAT) do service.get_queue_stats(queue_name).body end tests("#delete_queue(#{queue_name})").succeeds do service.delete_queue(queue_name) end end tests('failure') do tests("#create_queue('') => Invalid Create Critera").raises(Fog::Rackspace::Queues::MethodNotAllowed) do service.create_queue('') end tests("#get_queue('nonexistentqueue') => Does not exist").raises(Fog::Rackspace::Queues::NotFound) do service.get_queue('nonexistentqueue') end end end fog-rackspace-0.1.6/tests/rackspace/requests/queues/messages_tests.rb 0000644 0000041 0000041 00000003766 13411315054 026122 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | messages_tests', ['rackspace']) do service = Fog::Rackspace::Queues.new queue_name = 'fog' + Time.now.to_i.to_s client_id = service.client_id message_id = nil service.create_queue(queue_name) begin tests('success') do tests("#list_message(#{client_id}, #{queue_name}, {:echo => true}) => No Content").returns(204) do service.list_messages(client_id, queue_name, {:echo => true}).status end tests("#create_message(#{client_id}, #{queue_name}, '{ :blah => 'blah' }', 300)").succeeds do response = service.create_message(client_id, queue_name, { :blah => 'blah' }, 300) message_id = response.body['resources'][0].split('/').last end tests("#list_message(#{client_id}, #{queue_name}, {:echo => true}) => With Content").formats(LIST_MESSAGES_FORMAT) do service.list_messages(client_id, queue_name, {:echo => true}).body end tests("#get_message(#{client_id}, #{queue_name}, #{message_id})").formats(MESSAGE_FORMAT) do service.get_message(client_id, queue_name, message_id).body end tests("#delete_message(#{queue_name}, #{message_id}, { :claim_id => '10' })").raises(Fog::Rackspace::Queues::ServiceError) do #API team should be changing this pending service.delete_message(queue_name, message_id, { :claim_id => '10' }) end tests("#delete_message(#{queue_name}, #{message_id})").succeeds do service.delete_message(queue_name, message_id) end end tests('failure') do tests("#create_message('') => Invalid Create Critera").raises(Fog::Rackspace::Queues::BadRequest) do service.create_message(client_id, queue_name, '', 0) end tests("#get_message('queue_name', 'nonexistentmessage') => Does not exist").raises(Fog::Rackspace::Queues::NotFound) do service.get_message(client_id, queue_name, 'nonexistentmessage') end end ensure service.delete_queue(queue_name) end end fog-rackspace-0.1.6/tests/rackspace/requests/auto_scale/ 0000755 0000041 0000041 00000000000 13411315054 023340 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/auto_scale/helper.rb 0000644 0000041 0000041 00000010524 13411315054 025146 0 ustar www-data www-data ###Â FORMATS LIST_GROUPS_FORMAT = { "groups_links"=>[], "groups"=> [ { "state" => { "paused"=> Fog::Boolean, "desiredCapacity"=> Integer, "active"=>[], "pendingCapacity"=> Integer, "activeCapacity"=> Integer, "name"=> String } } ] } GROUP_STATE_FORMAT = { "group" => { "paused"=> Fog::Boolean, "desiredCapacity" => Integer, "active"=>[], "pendingCapacity" => Integer, "activeCapacity" => Integer, "name"=> String } } GET_GROUP_HEADERS_FORMAT = { "Content-Type"=>String, "Via"=>String, "x-response-id"=>String, "Date"=>String, "Transfer-Encoding"=>String, "Server"=>String } GROUP_DELETE_DATA_FORMAT = { :headers=> { "Content-Type"=>String, "Via"=>String, "x-response-id"=>String, "Date"=>String, "Server"=>String }, :status=>Integer, :remote_ip=>String } LAUNCH_CONFIG_FORMAT = { "args" => { "loadBalancers" => [ { "port" => Integer, "loadBalancerId" => Integer } ], "server" => { "name" => String, "imageRef" => String, "flavorRef" => String, "OS-DCF =>diskConfig" => String, "metadata" => { "build_config" => String, "meta_key_1" => String, "meta_key_2" => String }, "networks" => [ { "uuid" => String }, { "uuid" => String } ], "personality" => [ { "path" => String, "contents" => String } ] } }, "type" => String } GROUP_CONFIG_FORMAT = { "maxEntities" => Integer, "cooldown" => Integer, "name" => String, "minEntities" => Integer, "metadata" => { "gc_meta_key_2" => String, "gc_meta_key_1" => String } } POLICY_FORMAT = { "name"=> String, "links"=> Array, "cooldown"=>Integer, "type"=>String, "id"=>String, "change"=>Integer } POLICIES_FORMAT = [POLICY_FORMAT] GROUP_FORMAT = { "group" => { "launchConfiguration" => LAUNCH_CONFIG_FORMAT, "groupConfiguration" => GROUP_CONFIG_FORMAT, "scalingPolicies" => POLICIES_FORMAT, "links" => [ { "href" => String, "rel" => String } ], "id" => String } } WEBHOOK_FORMAT = { "id" => String, "name" => String, "metadata" => Hash, "links" => Array } LIST_WEBHOOKS_FORMAT = [ { "id" => String, "name" => String, "links"=>[{"href" => String, "rel" => String }], "metadata"=>{} } ] ### OPTIONS LAUNCH_CONFIG_OPTIONS = { "args" => { "loadBalancers" => [ { "port" => 8080, "loadBalancerId" => 9099 } ], "server" => { "name" => "autoscale_server", "imageRef" => "0d589460-f177-4b0f-81c1-8ab8903ac7d8", "flavorRef" => "2", "OS-DCF =>diskConfig" => "AUTO", "metadata" => { "build_config" => "core", "meta_key_1" => "meta_value_1", "meta_key_2" => "meta_value_2" }, "networks" => [ { "uuid" => "11111111-1111-1111-1111-111111111111" }, { "uuid" => "00000000-0000-0000-0000-000000000000" } ], "personality" => [ { "path" => "/root/.csivh", "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4=" } ] } }, "type" => "launch_server" } GROUP_CONFIG_OPTIONS = { "maxEntities" => 3, "cooldown" => 360, "name" => "testscalinggroup198547", "minEntities" => 0, "metadata" => { "gc_meta_key_2" => "gc_meta_value_2", "gc_meta_key_1" => "gc_meta_value_1" } } POLICIES_OPTIONS = [ { "cooldown" => 0, "type" => "webhook", "name" => "scale up by 1", "change" => 1 } ] POLICY_OPTIONS = { "cooldown" => 0, "type" => "webhook", "name" => "FOOBAR", "change" => 1 } GROUP_OPTIONS = { "launchConfiguration" => LAUNCH_CONFIG_OPTIONS, "groupConfiguration" => GROUP_CONFIG_OPTIONS, "scalingPolicies" => POLICIES_OPTIONS } WEBHOOK_OPTIONS = { "name" => "webhook name", "metadata" => {'foo' => 'bar'} } def deactive_auto_scale_group(group) return unless group config = group.group_config config.min_entities = 0 config.max_entities = 0 config.save end fog-rackspace-0.1.6/tests/rackspace/requests/auto_scale/config_tests.rb 0000644 0000041 0000041 00000006162 13411315054 026361 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | config_tests', ['rackspace', 'rackspace_autoscale']) do pending if Fog.mocking? service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord begin @group = service.create_group(LAUNCH_CONFIG_OPTIONS, GROUP_CONFIG_OPTIONS, POLICIES_OPTIONS).body['group'] @group_id = @group['id'] tests('success') do tests('#get_group_config').formats({"groupConfiguration" => GROUP_CONFIG_FORMAT}) do service.get_group_config(@group_id).body end tests('#update_group_config').returns(204) do data = service.update_group_config(@group_id, { 'maxEntities' => 0, 'minEntities' => 0, 'metadata' => {}, 'name' => 'foo', 'cooldown' => 20}) data.status end tests('#get_launch_config').formats(LAUNCH_CONFIG_FORMAT) do service.get_launch_config(@group_id).body["launchConfiguration"] end tests('#update_launch_config').returns(204) do data = service.update_launch_config(@group_id, { "args" => { "loadBalancers" => [ { "port" => 8000, "loadBalancerId" => 9099 } ], "server" => { "name" => "autoscale_server", "imageRef" => "0d589460-f177-4b0f-81c1-8ab8903ac7d8", "flavorRef" => "2", "OS-DCF =>diskConfig" => "AUTO", "metadata" => { "build_config" => "core", "meta_key_1" => "meta_value_1", "meta_key_2" => "meta_value_2" }, "networks" => [ { "uuid" => "11111111-1111-1111-1111-111111111111" }, { "uuid" => "00000000-0000-0000-0000-000000000000" } ], "personality" => [ { "path" => "/root/.csivh", "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4=" } ] } }, "type" => "launch_server" }) data.status end end ensure service.delete_group(@group_id) end tests('failure') do tests('#update group config').raises(Fog::Rackspace::AutoScale::BadRequest) do service.update_group_config(@group_id, {}) end tests('#delete group config').raises(NoMethodError) do service.delete_group_config(123) end tests('#create group config').raises(NoMethodError) do service.create_group_config({}) end tests('#update launch config').raises(Fog::Rackspace::AutoScale::BadRequest) do service.update_launch_config(@group_id, {}) end tests('#delete launch config').raises(NoMethodError) do service.delete_launch_config(123) end tests('#create launch config').raises(NoMethodError) do service.create_launch_config({}) end end # @group['scalingPolicies'].each do |p| # service.delete_policy(@group_id, p['id']) # end # service.delete_group(@group_id) end fog-rackspace-0.1.6/tests/rackspace/requests/auto_scale/webhook_tests.rb 0000644 0000041 0000041 00000004052 13411315054 026546 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | webhook_tests', ['rackspace', 'rackspace_autoscale']) do pending if Fog.mocking? service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord begin @group_id = service.create_group(LAUNCH_CONFIG_OPTIONS, GROUP_CONFIG_OPTIONS, POLICIES_OPTIONS).body['group']['id'] @policy_id = service.create_policy(@group_id, POLICY_OPTIONS).body['policies'][0]['id'] tests('success') do tests('#create_webhook').formats(201) do response = service.create_webhook(@group_id, @policy_id, WEBHOOK_OPTIONS) @webhook_id = response.body['webhooks'][0]['id'] response.data[:status] end tests('#list_webhooks').formats(LIST_WEBHOOKS_FORMAT, false) do response = service.list_webhooks(@group_id, @policy_id).body["webhooks"] end tests('#get_webhook').formats(WEBHOOK_FORMAT) do response = service.get_webhook(@group_id, @policy_id, @webhook_id) response.body['webhook'] end tests('#update_webhook').formats(204) do response = service.update_webhook(@group_id, @policy_id, @webhook_id, {'name' => 'new', 'metadata' => {}} ) response.data[:status] end tests('#delete_webhook').formats(204) do response = service.delete_webhook(@group_id, @policy_id, @webhook_id) response.data[:status] end end ensure service.delete_policy @group_id, @policy_id service.delete_group @group_id end tests('failure') do tests('#create_webhook').raises(Fog::Rackspace::AutoScale::BadRequest) do service.create_webhook(@group_id, @policy_id, {}) end tests('#get_webhook').raises(Fog::Rackspace::AutoScale::NotFound) do service.get_webhook(@group_id, @policy_id, 123) end tests('#update_webhook').raises(Fog::Rackspace::AutoScale::BadRequest) do service.update_webhook(@group_id, @policy_id, @webhook_id, {}) end tests('#delete_webhook').raises(Fog::Rackspace::AutoScale::NotFound) do service.delete_webhook(@group_id, @policy_id, 123) end end end fog-rackspace-0.1.6/tests/rackspace/requests/auto_scale/policy_tests.rb 0000644 0000041 0000041 00000004172 13411315054 026412 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | policy_tests', ['rackspace', 'rackspace_autoscale']) do pending if Fog.mocking? service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord begin @group_id = service.create_group(LAUNCH_CONFIG_OPTIONS, GROUP_CONFIG_OPTIONS, POLICIES_OPTIONS).body['group']['id'] tests('success') do tests('#list policies').formats(POLICIES_FORMAT) do service.list_policies(@group_id).body['policies'] end tests('#create_policy').returns(201) do response = service.create_policy(@group_id, POLICY_OPTIONS) @policy_id = response.body['policies'][0]['id'] response.status end tests('#get_policy').formats(POLICY_FORMAT) do response = service.get_policy(@group_id, @policy_id) response.body['policy'] end tests('#execute_policy').returns(202) do service.execute_policy(@group_id, @policy_id).status end tests('#update_policy').returns(204) do response = service.update_policy(@group_id, @policy_id, { 'name' => 'foo', 'changePercent' => 1, 'type' => 'webhook', 'cooldown' => 100 }) response.status end tests('#delete_policy').returns(204) do response = service.delete_policy(@group_id, @policy_id) response.status end end ensure group = service.groups.get(@group_id) deactive_auto_scale_group(group) group.destroy end tests('failure') do tests('#create policy').raises(Fog::Rackspace::AutoScale::BadRequest) do service.create_policy(@group_id, {}) end tests('#get policy').raises(Fog::Rackspace::AutoScale::NotFound) do service.get_policy(@group_id, 123) end tests('#update policy').raises(Fog::Rackspace::AutoScale::BadRequest) do service.update_policy(@group_id, 123, {}) end tests('#execute policy').raises(Fog::Rackspace::AutoScale::NotFound) do service.execute_policy(@group_id, 123) end tests('#delete policy').raises(Fog::Rackspace::AutoScale::NotFound) do service.delete_policy(@group_id, 123) end end end fog-rackspace-0.1.6/tests/rackspace/requests/auto_scale/group_tests.rb 0000644 0000041 0000041 00000003060 13411315054 026242 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | group_tests', ['rackspace', 'rackspace_autoscale']) do pending if Fog.mocking? service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord tests('success') do tests('#create new group').formats(GROUP_FORMAT) do response = service.create_group(LAUNCH_CONFIG_OPTIONS, GROUP_CONFIG_OPTIONS, POLICIES_OPTIONS).body @group_id = response['group']['id'] response end tests('#list_groups').formats(LIST_GROUPS_FORMAT) do service.list_groups.body end tests('#get group').succeeds do [200, 204].include? service.get_group(@group_id).status end tests('#get group - body').formats(GROUP_FORMAT) do service.get_group(@group_id).body end tests('#get_group_state').formats(GROUP_STATE_FORMAT) do service.get_group_state(@group_id).body end tests('#pause_group_state') do pending end tests('#resume_group_state') do pending end tests('#delete group').returns(204) do service.delete_group(@group_id).status end end tests('failure') do tests('#fail to create group(-1)').raises(Fog::Rackspace::AutoScale::BadRequest) do service.create_group(@launch_config, @group_config, {}) end tests('#fail to get group(-1)').raises(Fog::Rackspace::AutoScale::NotFound) do service.get_group(-1) end tests('#update group').raises(NoMethodError) do service.update_group end tests('#fail to delete group(-1)').raises(Fog::Rackspace::AutoScale::NotFound) do service.delete_group(-1) end end end fog-rackspace-0.1.6/tests/rackspace/requests/networking/ 0000755 0000041 0000041 00000000000 13411315054 023410 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/requests/networking/network_tests.rb 0000644 0000041 0000041 00000002233 13411315054 026650 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Networking | network_tests', ['rackspace']) do service = Fog::Rackspace::Networking.new network_format = { 'id' => String, 'label' => String, 'cidr' => Fog::Nullable::String } get_network_format = { 'network' => network_format } list_networks_format = { 'networks' => [network_format] } tests('success') do network_id = nil tests('#create_network').formats(get_network_format) do service.create_network("fog_#{Time.now.to_i.to_s}", '192.168.0.0/24').body.tap do |r| network_id = r['network']['id'] end end tests('#list_networks').formats(list_networks_format) do service.list_networks.body end tests('#get_network').formats(get_network_format) do service.get_network(network_id).body end tests('#delete_network').succeeds do service.delete_network(network_id) end end test('failure') do tests('#get_network').raises(Fog::Rackspace::Networking::NotFound) do service.get_network(0) end tests('#delete_network').raises(Fog::Rackspace::Networking::NotFound) do service.delete_network(0) end end end fog-rackspace-0.1.6/tests/rackspace/requests/networking/virtual_interface_tests.rb 0000644 0000041 0000041 00000003113 13411315054 030663 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Networking | virtual_interface_tests', ['rackspace']) do @service = Fog::Rackspace::Networking.new virtual_interface_format = { "virtual_interfaces"=> [{ "ip_addresses"=> [{ "network_id"=> String, "network_label"=> String, "address"=> String }], "id"=> String, "mac_address"=> String }] } begin unless Fog.mocking? network_id = nil @server = @service.servers.create(:name => "fog_virtual_interface_test_#{Time.now.to_i.to_s}", :flavor_id => rackspace_test_flavor_id(@service), :image_id => rackspace_test_image_id(@service)) @server.wait_for { ready? } @network = @service.networks.create(:label => "fog_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24') end tests('success') do pending if Fog.mocking? tests('#create_virtual_interface').formats(virtual_interface_format) do response = @service.create_virtual_interface @server.id, @network.id body = response.body @virtual_network_interface_id = body["virtual_interfaces"].first["id"] body end tests('#list_virtual_interfaces').formats(virtual_interface_format) do @service.list_virtual_interfaces(@server.id).body end tests('#delete_virtual_interfaces').succeeds do @service.delete_virtual_interface(@server.id, @virtual_network_interface_id) end end ensure @server.destroy if @server delete_test_network @network end end fog-rackspace-0.1.6/tests/rackspace/databases_tests.rb 0000644 0000041 0000041 00000014411 13411315054 023045 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Databases', ['rackspace']) do |variable| pending if Fog.mocking? def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Rackspace::Databases.new assert_method nil, :authenticate_v2 assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('authentication v1') do pending if Fog.mocking? tests('variables populated') do @service = Fog::Rackspace::Databases.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.flavors end tests('custom endpoint') do @service = Fog::Rackspace::Databases.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_database_url => 'https://my-custom-endpoint.com' returns(false, "auth token populated") { @service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('authentication v2') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::Databases.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => { :ssl_verify_peer => true } returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.flavors end tests('dfw region').succeeds do @service = Fog::Rackspace::Databases.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.flavors end tests('ord region').succeeds do @service = Fog::Rackspace::Databases.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil } @service.flavors end tests('custom endpoint') do @service = Fog::Rackspace::Databases.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_database_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::Rackspace::Databases.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.flavors end tests('specify old contstant style service endoint').succeeds do @service = Fog::Rackspace::Databases.new :rackspace_endpoint => Fog::Rackspace::Databases::ORD_ENDPOINT returns(true) { (@service.instance_variable_get("@uri").to_s =~ /#{Fog::Rackspace::Databases::ORD_ENDPOINT}/ ) != nil } @service.flavors end tests('specify region').succeeds do @service = Fog::Rackspace::Databases.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil } @service.flavors end tests('custom endpoint') do @service = Fog::Rackspace::Databases.new :rackspace_database_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::Rackspace::Databases.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad_token") returns(200) { @service.list_flavors.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::Rackspace::Databases.new :rackspace_api_key => 'bad_key' } end end @service = Fog::Rackspace::Databases.new tests('#flavors').succeeds do data = @service.flavors returns(true) { data.is_a? Array } end tests('#instances').succeeds do data = @service.instances returns(true) { data.is_a? Array } end tests('#databases').succeeds do data = @service.databases returns(true) { data.is_a? Array } end tests('#users').succeeds do data = @service.users returns(true) { data.is_a? Array } end end fog-rackspace-0.1.6/tests/rackspace/compute_tests.rb 0000644 0000041 0000041 00000011467 13411315054 022602 0 ustar www-data www-data Shindo.tests('Rackspace | Compute', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Compute::Rackspace.new assert_method nil, :authenticate_v2 assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('authentication v1') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Compute::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.list_flavors end tests('custom endpoint') do @service = Fog::Compute::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_compute_v1_url => 'https://my-custom-endpoint.com' returns(false, "auth token populated") { @service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('authentication v2') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Compute::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => { :ssl_verify_peer => true } returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host == 'servers.api.rackspacecloud.com') != nil } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.list_flavors end tests('custom endpoint') do @service = Fog::Compute::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_compute_v1_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::Compute::Rackspace.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host == 'servers.api.rackspacecloud.com') != nil } @service.list_flavors end tests('specify region').succeeds do @service = Fog::Compute::Rackspace.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host == 'servers.api.rackspacecloud.com') != nil } @service.list_flavors end tests('custom endpoint') do @service = Fog::Compute::Rackspace.new :rackspace_compute_v1_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::Compute::Rackspace.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad-token") returns(true) { [200, 203].include?(@service.list_flavors.status) } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::Compute::Rackspace.new :rackspace_api_key => 'bad_key' } end end end fog-rackspace-0.1.6/tests/rackspace/block_storage_tests.rb 0000644 0000041 0000041 00000013777 13411315054 023752 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Rackspace::BlockStorage.new assert_method nil, :authenticate_v2 assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('legacy authentication') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::BlockStorage.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.list_volumes end tests('custom endpoint') do @service = Fog::Rackspace::BlockStorage.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_block_storage_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('current authentication') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::BlockStorage.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true} returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.list_volumes end tests('dfw region').succeeds do @service = Fog::Rackspace::BlockStorage.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_volumes end tests('ord region').succeeds do @service = Fog::Rackspace::BlockStorage.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil } @service.list_volumes end tests('custom endpoint') do @service = Fog::Rackspace::BlockStorage.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_block_storage_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::Rackspace::BlockStorage.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_volumes end tests('specify old contstant style service endoint').succeeds do @service = Fog::Rackspace::BlockStorage.new :rackspace_endpoint => Fog::Rackspace::BlockStorage::ORD_ENDPOINT returns(true) { (@service.instance_variable_get("@uri").to_s =~ /#{Fog::Rackspace::BlockStorage::ORD_ENDPOINT}/ ) != nil } @service.list_volumes end tests('specify region') do @service = Fog::Rackspace::BlockStorage.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil } @service.list_volumes end tests('custom endpoint') do @service = Fog::Rackspace::BlockStorage.new :rackspace_block_storage_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::Rackspace::BlockStorage.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad-token") returns(200) { @service.list_volumes.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) {Fog::Rackspace::BlockStorage.new :rackspace_api_key => 'bad_key' } end end end fog-rackspace-0.1.6/tests/rackspace/helper.rb 0000644 0000041 0000041 00000006430 13411315054 021155 0 ustar www-data www-data LINKS_FORMAT = [{ 'href' => String, 'rel' => String }] module Shindo class Tests def given_a_load_balancer_service(&block) @service = Fog::Rackspace::LoadBalancers.new instance_eval(&block) end def given_a_load_balancer(&block) @lb = @service.load_balancers.create({ :name => ('fog' + Time.now.to_i.to_s), :protocol => 'HTTP', :port => 80, :virtual_ips => [{ :type => 'PUBLIC'}], :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}] }) @lb.wait_for { ready? } begin instance_eval(&block) ensure @lb.wait_for { ready? } @lb.destroy end end def wait_for_request(description = "waiting", &block) return if Fog.mocking? tests(description) do Fog.wait_for &block end end def wait_for_server_deletion(server) return if Fog.mocking? begin @instance.wait_for { state = 'DELETED' } rescue Fog::Compute::RackspaceV2::NotFound => e # do nothing end end def wait_for_server_state(service, server_id, state, error_states=nil) current_state = nil until current_state == state current_state = service.get_server(server_id).body['server']['status'] if error_states error_states = Array(error_states) if error_states.include?(current_state) Fog::Logger.warning caller Fog::Logger.warning "ERROR! Server should have transitioned to '#{state}' not '#{current_state}'" return end end sleep 10 unless Fog.mocking? end sleep 30 unless Fog.mocking? end def wait_for_volume_state(service, volume_id, state) current_state = nil until current_state == state current_state = service.get_volume(volume_id).body['volume']['status'] if current_state == 'error' Fog::Logger.warning caller Fog::Logger.warning "Volume is in an error state!" return end sleep 10 unless Fog.mocking? end end def rackspace_test_image_id(service) image_id = Fog.credentials[:rackspace_image_id] # I chose to use the first Ubuntu because it will work with the smallest flavor and it doesn't require a license image_id ||= Fog.mocking? ? service.images.first.id : service.images.find {|image| image.name =~ /Ubuntu/}.id # use the first Ubuntu image end def rackspace_test_flavor_id(service) @flavor_id ||= Fog.credentials[:rackspace_flavor_id] || service.flavors.first.id end # After a server has been successfully deleted they are still being reported as attached to a cloud network # causing delete calls to fail. This method attempts to address that. def delete_test_network(network) return false if Fog.mocking? || network.nil? attempt = 0 begin network.destroy rescue Fog::Compute::RackspaceV2::ServiceError => e if attempt == 3 Fog::Logger.warning "Unable to delete #{network.label}" return false end Fog::Logger.warning "Network #{network.label} Delete Fail Attempt #{attempt}- #{e.inspect}" attempt += 1 sleep 60 retry end return true end end end fog-rackspace-0.1.6/tests/rackspace/compute_v2_tests.rb 0000644 0000041 0000041 00000013672 13411315054 023211 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Compute::RackspaceV2.new assert_method nil, :authenticate_v2 assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('legacy authentication') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Compute::RackspaceV2.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.list_flavors end tests('custom endpoint') do @service = Fog::Compute::RackspaceV2.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_compute_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('current authentation') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Compute::RackspaceV2.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true} returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.list_flavors end tests('dfw region').succeeds do @service = Fog::Compute::RackspaceV2.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_flavors end tests('ord region').succeeds do @service = Fog::Compute::RackspaceV2.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil } @service.list_flavors end tests('custom endpoint') do @service = Fog::Compute::RackspaceV2.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_compute_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::Compute::RackspaceV2.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_flavors end tests('specify old contstant style service endoint').succeeds do @service = Fog::Compute::RackspaceV2.new :rackspace_endpoint => Fog::Compute::RackspaceV2::ORD_ENDPOINT returns(true) { (@service.instance_variable_get("@uri").to_s =~ /#{Fog::Compute::RackspaceV2::ORD_ENDPOINT}/ ) != nil } @service.list_flavors end tests('specify region').succeeds do @service = Fog::Compute::RackspaceV2.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil } @service.list_flavors end tests('custom endpoint') do @service = Fog::Compute::RackspaceV2.new :rackspace_compute_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::Compute::RackspaceV2.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad_token") returns(true) { [200, 203].include? @service.list_flavors.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::Compute::RackspaceV2.new :rackspace_api_key => 'bad_key' } end end end fog-rackspace-0.1.6/tests/rackspace/monitoring_tests.rb 0000644 0000041 0000041 00000007161 13411315054 023307 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring', ['rackspace','rackspace_monitoring']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Rackspace::Monitoring.new assert_method nil, :authenticate_v2 assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('current authentation') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::Monitoring.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true} returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.list_entities end tests('custom endpoint') do @service = Fog::Rackspace::Monitoring.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_monitoring_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::Rackspace::Monitoring.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /monitoring.api.rackspacecloud.com/) != nil } @service.list_entities end tests('custom endpoint') do @service = Fog::Rackspace::Monitoring.new :rackspace_monitoring_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::Rackspace::Monitoring.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad_token") returns(true) { [200, 203].include? @service.list_entities.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::Rackspace::Monitoring.new :rackspace_api_key => 'bad_key' } end end end fog-rackspace-0.1.6/tests/rackspace/auto_scale_tests.rb 0000644 0000041 0000041 00000010244 13411315054 023235 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Rackspace::AutoScale.new :rackspace_region => :dfw assert_method nil, :authenticate_v2 assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('current authentation') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::AutoScale.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true}, :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.list_groups end tests('dfw region').succeeds do @service = Fog::Rackspace::AutoScale.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_groups end tests('ord region').succeeds do @service = Fog::Rackspace::AutoScale.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil } @service.list_groups end tests('custom endpoint') do @service = Fog::Rackspace::AutoScale.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_auto_scale_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('specify region').succeeds do @service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil } @service.list_groups end tests('custom endpoint') do @service = Fog::Rackspace::AutoScale.new :rackspace_auto_scale_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? @service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad_token") returns(true) { [200, 203].include? @service.list_groups.status } end end fog-rackspace-0.1.6/tests/rackspace/storage_tests.rb 0000644 0000041 0000041 00000014251 13411315054 022564 0 ustar www-data www-data Shindo.tests('Rackspace | Storage', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Storage::Rackspace.new assert_method nil, :authenticate_v2 assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('authentication v1') do tests('variables populated').succeeds do @service = Fog::Storage::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.head_containers end tests('custom endpoint') do @service = Fog::Storage::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_storage_url => 'https://my-custom-endpoint.com' returns(false, "auth token populated") { @service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('authentation v2') do tests('variables populated').succeeds do @service = Fog::Storage::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => { :ssl_verify_peer => true } returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.head_containers end tests('dfw region').succeeds do @service = Fog::Storage::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw\d/) != nil } @service.head_containers end tests('ord region').succeeds do @service = Fog::Storage::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord\d/) != nil } @service.head_containers end tests('custom endpoint').succeeds do @service = Fog::Storage::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_storage_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do tests('no params').succeeds do @service = Fog::Storage::Rackspace.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw\d/) != nil } @service.head_containers end tests('specify region').succeeds do @service = Fog::Storage::Rackspace.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord\d/ ) != nil } @service.head_containers end tests('custom endpoint') do @service = Fog::Storage::Rackspace.new :rackspace_storage_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end tests('rackspace_servicenet') do @service = Fog::Storage::Rackspace.new :rackspace_servicenet => true returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /snet-/) != nil } end end tests('reauthentication') do tests('should reauth with valid credentials') do @service = Fog::Storage::Rackspace.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad-token") returns(204) { @service.head_containers.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::Storage::Rackspace.new :rackspace_api_key => 'bad_key' } end end tests('account').succeeds do Fog::Storage[:rackspace].account end tests('ssl') do tests('ssl enabled') do @service = Fog::Storage::Rackspace.new(:rackspace_cdn_ssl => true) returns(true) { @service.ssl? } end tests('ssl disabled') do @service = Fog::Storage::Rackspace.new(:rackspace_cdn_ssl => false) returns(false) { @service.ssl? } @service = Fog::Storage::Rackspace.new(:rackspace_cdn_ssl => nil) returns(false) { @service.ssl? } end end end fog-rackspace-0.1.6/tests/rackspace/service_tests.rb 0000644 0000041 0000041 00000004565 13411315054 022567 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Service', ['rackspace']) do tests('process_response') do @service = Fog::Rackspace::Service.new tests('nil').returns(nil) do @service.send(:process_response, nil) end tests('response missing body').returns(nil) do response = Excon::Response.new response.body = nil @service.send(:process_response, response) end tests('processes body').returns({'a'=>2, 'b'=>3}) do response = Excon::Response.new response.headers['Content-Type'] = "application/json" response.body = "{\"a\":2,\"b\":3}" @service.send(:process_response, response) response.body end tests('process body with hash').returns({:a=>2, :b=>3}) do response = Excon::Response.new response.headers['Content-Type'] = "application/json" response.body = {:a=>2, :b=>3} @service.send(:process_response, response) response.body end tests('handles malformed json').returns({}) do response = Excon::Response.new response.headers['Content-Type'] = "application/json" response.body = "I am totally not json" @service.send(:process_response, response) response.body end end tests('headers') do # adding an implementation for auth_token to service instance. Normally this would come from a subclass. def @service.auth_token "my_auth_token" end HEADER_HASH = { 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'X-Auth-Token' => @service.auth_token }.freeze tests('without options').returns(HEADER_HASH) do @service.send(:headers) end tests('with options not containing :header key').returns(HEADER_HASH) do @service.send(:headers, {:a => 3}) end tests('with options containing :header key').returns(HEADER_HASH.merge(:a => 3)) do @service.send(:headers, :headers => {:a => 3}) end end tests('request_params') do REQUEST_HASH = { :path=>"/endpoint/my_service", :headers=>{"Content-Type"=>"application/json", "Accept"=>"application/json", "X-Auth-Token"=>"my_auth_token"}, }.freeze uri = URI.parse("http://fog.io/endpoint") @service.instance_variable_set("@uri", uri) params = {:path => 'my_service'} tests('returns request hash').returns(REQUEST_HASH) do @service.send(:request_params, params) end end end fog-rackspace-0.1.6/tests/rackspace/models/ 0000755 0000041 0000041 00000000000 13411315054 020631 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/identity/ 0000755 0000041 0000041 00000000000 13411315054 022462 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/identity/credentials_tests.rb 0000644 0000041 0000041 00000001215 13411315054 026525 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity | credentials', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Identity.new user = service.users.all.first tests('success') do tests("#all").succeeds do credentials = user.credentials.all credentials.all? { |c| c.username && c.apiKey } end tests("#get").succeeds do list_credential = user.credentials.all.first credential = user.credentials.get(list_credential.identity) credential.username && credential.apiKey end end tests("failure").returns(nil) do user.credentials.get('i am a credential that does not exist') end end fog-rackspace-0.1.6/tests/rackspace/models/identity/service_catalog_tests.rb 0000644 0000041 0000041 00000026437 13411315054 027377 0 ustar www-data www-data require 'fog/rackspace/models/identity/service_catalog' Shindo.tests('Fog::Rackspace::ServiceCatalog | users', ['rackspace']) do tests('successful') do before_hash = {"access"=>{"token"=>{"expires"=>"2013-02-20T10:31:00.000-06:00", "tenant"=>{"name"=>"777", "id"=>"777"}, "id"=>"6ca10877-7c50-4a5c-b58f-004d835c39c3"}, "serviceCatalog"=>[{"type"=>"volume", "endpoints"=>[{"region"=>"DFW", "tenantId"=>"777", "publicURL"=>"https://dfw.blockstorage.api.rackspacecloud.com/v1/777"}, {"region"=>"ORD", "tenantId"=>"777", "publicURL"=>"https://ord.blockstorage.api.rackspacecloud.com/v1/777"}], "name"=>"cloudBlockStorage"}, {"type"=>"rax:load-balancer", "endpoints"=>[{"region"=>"ORD", "tenantId"=>"777", "publicURL"=>"https://ord.loadbalancers.api.rackspacecloud.com/v1.0/777"}, {"region"=>"DFW", "tenantId"=>"777", "publicURL"=>"https://dfw.loadbalancers.api.rackspacecloud.com/v1.0/777"}], "name"=>"cloudLoadBalancers"}, {"type"=>"object-store", "endpoints"=>[{"internalURL"=>"https://snet-storage101.dfw1.clouddrive.com/v1/Mosso777", "region"=>"DFW", "tenantId"=>"Mosso777", "publicURL"=>"https://storage101.dfw1.clouddrive.com/v1/Mosso777"}, {"internalURL"=>"https://snet-storage101.ord1.clouddrive.com/v1/Mosso777", "region"=>"ORD", "tenantId"=>"Mosso777", "publicURL"=>"https://storage101.ord1.clouddrive.com/v1/Mosso777"}], "name"=>"cloudFiles"}, {"type"=>"rax:database", "endpoints"=>[{"region"=>"DFW", "tenantId"=>"777", "publicURL"=>"https://dfw.databases.api.rackspacecloud.com/v1.0/777"}, {"region"=>"ORD", "tenantId"=>"777", "publicURL"=>"https://ord.databases.api.rackspacecloud.com/v1.0/777"}], "name"=>"cloudDatabases"}, {"type"=>"rax:dns", "endpoints"=>[{"tenantId"=>"777", "publicURL"=>"https://dns.api.rackspacecloud.com/v1.0/777"}], "name"=>"cloudDNS"}, {"type"=>"compute", "endpoints"=>[{"versionId"=>"1.0", "tenantId"=>"777", "versionList"=>"https://servers.api.rackspacecloud.com/", "versionInfo"=>"https://servers.api.rackspacecloud.com/v1.0", "publicURL"=>"https://servers.api.rackspacecloud.com/v1.0/777"}], "name"=>"cloudServers"}, {"type"=>"compute", "endpoints"=>[{"region"=>"DFW", "versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://dfw.servers.api.rackspacecloud.com/", "versionInfo"=>"https://dfw.servers.api.rackspacecloud.com/v2", "publicURL"=>"https://dfw.servers.api.rackspacecloud.com/v2/777"}, {"region"=>"ORD", "versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://ord.servers.api.rackspacecloud.com/", "versionInfo"=>"https://ord.servers.api.rackspacecloud.com/v2", "publicURL"=>"https://ord.servers.api.rackspacecloud.com/v2/777"}, {"versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://servers.api.rackspacecloud.com/", "versionInfo"=>"https://servers.api.rackspacecloud.com/v2", "publicURL"=>"https://servers.api.rackspacecloud.com/v2/777"}], "name"=>"cloudServersOpenStack"}, {"type"=>"rax:monitor", "endpoints"=>[{"tenantId"=>"777", "publicURL"=>"https://monitoring.api.rackspacecloud.com/v1.0/777"}], "name"=>"cloudMonitoring"}, {"type"=>"rax:object-cdn", "endpoints"=>[{"region"=>"DFW", "tenantId"=>"Mosso777", "publicURL"=>"https://cdn1.clouddrive.com/v1/Mosso777"}, {"region"=>"ORD", "tenantId"=>"Mosso777", "publicURL"=>"https://cdn2.clouddrive.com/v1/Mosso777"}], "name"=>"cloudFilesCDN"}, {"type"=>"not_here", "name" => "not_here", "endpoints"=>[{"tenantId"=>"777", "region" => "LON", "publicURL"=>"https://monitoring.api.rackspacecloud.com/v1.0/777"}]} ], "user"=>{"roles"=>[{"description"=>"User Admin Role.", "name"=>"identity:user-admin", "id"=>"3"}], "name"=>"joe-racker", "RAX-AUTH:defaultRegion"=>"", "id"=>"TK421"}}} @service_catalog = Fog::Rackspace::Identity::ServiceCatalog.from_response(nil, before_hash) end tests('services') do services = ["cloudBlockStorage", "cloudDNS", "cloudDatabases", "cloudFiles", "cloudFilesCDN", "cloudLoadBalancers", "cloudMonitoring", "cloudServers", "cloudServersOpenStack", "not_here"] returns(services) { @service_catalog.services.map {|s| s.to_s }.sort } end tests('get_endpoints') do endpoints = [{"region"=>"DFW", "versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://dfw.servers.api.rackspacecloud.com/", "versionInfo"=>"https://dfw.servers.api.rackspacecloud.com/v2", "publicURL"=>"https://dfw.servers.api.rackspacecloud.com/v2/777"}, {"region"=>"ORD", "versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://ord.servers.api.rackspacecloud.com/", "versionInfo"=>"https://ord.servers.api.rackspacecloud.com/v2", "publicURL"=>"https://ord.servers.api.rackspacecloud.com/v2/777"}, {"versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://servers.api.rackspacecloud.com/", "versionInfo"=>"https://servers.api.rackspacecloud.com/v2", "publicURL"=>"https://servers.api.rackspacecloud.com/v2/777"}] returns(endpoints) { @service_catalog.get_endpoints(:cloudServersOpenStack) } returns(endpoints) { @service_catalog.get_endpoints('cloudServersOpenStack') } returns({}) { @service_catalog.get_endpoints('non-existent') } end tests('get_endpoint') do tests('service with mulitple endpoints') do returns("https://dfw.servers.api.rackspacecloud.com/v2/777") { @service_catalog.get_endpoint(:cloudServersOpenStack, :dfw) } returns("https://ord.servers.api.rackspacecloud.com/v2/777") { @service_catalog.get_endpoint(:cloudServersOpenStack, :ord) } returns("https://dfw.servers.api.rackspacecloud.com/v2/777") { @service_catalog.get_endpoint(:cloudServersOpenStack, 'dfw') } returns("https://dfw.servers.api.rackspacecloud.com/v2/777") { @service_catalog.get_endpoint('cloudServersOpenStack', 'dfw') } returns("https://servers.api.rackspacecloud.com/v2/777") { @service_catalog.get_endpoint('cloudServersOpenStack', :global) } end tests('with one endpoint') do tests('catalog contains global endpoint') do catalog_hash = [{"type"=>"volume", "endpoints"=>[{"tenantId"=>"777", "publicURL"=>"https://blockstorage.api.rackspacecloud.com/v1/777"}], "name"=>"cloudBlockStorage"}] @service_catalog = Fog::Rackspace::Identity::ServiceCatalog.new(:service => nil, :catalog => catalog_hash) tests('no region specifed').returns("https://blockstorage.api.rackspacecloud.com/v1/777") do @service_catalog.get_endpoint(:cloudBlockStorage) end tests('region specifed').returns("https://blockstorage.api.rackspacecloud.com/v1/777") do @service_catalog.get_endpoint(:cloudBlockStorage, :ord) end end tests('catalog does not contain global endpoint') do catalog_hash = [{"type"=>"volume", "endpoints"=>[{"region" => "ORD", "tenantId"=>"777", "publicURL"=>"https://ord.blockstorage.api.rackspacecloud.com/v1/777"}], "name"=>"cloudBlockStorage"}] @service_catalog = Fog::Rackspace::Identity::ServiceCatalog.new(:service => nil, :catalog => catalog_hash) tests('non-existing region') do raises(RuntimeError) { @service_catalog.get_endpoint(:cloudBlockStorage, :dfw) } end tests('existing region').returns("https://ord.blockstorage.api.rackspacecloud.com/v1/777") do @service_catalog.get_endpoint(:cloudBlockStorage, :ord) end end end tests('endpoint type') do catalog_hash = [{"type"=>"object-store", "endpoints"=>[{"internalURL"=>"https://snet-storage101.dfw1.clouddrive.com/v1/Mosso777", "region"=>"DFW", "tenantId"=>"Mosso777", "publicURL"=>"https://storage101.dfw1.clouddrive.com/v1/Mosso777"}, {"internalURL"=>"https://snet-storage101.ord1.clouddrive.com/v1/Mosso777", "region"=>"ORD", "tenantId"=>"Mosso777", "publicURL"=>"https://storage101.ord1.clouddrive.com/v1/Mosso777"}], "name"=>"cloudFiles"}] @service_catalog = Fog::Rackspace::Identity::ServiceCatalog.new(:service => nil, :catalog => catalog_hash) returns("https://storage101.ord1.clouddrive.com/v1/Mosso777") { @service_catalog.get_endpoint(:cloudFiles, :ord) } returns("https://snet-storage101.ord1.clouddrive.com/v1/Mosso777") { @service_catalog.get_endpoint(:cloudFiles, :ord, true) } returns("https://storage101.ord1.clouddrive.com/v1/Mosso777") { @service_catalog.get_endpoint(:cloudFiles, :ord, false) } end tests('error conditions') do raises(RuntimeError) { @service_catalog.get_endpoint(:cloudServersOpenStack) } raises(RuntimeError) { @service_catalog.get_endpoint(:cloudServersOpenStack, :sat) } raises(RuntimeError) { @service_catalog.get_endpoint(:cloudServersOpenStack, :sat, true) } raises(RuntimeError) { @service_catalog.get_endpoint(:not_here, :dfw) } raises(RuntimeError) { @service_catalog.get_endpoint('non-existent') } raises(RuntimeError) { @service_catalog.get_endpoint(:cloudServersOpenStack, :ord, true) } end end tests('reload').succeeds do pending if Fog.mocking? service = Fog::Identity[:rackspace] service_catalog = service.service_catalog service_catalog.catalog << {"name"=>"fakeService", "endpoints"=>[{ "publicURL"=>"http:///fake-endpoint.com"}]} returns("http:///fake-endpoint.com") { service_catalog.get_endpoint :fakeService } returns("http:///fake-endpoint.com") { service.service_catalog.get_endpoint :fakeService } service_catalog.reload raises(RuntimeError) { service_catalog.get_endpoint :fakeService } raises(RuntimeError) { service.service_catalog.get_endpoint :fakeService } end tests('display_service_regions') do tests('with global endpoint').returns(":dfw, :ord, :global") do catalog_hash = [{"type"=>"compute", "endpoints"=>[{"region"=>"DFW", "versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://dfw.servers.api.rackspacecloud.com/", "versionInfo"=>"https://dfw.servers.api.rackspacecloud.com/v2", "publicURL"=>"https://dfw.servers.api.rackspacecloud.com/v2/777"}, {"region"=>"ORD", "versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://ord.servers.api.rackspacecloud.com/", "versionInfo"=>"https://ord.servers.api.rackspacecloud.com/v2", "publicURL"=>"https://ord.servers.api.rackspacecloud.com/v2/777"}, {"versionId"=>"2", "tenantId"=>"777", "versionList"=>"https://servers.api.rackspacecloud.com/", "versionInfo"=>"https://servers.api.rackspacecloud.com/v2", "publicURL"=>"https://servers.api.rackspacecloud.com/v2/777"}], "name"=>"cloudServersOpenStack"}] @service_catalog = Fog::Rackspace::Identity::ServiceCatalog.new(:service => nil, :catalog => catalog_hash) @service_catalog.display_service_regions(:cloudServersOpenStack) end tests('endpoint types') do catalog_hash = [{"type"=>"object-store", "endpoints"=>[{"internalURL"=>"https://snet-storage101.dfw1.clouddrive.com/v1/Mosso777", "region"=>"DFW", "tenantId"=>"Mosso777", "publicURL"=>"https://storage101.dfw1.clouddrive.com/v1/Mosso777"}, { "region"=>"ORD", "tenantId"=>"Mosso777", "publicURL"=>"https://storage101.ord1.clouddrive.com/v1/Mosso777"}], "name"=>"cloudFiles"},] @service_catalog = Fog::Rackspace::Identity::ServiceCatalog.new(:service => nil, :catalog => catalog_hash) tests('public').returns(":dfw, :ord") do @service_catalog.display_service_regions(:cloudFiles) end tests('private').returns(":dfw") do @service_catalog.display_service_regions(:cloudFiles, true) end end end end fog-rackspace-0.1.6/tests/rackspace/models/identity/users_tests.rb 0000644 0000041 0000041 00000000654 13411315054 025377 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity | users', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Identity.new username = "fog#{Time.now.to_i.to_s}" options = { :username => username, :email => 'email@example.com', :enabled => true } collection_tests(service.users, options, false) do tests('#get_by_name').succeeds do service.users.get_by_name(username) end end end fog-rackspace-0.1.6/tests/rackspace/models/identity/tenants_tests.rb 0000644 0000041 0000041 00000000717 13411315054 025712 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity | tenants', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Identity.new username = "fog_user_#{Time.now.to_i.to_s}" options = { :username => username, :email => 'email@example.com', :enabled => true } tests("#all").succeeds do service.tenants.all end tests("#get").succeeds do tenant = service.tenants.all.first service.tenants.get(tenant.identity) end end fog-rackspace-0.1.6/tests/rackspace/models/identity/user_tests.rb 0000644 0000041 0000041 00000000610 13411315054 025204 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity | user', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Identity.new options = { :username => "fog#{Time.now.to_i.to_s}", :email => 'email@example.com', :enabled => true } model_tests(service.users, options, false) do tests('#save with existing user').succeeds do @instance.save end end end fog-rackspace-0.1.6/tests/rackspace/models/identity/roles_tests.rb 0000644 0000041 0000041 00000000510 13411315054 025351 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity | roles', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Identity.new user = service.users.all.first tests("#all").succeeds do user.roles.all end tests("#get").succeeds do role = user.roles.all.first user.roles.get(role.identity) end end fog-rackspace-0.1.6/tests/rackspace/models/dns/ 0000755 0000041 0000041 00000000000 13411315054 021415 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/dns/zones_tests.rb 0000644 0000041 0000041 00000002735 13411315054 024331 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::DNS | zones', ['rackspace']) do provider = Fog::DNS[:rackspace] domain_sld = uniq_id domain_name = domain_sld + '.com' begin unless Fog.mocking? zone = provider.zones.create({:domain => domain_name, :email => "hostmaster@#{domain_name}"}) end tests("zones.find(#{domain_sld}) => finds domain_name") do pending if Fog.mocking? returns(true) { provider.zones.all.any? {|z| z.domain == domain_name} } end random_name = uniq_id tests("zones.find(#{random_name}) => finds nothing") do pending if Fog.mocking? returns(false) { provider.zones.all.any? {|z| z.domain == random_name} } end ensure zone.destroy unless Fog.mocking? end tests('next_params') do zones = Fog::DNS::Rackspace::Zones.new returns(nil, "no body") { zones.send(:next_params, nil)} returns(nil, "no links") { zones.send(:next_params, {}) } returns(nil, "links are empty") { zones.send(:next_params, {'links' => []}) } returns(nil, "links does not contain next hash") { zones.send(:next_params, {'links' => [ {'rel' => 'previous'} ] }) } returns(nil, "contains a link without parameters") { zones.send(:next_params, {'links' => [ {'rel' => 'next', 'href' => "http://localhost/next"} ] }) } returns({"offset"=>["3"], "limit"=>["3"]}, "contains a link without parameters") { zones.send(:next_params, {'links' => [ {'rel' => 'next', 'href' => "http://localhost/next?offset=3&limit=3"} ] }) } end end fog-rackspace-0.1.6/tests/rackspace/models/dns/zone_tests.rb 0000644 0000041 0000041 00000000721 13411315054 024137 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::DNS | zone', ['rackspace']) do pending if Fog.mocking? provider = Fog::DNS[:rackspace] domain_name = uniq_id + '.com' zone = provider.zones.create({:domain => domain_name, :email => 'hostmaster@' + domain_name}) tests('adding same domain twice throws error').raises(Fog::DNS::Rackspace::CallbackError) do provider.zones.create({:domain => domain_name, :email => 'hostmaster@' + domain_name}) end zone.destroy end fog-rackspace-0.1.6/tests/rackspace/models/databases/ 0000755 0000041 0000041 00000000000 13411315054 022560 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/databases/databases_tests.rb 0000644 0000041 0000041 00000000651 13411315054 026260 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Databases | databases', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new instance = service.instances.create({ :name => "fog_instance_#{Time.now.to_i.to_s}", :flavor_id => 1, :volume_size => 1 }) instance.wait_for { ready? } collection_tests(instance.databases, { :name => "db_#{Time.now.to_i.to_s}" }, false) instance.destroy end fog-rackspace-0.1.6/tests/rackspace/models/databases/database_tests.rb 0000644 0000041 0000041 00000001473 13411315054 026100 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Databases | database', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new instance = service.instances.create({ :name => "fog_instance_#{Time.now.to_i.to_s}", :flavor_id => 1, :volume_size => 1 }) instance.wait_for { ready? } model_tests(instance.databases, { :name => "db_#{Time.now.to_i.to_s}" }, false) user_no_host = instance.users.create(:name => "foo", :password => "foo") user_with_host = instance.users.create(:name => "bar", :host => "10.20.30.40", :password => "bar") db = instance.databases.create(:name => "Test_#{Time.now.to_i}") db.grant_access_for(user_no_host) db.grant_access_for(user_with_host) db.revoke_access_for(user_no_host) db.revoke_access_for(user_with_host) instance.destroy end fog-rackspace-0.1.6/tests/rackspace/models/databases/instances_tests.rb 0000644 0000041 0000041 00000000543 13411315054 026320 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Databases | instances', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new options = { :name => "fog_instance_#{Time.now.to_i.to_s}", :flavor_id => 1, :volume_size => 1 } collection_tests(service.instances, options, false) do @instance.wait_for { ready? } end end fog-rackspace-0.1.6/tests/rackspace/models/databases/users_tests.rb 0000644 0000041 0000041 00000000732 13411315054 025472 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Databases | users', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new instance = service.instances.create({ :name => "fog_instance_#{Time.now.to_i.to_s}", :flavor_id => 1, :volume_size => 1 }) instance.wait_for { ready? } options = { :name => "user_#{Time.now.to_i.to_s}", :password => "fog_user" } collection_tests(instance.users, options, false) instance.destroy end fog-rackspace-0.1.6/tests/rackspace/models/databases/instance_tests.rb 0000644 0000041 0000041 00000002243 13411315054 026134 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Databases | instance', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new options = { :name => "fog_instance_#{Time.now.to_i.to_s}", :flavor_id => 1, :volume_size => 1 } model_tests(service.instances, options, false) do @instance.wait_for { ready? } tests('root_user_enabled before user is enabled').returns(false) do @instance.root_user_enabled? end @instance.wait_for { ready? } tests('enable_root_user sets root user and password').succeeds do @instance.enable_root_user returns(false) { @instance.root_user.nil? } returns(false) { @instance.root_password.nil? } end @instance.wait_for { ready? } tests('restarts instance').succeeds do @instance.restart returns('REBOOT') { @instance.state } end @instance.wait_for { ready? } tests('resizes instance').succeeds do @instance.resize(2) returns('RESIZE') { @instance.state } end @instance.wait_for { ready? } tests('restarts instance').succeeds do @instance.resize_volume(2) returns('RESIZE') { @instance.state } end end end fog-rackspace-0.1.6/tests/rackspace/models/databases/flavors_tests.rb 0000644 0000041 0000041 00000000613 13411315054 026003 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Databases | flavors', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new tests("success") do tests("#all").succeeds do service.flavors.all end tests("#get").succeeds do service.flavors.get(1) end end tests("failure").returns(nil) do service.flavors.get('some_random_identity') end end fog-rackspace-0.1.6/tests/rackspace/models/databases/user_tests.rb 0000644 0000041 0000041 00000000724 13411315054 025310 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Databases | user', ['rackspace']) do pending if Fog.mocking? service = Fog::Rackspace::Databases.new instance = service.instances.create({ :name => "fog_instance_#{Time.now.to_i.to_s}", :flavor_id => 1, :volume_size => 1 }) instance.wait_for { ready? } options = { :name => "user_#{Time.now.to_i.to_s}", :password => "fog_user" } model_tests(instance.users, options, false) instance.destroy end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/ 0000755 0000041 0000041 00000000000 13411315054 022714 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/images_tests.rb 0000644 0000041 0000041 00000000676 13411315054 025741 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | images', ['rackspace']) do service = Fog::Compute::RackspaceV2.new image_id = nil tests("success") do tests("#all").succeeds do images = service.images.all image_id = images.first.id end tests("#get").succeeds do service.images.get(image_id) end end tests("failure").returns(nil) do service.images.get(Fog::Rackspace::MockData::NOT_FOUND_ID) end end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/image_tests.rb 0000644 0000041 0000041 00000004615 13411315054 025553 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | image', ['rackspace']) do service = Fog::Compute::RackspaceV2.new test_time = Time.now.to_i.to_s options = { :name => "fog_server_#{test_time}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service) } tests('ready?') do @server = Fog::Compute::RackspaceV2::Image.new tests('default in ready state').returns(true) do @server.state = Fog::Compute::RackspaceV2::Image::ACTIVE @server.ready? end tests('custom ready state').returns(true) do @server.state = Fog::Compute::RackspaceV2::Image::SAVING @server.ready?(Fog::Compute::RackspaceV2::Image::SAVING) end tests('default NOT in ready state').returns(false) do @server.state = Fog::Compute::RackspaceV2::Image::SAVING @server.ready? end tests('custom NOT ready state').returns(false) do @server.state = Fog::Compute::RackspaceV2::Image::UNKNOWN @server.ready?(Fog::Compute::RackspaceV2::Image::SAVING) end tests('default error state').returns(true) do @server.state = Fog::Compute::RackspaceV2::Image::ERROR exception_occurred = false begin @server.ready? rescue Fog::Compute::RackspaceV2::InvalidImageStateException => e exception_occurred = true returns(true) {e.desired_state == Fog::Compute::RackspaceV2::Image::ACTIVE } returns(true) {e.current_state == Fog::Compute::RackspaceV2::Image::ERROR } end exception_occurred end tests('custom error state').returns(true) do @server.state = Fog::Compute::RackspaceV2::Image::UNKNOWN exception_occurred = false begin @server.ready?(Fog::Compute::RackspaceV2::Image::SAVING, Fog::Compute::RackspaceV2::Image::UNKNOWN) rescue Fog::Compute::RackspaceV2::InvalidImageStateException => e exception_occurred = true returns(true) {e.desired_state == Fog::Compute::RackspaceV2::Image::SAVING } returns(true) {e.current_state == Fog::Compute::RackspaceV2::Image::UNKNOWN } end exception_occurred end end tests("success") do begin server = service.servers.create(options) server.wait_for { ready? } image = server.create_image("fog_image_#{test_time}") tests("destroy").succeeds do image.destroy end ensure server.destroy if server end end end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/keypairs_tests.rb 0000644 0000041 0000041 00000002307 13411315054 026314 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | key_pairs', ['rackspace']) do service = Fog::Compute::RackspaceV2.new name = Fog::Mock.random_letters(32) key = nil tests("API access") do begin tests("create").succeeds do key = service.key_pairs.create({:name => name}) end tests("list all").succeeds do service.key_pairs.all end tests("get").succeeds do service.key_pairs.get(name) end tests("delete").succeeds do key = nil if service.key_pairs.destroy(name) key == nil end tests("get unknown").returns(nil) do service.key_pairs.get(Fog::Mock.random_letters(32)) end tests("delete unknown").raises(Fog::Compute::RackspaceV2::NotFound) do service.key_pairs.destroy(Fog::Mock.random_letters(32)) end tests("create again after delete").succeeds do key = service.key_pairs.create({:name => name}) end tests("create already existing").raises(Fog::Compute::RackspaceV2::ServiceError) do service.key_pairs.create({:name => name}) end ensure key.destroy if key end end end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/networks_tests.rb 0000644 0000041 0000041 00000000416 13411315054 026340 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | networks', ['rackspace']) do service = Fog::Compute::RackspaceV2.new options = { :label => "fog_network_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24' } collection_tests(service.networks, options, true) end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/server_tests.rb 0000644 0000041 0000041 00000020607 13411315054 025776 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | server', ['rackspace']) do service = Fog::Compute::RackspaceV2.new cbs_service = Fog::Rackspace::BlockStorage.new tests('setup test network').succeeds do @network = service.networks.create :label => "fog_test_net_#{Time.now.to_i.to_s}", :cidr => '192.168.1.0/24' end options = { :name => "fog_server_#{Time.now.to_i.to_s}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service), :metadata => { 'fog_test' => 'true' }, :networks => [@network.id] } tests('ready?') do @server = Fog::Compute::RackspaceV2::Server.new tests('default in ready state').returns(true) do @server.state = Fog::Compute::RackspaceV2::Server::ACTIVE @server.ready? end tests('custom ready state').returns(true) do @server.state = Fog::Compute::RackspaceV2::Server::VERIFY_RESIZE @server.ready?(Fog::Compute::RackspaceV2::Server::VERIFY_RESIZE) end tests('default NOT in ready state').returns(false) do @server.state = Fog::Compute::RackspaceV2::Server::REBOOT @server.ready? end tests('custom NOT ready state').returns(false) do @server.state = Fog::Compute::RackspaceV2::Server::REBOOT @server.ready?(Fog::Compute::RackspaceV2::Server::VERIFY_RESIZE) end tests('default error state').returns(true) do @server.state = Fog::Compute::RackspaceV2::Server::ERROR exception_occurred = false begin @server.ready? rescue Fog::Compute::RackspaceV2::InvalidServerStateException => e exception_occurred = true returns(true) {e.desired_state == Fog::Compute::RackspaceV2::Server::ACTIVE } returns(true) {e.current_state == Fog::Compute::RackspaceV2::Server::ERROR } end exception_occurred end tests('custom error state').returns(true) do @server.state = Fog::Compute::RackspaceV2::Server::ACTIVE exception_occurred = false begin @server.ready?(Fog::Compute::RackspaceV2::Server::VERIFY_RESIZE, Fog::Compute::RackspaceV2::Server::ACTIVE) rescue Fog::Compute::RackspaceV2::InvalidServerStateException => e exception_occurred = true returns(true) {e.desired_state == Fog::Compute::RackspaceV2::Server::VERIFY_RESIZE } returns(true) {e.current_state == Fog::Compute::RackspaceV2::Server::ACTIVE } end exception_occurred end end model_tests(service.servers, options, true) do @instance.wait_for { ready? } tests('#metadata[\'fog_test\']').returns('true') do @instance.metadata['fog_test'] end tests("includes #{@network.label}").returns(true) do @instance.addresses.keys.include?(@network.label) end tests('#create').succeeds do pending unless Fog.mocking? original_options = Marshal.load(Marshal.dump(options)) @instance.create(options) returns(true) { original_options == options } end tests('#update').succeeds do new_name = "fog_server_update#{Time.now.to_i.to_s}" @instance.name = new_name @instance.access_ipv4_address= "10.10.0.1" @instance.access_ipv6_address= "::1" @instance.save sleep 60 unless Fog.mocking? @instance.reload returns("10.10.0.1") { @instance.access_ipv4_address } returns("::1") { @instance.access_ipv6_address } returns(new_name) { @instance.name } end tests('#reboot("SOFT")').succeeds do @instance.reboot('SOFT') returns('REBOOT') { @instance.state } end @instance.wait_for { ready? } tests('#reboot("HARD")').succeeds do @instance.reboot('HARD') returns('HARD_REBOOT') { @instance.state } end sleep 30 unless Fog.mocking? @instance.wait_for { ready? } sleep 60 unless Fog.mocking? tests('#rebuild').succeeds do @instance.rebuild rackspace_test_image_id(service) returns('REBUILD') { @instance.state } end sleep 30 unless Fog.mocking? @instance.wait_for { ready? } sleep 60 unless Fog.mocking? tests('#resize').succeeds do @instance.resize(3) returns('RESIZE') { @instance.state } end sleep 30 unless Fog.mocking? @instance.wait_for { ready?('VERIFY_RESIZE', ['ACTIVE', 'ERROR']) } sleep 60 unless Fog.mocking? tests('#confirm_resize').succeeds do @instance.confirm_resize end sleep 30 unless Fog.mocking? @instance.wait_for { ready? } sleep 60 unless Fog.mocking? tests('#resize').succeeds do @instance.resize(2) returns('RESIZE') { @instance.state } end @instance.wait_for { ready?('VERIFY_RESIZE') } sleep 60 unless Fog.mocking? tests('#revert_resize').succeeds do @instance.revert_resize end @instance.wait_for { ready? } tests('#rescue').succeeds do @instance.rescue end @instance.wait_for { ready?('RESCUE') } tests('#start').succeeds do @instance.start end sleep 30 unless Fog.mocking? @instance.wait_for { ready?('ACTIVE') } tests('#stop').succeeds do @instance.stop end sleep 30 unless Fog.mocking? @instance.wait_for { ready?('SHUTOFF') } tests('#unrescue').succeeds do @instance.unrescue end @instance.wait_for { ready? } tests('#change_admin_password').succeeds do @instance.change_admin_password('somerandompassword') returns('PASSWORD') { @instance.state } returns('somerandompassword') { @instance.password } end @instance.wait_for { ready? } @test_image = nil begin tests('#create_image').succeeds do @test_image = @instance.create_image('fog-test-image') @test_image.reload returns('SAVING') { @test_image.state } end ensure @test_image.destroy unless @test_image.nil? || Fog.mocking? end tests('attachments') do begin @volume = cbs_service.volumes.create(:size => 100, :display_name => "fog-#{Time.now.to_i.to_s}") @volume.wait_for { ready? } tests('#attach_volume').succeeds do @instance.attach_volume(@volume) end tests('#attachments').returns(true) do @instance.wait_for do !attachments.empty? end @instance.attachments.any? {|a| a.volume_id == @volume.id } end ensure @volume.wait_for { !attachments.empty? } @instance.attachments.each {|a| a.detach } @volume.wait_for { ready? && attachments.empty? } @volume.destroy if @volume end end @instance.wait_for { ready? } end tests('#setup') do ATTRIBUTES = { :name => "foo", :image_id => 42, :flavor_id => 42 } create_server = lambda { |attributes| service = Fog::Compute::RackspaceV2.new attributes.merge!(:service => service) Fog::SSH::Mock.data.clear server = Fog::Compute::RackspaceV2::Server.new(attributes) server.save(attributes) @address = 123 server.ipv4_address = @address server.identity = "bar" server.public_key = "baz" server.setup server } commands = lambda { Fog::SSH::Mock.data[@address].first[:commands] } test("lock user when requested") do create_server.call(ATTRIBUTES.merge(:passwd_lock => true)) commands.call.one? { |c| c =~ /passwd\s+-l\s+root/ } end test("provide a password when the passed isn't locked") do pwd = create_server.call( ATTRIBUTES.merge(:passwd_lock => false) ).password # shindo expects a boolean not truthyness :-( !!pwd end test("leaves user unlocked by default") do create_server.call(ATTRIBUTES) commands.call.none? { |c| c =~ /passwd\s+-l\s+root/ } end test("nils password when password is locked") do pwd = create_server.call(ATTRIBUTES.merge(:passwd_lock => true)).password pwd.nil? end end #When after testing resize/resize_confirm we get a 409 when we try to resize_revert so I am going to split it into two blocks model_tests(service.servers, options, true) do @instance.wait_for { ready? } tests('#resize').succeeds do @instance.resize(4) returns('RESIZE') { @instance.state } end @instance.wait_for { ready?('VERIFY_RESIZE') } sleep 60 unless Fog.mocking? tests('#revert_resize').succeeds do @instance.revert_resize end @instance.wait_for { ready? } end wait_for_server_deletion(@instance) delete_test_network(@network) end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/network_tests.rb 0000644 0000041 0000041 00000000410 13411315054 026147 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | network', ['rackspace']) do service = Fog::Compute::RackspaceV2.new options = { :label => "fog_network_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24' } model_tests(service.networks, options, true) end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/flavors_tests.rb 0000644 0000041 0000041 00000000626 13411315054 026143 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | flavors', ['rackspace']) do service = Fog::Compute::RackspaceV2.new tests("success") do tests("#all").succeeds do service.flavors.all end tests("#get").succeeds do service.flavors.get(service.flavors.first.id) end end tests("failure").returns(nil) do service.flavors.get(Fog::Rackspace::MockData::NOT_FOUND_ID) end end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/servers_tests.rb 0000644 0000041 0000041 00000001034 13411315054 026152 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | servers', ['rackspace']) do service = Fog::Compute::RackspaceV2.new options = { :name => "fog_server_#{Time.now.to_i.to_s}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service) } collection_tests(service.servers, options, true) do @instance.wait_for { ready? } end tests("#bootstrap").succeeds do pending if Fog.mocking? @server = service.servers.bootstrap(options) end if @server @server.destroy end end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/metadata_tests.rb 0000644 0000041 0000041 00000002502 13411315054 026242 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | metadata', ['rackspace']) do pending if Fog.mocking? service = Fog::Compute::RackspaceV2.new test_time = Time.now.to_i.to_s tests('success') do begin @server = service.servers.create(:name => "fog_server_#{test_time}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service)) @server.wait_for { ready? } tests('server') do collection_tests(@server.metadata, {:key => 'my_key', :value => 'my_value'}) do @server.wait_for { ready? } end end tests('image') do @image = @server.create_image("fog_image_#{test_time}", :metadata => {:my_key => 'my_value'}) @image.wait_for { ready? } tests("#all").succeeds do pending if Fog.mocking? && !mocks_implemented metadata = @image.metadata.all my_metadata = metadata.select {|datum| datum.key == 'my_key'} returns(1) { my_metadata.size } returns('my_value') {my_metadata[0].value } end tests("#get('my_key')").returns('my_value') do pending if Fog.mocking? && !mocks_implemented @image.metadata.get('my_key').value end end ensure @image.destroy if @image @server.destroy if @server end end end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/virtual_interface_tests.rb 0000644 0000041 0000041 00000001561 13411315054 030174 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | virtual_interface', ['rackspace']) do service = Fog::Compute::RackspaceV2.new net_options = { :label => "fog_network_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24' } server_options = { :name => "fog_server_#{Time.now.to_i.to_s}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service) } tests('virtual_interface') do pending if Fog.mocking? begin @server = service.servers.create server_options @network = service.networks.create net_options @server.wait_for { ready? } model_tests(@server.virtual_interfaces, {:network => @network}, false) ensure if @server @server.destroy # wait_for_server_deletion(@server) if @server delete_test_network(@network) if @network end end end end fog-rackspace-0.1.6/tests/rackspace/models/compute_v2/virtual_interfaces_tests.rb 0000644 0000041 0000041 00000001137 13411315054 030356 0 ustar www-data www-data Shindo.tests('Fog::Compute::RackspaceV2 | virtual_interfaces', ['rackspace']) do service = Fog::Compute::RackspaceV2.new options = { :name => "fog_server_#{Time.now.to_i.to_s}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service) } tests('virtual_interfaces') do pending if Fog.mocking? begin @server = service.servers.create options @server.wait_for { ready? } tests('#virtual_interfaces').succeeds do @server.virtual_interfaces.all end ensure @server.destroy if @server end end end fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/ 0000755 0000041 0000041 00000000000 13411315054 023562 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/virtual_ips_tests.rb 0000644 0000041 0000041 00000000456 13411315054 027677 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | virtual_ips', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do collection_tests(@lb.virtual_ips, { :type => 'PUBLIC'}, false) do @lb.wait_for { ready? } end end end end fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/virtual_ip_tests.rb 0000644 0000041 0000041 00000000632 13411315054 027510 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | virtual_ip', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do model_tests(@lb.virtual_ips, { :type => 'PUBLIC'}, false) do @lb.wait_for { ready? } tests("#save => existing virtual IP").raises(Fog::Errors::Error) do @instance.save end end end end end fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/access_list_tests.rb 0000644 0000041 0000041 00000000500 13411315054 027620 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | access_list', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do model_tests(@lb.access_rules, { :address => '1.1.1.2', :type => 'ALLOW'}, false) do @lb.wait_for { ready? } end end end end fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/load_balancer_tests.rb 0000644 0000041 0000041 00000014757 13411315054 030115 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer', ['rackspace']) do pending if Fog.mocking? MINIMAL_LB_ATTRIBUTES = { :name => "fog#{Time.now.to_i}", :protocol => 'HTTP', :virtual_ips => [{ :type => 'PUBLIC' }], } NORMAL_LB_ATTRIBUTES = MINIMAL_LB_ATTRIBUTES.merge({ :port => 8080, :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED' }] }) FULL_LB_ATTRIBUTES = NORMAL_LB_ATTRIBUTES.merge({ :algorithm => 'LEAST_CONNECTIONS', :timeout => 60 }) HTTPS_REDIRECT_LB_ATTRIBUTES = FULL_LB_ATTRIBUTES.merge({ :protocol => 'HTTPS', :https_redirect => true }) given_a_load_balancer_service do model_tests(@service.load_balancers, NORMAL_LB_ATTRIBUTES, false) do @instance.wait_for { ready? } tests('#save => saving existing with port = 88').succeeds do @instance.port = 88 @instance.save end @instance.wait_for { ready? } tests('#stats').succeeds do @instance.stats end tests('#enable_connection_logging').succeeds do @instance.enable_connection_logging returns(true) { @instance.connection_logging } end tests('#enable_connection_logging after reload').succeeds do @instance.reload returns(true) { @instance.connection_logging } end @instance.wait_for { ready? } tests('#disable_connection_logging').succeeds do @instance.disable_connection_logging returns(false) { @instance.connection_logging } end @instance.wait_for { ready? } tests('#enable_content_caching').succeeds do @instance.enable_content_caching returns(true) { @instance.content_caching } end tests('#enable_content_caching after reload').succeeds do @instance.reload returns(true) { @instance.content_caching } end @instance.wait_for { ready? } tests('#disable_content_caching').succeeds do @instance.disable_content_caching returns(false) { @instance.content_caching } end tests('#usage').succeeds do @instance.usage end tests("#usage(:start_time => '2010-05-10', :end_time => '2010-05-11')").succeeds do @instance.usage(:start_time => '2010-05-10', :end_time => '2010-05-11') end tests("#health_monitor").returns(nil) do @instance.health_monitor end @instance.wait_for { ready? } tests("#enable_health_monitor('CONNECT', 5, 5, 5)").succeeds do @instance.enable_health_monitor('CONNECT', 5, 5, 5) end @instance.wait_for { ready? } tests("#health_monitor").succeeds do monitor = @instance.health_monitor returns('CONNECT') { monitor['type'] } end @instance.wait_for { ready? } tests("#enable_health_monitor('HTTP', 10, 5, 2, {:status_regex => '^[234][0-9][0-9]$', :path=>'/', :body_regex=>' '})").succeeds do @instance.enable_health_monitor('HTTP', 10, 5, 2, {:status_regex => '^[234][0-9][0-9]$', :path=>'/', :body_regex=>' '}) end @instance.wait_for { ready? } tests("#disable_health_monitor").succeeds do @instance.disable_health_monitor end @instance.wait_for { ready? } tests("#connection_throttling").returns(nil) do @instance.connection_throttling end tests("#enable_connection_throttling(5, 5, 5, 5)").succeeds do @instance.enable_connection_throttling(5, 5, 5, 5) end @instance.wait_for { ready? } tests("#connection_throttling").succeeds do throttle = @instance.connection_throttling returns(5) { throttle['maxConnections'] } end @instance.wait_for { ready? } tests("#disable_connection_throttling").succeeds do @instance.disable_connection_throttling end @instance.wait_for { ready? } tests("#session_persistence").returns(nil) do @instance.session_persistence end tests("#enable_session_persistence('HTTP_COOKIE')").succeeds do @instance.enable_session_persistence('HTTP_COOKIE') end @instance.wait_for { ready? } tests("#connction_throttling").succeeds do persistence = @instance.session_persistence returns('HTTP_COOKIE') { persistence['persistenceType'] } end @instance.wait_for { ready? } tests("#disable_session_persistence").succeeds do @instance.disable_session_persistence end @instance.wait_for { ready? } tests("#error_page").succeeds do @instance.error_page end @instance.wait_for { ready? } tests("#error_page = 'asdf'").succeeds do @instance.error_page = 'asdf' end @instance.wait_for { ready? } tests("#reset_error_page").succeeds do @instance.reset_error_page end @instance.wait_for { ready? } tests("#ssl_termination is nil").returns(nil) do @instance.ssl_termination end @instance.wait_for { ready? } tests("#enable_ssl_termination(443, PRIVATE_KEY, CERTIFICATE").succeeds do @instance.enable_ssl_termination(443, PRIVATE_KEY, CERTIFICATE) end @instance.wait_for { ready? } tests("#ssl_termination").succeeds do @instance.ssl_termination end @instance.wait_for { ready? } tests("#disable_ssl_termination").succeeds do @instance.disable_ssl_termination end @instance.wait_for { ready? } end tests('create with minimal attributes') do @lb = @service.load_balancers.create MINIMAL_LB_ATTRIBUTES returns(MINIMAL_LB_ATTRIBUTES[:name]) { @lb.name } returns('HTTP') { @lb.protocol } returns(80) { @lb.port } @lb.wait_for { ready? } @lb.destroy end tests('create with full attributes') do @lb = @service.load_balancers.create FULL_LB_ATTRIBUTES returns('LEAST_CONNECTIONS') { @lb.algorithm } returns(60) { @lb.timeout } @lb.wait_for { ready? } @lb.destroy end tests('create with httpsRedirect') do @lb = @service.load_balancers.create HTTPS_REDIRECT_LB_ATTRIBUTES returns('HTTPS') { @lb.protocol } returns(true) { @lb.https_redirect } @lb.wait_for { ready? } @lb.destroy end tests('failure') do @lb = @service.load_balancers.new NORMAL_LB_ATTRIBUTES tests('#usage => Requires ID').raises(ArgumentError) do @lb.usage end tests('#health_monitor => Requires ID').raises(ArgumentError) do @lb.health_monitor end end end end fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/load_balancers_tests.rb 0000644 0000041 0000041 00000001017 13411315054 030261 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancers', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do @lb_name = 'fog' + Time.now.to_i.to_s collection_tests(@service.load_balancers, { :name => @lb_name, :protocol => 'HTTP', :port => 80, :virtual_ips => [{ :type => 'PUBLIC'}], :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}] }, false) do @instance.wait_for { ready? } end end end fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/node_tests.rb 0000644 0000041 0000041 00000000760 13411315054 026261 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | node', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do model_tests(@lb.nodes, { :address => '1.1.1.2', :port => 80, :condition => 'ENABLED'}, false) do @lb.wait_for { ready? } tests("#save() => existing node with port = 88").succeeds do @instance.port = 88 @instance.save end @lb.wait_for { ready? } end end end end fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/nodes_tests.rb 0000644 0000041 0000041 00000000514 13411315054 026441 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | nodes', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do collection_tests(@lb.nodes, { :address => '1.1.1.2', :port => 80, :condition => 'ENABLED'}, false) do @lb.wait_for { ready? } end end end end fog-rackspace-0.1.6/tests/rackspace/models/load_balancers/access_lists_tests.rb 0000644 0000041 0000041 00000000506 13411315054 030011 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers | access_lists', ['rackspace']) do pending if Fog.mocking? given_a_load_balancer_service do given_a_load_balancer do collection_tests(@lb.access_rules, { :address => '1.1.1.2', :type => 'ALLOW'}, false) do @lb.wait_for { ready? } end end end end fog-rackspace-0.1.6/tests/rackspace/models/block_storage/ 0000755 0000041 0000041 00000000000 13411315054 023447 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/block_storage/volume_types_tests.rb 0000644 0000041 0000041 00000000646 13411315054 027757 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage | volume_types', ['rackspace']) do service = Fog::Rackspace::BlockStorage.new tests("success") do tests("#all").succeeds do service.volume_types.all end tests("#get").succeeds do service.volume_types.get(service.volume_types.first.id) end end tests("failure").returns(nil) do service.volume_types.get('some_random_identity') end end fog-rackspace-0.1.6/tests/rackspace/models/block_storage/volume_tests.rb 0000644 0000041 0000041 00000001503 13411315054 026524 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage | volume', ['rackspace']) do service = Fog::Rackspace::BlockStorage.new options = { :display_name => "fog_#{Time.now.to_i.to_s}", :size => 100 } model_tests(service.volumes, options, true) do @instance.wait_for{ ready? } tests('double save').raises(Fog::Rackspace::BlockStorage::IdentifierTaken) do @instance.save end tests('#attached?').succeeds do @instance.state = 'in-use' returns(true) { @instance.attached? } end tests('#snapshots').succeeds do begin snapshot = @instance.create_snapshot snapshot.wait_for { ready? } returns(true) { @instance.snapshots.first.id == snapshot.id } ensure snapshot.destroy if snapshot end end @instance.wait_for { snapshots.empty? } end end fog-rackspace-0.1.6/tests/rackspace/models/block_storage/snapshots_tests.rb 0000644 0000041 0000041 00000000767 13411315054 027252 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage | snapshots', ['rackspace']) do service = Fog::Rackspace::BlockStorage.new volume = service.volumes.create({ :display_name => "fog_#{Time.now.to_i.to_s}", :size => 100 }) volume.wait_for { ready? } options = { :display_name => "fog_#{Time.now.to_i.to_s}", :volume_id => volume.id } collection_tests(service.snapshots, options, true) do @instance.wait_for { ready? } end volume.wait_for { snapshots.empty? } volume.destroy end fog-rackspace-0.1.6/tests/rackspace/models/block_storage/volumes_tests.rb 0000644 0000041 0000041 00000000445 13411315054 026713 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage | volumes', ['rackspace']) do service = Fog::Rackspace::BlockStorage.new options = { :display_name => "fog_#{Time.now.to_i.to_s}", :size => 100 } collection_tests(service.volumes, options, true) do @instance.wait_for { ready? } end end fog-rackspace-0.1.6/tests/rackspace/models/block_storage/snapshot_tests.rb 0000644 0000041 0000041 00000001236 13411315054 027057 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::BlockStorage | snapshot', ['rackspace']) do service = Fog::Rackspace::BlockStorage.new begin volume = service.volumes.create({ :display_name => "fog_#{Time.now.to_i.to_s}", :size => 100 }) volume.wait_for { ready? } options = { :display_name => "fog_#{Time.now.to_i.to_s}", :volume_id => volume.id } model_tests(service.snapshots, options, true) do @instance.wait_for { ready? } tests('double save').raises(Fog::Rackspace::BlockStorage::IdentifierTaken) do @instance.save end end volume.wait_for { snapshots.empty? } ensure volume.destroy if volume end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/ 0000755 0000041 0000041 00000000000 13411315054 023016 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/monitoring/data_points_tests.rb 0000644 0000041 0000041 00000001325 13411315054 027073 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | datapoints', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new begin label = "fog_#{Time.now.to_i.to_s}" @entity = service.entities.create :label => label @check = service.checks.create CHECK_CREATE_OPTIONS.merge(:label => label, :entity => @entity) sleep(@check.period + 30) unless Fog.mocking? @metric = service.metrics(:check => @check).first tests('#datapoints').succeeds do service.data_points(:metric => @metric).fetch({ :from => ((Time.now.to_i * 1000) - (3600 * 1000)) }) end ensure @check.destroy rescue nil if @check @entity.destroy rescue nil if @entity end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/notifications_tests.rb 0000644 0000041 0000041 00000000546 13411315054 027443 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | notifications', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new options = { :label => "fog_#{Time.now.to_i.to_s}", :type => "email", :details => {:address => "test@test.com"} } collection_tests(service.notifications, options, false) do end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/check_types_tests.rb 0000644 0000041 0000041 00000000501 13411315054 027062 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | check_types', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new @check_types = service.check_types tests('#all').succeeds do @check_types.all end tests('#new').succeeds do @check_types.new end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/alarm_tests.rb 0000644 0000041 0000041 00000003775 13411315054 025675 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | alarm', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new tests('#alarm=') do tests('should assign alarm id if object is a string') do alarm = Fog::Rackspace::Monitoring::Alarm.new id = "123123" alarm.id = "123123" returns(Fog::Rackspace::Monitoring::Alarm) { alarm.class } returns(id) { alarm.id } end tests('should set check if object is a check') do entity_id = "555" entity = Fog::Rackspace::Monitoring::Entity.new(:id => entity_id) check_id = "54321" check = Fog::Rackspace::Monitoring::Check.new(:id => check_id) check.entity = entity alarm = Fog::Rackspace::Monitoring::Alarm.new alarm.check = check.id returns(Fog::Rackspace::Monitoring::Alarm) { alarm.class } returns(check_id) { alarm.check.id } end end begin @entity = service.entities.create :label => "fog_#{Time.now.to_i.to_s}" @check = service.checks.create(CHECK_CREATE_OPTIONS.merge( :label => "fog_#{Time.now.to_i.to_s}", :entity => @entity) ) np = "npTechnicalContactsEmail" options = CHECK_CREATE_OPTIONS.merge( :disabled => false, :label => "fog_#{Time.now.to_i.to_s}", :entity => @entity, :entity_id => @entity.id, :check => @check, :check_id => @check.id, :notification_plan_id => np ) collection = service.alarms(:entity => @entity) model_tests(collection, options, false) do tests('#update').succeeds do @instance.disabled = true new_label = "new_label_#{Time.now.to_i.to_s}" @instance.label = new_label @instance.save @instance.label = nil # blank out label just to make sure @instance.reload returns(new_label) { @instance.label} returns(true) { @instance.disabled } end end ensure @entity.destroy if @entity end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/entities_tests.rb 0000644 0000041 0000041 00000000620 13411315054 026407 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | entities', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new options = { :label => "fog_#{Time.now.to_i.to_s}", :ip_addresses => {:default => "127.0.0.1"} } collection_tests(service.entities, options, false) do end tests('overview').succeeds do service.entities.overview end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/agent_token_tests.rb 0000644 0000041 0000041 00000000407 13411315054 027064 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | agent token', ['rackspace','rackspace_monitoring']) do service = Fog::Rackspace::Monitoring.new options = { :label => "fog_#{Time.now.to_i.to_s}" } model_tests(service.agent_tokens, options, false) do end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/entity_tests.rb 0000644 0000041 0000041 00000001336 13411315054 026104 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | entity', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new options = { :label => "fog_#{Time.now.to_i.to_s}", :ip_addresses => {:default => "127.0.0.1"} } model_tests(service.entities, options, false) do tests('#update').succeeds do new_label = "new_label_#{Time.now.to_i.to_s}" @instance.label = new_label @instance.save @instance.label = nil # blank out label just to make sure @instance.reload returns(new_label) { @instance.label } end tests('#checks').succeeds do @instance.checks end tests('#alarms').succeeds do @instance.alarms end end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/notification_tests.rb 0000644 0000041 0000041 00000001171 13411315054 027253 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | notification', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new options = { :label => "fog_#{Time.now.to_i.to_s}", :type => "email", :details => {:address => "test@test.com"} } model_tests(service.notifications, options, false) do tests('#update').succeeds do new_label = "new_label_#{Time.now.to_i.to_s}" @instance.label = new_label @instance.save @instance.label = nil # blank out label just to make sure @instance.reload returns(new_label) { @instance.label } end end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/agent_tokens_tests.rb 0000644 0000041 0000041 00000000415 13411315054 027246 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | agent tokens', ['rackspace','rackspace_monitoring']) do service = Fog::Rackspace::Monitoring.new options = { :label => "fog_#{Time.now.to_i.to_s}" } collection_tests(service.agent_tokens, options, false) do end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/check_tests.rb 0000644 0000041 0000041 00000003232 13411315054 025642 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | check', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new tests('#entity=') do tests('should create new entity if object is a string') do check = Fog::Rackspace::Monitoring::Check.new id = "123123" check.entity = "123123" returns(Fog::Rackspace::Monitoring::Entity) { check.entity.class } returns(id) { check.entity.id } end tests('should set entity if object is an entity') do id = "555" entity = Fog::Rackspace::Monitoring::Entity.new(:id => id) check = Fog::Rackspace::Monitoring::Check.new check.entity = entity returns(Fog::Rackspace::Monitoring::Entity) { check.entity.class } returns(id) { check.entity.id } end end begin @entity = service.entities.create :label => "fog_#{Time.now.to_i.to_s}" options = CHECK_CREATE_OPTIONS.merge(:label => "fog_#{Time.now.to_i.to_s}", :entity => @entity) collection = service.checks(:entity => @entity) model_tests(collection, options, false) do tests('#update').succeeds do new_label = "new_label_#{Time.now.to_i.to_s}" @instance.label = new_label timeout = 2 @instance.timeout = 2 @instance.save @instance.timeout = -1 # blank out timeout just to make sure @instance.label = nil # blank out label just to make sure @instance.reload returns(timeout) { @instance.timeout } returns(new_label) { @instance.label} end tests('#metrics').succeeds do @instance.metrics end end ensure @entity.destroy if @entity end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/metric_tests.rb 0000644 0000041 0000041 00000001200 13411315054 026041 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | metrics', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new begin label = "fog_#{Time.now.to_i.to_s}" @entity = service.entities.create :label => label @check = service.checks.create CHECK_CREATE_OPTIONS.merge(:label => label, :entity => @entity) sleep(@check.period + 30) unless Fog.mocking? @metric = service.metrics(:check => @check).first tests('#datapoints').succeeds do @metric.datapoints end ensure @check.destroy rescue nil if @check @entity.destroy rescue nil if @entity end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/alarms_tests.rb 0000644 0000041 0000041 00000001570 13411315054 026047 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | alarms', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new begin @entity = service.entities.create :label => "fog_#{Time.now.to_i.to_s}" @check = service.checks.create(CHECK_CREATE_OPTIONS.merge( :label => "fog_#{Time.now.to_i.to_s}", :entity => @entity) ) np = "npTechnicalContactsEmail" options = CHECK_CREATE_OPTIONS.merge( :label => "fog_#{Time.now.to_i.to_s}", :entity => @entity, :entity_id => @entity.id, :check => @check, :check_id => @check.id, :notification_plan_id => np ) collection = service.alarms(:entity => @entity) collection_tests(collection, options, false) do end ensure @entity.destroy if @entity end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/checks_tests.rb 0000644 0000041 0000041 00000000777 13411315054 026040 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | checks', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new begin @entity = service.entities.create :label => "fog_#{Time.now.to_i.to_s}" options = CHECK_CREATE_OPTIONS.merge(:label => "fog_#{Time.now.to_i.to_s}", :entity => @entity) collection = service.checks(:entity => @entity) collection_tests(collection, options, false) do end ensure @entity.destroy if @entity end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/alarm_example_tests.rb 0000644 0000041 0000041 00000001122 13411315054 027370 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | alarm_example', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new alarm_example_id = 'remote.http_body_match_1' alarm = service.alarm_examples.get(alarm_example_id) tests('#bound?') do tests('should return false if not bound') do returns(false) {alarm.bound?} end tests('should return true if bound') do values = {'string' => '12345'} alarm = service.alarm_examples.evaluate(alarm_example_id,values) returns(true) {alarm.bound?} end end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/metrics_tests.rb 0000644 0000041 0000041 00000001056 13411315054 026235 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | metrics', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new begin label = "fog_#{Time.now.to_i.to_s}" @entity = service.entities.create :label => label @check = service.checks.create CHECK_CREATE_OPTIONS.merge(:label => label, :entity => @entity) tests('#list_metrics').succeeds do service.metrics(:check => @check).all end ensure @check.destroy rescue nil if @check @entity.destroy rescue nil if @entity end end fog-rackspace-0.1.6/tests/rackspace/models/monitoring/alarm_examples_tests.rb 0000644 0000041 0000041 00000001047 13411315054 027561 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Monitoring | alarm_examples', ['rackspace','rackspace_monitoring']) do pending if Fog.mocking? service = Fog::Rackspace::Monitoring.new alarm_example_id = 'remote.http_body_match_1' tests('success') do tests('all').succeeds do service.alarm_examples.all end tests('get').succeeds do service.alarm_examples.get(alarm_example_id) end tests('evaluate').succeeds do values = {'string'=> '12345'} service.alarm_examples.evaluate(alarm_example_id,values) end end end fog-rackspace-0.1.6/tests/rackspace/models/storage/ 0000755 0000041 0000041 00000000000 13411315054 022275 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/storage/account_tests.rb 0000644 0000041 0000041 00000001507 13411315054 025503 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Storage | account', ['rackspace']) do @account = Fog::Storage[:rackspace].account tests('load') do headers = @account.service.head_containers.headers returns(headers['X-Account-Meta-Temp-Url-Key']) { @account.meta_temp_url_key } returns(headers['X-Account-Container-Count'].to_i) { @account.container_count } returns(headers['X-Account-Bytes-Used'].to_i) { @account.bytes_used } returns(headers['X-Account-Object-Count'].to_i) { @account.object_count } end tests('reload') do @account.reload end tests('save') do key = "testing-update-#{Time.now.to_i}" @account.meta_temp_url_key = "testing-update-#{Time.now.to_i}" @account.save headers = @account.service.head_containers.headers returns(key) { headers['X-Account-Meta-Temp-Url-Key'] } end end fog-rackspace-0.1.6/tests/rackspace/models/storage/file_tests.rb 0000644 0000041 0000041 00000027420 13411315054 024770 0 ustar www-data www-data require 'fog/rackspace/models/storage/file' Shindo.tests('Fog::Rackspace::Storage | file', ['rackspace']) do tests("last_modified=") do tests("no timezone") do file = Fog::Storage::Rackspace::File.new file.last_modified = "2013-05-09T22:20:59.287990" returns(Fog::Time.utc(2013, 5, 9, 22, 20, 59, 287990, nil) == file.last_modified) { true } end tests("with timezone") do file = Fog::Storage::Rackspace::File.new file.last_modified = "Thu, 09 May 2015 22:20:59 GMT" returns(Fog::Time.utc(2015, 5, 9, 22, 20, 59, 0, nil).to_i == file.last_modified.to_i) { true } end tests("with time") do file = Fog::Storage::Rackspace::File.new file.last_modified = Fog::Time.utc(2015, 5, 9, 22, 20, 59, 0, nil) returns(Fog::Time.utc(2015, 5, 9, 22, 20, 59, 0, nil) == file.last_modified) { true } end tests("nil") do file = Fog::Storage::Rackspace::File.new file.last_modified = nil returns(nil) { file.last_modified } end tests("empty string") do file = Fog::Storage::Rackspace::File.new file.last_modified = "" returns("") { file.last_modified } end end def object_attributes(file=@instance) @instance.service.head_object(@directory.key, file.key).headers end def object_meta_attributes(file=@instance) object_attributes(file).reject {|k, v| !(k =~ /X-Object-Meta-/)} end def clear_metadata @instance.metadata.tap do |metadata| metadata.each_pair {|k, v| metadata[k] = nil } end end file_attributes = { :key => 'fog_file_tests', :body => lorem_file } directory_attributes = { # Add a random suffix to prevent collision :key => "fogfilestests-#{rand(65536)}" } @service = Fog::Storage.new :provider => 'rackspace', :rackspace_temp_url_key => "my_secret" @directory = @service.directories.create(directory_attributes) model_tests(@directory.files, file_attributes, Fog.mocking?) do tests("#metadata should load empty metadata").returns({}) do @instance.metadata.data end tests('#save') do tests('#metadata') do before do @instance.metadata[:foo] = 'bar' @instance.save end after do clear_metadata @instance.save end tests("should update metadata").returns('bar') do object_meta_attributes['X-Object-Meta-Foo'] end tests('should cache metadata').returns('bar') do @instance.metadata[:foo] end tests('should remove empty metadata').returns({}) do @instance.metadata[:foo] = nil @instance.save object_meta_attributes end tests("removes one key while leaving the other") do @instance.metadata[:color] = "green" @instance.save returns({"X-Object-Meta-Foo"=>"bar", "X-Object-Meta-Color"=>"green"}) { object_meta_attributes } tests("set metadata[:color] = nil").returns({"X-Object-Meta-Foo"=>"bar"}) do @instance.metadata[:color] = nil @instance.save object_meta_attributes end end end begin tests("sets metadata on create").returns("true") do @file = @directory.files.create :key => 'meta-test', :body => lorem_file, :metadata => {:works => true } object_meta_attributes(@file)["X-Object-Meta-Works"] end tests("sets Content-Disposition on create").returns("ho-ho-ho") do @file = @directory.files.create :key => 'meta-test', :body => lorem_file, :content_disposition => 'ho-ho-ho' object_attributes(@file)["Content-Disposition"] end ensure @file.destroy if @file end tests('urls') do tests('no CDN') do tests('url') do tests('http').succeeds do expire_time = Time.now + 3600 url = @instance.url(expire_time) url =~ /^http:/ end tests('https').succeeds do @directory.service.instance_variable_set "@rackspace_cdn_ssl", true expire_time = Time.now + 3600 url = @instance.url(expire_time) url =~ /^https:/ end @directory.service.instance_variable_set "@rackspace_cdn_ssl", false end tests('#public_url') do tests('http').returns(nil) do @instance.public_url end @directory.cdn_cname = "my_cname.com" tests('cdn_cname').returns(nil) do @instance.public_url end @directory.cdn_cname = nil @directory.service.instance_variable_set "@rackspace_cdn_ssl", true tests('ssl').returns(nil) do @instance.public_url end @directory.service.instance_variable_set "@rackspace_cdn_ssl", nil end tests('#ios_url').returns(nil) do @instance.ios_url end tests('#streaming_url').returns(nil) do @instance.streaming_url end end tests('With CDN') do tests('#public_url') do @directory.public = true @directory.save tests('http').returns(0) do @instance.public_url =~ /http:\/\/.*#{@instance.key}/ end @directory.cdn_cname = "my_cname.com" tests('cdn_cname').returns(0) do @instance.public_url =~ /my_cname\.com.*#{@instance.key}/ end @directory.cdn_cname = nil @directory.service.instance_variable_set "@rackspace_cdn_ssl", true tests('ssl').returns(0) do @instance.public_url =~ /https:\/\/.+\.ssl\..*#{@instance.key}/ end @directory.service.instance_variable_set "@rackspace_cdn_ssl", nil end tests('#ios_url').returns(0) do @instance.ios_url =~ /http:\/\/.+\.iosr\..*#{@instance.key}/ end tests('#streaming_url').returns(0) do @instance.streaming_url =~ /http:\/\/.+\.stream\..*#{@instance.key}/ end end tests('etags') do text = lorem_file.read md5 = Digest::MD5.new md5 << text etag = md5.hexdigest begin tests('valid tag').returns(true) do @file = @directory.files.create :key => 'valid-etag.txt', :body => text, :etag => etag @file.reload @file.etag == etag end ensure @file.destroy if @file end tests('invalid tag').raises(Fog::Storage::Rackspace::ServiceError) do @directory.files.create :key => 'invalid-etag.txt', :body => text, :etag => "bad-bad-tag" end end end tests('#metadata keys') do after do clear_metadata @instance.save end @instance.metadata[:foo_bar] = 'baz' tests("should support compound key names").returns('baz') do @instance.save object_meta_attributes['X-Object-Meta-Foo-Bar'] end @instance.metadata['foo'] = 'bar' tests("should support string keys").returns('bar') do @instance.save object_meta_attributes['X-Object-Meta-Foo'] end @instance.metadata['foo_bar'] = 'baz' tests("should support compound string key names").returns('baz') do @instance.save object_meta_attributes['X-Object-Meta-Foo-Bar'] end @instance.metadata['foo-bar'] = 'baz' tests("should support hyphenated keys").returns('baz') do @instance.save object_meta_attributes['X-Object-Meta-Foo-Bar'] end end end tests("#access_control_allow_origin") do tests("#access_control_allow_origin should default to nil").returns(nil) do @instance.access_control_allow_origin end @instance.access_control_allow_origin = 'http://example.com' @instance.save tests("#access_control_allow_origin should return access control attribute").returns('http://example.com') do @instance.access_control_allow_origin end @instance.access_control_allow_origin = 'foo' @instance.save tests("#access_control_allow_origin= should update access_control_allow_origin").returns('bar') do @instance.access_control_allow_origin = 'bar' @instance.save @instance.access_control_allow_origin end tests("#access_control_allow_origin= should not blow up on nil") do @instance.access_control_allow_origin = nil @instance.save end end tests("#delete_at") do @delete_at_time = (Time.now + 300).to_i tests("#delete_at should default to nil").returns(nil) do @instance.delete_at end @instance.delete_at = @delete_at_time @instance.save tests("#delete_at should return delete_at attribute").returns(@delete_at_time) do @instance.delete_at end @instance.delete_at = @delete_at_time @instance.save tests("#delete_at= should update delete_at").returns(@delete_at_time + 100) do @instance.delete_at = @delete_at_time + 100 @instance.save @instance.delete_at end tests("#delete_at= should not blow up on nil") do @instance.delete_at = nil @instance.save end end tests("#delete_after") do @delete_after_time = (Time.now + 300).to_i tests("#delete_after should default to nil").returns(nil) do @instance.delete_after end @instance.delete_after = @delete_after_time @instance.save tests("#delete_after should return delete_after attribute").returns(@delete_after_time) do @instance.delete_after end @instance.delete_after = @delete_after_time @instance.save tests("#delete_after= should update delete_after").returns(@delete_after_time + 100) do @instance.delete_after = @delete_after_time + 100 @instance.save @instance.delete_after end tests("#delete_after= should not blow up on nil") do @instance.delete_after = nil @instance.save end end end model_tests(@directory.files, file_attributes, Fog.mocking?) do tests("#origin") do tests("#origin should default to nil").returns(nil) do @instance.save @instance.origin end @instance.origin = 'http://example.com' @instance.save tests("#origin should return access control attributes").returns('http://example.com') do @instance.origin end @instance.attributes.delete('Origin') @instance.origin = 'foo' @instance.save tests("#origin= should update origin").returns('bar') do @instance.origin = 'bar' @instance.save @instance.origin end tests("#origin= should not blow up on nil") do @instance.origin = nil @instance.save end end tests("#content_encoding") do tests("#content_encoding should default to nil").returns(nil) do @instance.save @instance.content_encoding end @instance.content_encoding = 'gzip' @instance.save tests("#content_encoding should return the content encoding").returns('gzip') do @instance.content_encoding end @instance.attributes.delete('content_encoding') @instance.content_encoding = 'foo' @instance.save tests("#content_encoding= should update content_encoding").returns('bar') do @instance.content_encoding = 'bar' @instance.save @instance.content_encoding end tests("#content_encoding= should not blow up on nil") do @instance.content_encoding = nil @instance.save end end end @directory.destroy end fog-rackspace-0.1.6/tests/rackspace/models/storage/directories_tests.rb 0000644 0000041 0000041 00000001460 13411315054 026361 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Storage | directories', ['rackspace']) do @service = Fog::Storage[:rackspace] begin @name = "fog-directories-test-#{Time.now.to_i.to_s}" @filename = 'lorem.txt' @dir = @service.directories.create :key => @name, :metadata => {:fog_test => true} @file = @dir.files.create :key => @filename, :body => lorem_file tests('#get').succeeds do instance = @service.directories.get @name returns(false) { instance.nil? } returns('true') { instance.metadata[:fog_test] } returns(@name) { instance.key } returns(1) { instance.count } returns( Fog::Storage.get_body_size(lorem_file)) {instance.bytes } returns(@filename) { instance.files.first.key } end ensure @file.destroy if @file @dir.destroy if @dir end end fog-rackspace-0.1.6/tests/rackspace/models/storage/files_tests.rb 0000644 0000041 0000041 00000002137 13411315054 025151 0 ustar www-data www-data Shindo.tests("Fog::Rackspace::Storage | files", ['rackspace', 'storage']) do file_attributes = { :key => 'fog_files_tests', :body => lorem_file } directory_attributes = { :key => 'fogfilestests', :public => true } tests('success') do collection_tests(Fog::Storage[:rackspace].directories.create(directory_attributes).files, file_attributes, Fog.mocking?) @service = Fog::Storage.new :provider => 'rackspace', :rackspace_temp_url_key => "my_secret" @directory = @service.directories.create(directory_attributes) @file = @directory.files.create(file_attributes) tests("#get_url('#{@directory.key}')").succeeds do @directory.files.get_url(@directory.key) end tests("#get_http_url('#{@directory.key}')").succeeds do expire_time = Time.now + 3600 @directory.files.get_http_url(@file.key, expire_time) end tests("#get_https_url('#{@directory.key}', '#{@file.key}')").succeeds do expire_time = Time.now + 3600 @directory.files.get_https_url(@file.key, expire_time) end @file.destroy @directory.destroy end end fog-rackspace-0.1.6/tests/rackspace/models/storage/directory_tests.rb 0000644 0000041 0000041 00000010072 13411315054 026050 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Storage | directory', ['rackspace']) do @service = Fog::Storage[:rackspace] def container_meta_attributes @service.head_container(@instance.key).headers.reject {|k, v| !(k =~ /X-Container-Meta-/)} end directory_attributes = { # Add a random suffix to prevent collision :key => "fog-directory-tests-#{rand(65536)}" } model_tests(@service.directories, directory_attributes, Fog.mocking?) do tests('#public?').returns(false) do @instance.public? end tests('#public_url') do tests('http').returns(nil) do @instance.public_url end @instance.cdn_cname = "my_cname.com" tests('cdn_cname').returns(nil) do @instance.public_url end @instance.cdn_cname = nil @service.instance_variable_set "@rackspace_cdn_ssl", true tests('ssl').returns(nil) do @instance.public_url end @service.instance_variable_set "@rackspace_cdn_ssl", nil end tests('#ios_url').returns(nil) do @instance.ios_url end tests('#streaming_url').returns(nil) do @instance.streaming_url end tests('cdn') do @instance.public = true @instance.save tests('#public?').returns(true) do @instance.public? end tests('#public_url') do tests('http').returns(0) do @instance.public_url =~ /http:\/\// end @instance.cdn_cname = "my_cname.com" tests('cdn_cname').returns(0) do @instance.public_url =~ /my_cname\.com/ end @instance.cdn_cname = nil @service.instance_variable_set "@rackspace_cdn_ssl", true tests('ssl').returns(0) do @instance.public_url =~ /https:\/\/.+\.ssl\./ end @service.instance_variable_set "@rackspace_cdn_ssl", nil end tests('#ios_url').returns(0) do @instance.ios_url =~ /http:\/\/.+\.iosr\./ end tests('#streaming_url').returns(0) do @instance.streaming_url =~ /http:\/\/.+\.stream\./ end end tests("reload") do @instance.reload returns(nil) { @instance.instance_variable_get("@urls") } returns(nil) { @instance.instance_variable_get("@files") } returns(nil) { @instance.instance_variable_get("@public") } end end directory_attributes[:metadata] = {:draft => 'true'} tests('metadata') do model_tests(@service.directories, directory_attributes, Fog.mocking?) do tests('sets metadata on create').returns('true') do @instance.metadata.data container_meta_attributes["X-Container-Meta-Draft"] end tests('update metadata').returns({"X-Container-Meta-Draft"=>"true", "X-Container-Meta-Color"=>"green"}) do @instance.metadata[:color] = 'green' @instance.save container_meta_attributes end tests('set metadata to nil').returns({"X-Container-Meta-Draft"=>"true"}) do @instance.metadata[:color] = nil @instance.save container_meta_attributes end tests('delete metadata').returns({}) do @instance.metadata.delete(:draft) @instance.save container_meta_attributes end tests('should retrieve metadata when necessary') do @service.put_container(@instance.key, {"X-Container-Meta-List-Test"=>"true"} ) dir = @service.directories.find {|d| d.key == @instance.key } returns(nil) { dir.instance_variable_get("@metadata") } returns('true') { dir.metadata[:list_test] } end tests("should reload metadata after calling reload").returns("42") do @service.put_container @instance.key, "X-Container-Meta-Answer" => 42 @instance.reload @instance.metadata[:answer] end tests("should reload metadata after calling reload").returns("42") do @service.put_container @instance.key, "X-Container-Meta-Answer" => 42 @instance.reload @instance.metadata[:answer] end end end end fog-rackspace-0.1.6/tests/rackspace/models/storage/metadata_tests.rb 0000644 0000041 0000041 00000016146 13411315054 025634 0 ustar www-data www-data require 'fog/rackspace/models/storage/metadata' require 'fog/rackspace/models/storage/directory' require 'fog/rackspace/models/storage/directories' require 'fog/rackspace/models/storage/file' Shindo.tests('Fog::Rackspace::Storage | metadata', ['rackspace']) do def assert_directory(obj, assert_value) metadata = Fog::Storage::Rackspace::Metadata.new obj returns(assert_value) { metadata.send :directory? } end def assert_file(obj, assert_value) metadata = Fog::Storage::Rackspace::Metadata.new obj returns(assert_value) { metadata.send :file? } end tests('Directory') do @directory = Fog::Storage::Rackspace::Directory.new tests('#to_key') do tests('valid key').returns(:image_size) do metadata = Fog::Storage::Rackspace::Metadata.new @directory metadata.send(:to_key, "X-Container-Meta-Image-Size") end tests('invalid key').returns(nil) do metadata = Fog::Storage::Rackspace::Metadata.new @directory metadata.send(:to_key, "bad-key") end end tests('#[]') do tests('[:symbol_test]=42') do metadata = Fog::Storage::Rackspace::Metadata.new @directory metadata[:symbol_test] = 42 returns(42) { metadata[:symbol_test] } returns(42) { metadata['symbol_test'] } returns(nil) { metadata[:nil_test] } end tests('[\'string_test\']=55') do metadata = Fog::Storage::Rackspace::Metadata.new @directory metadata['string_test'] = 55 returns(55) { metadata[:string_test] } returns(55) { metadata['string_test'] } returns(nil) { metadata['nil_test'] } end tests('set string and symbol') do metadata = Fog::Storage::Rackspace::Metadata.new @directory metadata[:key_test] = 55 metadata['key_test'] = 55 returns(1) { metadata.size } end tests('key to remove').returns("X-Remove-Container-Meta-Thumbnail-Image") do metadata = Fog::Storage::Rackspace::Metadata.new @directory metadata.send(:to_header_key, :thumbnail_image, nil) end end tests('#to_header_key') do metadata = Fog::Storage::Rackspace::Metadata.new @directory tests('key to add').returns("X-Container-Meta-Thumbnail-Image") do metadata.send(:to_header_key, :thumbnail_image, true) end tests('key to remove').returns("X-Remove-Container-Meta-Thumbnail-Image") do metadata.send(:to_header_key, :thumbnail_image, nil) end end tests('#to_headers').returns({"X-Container-Meta-Preview"=>true, "X-Remove-Container-Meta-Delete-Me"=>1}) do metadata = Fog::Storage::Rackspace::Metadata.new @directory metadata[:preview] = true metadata[:delete_me] = nil metadata.to_headers end tests("#from_headers").returns({:my_boolean=>"true", :my_integer=>"42", :my_string=>"I am a string"}) do headers = { "X-Container-Meta-My-Integer"=> "42", "X-Container-Meta-My-Boolean"=> "true", "X-Container-Meta-My-String"=> "I am a string" } metadata = Fog::Storage::Rackspace::Metadata.from_headers @directory, headers metadata.data end tests("#delete").returns({"X-Remove-Container-Meta-Delete-Me"=>1}) do metadata = Fog::Storage::Rackspace::Metadata.new @directory metadata.delete(:delete_me) metadata.to_headers end end tests('File') do @file = Fog::Storage::Rackspace::File.new tests('#to_key') do tests('valid key').returns(:image_size) do metadata = Fog::Storage::Rackspace::Metadata.new @file metadata.send(:to_key, "X-Object-Meta-Image-Size") end tests('invalid key').returns(nil) do metadata = Fog::Storage::Rackspace::Metadata.new @file metadata.send(:to_key, "bad-key") end end tests('#to_header_key') do metadata = Fog::Storage::Rackspace::Metadata.new @file tests('key to add').returns("X-Object-Meta-Thumbnail-Image") do metadata.send(:to_header_key, :thumbnail_image, true) end tests('key to remove').returns("X-Remove-Object-Meta-Thumbnail-Image") do metadata.send(:to_header_key, :thumbnail_image, nil) end end tests('#to_headers').returns({"X-Object-Meta-Preview"=>true, "X-Remove-Object-Meta-Delete-Me"=>1}) do metadata = Fog::Storage::Rackspace::Metadata.new @file metadata[:preview] = true metadata[:delete_me] = nil metadata.to_headers end tests("#from_headers").returns({:my_boolean=>"true", :my_integer=>"42", :my_string=>"I am a string"}) do headers = { "X-Object-Meta-My-Integer"=> "42", "X-Object-Meta-My-Boolean"=> "true", "X-Object-Meta-My-String"=> "I am a string" } metadata = Fog::Storage::Rackspace::Metadata.from_headers @file, headers metadata.data end tests("#delete").returns({"X-Remove-Object-Meta-Delete-Me"=>1}) do metadata = Fog::Storage::Rackspace::Metadata.new @file metadata.delete(:delete_me) metadata.to_headers end end tests("#respond_to?") do tests('Should respond to all of the methods in Hash class').returns(true) do metadata = Fog::Storage::Rackspace::Metadata.new @file Hash.instance_methods.all? {|method| metadata.respond_to?(method)} end tests('Should respond to all of the methods in the Metadata class').returns(true) do metadata = Fog::Storage::Rackspace::Metadata.new @file metadata.methods.all? {|method| metadata.respond_to?(method)} end end tests("#method_missing").returns(true) do metadata = Fog::Storage::Rackspace::Metadata.new @file metadata[:test] = true metadata[:test] end tests('#directory?') do assert_directory Fog::Storage::Rackspace::Directories, true assert_directory Fog::Storage::Rackspace::Directory, true assert_directory Fog::Storage::Rackspace::Directory.new, true assert_directory nil, false assert_directory Fog::Storage::Rackspace::Files, false assert_directory Fog::Storage::Rackspace::File, false assert_directory Fog::Storage::Rackspace::File.new, false assert_directory "I am a string!", false end tests('#file?') do assert_file Fog::Storage::Rackspace::Directories, false assert_file Fog::Storage::Rackspace::Directory, false assert_file Fog::Storage::Rackspace::Directory.new, false assert_file nil, false assert_file Fog::Storage::Rackspace::Files, true assert_file Fog::Storage::Rackspace::File, true assert_file Fog::Storage::Rackspace::File.new, true assert_file "I am a string!", false end tests('#parent_class') do tests('Fog::Storage::Rackspace::Directory object') do metadata = Fog::Storage::Rackspace::Metadata.new Fog::Storage::Rackspace::Directory.new returns(Fog::Storage::Rackspace::Directory) { metadata.send :parent_class } end tests('Fog::Storage::Rackspace::Directory class') do metadata = Fog::Storage::Rackspace::Metadata.new Fog::Storage::Rackspace::Directory returns(Fog::Storage::Rackspace::Directory) { metadata.send :parent_class } end end end fog-rackspace-0.1.6/tests/rackspace/models/queues/ 0000755 0000041 0000041 00000000000 13411315054 022140 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/queues/queue_tests.rb 0000644 0000041 0000041 00000001700 13411315054 025031 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | queue', ['rackspace']) do service = Fog::Rackspace::Queues.new options = { :name => "fog_instance_#{Time.now.to_i.to_s}", } model_tests(service.queues, options) do tests('#stats').formats(QUEUE_STATS_FORMAT['messages']) do @instance.stats end tests('#enqueue("msg", 60)') do @instance.enqueue("msg", 60) end tests('#dequeue(60, 60)').returns(true) do @instance.dequeue(60, 60) do |message| returns("msg") { message.body } end end tests('#dequeue(60, 60) => with not messages').returns(false) do @instance.dequeue(60, 60) do |message| end end tests('#dequeue(60, 60) => not passing block').returns(true) do @instance.enqueue("msg", 60) @instance.dequeue(60, 60) end tests('#dequeue(60, 60) => with not messages and not passing block').returns(false) do @instance.dequeue(60, 60) end end end fog-rackspace-0.1.6/tests/rackspace/models/queues/claim_tests.rb 0000644 0000041 0000041 00000001653 13411315054 025001 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | claim', ['rackspace']) do service = Fog::Rackspace::Queues.new queue = service.queues.create({ :name => "fog_queue_#{Time.now.to_i.to_s}", }) queue.messages.create({ :ttl => VALID_TTL, :body => { :random => :body } }) params = { :ttl => VALID_TTL, :grace => VALID_GRACE } begin model_tests(queue.claims, params) do tests('#messages') do returns(1) { @instance.messages.length } returns('body') { @instance.messages.first.body['random'] } end tests('#update').succeeds do @instance.ttl = VALID_TTL + 5 @instance.save end end queue.messages.create({ :ttl => VALID_TTL, :body => { :random => :body } }) tests('destroying claimed messages').succeeds do claim = queue.claims.create(params) claim.messages.first.destroy end ensure queue.destroy end end fog-rackspace-0.1.6/tests/rackspace/models/queues/claims_tests.rb 0000644 0000041 0000041 00000002457 13411315054 025167 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | claims', ['rackspace']) do service = Fog::Rackspace::Queues.new queue = service.queues.create({ :name => "fog_queue_#{Time.now.to_i.to_s}", }) queue.messages.create({ :ttl => VALID_TTL, :body => { :random => :body } }) params = { :ttl => VALID_TTL, :grace => VALID_GRACE } begin collection_tests(queue.claims, params) tests('creating claims when there are no messages') do before do #clear all message from queue queue.messages.all.each do |message| message.destroy end end tests("#create(#{params.inspect}) => with no messages does not show up in claim list") do returns(false) { queue.claims.create(params) } returns(true) { queue.claims.empty? } end end tests('create claims when there are messages') do before do queue.messages.create({ :ttl => VALID_TTL, :body => { :random => :body } }) end tests("#create(#{params.inspect}) => with messages does show up in claim list") do returns(true) do queue.claims.create(params).instance_of? Fog::Rackspace::Queues::Claim end returns(false) { queue.claims.empty? } end end ensure queue.destroy end end fog-rackspace-0.1.6/tests/rackspace/models/queues/message_tests.rb 0000644 0000041 0000041 00000002776 13411315054 025347 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | message', ['rackspace']) do service = Fog::Rackspace::Queues.new queue = service.queues.create({ :name => "fog_instance_#{Time.now.to_i.to_s}", }) options = { :ttl => VALID_TTL, :body => { :key => 'value' } } begin model_tests(queue.messages, options) do tests('#href').returns(true) do !@instance.href.nil? end tests('#identity').returns(true) do !@instance.identity.nil? end tests('#save => Fails to update').raises(StandardError) do @instance.save end end message = queue.messages.create(options.merge({:claim_id => '10'})) tests('#destroy => fails if claim is not valid').raises(Fog::Rackspace::Queues::ServiceError) do #API team should be fixing this so that it errors in this scenario pending message.destroy end ensure queue.destroy end tests('identity') do tests('nil') do message = Fog::Rackspace::Queues::Message.new :href => nil returns(nil) { message.id } end tests('with claim id') do message = Fog::Rackspace::Queues::Message.new :href => '/v1/queues/queue1/messages/528b7e4bb04a584f2eb805a3?claim_id=528b7e6aef913e6d2977ee6d' returns('528b7e4bb04a584f2eb805a3') { message.id } end tests('without claim id') do message = Fog::Rackspace::Queues::Message.new :href => '/v1/queues/queue1/messages/528b7e4bb04a584f2eb805a3' returns('528b7e4bb04a584f2eb805a3') { message.id } end end end fog-rackspace-0.1.6/tests/rackspace/models/queues/queues_tests.rb 0000644 0000041 0000041 00000000337 13411315054 025221 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | queues', ['rackspace']) do service = Fog::Rackspace::Queues.new options = { :name => "fog_instance_#{Time.now.to_i.to_s}", } collection_tests(service.queues, options) end fog-rackspace-0.1.6/tests/rackspace/models/queues/messages_tests.rb 0000644 0000041 0000041 00000000475 13411315054 025524 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues | messages', ['rackspace']) do service = Fog::Rackspace::Queues.new queue = service.queues.create({ :name => "fog_queue_#{Time.now.to_i.to_s}", }) options = { :ttl => 300, :body => "blah" } collection_tests(queue.messages, options) queue.destroy end fog-rackspace-0.1.6/tests/rackspace/models/auto_scale/ 0000755 0000041 0000041 00000000000 13411315054 022750 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/auto_scale/policies_tests.rb 0000644 0000041 0000041 00000001160 13411315054 026324 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | policies', ['rackspace', 'rackspace_autoscale']) do pending if Fog.mocking? service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord begin group = service.groups.create({ :policies => POLICIES_OPTIONS, :group_config => GROUP_CONFIG_OPTIONS, :launch_config => LAUNCH_CONFIG_OPTIONS }) options = { :name => "policy 2", :change => 5, :cooldown => 100, :type => 'webhook' } collection_tests(group.policies, options, false) ensure deactive_auto_scale_group(group) group.destroy if group end end fog-rackspace-0.1.6/tests/rackspace/models/auto_scale/webhooks_tests.rb 0000644 0000041 0000041 00000001410 13411315054 026334 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | webhooks', ['rackspace', 'rackspace_autoscale']) do pending if Fog.mocking? service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord begin group = service.groups.create({ :policies => POLICIES_OPTIONS, :group_config => GROUP_CONFIG_OPTIONS, :launch_config => LAUNCH_CONFIG_OPTIONS }) policy = group.policies.create({ :name => "policy 2", :change => 5, :cooldown => 100, :type => 'webhook', :group => group }) options = {:name => 'New webhook', :group => group, :policy => policy } collection_tests(policy.webhooks, options, false) ensure policy.destroy if policy deactive_auto_scale_group(group) group.destroy if group end end fog-rackspace-0.1.6/tests/rackspace/models/auto_scale/group_builder_tests.rb 0000644 0000041 0000041 00000011723 13411315054 027365 0 ustar www-data www-data require 'fog/rackspace/models/auto_scale/group_builder' require 'fog/rackspace/models/auto_scale/group' require 'fog/rackspace/models/compute_v2/flavor' require 'fog/rackspace/models/load_balancers/load_balancer' Shindo.tests('Fog::Rackspace::AutoScale | group builder', ['rackspace', 'rackspace_autoscale']) do builder = Fog::Rackspace::AutoScale::GroupBuilder tests('#get_id') do tests('widget_id').returns(5) do builder.send(:get_id, 'widget', {:widget_id => 5, :noise => 3}) end tests('widget').returns(5) do Fog::Rackspace::AutoScale::GroupBuilder.send(:get_id, 'widget', {:widget => 5, :noise => 3}) end tests('Flavor object').returns(2) do flavor = Fog::Compute::RackspaceV2::Flavor.new(:id => 2) builder.send(:get_id, 'flavor', {:flavor => flavor, :noise => 3}) end end tests('networks_to_hash').returns([{"uuid" => '00000000-0000-0000-0000-000000000000'}]) do builder.send(:networks_to_hash, ['00000000-0000-0000-0000-000000000000']) end tests('#build_server_template').returns(LAUNCH_CONFIG_OPTIONS["args"]["server"]) do attributes = { :server_name => "autoscale_server", :image => "0d589460-f177-4b0f-81c1-8ab8903ac7d8", :flavor => "2", :disk_config => "AUTO", :server_metadata => { "build_config" => "core", "meta_key_1" => "meta_value_1", "meta_key_2" => "meta_value_2" }, :networks => ["11111111-1111-1111-1111-111111111111", "00000000-0000-0000-0000-000000000000"], :personality => [ { "path" => "/root/.csivh", "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4=" } ] } builder.send(:build_server_template, attributes) end tests('#load_balancer_to_hash') do lb_test_hash = { "port" => 80, "loadBalancerId" => 1234 } tests('hash').raises(ArgumentError, "Expected LoadBalancer") do builder.send(:load_balancer_to_hash, lb_test_hash) end tests('LoadBalancer').returns(lb_test_hash) do lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234 builder.send(:load_balancer_to_hash, lb) end end tests('build_load_balancers') do lb_test_hash = { "port" => 80, "loadBalancerId" => 1234 } tests('nil').returns(nil) do builder.send(:build_load_balancers, {}) end tests('hash').returns([lb_test_hash]) do builder.send(:build_load_balancers, :load_balancers => [lb_test_hash]) end tests('LoadBalancer').returns([lb_test_hash]) do lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234 builder.send(:build_load_balancers, :load_balancers => [lb]) end tests('multiple lbs').returns([lb_test_hash, lb_test_hash]) do lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234 builder.send(:build_load_balancers, :load_balancers => [lb, lb]) end end tests('build_server_launch_config') do tests('no launch_config_type').returns(nil) do builder.build_server_launch_config({:pancakes => true}) end tests('wrong launch_config_type').returns(nil) do builder.build_server_launch_config({:launch_config_type => :something_else}) end tests('valid launch config').returns(LAUNCH_CONFIG_OPTIONS["args"]) do attributes = { :server_name => "autoscale_server", :image => "0d589460-f177-4b0f-81c1-8ab8903ac7d8", :flavor => "2", :disk_config => "AUTO", :server_metadata => { "build_config" => "core", "meta_key_1" => "meta_value_1", "meta_key_2" => "meta_value_2" }, :networks => ["11111111-1111-1111-1111-111111111111", "00000000-0000-0000-0000-000000000000"], :personality => [ { "path" => "/root/.csivh", "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4=" } ], :launch_config_type => :launch_server, :load_balancers => { "port" => 8080, "loadBalancerId" => 9099} } builder.build_server_launch_config(attributes).args end end tests('#build_group_config') do attributes = { :max_entities => 3, :min_entities => 0, :cooldown => 360, :name => "testscalinggroup198547", :metadata => { "gc_meta_key_2" => "gc_meta_value_2", "gc_meta_key_1" => "gc_meta_value_1" } } config = builder.build_group_config(attributes) returns(3) { config.max_entities } returns(0) { config.min_entities } returns(360) { config.cooldown } returns("testscalinggroup198547") { config.name } returns(attributes[:metadata]) { config.metadata } end tests('build') do pending if Fog.mocking? service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord group = builder.build(service, :launch_config_type => :launch_server, :server_name => 'test', :cooldown => 500) returns(500) { group.group_config.cooldown } returns('test') { group.launch_config.args["server"]["name"]} end end fog-rackspace-0.1.6/tests/rackspace/models/auto_scale/webhook_tests.rb 0000644 0000041 0000041 00000001713 13411315054 026157 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | webhook', ['rackspace', 'rackspace_autoscale']) do service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord pending if Fog.mocking? begin group = service.groups.create({ :policies => POLICIES_OPTIONS, :group_config => GROUP_CONFIG_OPTIONS, :launch_config => LAUNCH_CONFIG_OPTIONS }) policy = group.policies.create({ :name => "set group to 5 servers", :desired_capacity => 5, :cooldown => 1800, :type => "webhook", :group => group }) options = { :name => 'webhook name', :metadata => { 'owner' => 'me' }, :group => group, :policy => policy } model_tests(policy.webhooks, options, false) do tests('#execution_url').succeeds do @instance.execution_url end end ensure policy.destroy if policy deactive_auto_scale_group(group) group.destroy if group end end fog-rackspace-0.1.6/tests/rackspace/models/auto_scale/groups_tests.rb 0000644 0000041 0000041 00000000754 13411315054 026044 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | groups', ['rackspace', 'rackspace_autoscale']) do pending if Fog.mocking? service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord options = { :policies => POLICIES_OPTIONS, :group_config => GROUP_CONFIG_OPTIONS, :launch_config => LAUNCH_CONFIG_OPTIONS } collection_tests(service.groups, options, false) do tests('deactive scaling group').succeeds do deactive_auto_scale_group(@instance) end end end fog-rackspace-0.1.6/tests/rackspace/models/auto_scale/policy_tests.rb 0000644 0000041 0000041 00000001440 13411315054 026015 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | policy', ['rackspace', 'rackspace_autoscale']) do service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord pending if Fog.mocking? begin group = service.groups.create({ :policies => POLICIES_OPTIONS, :group_config => GROUP_CONFIG_OPTIONS, :launch_config => LAUNCH_CONFIG_OPTIONS }) options = { :name => "policy 2", :change => 1, :cooldown => 100, :type => 'webhook', :group => group } model_tests(group.policies, options, false) do tests('#execute').succeeds do @instance.execute end tests('#webhooks').succeeds do @instance.webhooks end end ensure deactive_auto_scale_group(group) group.destroy if group end end fog-rackspace-0.1.6/tests/rackspace/models/auto_scale/group_tests.rb 0000644 0000041 0000041 00000001433 13411315054 025654 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::AutoScale | group', ['rackspace', 'rackspace_autoscale']) do service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord options = { :name => "fog_#{Time.now.to_i.to_s}", :policies => POLICIES_OPTIONS, :launch_config => LAUNCH_CONFIG_OPTIONS, :group_config => GROUP_CONFIG_OPTIONS } model_tests(service.groups, options, false) do pending if Fog.mocking? tests('#policies').succeeds do @instance.policies end tests('#launch_config').succeeds do @instance.launch_config end tests('#group_config').succeeds do @instance.group_config end tests('#state').succeeds do @instance.state end tests('deactive scaling group').succeeds do deactive_auto_scale_group(@instance) end end end fog-rackspace-0.1.6/tests/rackspace/models/networking/ 0000755 0000041 0000041 00000000000 13411315054 023020 5 ustar www-data www-data fog-rackspace-0.1.6/tests/rackspace/models/networking/networks_tests.rb 0000644 0000041 0000041 00000000420 13411315054 026437 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Networking | networks', ['rackspace']) do service = Fog::Rackspace::Networking.new options = { :label => "fog_network_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24' } collection_tests(service.networks, options, true) end fog-rackspace-0.1.6/tests/rackspace/models/networking/network_tests.rb 0000644 0000041 0000041 00000000412 13411315054 026255 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Networking | network', ['rackspace']) do service = Fog::Rackspace::Networking.new options = { :label => "fog_network_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24' } model_tests(service.networks, options, true) end fog-rackspace-0.1.6/tests/rackspace/models/networking/virtual_interface_tests.rb 0000644 0000041 0000041 00000001563 13411315054 030302 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Networking | virtual_interface', ['rackspace']) do service = Fog::Rackspace::Networking.new net_options = { :label => "fog_network_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24' } server_options = { :name => "fog_server_#{Time.now.to_i.to_s}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service) } tests('virtual_interface') do pending if Fog.mocking? begin @server = service.servers.create server_options @network = service.networks.create net_options @server.wait_for { ready? } model_tests(@server.virtual_interfaces, {:network => @network}, false) ensure if @server @server.destroy # wait_for_server_deletion(@server) if @server delete_test_network(@network) if @network end end end end fog-rackspace-0.1.6/tests/rackspace/models/networking/virtual_interfaces_tests.rb 0000644 0000041 0000041 00000001141 13411315054 030455 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Networking | virtual_interfaces', ['rackspace']) do service = Fog::Rackspace::Networking.new options = { :name => "fog_server_#{Time.now.to_i.to_s}", :flavor_id => rackspace_test_flavor_id(service), :image_id => rackspace_test_image_id(service) } tests('virtual_interfaces') do pending if Fog.mocking? begin @server = service.servers.create options @server.wait_for { ready? } tests('#virtual_interfaces').succeeds do @server.virtual_interfaces.all end ensure @server.destroy if @server end end end fog-rackspace-0.1.6/tests/rackspace/identity_tests.rb 0000644 0000041 0000041 00000002232 13411315054 022745 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Identity', ['rackspace']) do tests('current authentication') do tests('variables populated').returns(200) do @service = Fog::Rackspace::Identity.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true} returns(true, "auth token populated") { !@service.auth_token.nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } returns(false, "service catalog populated") { @service.service_catalog.nil? } @service.list_tenants.status end end tests('reauthentication') do tests('should reauth with valid credentials') do @service = Fog::Rackspace::Identity.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.auth_token.nil? } @service.instance_variable_set("@auth_token", "bad-token") returns(true) { [200, 203].include? @service.list_tenants.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::Rackspace::Identity.new :rackspace_api_key => 'bad_key' } end end end fog-rackspace-0.1.6/tests/rackspace/queues_tests.rb 0000644 0000041 0000041 00000011157 13411315054 022431 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Queues', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Rackspace::Queues.new assert_method nil, :authenticate_v2 assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('authentication v1') do raises(Fog::Errors::NotImplemented) do @service = Fog::Rackspace::Queues.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' end end tests('authentication v2') do tests('variables populated').succeeds do @service = Fog::Rackspace::Queues.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => { :ssl_verify_peer => true } returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.queues end tests('dfw region').succeeds do #We consistently use DFW as our default but queues doesn't have a DFW default region yet. # We can enable this test once they have a DFW region (which they will) pending @service = Fog::Rackspace::Queues.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.queues end tests('ord region').succeeds do @service = Fog::Rackspace::Queues.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil } @service.queues end end tests('default auth') do tests('no params').succeeds do #We consistently use DFW as our default but queues doesn't have a DFW default region yet. # We can enable this test once they have a DFW region (which they will) pending @service = Fog::Rackspace::Queues.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.queues end tests('specify region').succeeds do @service = Fog::Rackspace::Queues.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil } @service.queues end end tests('reauthentication') do @service = Fog::Rackspace::Queues.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad_token") returns(true, 'list queues call succeeds') { [200, 204].include?(@service.list_queues.status) } end @service = Fog::Rackspace::Queues.new tests('#queues').succeeds do data = @service.queues returns(true) { data.is_a? Array } end tests('client_id') do tests('should generate uuid if a client id is not provided').succeeds do pending unless Fog::UUID.supported? service = Fog::Rackspace::Queues.new service.client_id =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ end tests('should use specified uuid').succeeds do pending unless Fog::UUID.supported? my_uuid = Fog::UUID.uuid service = Fog::Rackspace::Queues.new :rackspace_queues_client_id => my_uuid service.client_id == my_uuid end end end fog-rackspace-0.1.6/tests/rackspace/load_balancer_tests.rb 0000644 0000041 0000041 00000014677 13411315054 023702 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::LoadBalancers', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Rackspace::LoadBalancers.new assert_method nil, :authenticate_v2 assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('legacy authentication') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.list_load_balancers end tests('custom endpoint') do @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_load_balancers_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('current authentation') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => { :ssl_verify_peer => true } returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.list_load_balancers end tests('dfw region').succeeds do @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_load_balancers end tests('ord region').succeeds do @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil } @service.list_load_balancers end tests('custom endpoint') do @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_load_balancers_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::Rackspace::LoadBalancers.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_load_balancers end tests('specify old contstant style service endoint').succeeds do @service = Fog::Rackspace::LoadBalancers.new :rackspace_lb_endpoint => Fog::Rackspace::LoadBalancers::ORD_ENDPOINT returns(true) { (@service.instance_variable_get("@uri").to_s =~ /#{Fog::Rackspace::LoadBalancers::ORD_ENDPOINT}/ ) != nil } @service.list_load_balancers end tests('specify region').succeeds do @service = Fog::Rackspace::LoadBalancers.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil } @service.list_load_balancers end tests('custom endpoint') do @service = Fog::Rackspace::LoadBalancers.new :rackspace_load_balancers_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::Rackspace::LoadBalancers.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad-token") returns(200) { @service.list_load_balancers.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::Rackspace::LoadBalancers.new:rackspace_api_key => 'bad_key' } end end pending if Fog.mocking? @service = Fog::Rackspace::LoadBalancers.new tests('#algorithms').succeeds do data = @service.algorithms returns(true) { data.is_a? Array } returns(true) { data.first.is_a? String } end tests('#protocols').succeeds do data = @service.protocols returns(true) { data.is_a? Array } end tests('#usage').succeeds do @service.usage end end fog-rackspace-0.1.6/tests/rackspace/rackspace_tests.rb 0000644 0000041 0000041 00000004176 13411315054 023061 0 ustar www-data www-data Shindo.tests('Fog::Rackspace', ['rackspace']) do tests('normalize_url') do tests('should return nil if endpoint is nil').returns(nil) do Fog::Rackspace.normalize_url nil end tests('should remove trailing spaces').returns("https://dfw.blockstorage.api.rackspacecloud.com/v1") do Fog::Rackspace.normalize_url "https://dfw.blockstorage.api.rackspacecloud.com/v1 " end tests('should remove trailing /').returns("https://dfw.blockstorage.api.rackspacecloud.com/v1") do Fog::Rackspace.normalize_url "https://dfw.blockstorage.api.rackspacecloud.com/v1/" end tests('should downcase url').returns("https://dfw.blockstorage.api.rackspacecloud.com/v1") do Fog::Rackspace.normalize_url "HTTPS://DFW.BLOCKSTORAGE.API.RACKSPACECLOUD.COM/V1" end tests('show do all three').returns("https://dfw.blockstorage.api.rackspacecloud.com/v1") do Fog::Rackspace.normalize_url "HTTPS://DFW.BLOCKSTORAGE.API.RACKSPACECLOUD.COM/V1/ " end end tests('json_response?') do returns(false, "nil") { Fog::Rackspace.json_response?(nil) } tests('missing header').returns(false) do response = Excon::Response.new response.headers = nil #maybe this is a forced case returns(true) { response.headers.nil? } Fog::Rackspace.json_response?(response) end tests('nil Content-Type header').returns(false) do response = Excon::Response.new response.headers['Content-Type'] = nil Fog::Rackspace.json_response?(response) end tests('text/html Content-Type header').returns(false) do response = Excon::Response.new response.headers['Content-Type'] = 'text/html' Fog::Rackspace.json_response?(response) end tests('application/json Content-Type header').returns(true) do response = Excon::Response.new response.headers['Content-Type'] = 'application/json' Fog::Rackspace.json_response?(response) end tests('APPLICATION/JSON Content-Type header').returns(true) do response = Excon::Response.new response.headers['Content-Type'] = 'APPLICATION/JSON' Fog::Rackspace.json_response?(response) end end end fog-rackspace-0.1.6/tests/rackspace/networking_tests.rb 0000644 0000041 0000041 00000013712 13411315054 023310 0 ustar www-data www-data Shindo.tests('Fog::Rackspace::Networking', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::Rackspace::Networking.new assert_method nil, :authenticate_v2 assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('legacy authentication') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.list_flavors end tests('custom endpoint') do @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_compute_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('current authentation') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true} returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.list_flavors end tests('dfw region').succeeds do @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_flavors end tests('ord region').succeeds do @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil } @service.list_flavors end tests('custom endpoint') do @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_compute_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::Rackspace::Networking.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil } @service.list_flavors end tests('specify old contstant style service endoint').succeeds do @service = Fog::Rackspace::Networking.new :rackspace_endpoint => Fog::Rackspace::Networking::ORD_ENDPOINT returns(true) { (@service.instance_variable_get("@uri").to_s =~ /#{Fog::Rackspace::Networking::ORD_ENDPOINT}/ ) != nil } @service.list_flavors end tests('specify region').succeeds do @service = Fog::Rackspace::Networking.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil } @service.list_flavors end tests('custom endpoint') do @service = Fog::Rackspace::Networking.new :rackspace_compute_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::Rackspace::Networking.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad_token") returns(true) { [200, 203].include? @service.list_flavors.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::Rackspace::Networking.new :rackspace_api_key => 'bad_key' } end end end fog-rackspace-0.1.6/tests/rackspace/dns_tests.rb 0000644 0000041 0000041 00000012727 13411315054 021712 0 ustar www-data www-data Shindo.tests('Fog::DNS::Rackspace', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::DNS::Rackspace.new assert_method nil, :authenticate_v2 assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('legacy authentication') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::DNS::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "contains tenant id") { (@service.instance_variable_get("@uri").path =~ /\/v1\.0\/\d+$/) != nil} #dns does not error if tenant id is missing returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.list_domains end tests('custom endpoint') do @service = Fog::DNS::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_dns_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('current authentication') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::DNS::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => { :ssl_verify_peer => true } returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } returns(true, "contains tenant id") { (@service.instance_variable_get("@uri").path =~ /\/v1\.0\/\d+$/) != nil} #dns does not error if tenant id is missing identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.list_domains end tests('custom endpoint') do @service = Fog::DNS::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_dns_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::DNS::Rackspace.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? } returns(true, "contains tenant id") { (@service.instance_variable_get("@uri").path =~ /\/v1\.0\/\d+$/) != nil} #dns does not error if tenant id is missing @service.list_domains end tests('custom endpoint') do @service = Fog::DNS::Rackspace.new :rackspace_dns_url => 'https://my-custom-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::DNS::Rackspace.new returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad_token") returns(200) { @service.list_domains.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::DNS::Rackspace.new :rackspace_api_key => 'bad_key' } end end tests('array_to_query_string') do pending if Fog.mocking? @service = Fog::DNS::Rackspace.new returns("") { @service.send(:array_to_query_string, nil) } returns("param1=1") { @service.send(:array_to_query_string, {:param1 => [1]}) } returns("param1=1") { @service.send(:array_to_query_string, {:param1 => 1}) } returns("param1=1,2") { @service.send(:array_to_query_string, {:param1 => [1,2]}) } returns("param1=1¶m2=2") { @service.send(:array_to_query_string, {:param1 => [1], :param2 => [2]}) } end end fog-rackspace-0.1.6/tests/rackspace/cdn_tests.rb 0000644 0000041 0000041 00000020526 13411315054 021666 0 ustar www-data www-data Shindo.tests('Fog::CDN::Rackspace', ['rackspace']) do def assert_method(url, method) @service.instance_variable_set "@rackspace_auth_url", url returns(method) { @service.send :authentication_method } end tests('#authentication_method') do @service = Fog::CDN::Rackspace.new assert_method nil, :authenticate_v2 assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2 assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1 assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2 end tests('authentication v1') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::CDN::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? } returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? } @service.get_containers end tests('custom endpoint') do @service = Fog::CDN::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0', :rackspace_cdn_url => 'https://my-custom-cdn-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-cdn-endpoint\.com/) != nil } end end tests('authentication v2') do pending if Fog.mocking? tests('variables populated').succeeds do @service = Fog::CDN::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => { :ssl_verify_peer => true } returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? } identity_service = @service.instance_variable_get("@identity_service") returns(false, "identity service was used") { identity_service.nil? } returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) } @service.get_containers end tests('dfw region').succeeds do @service = Fog::CDN::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /cdn1/) != nil } @service.get_containers end tests('ord region').succeeds do @service = Fog::CDN::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /cdn2/) != nil } @service.get_containers end tests('custom endpoint') do @service = Fog::CDN::Rackspace.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_cdn_url => 'https://my-custom-cdn-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-cdn-endpoint\.com/) != nil } end end tests('default auth') do pending if Fog.mocking? tests('no params').succeeds do @service = Fog::CDN::Rackspace.new :rackspace_region => nil returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses DFW") { (@service.instance_variable_get("@uri").host =~ /cdn1/) != nil } @service.get_containers end tests('specify region').succeeds do @service = Fog::CDN::Rackspace.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true) { (@service.instance_variable_get("@uri").host =~ /cdn2/) != nil } @service.get_containers end tests('custom endpoint') do @service = Fog::CDN::Rackspace.new :rackspace_cdn_url => 'https://my-custom-cdn-endpoint.com' returns(true, "auth token populated") { !@service.send(:auth_token).nil? } returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-cdn-endpoint\.com/) != nil } end end tests('reauthentication') do pending if Fog.mocking? tests('should reauth with valid credentials') do @service = Fog::CDN::Rackspace.new :rackspace_region => :ord returns(true, "auth token populated") { !@service.send(:auth_token).nil? } @service.instance_variable_set("@auth_token", "bad-token") returns(true) { [200, 204].include? @service.get_containers.status } end tests('should terminate with incorrect credentials') do raises(Excon::Errors::Unauthorized) { Fog::CDN::Rackspace.new :rackspace_api_key => 'bad_key' } end end pending if Fog.mocking? def container_meta_attributes @cdn.head_container(@directory.key).headers end def clear_metadata @instance.metadata.tap do |metadata| metadata.each_pair {|k, v| metadata[k] = nil } end end directory_attributes = { # Add a random suffix to prevent collision :key => "fogfilestests-#{rand(65536)}" } @directory = Fog::Storage[:rackspace].directories.create(directory_attributes) @cdn = @directory.service.cdn begin tests('publish_container').succeeds do returns("False", "CDN is not enabled") { container_meta_attributes['X-CDN-Enabled'] } urls = @cdn.publish_container @directory returns(true, "hash contains expected urls") { Fog::CDN::Rackspace::Base::URI_HEADERS.values.all? { |url_type| urls[url_type] } } returns("True", "CDN is enabled") { container_meta_attributes['X-Cdn-Enabled'] } end tests('urls') do tests('CDN enabled container').returns(false) do @cdn.publish_container @directory @cdn.urls(@directory).empty? end tests('Non-CDN enabled container').returns(true) do @cdn.publish_container @directory, false @cdn.urls(@directory).empty? end tests('Non-existent container').returns(true) do non_existent_container = Fog::Storage::Rackspace::Directory.new :key => "non-existent" @cdn.urls(non_existent_container).empty? end end tests('urls_from_headers') do headers = { "X-Cdn-Streaming-Uri"=>"http://168e307d41afe64f1a62-d1e9259b2132e81da48ed3e1e802ef22.r2.stream.cf1.rackcdn.com", "X-Cdn-Uri"=>"http://6e8f4bf5125c9c2e4e3a-d1e9259b2132e81da48ed3e1e802ef22.r2.cf1.rackcdn.com", "Date"=>"Fri, 15 Feb 2013 18:36:41 GMT", "Content-Length"=>"0", "X-Trans-Id"=>"tx424df53b79bc43fe994d3cec0c4d2d8a", "X-Ttl"=>"3600", "X-Cdn-Ssl-Uri"=>"https://f83cb7d39e0b9ff9581b-d1e9259b2132e81da48ed3e1e802ef22.ssl.cf1.rackcdn.com", "X-Cdn-Ios-Uri"=>"http://a590286a323fec6aed22-d1e9259b2132e81da48ed3e1e802ef22.iosr.cf1.rackcdn.com", "X-Cdn-Enabled"=>"True", "Content-Type"=>"text/html; charset=UTF-8", "X-Log-Retention"=>"False" } urls = @cdn.send(:urls_from_headers, headers) returns(4) { urls.size } returns("http://168e307d41afe64f1a62-d1e9259b2132e81da48ed3e1e802ef22.r2.stream.cf1.rackcdn.com") { urls[:streaming_uri] } returns("http://6e8f4bf5125c9c2e4e3a-d1e9259b2132e81da48ed3e1e802ef22.r2.cf1.rackcdn.com") { urls[:uri] } returns("https://f83cb7d39e0b9ff9581b-d1e9259b2132e81da48ed3e1e802ef22.ssl.cf1.rackcdn.com") { urls[:ssl_uri] } returns("http://a590286a323fec6aed22-d1e9259b2132e81da48ed3e1e802ef22.iosr.cf1.rackcdn.com") { urls[:ios_uri] } end tests('purge') do pending end ensure @directory.destroy if @directory end end fog-rackspace-0.1.6/tests/rackspace/url_encoding_tests.rb 0000644 0000041 0000041 00000000433 13411315054 023565 0 ustar www-data www-data Shindo.tests('Rackspace | url_encoding', ['rackspace']) do returns("is%20this%20my%20file%3F.jpg") { Fog::Rackspace.escape("is this my file?.jpg") } returns("foo/bar") { Fog::Rackspace.escape("foo/bar", "/") } returns("foo%2Fbar") { Fog::Rackspace.escape("foo/bar", "0") } end fog-rackspace-0.1.6/tests/lorem.txt 0000644 0000041 0000041 00000000677 13411315054 017303 0 ustar www-data www-data Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. fog-rackspace-0.1.6/bin/ 0000755 0000041 0000041 00000000000 13411315054 015020 5 ustar www-data www-data fog-rackspace-0.1.6/bin/console 0000755 0000041 0000041 00000000522 13411315054 016407 0 ustar www-data www-data #!/usr/bin/env ruby require "bundler/setup" require "fog/rackspace" # You can add fixtures and/or initialization code here to make experimenting # with your gem easier. You can also use a different console, if you like. # (If you use this, don't forget to add pry to your Gemfile!) # require "pry" # Pry.start require "irb" IRB.start fog-rackspace-0.1.6/bin/setup 0000755 0000041 0000041 00000000203 13411315054 016101 0 ustar www-data www-data #!/usr/bin/env bash set -euo pipefail IFS=$'\n\t' set -vx bundle install # Do any other automated setup that you need to do here fog-rackspace-0.1.6/LICENSE.md 0000644 0000041 0000041 00000002203 13411315054 015651 0 ustar www-data www-data The MIT License (MIT) Copyright (c) 2014-2015 [CONTRIBUTORS.md](https://github.com/fog/fog-rackspace/blob/master/CONTRIBUTORS.md) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. fog-rackspace-0.1.6/CONTRIBUTORS.md 0000644 0000041 0000041 00000012522 13411315054 016531 0 ustar www-data www-data 359 Kyle RamesKey | Description |
---|---|
:connect_timeout | Connection timeout (default: 60 seconds) |
:read_timeout | Read timeout for connection (default: 60 seconds) |
:write_timeout | Write timeout for connection (default: 60 seconds) |
:proxy | Proxy for HTTP and HTTPS connections |
:ssl_ca_path | Path to SSL certificate authorities |
:ssl_ca_file | SSL certificate authority file |
:ssl_verify_peer | SSL verify peer (default: true) |
Method | Description |
---|---|
create |
Accepts hash of attributes and creates object. Note: creation is a non-blocking call and you will be required to wait for a valid state before using resulting object. |
save | Saves object. Note: not all objects support updating object. |
persisted? | Returns true if the object has been persisted. |
destroy |
Destroys object. Note: this is a non-blocking call and object deletion might not be instantaneous. |
reload | Updates object with latest state from service. |
ready? | Returns true if object is in a ready state and able to perform actions. This method will raise an exception if object is in an error state. |
attributes | Returns a hash containing the list of model attributes and values. | identity |
Returns the identity of the object. Note: This might not always be equal to object.id. |
wait_for | This method periodically reloads model and then yields to specified block until block returns true or a timeout occurs. |
Key | Description |
---|---|
:connect_timeout | Connection timeout (default: 60 seconds) |
:read_timeout | Read timeout for connection (default: 60 seconds) |
:write_timeout | Write timeout for connection (default: 60 seconds) |
:proxy | Proxy for HTTP and HTTPS connections |
:ssl_ca_path | Path to SSL certificate authorities |
:ssl_ca_file | SSL certificate authority file |
:ssl_verify_peer | SSL verify peer (default: true) |
Method | Description |
---|---|
create |
Accepts hash of attributes and creates object. Note: creation is a non-blocking call and you will be required to wait for a valid state before using resulting object. |
save | Saves object. Note: not all objects support updating object. |
persisted? | Returns true if the object has been persisted. |
destroy |
Destroys object. Note: this is a non-blocking call and object deletion might not be instantaneous. |
reload | Updates object with latest state from service. |
ready? | Returns true if object is in a ready state and able to perform actions. This method will raise an exception if object is in an error state. |
attributes | Returns a hash containing the list of model attributes and values. | identity |
Returns the identity of the object. Note: This might not always be equal to object.id. |
wait_for | This method periodically reloads model and then yields to specified block until block returns true or a timeout occurs. |
Key | Description |
---|---|
:rackspace_servicenet | If set to true, the service will access Cloud Files using the internal Rackspace ServiceNet. This option should only be used for internal network connections. |
:rackspace_cdn_ssl | If set to true, the public_url method will return the SSL based URLs. |
:persistent | If set to true, the service will use a persistent connection. |
:rackspace_storage_url | The endpoint for the Cloud Files service. By default, Fog::Storage will pick the appropriate endpoint for region. This option will typically only be used for Rackspace Private Cloud Access. |
:rackspace_cdn_url | The endpoint for the CDN service. By default, Fog::Storage pick the appropriate endpoint for region. This option will typically only be used for Rackspace Private Cloud Access. |
Key | Description |
---|---|
:connect_timeout | Connection timeout (default: 60 seconds) |
:read_timeout | Read timeout for connection (default: 60 seconds) |
:write_timeout | Write timeout for connection (default: 60 seconds) |
:proxy | Proxy for HTTP and HTTPS connections |
:ssl_ca_path | Path to SSL certificate authorities |
:ssl_ca_file | SSL certificate authority file |
:ssl_verify_peer | SSL verify peer (default: true) |
:chunk_size | The chunk size in bytes used for block transfers. By default, Fog uses 1 MB chunks. |
Method | Description |
---|---|
create |
Accepts hash of attributes and creates object. Note: creation is a non-blocking call and you will be required to wait for a valid state before using resulting object. |
save | Saves object. Note: not all objects support updating object. |
destroy |
Destroys object. Note: this is a non-blocking call and object deletion might not be instantaneous. |
reload | Updates object with latest state from service. |
attributes | Returns a hash containing the list of model attributes and values. | identity |
Returns the identity of the object. Note: This might not always be equal to object.id. |
Key | Description |
---|---|
:metadata | Hash containing directory metadata. |
Key | Description |
---|---|
:content_type | The content type of the object. Cloud Files will attempt to auto detect this value if omitted. |
:access_control_allow_origin | URLs can make Cross Origin Requests. Format is http://www.example.com. Separate URLs with a space. An asterisk (*) allows all. Please refer to CORS Container Headers for more information. |
:origin | The origin is the URI of the object's host. |
:etag | The MD5 checksum of your object's data. If specified, Cloud Files will validate the integrity of the uploaded object. |
:metadata | Hash containing file metadata. |
Key | Description |
---|---|
:connect_timeout | Connection timeout (default: 60 seconds) |
:read_timeout | Read timeout for connection (default: 60 seconds) |
:write_timeout | Write timeout for connection (default: 60 seconds) |
:proxy | Proxy for HTTP and HTTPS connections |
:ssl_ca_path | Path to SSL certificate authorities |
:ssl_ca_file | SSL certificate authority file |
:ssl_verify_peer | SSL verify peer (default: true) |
Method | Description |
---|---|
create |
Accepts hash of attributes and creates object. Note: creation is a non-blocking call and you will be required to wait for a valid state before using resulting object. |
save | Saves object. Note: not all objects support updating object. |
persisted? | Returns true if the object has been persisted. |
destroy |
Destroys object. Note: this is a non-blocking call and object deletion might not be instantaneous. |
reload | Updates object with latest state from service. |
ready? | Returns true if object is in a ready state and able to perform actions. This method will raise an exception if object is in an error state. |
attributes | Returns a hash containing the list of model attributes and values. | identity |
Returns the identity of the object. Note: This might not always be equal to object.id. |
wait_for | This method periodically reloads model and then yields to specified block until block returns true or a timeout occurs. |
Key | Description |
---|---|
:connect_timeout | Connection timeout (default: 60 seconds) |
:read_timeout | Read timeout for connection (default: 60 seconds) |
:write_timeout | Write timeout for connection (default: 60 seconds) |
:proxy | Proxy for HTTP and HTTPS connections |
:ssl_ca_path | Path to SSL certificate authorities |
:ssl_ca_file | SSL certificate authority file |
:ssl_verify_peer | SSL verify peer (default: true) |
Method | Description |
---|---|
create |
Accepts hash of attributes and creates object. Note: creation is a non-blocking call and you will be required to wait for a valid state before using resulting object. |
save | Saves object. Note: not all objects support updating object. |
persisted? | Returns true if the object has been persisted. |
destroy |
Destroys object. Note: this is a non-blocking call and object deletion might not be instantaneous. |
reload | Updates object with latest state from service. |
ready? | Returns true if object is in a ready state and able to perform actions. This method will raise an exception if object is in an error state. |
attributes | Returns a hash containing the list of model attributes and values. | identity |
Returns the identity of the object. Note: This might not always be equal to object.id. |
wait_for | This method periodically reloads model and then yields to specified block until block returns true or a timeout occurs. |
Key | Description |
---|---|
:connect_timeout | Connection timeout (default: 60 seconds) |
:read_timeout | Read timeout for connection (default: 60 seconds) |
:write_timeout | Write timeout for connection (default: 60 seconds) |
:proxy | Proxy for HTTP and HTTPS connections |
:ssl_ca_path | Path to SSL certificate authorities |
:ssl_ca_file | SSL certificate authority file |
:ssl_verify_peer | SSL verify peer (default: true) |
Method | Description |
---|---|
create |
Accepts hash of attributes and creates object. Note: creation is a non-blocking call and you will be required to wait for a valid state before using resulting object. |
save | Saves object. Note: not all objects support updating object. |
persisted? | Returns true if the object has been persisted. |
destroy |
Destroys object. Note: this is a non-blocking call and object deletion might not be instantaneous. |
reload | Updates object with latest state from service. |
ready? | Returns true if object is in a ready state and able to perform actions. This method will raise an exception if object is in an error state. |
attributes | Returns a hash containing the list of model attributes and values. | identity |
Returns the identity of the object. Note: This might not always be equal to object.id. |
wait_for | This method periodically reloads model and then yields to specified block until block returns true or a timeout occurs. |
Key | Description |
---|---|
:display_name | The name of the volume. |
:display_description | A description of the volume. |
:snapshot_id | The optional snapshot from which to create a volume. |
:volume_type | The type of volume to create. Refer to List Volume Types section for valid types. SATA is the default volume type. |
Key | Description |
---|---|
:display_name | The name of the snapshot. |
:display_description | A description of the snapshot. |
:force | If set to true, snapshot will be taken even if volume is still mounted. |
Key | Description |
---|---|
:connect_timeout | Connection timeout (default: 60 seconds) |
:read_timeout | Read timeout for connection (default: 60 seconds) |
:write_timeout | Write timeout for connection (default: 60 seconds) |
:proxy | Proxy for HTTP and HTTPS connections |
:ssl_ca_path | Path to SSL certificate authorities |
:ssl_ca_file | SSL certificate authority file |
:ssl_verify_peer | SSL verify peer (default: true) |
Method | Description |
---|---|
create |
Accepts hash of attributes and creates object. Note: creation is a non-blocking call and you will be required to wait for a valid state before using resulting object. |
save | Saves object. Note: not all objects support updating object. |
persisted? | Returns true if the object has been persisted. |
destroy |
Destroys object. Note: this is a non-blocking call and object deletion might not be instantaneous. |
reload | Updates object with latest state from service. |
ready? | Returns true if object is in a ready state and able to perform actions. This method will raise an exception if object is in an error state. |
attributes | Returns a hash containing the list of model attributes and values. | identity |
Returns the identity of the object. Note: This might not always be equal to object.id. |
wait_for | This method periodically reloads model and then yields to specified block until block returns true or a timeout occurs. |
Key | Description |
---|---|
:disk_config | The disk configuration value (AUTO or MANUAL). Refer to Next Gen Server API documentation - Disk Configuration Extension. |
:metadata | Hash containing server metadata. |
:personality | Array of files to be injected onto the server. Please refer to the Fog personality API documentation for further information. |
:config_drive | Whether a read-only configuration drive is attached. Refer to Next Gen Server API documentation - Config Drive Extension. |
:networks | Array of uuids corresponding to cloud networks that should be attached to the server, and defaults to two elements (all-zeros for public internet and all-ones for ServiceNet). Please refer to the Rackspace Create Server API documentation for further information. |
Key | Description |
---|---|
:name | Name of Server |
:flavorRef | Flavor id |
:accessIPv4 | IPv4 access address |
:accessIPv6 | IPv6 access address |
:metadata | Hash containing server metadata |
:personality | File path and contents. Refer to Next Gen Server API documentation - Server Personality. |
:disk_config | The disk configuration value (AUTO or MANUAL). Refer to Next Gen Server API documentation - Disk Configuration Extension. |