fog-aws 3.5.2 → 3.19.0

data/tests/credentials_tests.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-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::AWS::Compute.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::AWS::Compute.fetch_credentials(use_iam_profile: true) }
-    end
-
-    ENV['AWS_CONTAINER_CREDENTIALS_RELATIVE_URI'] = nil
-
-    compute = Fog::AWS::Compute.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::AWS::Compute.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::AWS::Compute.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::AWS::Compute::Mock.data[:iam_role_based_creds] = mocked_credentials
-      returns(mocked_credentials) { Fog::AWS::Compute.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,90 +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?'
-      ]
-
-      methods.each do |enum_method|
-        if collection.respond_to?(enum_method)
-          tests("##{enum_method}").succeeds do
-            block_called = false
-            collection.send(enum_method) { 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) { 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,28 +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,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