fog-aws 1.4.1 → 3.27.0

data/Rakefile

@@ -1,8 +0,0 @@
-require "bundler/gem_tasks"
-
-task :default => :test
-
-mock = ENV['FOG_MOCK'] || 'true'
-task :test do
-  sh("export FOG_MOCK=#{mock} && bundle exec shindont")
-end

data/gemfiles/Gemfile-edge

@@ -1,14 +0,0 @@
-source "https://rubygems.org"
-
-# Shared components
-gem "fog-core", :github => "fog/fog-core"
-gem "fog-json", :github => "fog/fog-json"
-
-group :test, :default do
-  gem 'pry-nav'
-  gem 'mime-types', '~> 3.1'
-end
-
-gem "codeclimate-test-reporter", group: :test, require: nil
-
-gemspec :path => "../"

data/gemfiles/Gemfile-ruby-1.8.7

@@ -1,6 +0,0 @@
-source "https://rubygems.org"
-
-gem 'mime-types', '~> 1.16'
-gem 'nokogiri', '~> 1.5.11'
-
-gemspec :path => "../"

data/gemfiles/Gemfile-ruby-1.9

@@ -1,7 +0,0 @@
-source "https://rubygems.org"
-
-gem 'json', '~> 1.8'
-gem 'mime-types', '~> 2.6', '>= 2.6.2'
-gem 'nokogiri', '~> 1.6.8'
-
-gemspec :path => "../"

data/gemfiles/Gemfile-ruby-2.0

@@ -1,7 +0,0 @@
-
-source "https://rubygems.org"
-
-gem 'mime-types', '~> 3.1'
-gem 'nokogiri', '~> 1.6.8'
-
-gemspec :path => "../"

data/tests/credentials_tests.rb

@@ -1,86 +0,0 @@
-Shindo.tests('AWS | credentials', ['aws']) do
-  old_mock_value = Excon.defaults[:mock]
-  fog_was_mocked = Fog.mocking?
-  Excon.stubs.clear
-  Fog.unmock!
-  begin
-    Excon.defaults[:mock] = true
-    Excon.stub({:method => :get, :path => "/latest/meta-data/iam/security-credentials/"}, {:status => 200, :body => 'arole'})
-    Excon.stub({:method => :get, :path => "/latest/meta-data/placement/availability-zone/"}, {:status => 200, :body => 'us-west-1a'})
-
-    expires_at = Time.at(Time.now.to_i + 500)
-    credentials = {
-      'AccessKeyId' => 'dummykey',
-      'SecretAccessKey' => 'dummysecret',
-      'Token' => 'dummytoken',
-      'Expiration' => expires_at.xmlschema
-    }
-
-    Excon.stub({:method => :get, :path => "/latest/meta-data/iam/security-credentials/arole"}, {:status => 200, :body => Fog::JSON.encode(credentials)})
-
-    tests("#fetch_credentials") do
-      returns({:aws_access_key_id => 'dummykey',
-                :aws_secret_access_key => 'dummysecret',
-                :aws_session_token => 'dummytoken',
-                :region => "us-west-1",
-                :aws_credentials_expire_at => expires_at}) { Fog::Compute::AWS.fetch_credentials(:use_iam_profile => true) }
-    end
-
-    ENV["AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"] = '/v1/credentials?id=task_id'
-    Excon.stub({:method => :get, :path => '/v1/credentials?id=task_id'}, {:status => 200, :body => Fog::JSON.encode(credentials)})
-
-    tests("#fetch_credentials") do
-      returns({:aws_access_key_id => 'dummykey',
-                :aws_secret_access_key => 'dummysecret',
-                :aws_session_token => 'dummytoken',
-                :region => "us-west-1",
-                :aws_credentials_expire_at => expires_at}) { Fog::Compute::AWS.fetch_credentials(:use_iam_profile => true) }
-    end
-
-    ENV["AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"] = nil
-
-    compute = Fog::Compute::AWS.new(:use_iam_profile => true)
-
-    tests("#refresh_credentials_if_expired") do
-      returns(nil){compute.refresh_credentials_if_expired}
-    end
-
-    credentials['AccessKeyId'] = 'newkey'
-    credentials['SecretAccessKey'] = 'newsecret'
-    credentials['Expiration'] = (expires_at + 10).xmlschema
-
-    Excon.stub({:method => :get, :path => "/latest/meta-data/iam/security-credentials/arole"}, {:status => 200, :body => Fog::JSON.encode(credentials)})
-
-    Fog::Time.now = expires_at + 1
-    tests("#refresh_credentials_if_expired") do
-      returns(true){compute.refresh_credentials_if_expired}
-      returns("newkey"){ compute.instance_variable_get(:@aws_access_key_id)}
-    end
-    Fog::Time.now = Time.now
-
-    default_credentials = Fog::Compute::AWS.fetch_credentials({})
-    tests("#fetch_credentials when the url 404s") do
-      Excon.stub({:method => :get, :path => "/latest/meta-data/iam/security-credentials/"}, {:status => 404, :body => 'not bound'})
-      Excon.stub({:method => :get, :path => "/latest/meta-data/placement/availability-zone/"}, {:status => 400, :body => 'not found'})
-      returns(default_credentials) {Fog::Compute::AWS.fetch_credentials(:use_iam_profile => true)}
-    end
-
-    mocked_credentials = {
-      :aws_access_key_id => "access-key-id",
-      :aws_secret_access_key => "secret-access-key",
-      :aws_session_token => "session-token",
-      :aws_credentials_expire_at => Time.at(Time.now.to_i + 500).xmlschema
-    }
-    tests("#fetch_credentials when mocking") do
-      Fog.mock!
-      Fog::Compute::AWS::Mock.data[:iam_role_based_creds] = mocked_credentials
-      returns(mocked_credentials) {Fog::Compute::AWS.fetch_credentials(:use_iam_profile => true)}
-    end
-
-  ensure
-    ENV["AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"] = nil
-    Excon.stubs.clear
-    Excon.defaults[:mock] = old_mock_value
-    Fog.mock! if fog_was_mocked
-  end
-end

data/tests/helper.rb

@@ -1,29 +0,0 @@
-begin
-  require 'simplecov'
-  SimpleCov.start
-  SimpleCov.command_name "Shindo"
-rescue LoadError => e
-  $stderr.puts "not recording test coverage: #{e.inspect}"
-end
-
-require File.expand_path('../../lib/fog/aws', __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

data/tests/helpers/collection_helper.rb

@@ -1,97 +0,0 @@
-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

data/tests/helpers/compute/flavors_helper.rb

@@ -1,32 +0,0 @@
-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

data/tests/helpers/compute/server_helper.rb

@@ -1,25 +0,0 @@
-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

data/tests/helpers/compute/servers_helper.rb

@@ -1,10 +0,0 @@
-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

data/tests/helpers/dns_helper.rb

@@ -1,55 +0,0 @@
-def dns_providers
-  {
-    :aws          => {
-      :mocked => false
-    },
-    :bluebox      => {
-      :mocked => false,
-      :zone_attributes => {
-        :ttl => 60
-      }
-    },
-    :dnsimple     => {
-      :mocked => false
-    },
-    :dnsmadeeasy  => {
-      :mocked => false
-    },
-    :dynect       => {
-      :mocked => false,
-      :zone_attributes => {
-        :email => 'fog@example.com'
-      }
-    },
-    :linode       => {
-      :mocked => false,
-      :zone_attributes => {
-        :email => 'fog@example.com'
-      }
-    },
-    :zerigo       => {
-      :mocked => false
-    },
-    :rackspace    => {
-      :mocked => false,
-      :zone_attributes => {
-        :email => 'fog@example.com'
-      }
-    },
-    :rage4 => {
-      :mocked => false
-    }
-  }
-end
-
-def generate_unique_domain( with_trailing_dot = false)
-  #get time (with 1/100th of sec accuracy)
-  #want unique domain name and if provider is fast, this can be called more than once per second
-  time= (Time.now.to_f * 100).to_i
-  domain = 'test-' + time.to_s + '.com'
-  if with_trailing_dot
-    domain+= '.'
-  end
-
-  domain
-end

data/tests/helpers/formats_helper.rb

@@ -1,98 +0,0 @@
-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

data/tests/helpers/formats_helper_tests.rb

@@ -1,110 +0,0 @@
-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