fog-core 2.3.0 → 2.5.0

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 = 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