fog-core 2.2.4 → 2.4.0

data/spec/formatador_spec.rb

@@ -26,15 +26,15 @@ describe Fog::Formatador do
         end
       end
 
-      @collection = @collection_class.new(:attr_one => "String", :attr_two => 5)
-      @collection << @member_class.new(:name => "Member name")
+      @collection = @collection_class.new(attr_one: "String", attr_two: 5)
+      @collection << @member_class.new(name: "Member name")
       @expected = <<-EOS.gsub(/^ {6}/, "").chomp!
         <InspectionGadget
-          attr_one=\"String\",
+          attr_one="String",
           attr_two=5
           [
                         <MemberGadget
-              name=\"Member name\"
+              name="Member name"
             >    
           ]
         >
@@ -78,18 +78,18 @@ describe Fog::Formatador do
           self
         end
       end
-      @collection = @collection_class.new(:name => "Name")
+      @collection = @collection_class.new(name: "Name")
       @collection << "this"
     end
 
     it "returns formatted representation" do
       @expected = <<-EOS.gsub(/^ {6}/, "").chomp!
         <
-          name=\"Name\"
+          name="Name"
         >
       EOS
 
-      opts = { :include_nested => false }
+      opts = { include_nested: false }
       Fog::Formatador.format(@collection, opts).must_equal @expected
     end
   end

data/spec/identity_spec.rb

@@ -8,13 +8,6 @@ end
 
 describe "Fog::Identity" do
   describe "#new" do
-    module Fog
-      module TheRightWay
-        extend Provider
-        service(:identity, "Identity")
-      end
-    end
-
     module Fog
       module TheRightWay
         class Identity
@@ -23,18 +16,18 @@ describe "Fog::Identity" do
       end
     end
 
-    it "instantiates an instance of Fog::Identity::<Provider> from the :provider keyword arg" do
-      identity = Fog::Identity.new(:provider => :therightway)
-      assert_instance_of(Fog::TheRightWay::Identity, identity)
-    end
-
     module Fog
-      module TheWrongWay
+      module TheRightWay
         extend Provider
         service(:identity, "Identity")
       end
     end
 
+    it "instantiates an instance of Fog::Identity::<Provider> from the :provider keyword arg" do
+      identity = Fog::Identity.new(provider: :therightway)
+      assert_instance_of(Fog::TheRightWay::Identity, identity)
+    end
+
     module Fog
       module Identity
         class TheWrongWay
@@ -43,18 +36,18 @@ describe "Fog::Identity" do
       end
     end
 
-    it "instantiates an instance of Fog::<Provider>::Identity from the :provider keyword arg" do
-      identity = Fog::Identity.new(:provider => :thewrongway)
-      assert_instance_of(Fog::Identity::TheWrongWay, identity)
-    end
-
     module Fog
-      module BothWays
+      module TheWrongWay
         extend Provider
         service(:identity, "Identity")
       end
     end
 
+    it "instantiates an instance of Fog::<Provider>::Identity from the :provider keyword arg" do
+      identity = Fog::Identity.new(provider: :thewrongway)
+      assert_instance_of(Fog::Identity::TheWrongWay, identity)
+    end
+
     module Fog
       module BothWays
         class Identity
@@ -74,21 +67,28 @@ describe "Fog::Identity" do
       end
     end
 
+    module Fog
+      module BothWays
+        extend Provider
+        service(:identity, "Identity")
+      end
+    end
+
     describe "when both Fog::Identity::<Provider> and Fog::<Provider>::Identity exist" do
       it "prefers Fog::Identity::<Provider>" do
-        identity = Fog::Identity.new(:provider => :bothways)
+        identity = Fog::Identity.new(provider: :bothways)
         assert_instance_of(Fog::BothWays::Identity, identity)
       end
     end
 
     it "passes the supplied keyword args less :provider to Fog::Identity::<Provider>#new" do
-      identity = Fog::Identity.new(:provider => :bothways, :extra => :stuff)
-      assert_equal({ :extra => :stuff }, identity.args)
+      identity = Fog::Identity.new(provider: :bothways, extra: :stuff)
+      assert_equal({ extra: :stuff }, identity.args)
     end
 
     it "raises ArgumentError when given a :provider where a Fog::Identity::Provider that does not exist" do
       assert_raises(ArgumentError) do
-        Fog::Identity.new(:provider => :wat)
+        Fog::Identity.new(provider: :wat)
       end
     end
   end

data/spec/mocking_spec.rb

@@ -60,16 +60,16 @@ describe "Fog mocking" do
     end
 
     it "supports explicit request for v4" do
-      assert IPAddr.new(Fog::Mock.random_ip(:version => :v4)).ipv4?
+      assert IPAddr.new(Fog::Mock.random_ip(version: :v4)).ipv4?
     end
 
     it "supports explicit request for v6" do
-      assert IPAddr.new(Fog::Mock.random_ip(:version => :v6)).ipv6?
+      assert IPAddr.new(Fog::Mock.random_ip(version: :v6)).ipv6?
     end
 
     it "raises when supplied an illegal IP version" do
       assert_raises(ArgumentError) do
-        IPAddr.new(Fog::Mock.random_ip(:version => :v5)).ipv4?
+        IPAddr.new(Fog::Mock.random_ip(version: :v5)).ipv4?
       end
     end
   end

data/spec/service_spec.rb

@@ -32,10 +32,10 @@ describe Fog::Service do
       "User-Agent" => "Generic Fog Client"
     }
     params = {
-      :generic_user => "bob",
-      :generic_api_key => "1234",
-      :connection_options => {
-        :headers => user_agent_hash
+      generic_user: "bob",
+      generic_api_key: "1234",
+      connection_options: {
+        headers: user_agent_hash
       }
     }
     service = TestService.new(params)
@@ -54,27 +54,27 @@ describe Fog::Service do
     end
 
     it "removes keys with `nil` values" do
-      service = TestService.new :generic_api_key => "abc", :generic_user => nil
+      service = TestService.new generic_api_key: "abc", generic_user: nil
       refute_includes service.options.keys, :generic_user
     end
 
     it "converts number String values with to_i" do
-      service = TestService.new :generic_api_key => "3421"
+      service = TestService.new generic_api_key: "3421"
       assert_equal 3421, service.options[:generic_api_key]
     end
 
     it "converts 'true' String values to TrueClass" do
-      service = TestService.new :generic_api_key => "true"
+      service = TestService.new generic_api_key: "true"
       assert_equal true, service.options[:generic_api_key]
     end
 
     it "converts 'false' String values to FalseClass" do
-      service = TestService.new :generic_api_key => "false"
+      service = TestService.new generic_api_key: "false"
       assert_equal false, service.options[:generic_api_key]
     end
 
     it "warns for unrecognised options" do
-      bad_options = { :generic_api_key => "abc", :bad_option => "bad value" }
+      bad_options = { generic_api_key: "abc", bad_option: "bad value" }
       logger = Minitest::Mock.new
       logger.expect :warning, nil, ["Unrecognized arguments: bad_option"]
       Fog.stub_const :Logger, logger do
@@ -87,14 +87,14 @@ describe Fog::Service do
   describe "when creating and mocking is disabled" do
     it "returns the real service" do
       Fog.stub :mocking?, false do
-        service = TestService.new(:generic_api_key => "abc")
+        service = TestService.new(generic_api_key: "abc")
         service.must_be_instance_of TestService::Real
       end
     end
 
     it "TestService::Real has TestService::Collections mixed into the mocked service" do
       Fog.stub :mocking?, false do
-        service = TestService.new(:generic_api_key => "abc")
+        service = TestService.new(generic_api_key: "abc")
         assert_includes(service.class.ancestors, TestService::Collections)
         assert_includes(service.class.ancestors, Fog::Service::Collections)
         refute_includes(service.class.ancestors, ChildOfTestService::Collections)
@@ -114,14 +114,14 @@ describe Fog::Service do
   describe "when creating and mocking is enabled" do
     it "returns mocked service" do
       Fog.stub :mocking?, true do
-        service = TestService.new(:generic_api_key => "abc")
+        service = TestService.new(generic_api_key: "abc")
         service.must_be_instance_of TestService::Mock
       end
     end
 
     it "TestService::Mock has TestService::Collections mixed into the mocked service" do
       Fog.stub :mocking?, true do
-        service = TestService.new(:generic_api_key => "abc")
+        service = TestService.new(generic_api_key: "abc")
         assert_includes(service.class.ancestors, Fog::Service::Collections)
         assert_includes(service.class.ancestors, TestService::Collections)
         refute_includes(service.class.ancestors, ChildOfTestService::Collections)
@@ -141,8 +141,8 @@ describe Fog::Service do
   describe "when no credentials are provided" do
     it "uses the global values" do
       @global_credentials = {
-        :generic_user => "fog",
-        :generic_api_key => "fog"
+        generic_user: "fog",
+        generic_api_key: "fog"
       }
 
       Fog.stub :credentials, @global_credentials do
@@ -155,11 +155,11 @@ describe Fog::Service do
   describe "when credentials are provided as settings" do
     it "merges the global values into settings" do
       @settings = {
-        :generic_user => "fog"
+        generic_user: "fog"
       }
       @global_credentials = {
-        :generic_user => "bob",
-        :generic_api_key => "fog"
+        generic_user: "bob",
+        generic_api_key: "fog"
       }
 
       Fog.stub :credentials, @global_credentials do
@@ -172,7 +172,7 @@ describe Fog::Service do
 
   describe "when config object can configure the service itself" do
     it "ignores the global and its values" do
-      @config = MiniTest::Mock.new
+      @config = Minitest::Mock.new
       def @config.config_service?;  true; end
       def @config.nil?; false; end
       def @config.==(other); object_id == other.object_id; end

data/spec/spec_helper.rb

@@ -1,11 +1,6 @@
-if ENV["COVERAGE"]
-  require "coveralls"
-  require "simplecov"
-
-  SimpleCov.start do
-    add_filter "/spec/"
-  end
-end
+# Set home outside of real user
+require "tmpdir"
+ENV["HOME"] = Dir.mktmpdir("foghome")
 
 require "minitest/autorun"
 require "minitest/spec"

data/spec/storage_spec.rb

@@ -10,49 +10,42 @@ describe "Fog::Storage" do
   describe "#new" do
     module Fog
       module TheRightWay
-        extend Provider
-        service(:storage, "Storage")
+        class Storage
+          def initialize(_args); end
+        end
       end
     end
 
     module Fog
       module TheRightWay
-        class Storage
-          def initialize(_args); end
-        end
+        extend Provider
+        service(:storage, "Storage")
       end
     end
 
     it "instantiates an instance of Fog::<Provider>::Storage from the :provider keyword arg" do
-      compute = Fog::Storage.new(:provider => :therightway)
+      compute = Fog::Storage.new(provider: :therightway)
       assert_instance_of(Fog::TheRightWay::Storage, compute)
     end
 
     module Fog
-      module TheWrongWay
-        extend Provider
-        service(:storage, "Storage")
-      end
-
       module Storage
         class TheWrongWay
           def initialize(_args); end
         end
       end
-    end
-
-    it "instantiates an instance of Fog::Storage::<Provider> from the :provider keyword arg" do
-      compute = Fog::Storage.new(:provider => :thewrongway)
-      assert_instance_of(Fog::Storage::TheWrongWay, compute)
-    end
 
-    module Fog
-      module BothWays
+      module TheWrongWay
         extend Provider
         service(:storage, "Storage")
       end
     end
 
+    it "instantiates an instance of Fog::Storage::<Provider> from the :provider keyword arg" do
+      compute = Fog::Storage.new(provider: :thewrongway)
+      assert_instance_of(Fog::Storage::TheWrongWay, compute)
+    end
+
     module Fog
       module BothWays
         class Storage
@@ -73,21 +66,28 @@ describe "Fog::Storage" do
       end
     end
 
+    module Fog
+      module BothWays
+        extend Provider
+        service(:storage, "Storage")
+      end
+    end
+
     describe "when both Fog::Storage::<Provider> and Fog::<Provider>::Storage exist" do
       it "prefers Fog::Storage::<Provider>" do
-        compute = Fog::Storage.new(:provider => :bothways)
+        compute = Fog::Storage.new(provider: :bothways)
         assert_instance_of(Fog::BothWays::Storage, compute)
       end
     end
 
     it "passes the supplied keyword args less :provider to Fog::Storage::<Provider>#new" do
-      compute = Fog::Storage.new(:provider => :bothways, :extra => :stuff)
-      assert_equal({ :extra => :stuff }, compute.args)
+      compute = Fog::Storage.new(provider: :bothways, extra: :stuff)
+      assert_equal({ extra: :stuff }, compute.args)
     end
 
     it "raises ArgumentError when given a :provider where a Fog::Storage::Provider that does not exist" do
       assert_raises(ArgumentError) do
-        Fog::Storage.new(:provider => :wat)
+        Fog::Storage.new(provider: :wat)
       end
     end
   end

data/spec/test_helpers/formats_helper_spec.rb

@@ -14,8 +14,8 @@ 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 }
+    data = { welcome: "Hello" }
+    assert shindo.data_matches_schema(welcome: String) { data }
   end
 
   describe "#data_matches_schema" do
@@ -28,7 +28,7 @@ describe "formats_helper" do
     end
 
     it "when nested values match schema expectation" do
-      assert shindo.data_matches_schema("key" => { :nested_key => String }) { { "key" => { :nested_key => "Value" } } }
+      assert shindo.data_matches_schema("key" => { nested_key: String }) { { "key" => { nested_key: "Value" } } }
     end
 
     it "when collection of values all match schema expectation" do
@@ -36,11 +36,11 @@ describe "formats_helper" do
     end
 
     it "when collection is empty although schema covers optional members" do
-      assert shindo.data_matches_schema([{ "key" => String }], :allow_optional_rules => true) { [] }
+      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" } }
+      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
@@ -60,11 +60,11 @@ describe "formats_helper" do
     end
 
     it "when key is missing but value should be NilClass (#1477)" do
-      assert shindo.data_matches_schema({ "key" => NilClass }, { :allow_optional_rules => true }) { {} }
+      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 }) { {} }
+      assert shindo.data_matches_schema({ "key" => Fog::Nullable::String }, { allow_optional_rules: true }) { {} }
     end
   end
 
@@ -79,7 +79,7 @@ describe "formats_helper" do
     end
 
     it "when nested values match schema expectation" do
-      assert shindo.formats("key" => { :nested_key => String }) { { "key" => { :nested_key => "Value" } } }
+      assert shindo.formats("key" => { nested_key: String }) { { "key" => { nested_key: "Value" } } }
     end
 
     it "when collection of values all match schema expectation" do

data/spec/test_helpers/schema_validator_spec.rb

@@ -15,7 +15,7 @@ describe "SchemaValidator" do
     end
 
     it "returns true when nested values match schema expectation" do
-      assert validator.validate({ "key" => { :nested_key => "Value" } }, { "key" => { :nested_key => String } })
+      assert validator.validate({ "key" => { nested_key: "Value" } }, { "key" => { nested_key: String } })
     end
 
     it "returns true when collection of values all match schema expectation" do
@@ -27,7 +27,7 @@ describe "SchemaValidator" do
     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 })
+      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
@@ -47,11 +47,11 @@ describe "SchemaValidator" do
     end
 
     it "returns true when key is missing but value should be NilClass (#1477)" do
-      assert validator.validate({}, { "key" => NilClass }, { :allow_optional_rules => true })
+      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 })
+      assert validator.validate({}, { "key" => Fog::Nullable::String }, { allow_optional_rules: true })
     end
 
     it "returns false when value does not match schema expectation" do
@@ -59,7 +59,7 @@ describe "SchemaValidator" do
     end
 
     it "returns false when key formats do not match" do
-      refute validator.validate({ "key" => "Value" }, { :key => String })
+      refute validator.validate({ "key" => "Value" }, { key: String })
     end
 
     it "returns false when additional keys are passed and strict" do
@@ -87,15 +87,15 @@ describe "SchemaValidator" do
     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 => {} } })
+      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 })
+      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 })
+      refute validator.validate({}, { "key" => Fog::Nullable::String }, { allow_optional_rules: false })
     end
   end
 end

data/spec/utils_spec.rb

@@ -4,25 +4,25 @@ describe Fog::Core::Utils do
   describe "prepare_service_settings" do
     it "changes String keys to be Symbols" do
       settings = { "a" => 3 }
-      expected = { :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 }
+      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 } }
+      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" } }
+      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

data/spec/wait_for_spec.rb

@@ -2,7 +2,7 @@ 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 })
+    assert_equal({ duration: 0 }, Fog.wait_for(1) { true })
   end
 
   it "raises if the wait timeout is exceeded" do
@@ -14,7 +14,7 @@ describe "Fog#wait_for" do
   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 }
+    ret = Fog.wait_for(timeout) { i += 1; i > 2 }
     assert_operator(ret[:duration], :>, timeout)
   end