fog-core 2.4.0 → 2.5.0

data/spec/test_helpers/formats_helper_spec.rb

@@ -1,121 +0,0 @@
-require "spec_helper"
-require "fog/test_helpers/formats_helper"
-require "fog/test_helpers/types_helper"
-
-module Shindo
-  class Tests
-    def test(_str, &_block)
-      yield
-    end
-  end
-end
-
-describe "formats_helper" do
-  let(:shindo) { Shindo::Tests.new }
-
-  it "comparing welcome data against schema" do
-    data = { welcome: "Hello" }
-    assert shindo.data_matches_schema(welcome: String) { data }
-  end
-
-  describe "#data_matches_schema" do
-    it "when value matches schema expectation" do
-      assert shindo.data_matches_schema("key" => String) { { "key" => "Value" } }
-    end
-
-    it "when values within an array all match schema expectation" do
-      assert shindo.data_matches_schema("key" => [Integer]) { { "key" => [1, 2] } }
-    end
-
-    it "when nested values match schema expectation" do
-      assert shindo.data_matches_schema("key" => { nested_key: String }) { { "key" => { nested_key: "Value" } } }
-    end
-
-    it "when collection of values all match schema expectation" do
-      assert shindo.data_matches_schema([{ "key" => String }]) { [{ "key" => "Value" }, { "key" => "Value" }] }
-    end
-
-    it "when collection is empty although schema covers optional members" do
-      assert shindo.data_matches_schema([{ "key" => String }], allow_optional_rules: true) { [] }
-    end
-
-    it "when additional keys are passed and not strict" do
-      assert shindo.data_matches_schema({ "key" => String }, { allow_extra_keys: true }) { { "key" => "Value", :extra => "Bonus" } }
-    end
-
-    it "when value is nil and schema expects NilClass" do
-      assert shindo.data_matches_schema("key" => NilClass) { { "key" => nil } }
-    end
-
-    it "when value and schema match as hashes" do
-      assert shindo.data_matches_schema({}) { {} }
-    end
-
-    it "when value and schema match as arrays" do
-      assert shindo.data_matches_schema([]) { [] }
-    end
-
-    it "when value is a Time" do
-      assert shindo.data_matches_schema("time" => Time) { { "time" => Time.now } }
-    end
-
-    it "when key is missing but value should be NilClass (#1477)" do
-      assert shindo.data_matches_schema({ "key" => NilClass }, { allow_optional_rules: true }) { {} }
-    end
-
-    it "when key is missing but value is nullable (#1477)" do
-      assert shindo.data_matches_schema({ "key" => Fog::Nullable::String }, { allow_optional_rules: true }) { {} }
-    end
-  end
-
-  describe "#formats backwards compatible changes" do
-
-    it "when value matches schema expectation" do
-      assert shindo.formats("key" => String) { { "key" => "Value" } }
-    end
-
-    it "when values within an array all match schema expectation" do
-      assert shindo.formats("key" => [Integer]) { { "key" => [1, 2] } }
-    end
-
-    it "when nested values match schema expectation" do
-      assert shindo.formats("key" => { nested_key: String }) { { "key" => { nested_key: "Value" } } }
-    end
-
-    it "when collection of values all match schema expectation" do
-      assert shindo.formats([{ "key" => String }]) { [{ "key" => "Value" }, { "key" => "Value" }] }
-    end
-
-    it "when collection is empty although schema covers optional members" do
-      assert shindo.formats([{ "key" => String }]) { [] }
-    end
-
-    it "when additional keys are passed and not strict" do
-      assert shindo.formats({ "key" => String }, false) { { "key" => "Value", :extra => "Bonus" } }
-    end
-
-    it "when value is nil and schema expects NilClass" do
-      assert shindo.formats("key" => NilClass) { { "key" => nil } }
-    end
-
-    it "when value and schema match as hashes" do
-      assert shindo.formats({}) { {} }
-    end
-
-    it "when value and schema match as arrays" do
-      assert shindo.formats([]) { [] }
-    end
-
-    it "when value is a Time" do
-      assert shindo.formats("time" => Time) { { "time" => Time.now } }
-    end
-
-    it "when key is missing but value should be NilClass (#1477)" do
-      assert shindo.formats("key" => NilClass) { {} }
-    end
-
-    it "when key is missing but value is nullable (#1477)" do
-      assert shindo.formats("key" => Fog::Nullable::String) { {} }
-    end
-  end
-end

data/spec/test_helpers/schema_validator_spec.rb

@@ -1,101 +0,0 @@
-require "spec_helper"
-require "fog/test_helpers/formats_helper"
-require "fog/schema/data_validator"
-
-describe "SchemaValidator" do
-  let(:validator) { Fog::Schema::DataValidator.new }
-
-  describe "#validate" do
-    it "returns true when value matches schema expectation" do
-      assert validator.validate({ "key" => "Value" }, { "key" => String })
-    end
-
-    it "returns true when values within an array all match schema expectation" do
-      assert validator.validate({ "key" => [1, 2] }, { "key" => [Integer] })
-    end
-
-    it "returns true when nested values match schema expectation" do
-      assert validator.validate({ "key" => { nested_key: "Value" } }, { "key" => { nested_key: String } })
-    end
-
-    it "returns true when collection of values all match schema expectation" do
-      assert validator.validate([{ "key" => "Value" }, { "key" => "Value" }], [{ "key" => String }])
-    end
-
-    it "returns true when collection is empty although schema covers optional members" do
-      assert validator.validate([], [{ "key" => String }])
-    end
-
-    it "returns true when additional keys are passed and not strict" do
-      assert validator.validate({ "key" => "Value", :extra => "Bonus" }, { "key" => String }, { allow_extra_keys: true })
-    end
-
-    it "returns true when value is nil and schema expects NilClass" do
-      assert validator.validate({ "key" => nil }, { "key" => NilClass })
-    end
-
-    it "returns true when value and schema match as hashes" do
-      assert validator.validate({}, {})
-    end
-
-    it "returns true when value and schema match as arrays" do
-      assert validator.validate([], [])
-    end
-
-    it "returns true when value is a Time" do
-      assert validator.validate({ "time" => Time.now }, { "time" => Time })
-    end
-
-    it "returns true when key is missing but value should be NilClass (#1477)" do
-      assert validator.validate({}, { "key" => NilClass }, { allow_optional_rules: true })
-    end
-
-    it "returns true when key is missing but value is nullable (#1477)" do
-      assert validator.validate({}, { "key" => Fog::Nullable::String }, { allow_optional_rules: true })
-    end
-
-    it "returns false when value does not match schema expectation" do
-      refute validator.validate({ "key" => nil }, { "key" => String })
-    end
-
-    it "returns false when key formats do not match" do
-      refute validator.validate({ "key" => "Value" }, { key: String })
-    end
-
-    it "returns false when additional keys are passed and strict" do
-      refute validator.validate({ "key" => "Missing" }, {})
-    end
-
-    it "returns false when some keys do not appear" do
-      refute validator.validate({}, { "key" => String })
-    end
-
-    it "returns false when collection contains a member that does not match schema" do
-      refute validator.validate([{ "key" => "Value" }, { "key" => 5 }], [{ "key" => String }])
-    end
-
-    it "returns false when collection has multiple schema patterns" do
-      refute validator.validate([{ "key" => "Value" }], [{ "key" => Integer }, { "key" => String }])
-    end
-
-    it "returns false when hash and array are compared" do
-      refute validator.validate({}, [])
-    end
-
-    it "returns false when array and hash are compared" do
-      refute validator.validate([], {})
-    end
-
-    it "returns false when a hash is expected but another data type is found" do
-      refute validator.validate({ "key" => { nested_key: [] } }, { "key" => { nested_key: {} } })
-    end
-
-    it "returns false when key is missing but value should be NilClass (#1477)" do
-      refute validator.validate({}, { "key" => NilClass }, { allow_optional_rules: false })
-    end
-
-    it "returns false when key is missing but value is nullable (#1477)" do
-      refute validator.validate({}, { "key" => Fog::Nullable::String }, { allow_optional_rules: false })
-    end
-  end
-end

data/spec/timeout_spec.rb

@@ -1,20 +0,0 @@
-require "spec_helper"
-
-describe "Fog#timeout" do
-  before do
-    @old_timeout = Fog.timeout
-  end
-
-  after do
-    Fog.timeout = @old_timeout
-  end
-
-  it "defaults to 600" do
-    assert_equal 600, Fog.timeout
-  end
-
-  it "can be reassigned through Fog#timeout=" do
-    Fog.timeout = 300
-    assert_equal 300, Fog.timeout
-  end
-end

data/spec/utils_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe Fog::Core::Utils do
-  describe "prepare_service_settings" do
-    it "changes String keys to be Symbols" do
-      settings = { "a" => 3 }
-      expected = { a: 3 }
-      assert_equal expected, Fog::Core::Utils.prepare_service_settings(settings)
-    end
-
-    it "leaves Symbol keys unchanged" do
-      settings = { something: 2 }
-      expected = { something: 2 }
-      assert_equal expected, Fog::Core::Utils.prepare_service_settings(settings)
-    end
-
-    it "changes nested String keys to Symbols" do
-      settings = { "connection_options" => { "val" => 5 } }
-      expected = { connection_options: { val: 5 } }
-      assert_equal expected, Fog::Core::Utils.prepare_service_settings(settings)
-    end
-
-    it "does not change the :header key or contents" do
-      settings = { headers: { "User-Agent" => "my user agent" } }
-      expected = { headers: { "User-Agent" => "my user agent" } }
-      assert_equal expected, Fog::Core::Utils.prepare_service_settings(settings)
-    end
-  end
-end

data/spec/uuid_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-
-describe "Fog::UUID" do
-  it "#supported?" do
-    Fog::UUID.supported? == SecureRandom.respond_to?(:uuid)
-  end
-
-  it "generates a valid UUID" do
-    Fog::UUID.uuid =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
-  end
-end

data/spec/wait_for_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe "Fog#wait_for" do
-  it "returns a Hash indicating the wait duration if successful" do
-    assert_equal({ duration: 0 }, Fog.wait_for(1) { true })
-  end
-
-  it "raises if the wait timeout is exceeded" do
-    assert_raises(Fog::Errors::TimeoutError) do
-      Fog.wait_for(2) { false }
-    end
-  end
-
-  it "does not raise if successful when the wait timeout is exceeded" do
-    timeout = 2
-    i = 0
-    ret = Fog.wait_for(timeout) { i += 1; i > 2 }
-    assert_operator(ret[:duration], :>, timeout)
-  end
-
-  it "accepts a proc to determine the sleep interval" do
-    i = 0
-    ret = Fog.wait_for(1, lambda { |_t| 1 }) do
-      i += 1
-      i > 1
-    end
-    assert(1 <= ret[:duration])
-    assert(ret[:duration] < 2)
-  end
-end