fog-google 0.6.0 → 1.0.0

data/tests/helper.rb

@@ -1,124 +0,0 @@
-ENV["FOG_RC"]         = ENV["FOG_RC"] || File.expand_path("../.fog", __FILE__)
-ENV["FOG_CREDENTIAL"] = ENV["FOG_CREDENTIAL"] || "default"
-
-require "fog/google"
-require "securerandom"
-
-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
-if Fog.mocking?
-  FOG_TESTING_TIMEOUT = ENV["FOG_TEST_TIMEOUT"] || 2000
-  Fog.timeout = 2000
-  Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
-else
-  FOG_TESTING_TIMEOUT = Fog.timeout
-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
-
-# create a disk to be used in tests
-def create_test_disk(connection, zone)
-  zone = "us-central1-a"
-  random_string = SecureRandom.hex
-
-  disk = connection.disks.create({
-                                   :name => "fog-test-disk-#{random_string}",
-                                   :size_gb => "10",
-                                   :zone => zone,
-                                   :source_image => "debian-8-jessie-v20161215"
-                                 })
-  disk.wait_for { ready? }
-  disk
-end
-
-def create_test_http_health_check(connection)
-  random_string = SecureRandom.hex
-  health_check = connection.http_health_checks.create({
-                                                        :name => "fog-test-check-#{random_string}"
-                                                      })
-  health_check
-end
-
-def create_test_backend_service(connection)
-  random_string = SecureRandom.hex
-  health_check = create_test_http_health_check(connection)
-  backend_service = connection.backend_services.create({
-                                                         :name => "fog-test-backend-service-#{random_string}",
-                                                         :health_checks => [health_check]
-                                                       })
-end
-
-def create_test_url_map(connection)
-  random_string = SecureRandom.hex
-  backend_service = create_test_backend_service(connection)
-  url_map = connection.url_maps.create({
-                                         :name => "fog-test-url-map-#{random_string}",
-                                         :default_service => backend_service.self_link
-                                       })
-end
-
-def create_test_server(connection, zone)
-  random_string = SecureRandom.hex
-  disk = create_test_disk(connection, zone)
-  server = connection.servers.create({
-                                       :name => "fog-test-server-#{random_string}",
-                                       :disks => [disk],
-                                       :zone => zone,
-                                       :machine_type => "n1-standard-1"
-                                     })
-end
-
-def create_test_target_http_proxy(connection)
-  random_string = SecureRandom.hex
-  url_map = create_test_url_map(connection)
-  proxy = connection.target_http_proxies.create({
-                                                  :name => "fog-test-target-http-proxy-#{random_string}",
-                                                  :url_map => url_map.self_link
-                                                })
-end
-
-def create_test_zone_view(connection, zone)
-  random_string = SecureRandom.hex
-  zone_view = connection.zone_views.create({
-                                             :name => "fog-test-zone-view-#{random_string}",
-                                             :zone => zone
-                                           })
-  zone_view.wait_for { ready? }
-  zone_view
-end
-
-def create_test_target_pool(connection, region)
-  random_string = SecureRandom.hex
-  http_health_check = create_test_http_health_check(connection)
-  instance = create_test_server(connection, "us-central1-a")
-  target_pool = connection.target_pools.create({
-                                                 :name => "fog-test-target-pool-#{random_string}",
-                                                 :region => region,
-                                                 :health_checks => [http_health_check.self_link],
-                                                 :instances => [instance.self_link]\
-                                               })
-end
-
-def wait_operation(connection, response)
-  operation = connection.operations.get(response["name"], response["zone"], response["region"])
-  operation.wait_for { ready? }
-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"
-  domain += "." if with_trailing_dot
-
-  domain
-end

data/tests/helpers/collection_helper.rb

@@ -1,88 +0,0 @@
-# TODO: REMOVE this testing functionality is now covered in `spec/helpers/model_helper.rb`
-
-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
-
-    @identity = @instance.identity if !Fog.mocking? || mocks_implemented
-
-    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" && JRUBY_VERSION =~ /1\.7\.[5-8]/
-        methods.delete("all?")
-      end
-
-      methods.each do |enum_method|
-        next unless collection.respond_to?(enum_method)
-        tests("##{enum_method}").succeeds do
-          block_called = false
-          collection.send(enum_method) { |_| block_called = true }
-          block_called
-        end
-      end
-
-      %w(
-        max_by min_by).each do |enum_method|
-        next unless collection.respond_to?(enum_method)
-        tests("##{enum_method}").succeeds do
-          block_called = false
-          collection.send(enum_method) do |_|
-            block_called = true
-            0
-          end
-          block_called
-        end
-      end
-    end
-
-    yield(@instance) if block_given?
-
-    @instance.destroy if !Fog.mocking? || mocks_implemented
-  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,21 +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
-
-    @instance.wait_for { ready? } if !Fog.mocking? || mocks_implemented
-  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/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,106 +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