fog-aws 3.12.0 → 3.15.0

data/tests/helpers/compute/server_helper.rb

@@ -1,23 +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(%i[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,8 +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,56 +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,100 +0,0 @@
-# frozen_string_literal: true
-
-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
-  # 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]
-  class Tests
-    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,107 +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

data/tests/helpers/mock_helper.rb

@@ -1,109 +0,0 @@
-# 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 = {
-    aws_access_key_id:                 'aws_access_key_id',
-    aws_secret_access_key:             'aws_secret_access_key',
-    ia_access_key_id:                  'aws_access_key_id',
-    ia_secret_access_key:              'aws_secret_access_key',
-    bluebox_api_key:                   'bluebox_api_key',
-    bluebox_customer_id:               'bluebox_customer_id',
-    brightbox_client_id:               'brightbox_client_id',
-    brightbox_secret:                  'brightbox_secret',
-    cloudstack_disk_offering_id:       '',
-    cloudstack_host:                   'http://cloudstack.example.org',
-    cloudstack_network_ids:            '',
-    cloudstack_service_offering_id:    '4437ac6c-9fe3-477a-57ec-60a5a45896a4',
-    cloudstack_template_id:            '8a31cf9c-f248-0588-256e-9dbf58785216',
-    cloudstack_zone_id:                'c554c592-e09c-9df5-7688-4a32754a4305',
-    cloudstack_project_id:             'f1f1f1f1-f1f1-f1f1-f1f1-f1f1f1f1f1f1',
-    clodo_api_key:                     'clodo_api_key',
-    clodo_username:                    'clodo_username',
-    digitalocean_api_key:              'digitalocean_api_key',
-    digitalocean_client_id:            'digitalocean_client_id',
-    dnsimple_email:                    'dnsimple_email',
-    dnsimple_password:                 'dnsimple_password',
-    dnsmadeeasy_api_key:               'dnsmadeeasy_api_key',
-    dnsmadeeasy_secret_key:            'dnsmadeeasy_secret_key',
-    glesys_username:                   'glesys_username',
-    glesys_api_key:                    'glesys_api_key',
-    go_grid_api_key:                   'go_grid_api_key',
-    go_grid_shared_secret:             'go_grid_shared_secret',
-    google_storage_access_key_id:      'google_storage_access_key_id',
-    google_storage_secret_access_key:  'google_storage_secret_access_key',
-    google_project:                    'google_project_name',
-    google_client_email:               'fake@developer.gserviceaccount.com',
-    google_key_location:               '~/fake.p12',
-    hp_access_key:                     'hp_access_key',
-    hp_secret_key:                     'hp_secret_key',
-    hp_tenant_id:                      'hp_tenant_id',
-    hp_avl_zone:                       'hp_avl_zone',
-    os_account_meta_temp_url_key:      'os_account_meta_temp_url_key',
-    ibm_username:                      'ibm_username',
-    ibm_password:                      'ibm_password',
-    joyent_username:                   'joyentuser',
-    joyent_password:                   'joyentpass',
-    linode_api_key:                    'linode_api_key',
-    local_root:                        '~/.fog',
-    bare_metal_cloud_password:         'bare_metal_cloud_password',
-    bare_metal_cloud_username:         'bare_metal_cloud_username',
-    ninefold_compute_key:              'ninefold_compute_key',
-    ninefold_compute_secret:           'ninefold_compute_secret',
-    ninefold_storage_secret:           'ninefold_storage_secret',
-    ninefold_storage_token:            'ninefold_storage_token',
-#    public_key_path:                   '~/.ssh/id_rsa.pub',
-#    private_key_path:                  '~/.ssh/id_rsa',
-    opennebula_endpoint:               'http://opennebula:2633/RPC2',
-    opennebula_username:               'oneadmin',
-    opennebula_password:               'oneadmin',
-    openstack_api_key:                 'openstack_api_key',
-    openstack_username:                'openstack_username',
-    openstack_tenant:                  'openstack_tenant',
-    openstack_auth_url:                'http://openstack:35357/v2.0/tokens',
-    ovirt_url:                         'http://ovirt:8080/api',
-    ovirt_username:                    'admin@internal',
-    ovirt_password:                    '123123',
-    profitbricks_username:             'profitbricks_username',
-    profitbricks_password:             'profitbricks_password',
-    libvirt_uri:                       'qemu://libvirt/system',
-    rackspace_api_key:                 'rackspace_api_key',
-    rackspace_region:                  'dfw',
-    rackspace_username:                'rackspace_username',
-    riakcs_access_key_id:              'riakcs_access_key_id',
-    riakcs_secret_access_key:          'riakcs_secret_access_key',
-    sakuracloud_api_token:             'sakuracloud_api_token',
-    sakuracloud_api_token_secret:      'sakuracloud_api_token_secret',
-    storm_on_demand_username:          'storm_on_demand_username',
-    storm_on_demand_password:          'storm_on_demand_password',
-    vcloud_host:                       'vcloud_host',
-    vcloud_password:                   'vcloud_password',
-    vcloud_username:                   'vcloud_username',
-    vcloud_director_host:              'vcloud-director-host',
-    vcloud_director_password:          'vcloud_director_password',
-    vcloud_director_username:          'vcd_user@vcd_org_name',
-    zerigo_email:                      'zerigo_email',
-    zerigo_token:                      'zerigo_token',
-    dynect_customer:                   'dynect_customer',
-    dynect_username:                   'dynect_username',
-    dynect_password:                   'dynect_password',
-    vsphere_server:                    'virtualcenter.lan',
-    vsphere_username:                  'apiuser',
-    vsphere_password:                  'apipassword',
-    vsphere_expected_pubkey_hash:      'abcdef1234567890',
-    libvirt_username:                  'root',
-    libvirt_password:                  'password',
-    cloudsigma_username:               'csuname',
-    cloudsigma_password:               'cspass',
-    docker_username:                   'docker-fan',
-    docker_password:                   'i<3docker',
-    docker_email:                      'dockerfan@gmail.com',
-    docker_url:                        'unix://var/run/docker.sock'
-  }.merge(Fog.credentials)
-end

data/tests/helpers/model_helper.rb

@@ -1,30 +0,0 @@
-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(65_536).to_s(16).rjust(4, '0')
-  [base_name, suffix].join('-')
-end

data/tests/helpers/responds_to_helper.rb

@@ -1,11 +0,0 @@
-module Shindo
-  class Tests
-    def responds_to(method_names)
-      [*method_names].each do |method_name|
-        tests("#respond_to?(:#{method_name})").returns(true) do
-          @instance.respond_to?(method_name)
-        end
-      end
-    end
-  end
-end

data/tests/helpers/schema_validator_tests.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-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

data/tests/helpers/succeeds_helper.rb

@@ -1,9 +0,0 @@
-module Shindo
-  class Tests
-    def succeeds(&block)
-      test('succeeds') do
-        !instance_eval(&Proc.new(&block)).nil?
-      end
-    end
-  end
-end

data/tests/lorem.txt

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

data/tests/models/auto_scaling/activities_tests.rb

@@ -1,6 +0,0 @@
-Shindo.tests('AWS::AutoScaling | activities', ['aws', 'auto_scaling_m']) do
-
-  pending # FIXME: activity#save is not implemented
-  collection_tests(Fog::AWS[:auto_scaling].activities, {}, false)
-
-end

data/tests/models/auto_scaling/configuration_test.rb

@@ -1,13 +0,0 @@
-Shindo.tests('AWS::AutoScaling | configuration', ['aws', 'auto_scaling_m']) do
-
-  params = {
-    :id => uniq_id,
-    :image_id => 'ami-8c1fece5',
-    :instance_type => 't1.micro'
-  }
-
-  model_tests(Fog::AWS[:auto_scaling].configurations, params, false) do
-    @instance.wait_for { ready? }
-  end
-
-end

data/tests/models/auto_scaling/configurations_tests.rb

@@ -1,11 +0,0 @@
-Shindo.tests('AWS::AutoScaling | configurations', ['aws', 'auto_scaling_m']) do
-
-  params = {
-    :id => uniq_id,
-    :image_id => 'ami-8c1fece5',
-    :instance_type => 't1.micro'
-  }
-
-  collection_tests(Fog::AWS[:auto_scaling].configurations, params, false)
-
-end

data/tests/models/auto_scaling/groups_test.rb

@@ -1,27 +0,0 @@
-Shindo.tests('AWS::AutoScaling | group', ['aws', 'auto_scaling_m']) do
-
-  params = {
-    :id => uniq_id,
-    :auto_scaling_group_name => "name",
-    :availability_zones => [],
-    :launch_configuration_name => "lc"
-  }
-
-  lc_params = {
-    :id => params[:launch_configuration_name],
-    :image_id => "image-id",
-    :instance_type => "instance-type",
-  }
-
-  Fog::AWS[:auto_scaling].configurations.new(lc_params).save
-
-  model_tests(Fog::AWS[:auto_scaling].groups, params, true) do
-    @instance.update
-  end
-
-  test("setting attributes in the constructor") do
-    group = Fog::AWS[:auto_scaling].groups.new(:min_size => 1, :max_size => 2)
-    group.min_size == 1 && group.max_size == 2
-  end
-
-end

data/tests/models/auto_scaling/instance_tests.rb

@@ -1,15 +0,0 @@
-require 'fog/aws/models/auto_scaling/instance'
-
-Shindo.tests("Fog::AWS::AutoScaling::Instance", 'aws') do
-  @instance = Fog::AWS::AutoScaling::Instance.new
-
-  test('#healthy? = true') do
-    @instance.health_status = 'Healthy'
-    @instance.healthy? == true
-  end
-
-  test('#heatlhy? = false') do
-    @instance.health_status = 'Unhealthy'
-    @instance.healthy? == false
-  end
-end

data/tests/models/auto_scaling/instances_tests.rb

@@ -1,6 +0,0 @@
-Shindo.tests('AWS::AutoScaling | instances', ['aws', 'auto_scaling_m']) do
-
-  pending # FIXME: instance#save is not defined
-  #collection_tests(Fog::AWS[:auto_scaling].instances, {}, false)
-
-end