fog-openstack 0.1.12 → 0.1.13

data/tests/helper.rb

@@ -1,24 +0,0 @@
-require 'coveralls'
-Coveralls.wear!
-
-require File.expand_path('../../lib/fog/openstack', __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/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

data/tests/helpers/mock_helper.rb

@@ -1,17 +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 = {
-    :openstack_api_key => 'openstack_api_key',
-    :openstack_username => 'openstack_username',
-    :openstack_tenant => 'openstack_tenant',
-    :openstack_auth_url => 'http://openstack:35357/v2.0/tokens',
-  }.merge(Fog.credentials)
-end

data/tests/helpers/model_helper.rb

@@ -1,31 +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(65536).to_s(16).rjust(4, '0')
-  [base_name, suffix] * '-'
-end