fog-core 1.24.0 → 1.25.0

data/spec/identity_spec.rb

@@ -1,9 +1,8 @@
-require 'spec_helper'
-
+require "spec_helper"
 
 module Fog
   module Identity
-    def self.require(*args); end
+    def self.require(*_args); end
   end
 end
 
@@ -12,14 +11,14 @@ describe "Fog::Identity" do
     module Fog
       module TheRightWay
         extend Provider
-        service(:identity, 'Identity')
+        service(:identity, "Identity")
       end
     end
 
     module Fog
       module Identity
         class TheRightWay
-          def initialize(args); end
+          def initialize(_args); end
         end
       end
     end
@@ -29,18 +28,17 @@ describe "Fog::Identity" do
       assert_instance_of(Fog::Identity::TheRightWay, identity)
     end
 
-
     module Fog
       module Rackspace
         extend Provider
-        service(:identity, 'Identity')
+        service(:identity, "Identity")
       end
     end
 
     module Fog
       module Rackspace
         class Identity
-          def initialize(args); end
+          def initialize(_args); end
         end
       end
     end
@@ -53,14 +51,14 @@ describe "Fog::Identity" do
     module Fog
       module BothWays
         extend Provider
-        service(:identity, 'Identity')
+        service(:identity, "Identity")
       end
     end
 
     module Fog
       module BothWays
         class Identity
-          def initialize(args); end
+          def initialize(_args); end
         end
       end
     end
@@ -82,16 +80,16 @@ describe "Fog::Identity" do
         assert_instance_of(Fog::Identity::BothWays, 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)
+      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)
       end
-    end    
+    end
   end
 end

data/spec/mocking_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "Fog mocking" do
   before do
@@ -14,7 +14,7 @@ describe "Fog mocking" do
     it "Fog.mock! returns true" do
       assert_equal true, Fog.mock!
     end
-    
+
     it "Fog.mock? without Fog.mock! returns false" do
       assert_equal false, Fog.mock?
     end
@@ -58,18 +58,18 @@ describe "Fog mocking" do
     it "defaults to ipv4" do
       assert IPAddr.new(Fog::Mock.random_ip).ipv4?
     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 
+    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
@@ -82,4 +82,3 @@ describe "Fog mocking" do
     end
   end
 end
-

data/spec/service_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Fog::Service do
   class TestService < Fog::Service
@@ -23,8 +23,8 @@ describe Fog::Service do
   end
 
   class ChildOfTestService < TestService
-    class Real; def initialize(*args); end; end
-    class Mock; def initialize(*args); end; end
+    class Real; def initialize(*_args); end; end
+    class Mock; def initialize(*_args); end; end
   end
 
   it "properly passes headers" do
@@ -98,7 +98,7 @@ describe Fog::Service do
         assert_includes(service.class.ancestors, TestService::Collections)
         assert_includes(service.class.ancestors, Fog::Service::Collections)
         refute_includes(service.class.ancestors, ChildOfTestService::Collections)
-      end       
+      end
     end
 
     it "ChildOfTestService::Real has ChildOfTestService::Collections and TestService::Collections mixed in" do
@@ -107,7 +107,7 @@ describe Fog::Service do
         assert_includes(service.class.ancestors, Fog::Service::Collections)
         assert_includes(service.class.ancestors, TestService::Collections)
         assert_includes(service.class.ancestors, ChildOfTestService::Collections)
-      end       
+      end
     end
   end
 
@@ -125,7 +125,7 @@ describe Fog::Service do
         assert_includes(service.class.ancestors, Fog::Service::Collections)
         assert_includes(service.class.ancestors, TestService::Collections)
         refute_includes(service.class.ancestors, ChildOfTestService::Collections)
-      end       
+      end
     end
 
     it "ChildOfTestService::Mock has ChildOfTestService::Collections and TestService::Collections mixed in" do
@@ -134,7 +134,7 @@ describe Fog::Service do
         assert_includes(service.class.ancestors, Fog::Service::Collections)
         assert_includes(service.class.ancestors, TestService::Collections)
         assert_includes(service.class.ancestors, ChildOfTestService::Collections)
-      end       
+      end
     end
   end
 
@@ -183,4 +183,18 @@ describe Fog::Service do
       end
     end
   end
+
+  describe "#setup_requirements" do
+    before :each do
+      @service = FakeService.new
+    end
+
+    it "should require collections" do
+      assert @service.respond_to?(:collection)
+    end
+
+    it "should mock" do
+      assert_includes @service.mocked_requests, :request
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,16 +1,22 @@
-require 'minitest/autorun'
-require 'minitest/spec'
-require 'minitest/stub_const'
+require "rubygems"
+
+require "minitest/autorun"
+require "minitest/spec"
+require "minitest/stub_const"
 
 $LOAD_PATH.unshift "lib"
 
-if ENV['COVERAGE']
-  require 'coveralls'
-  require 'simplecov'
+if ENV["COVERAGE"]
+  require "coveralls"
+  require "simplecov"
 
   SimpleCov.start do
-    add_filter '/spec/'
+    add_filter "/spec/"
   end
 end
 
-require 'fog/core'
+require "fog/core"
+
+Dir["spec/fake_app/**/*.rb"].each do |file|
+  require File.join(File.dirname(__FILE__), "..", file)
+end

data/spec/storage_spec.rb

@@ -1,9 +1,8 @@
-require 'spec_helper'
-
+require "spec_helper"
 
 module Fog
   module Storage
-    def self.require(*args); end
+    def self.require(*_args); end
   end
 end
 
@@ -12,14 +11,14 @@ describe "Fog::Storage" do
     module Fog
       module TheRightWay
         extend Provider
-        service(:storage, 'Storage')
+        service(:storage, "Storage")
       end
     end
 
     module Fog
       module Storage
         class TheRightWay
-          def initialize(args); end
+          def initialize(_args); end
         end
       end
     end
@@ -29,18 +28,17 @@ describe "Fog::Storage" do
       assert_instance_of(Fog::Storage::TheRightWay, compute)
     end
 
-
     module Fog
       module TheWrongWay
         extend Provider
-        service(:storage, 'Storage')
+        service(:storage, "Storage")
       end
     end
 
     module Fog
       module TheWrongWay
         class Storage
-          def initialize(args); end
+          def initialize(_args); end
         end
       end
     end
@@ -53,14 +51,14 @@ describe "Fog::Storage" do
     module Fog
       module BothWays
         extend Provider
-        service(:storage, 'Storage')
+        service(:storage, "Storage")
       end
     end
 
     module Fog
       module BothWays
         class Storage
-          def initialize(args); end
+          def initialize(_args); end
         end
       end
     end
@@ -82,16 +80,30 @@ describe "Fog::Storage" do
         assert_instance_of(Fog::Storage::BothWays, 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)
+      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)
       end
-    end    
+    end
+  end
+
+  describe ".get_body_size" do
+    current_version = Gem::Version.new(RUBY_VERSION)
+
+    # Ruby 1.8 doesn't support string encodings, so we can't test that
+    if current_version >= Gem::Version.new("1.9.0")
+      it "doesn't alter the encoding of the string passed to it" do
+        body = "foo".encode("UTF-8")
+        Fog::Storage.get_body_size(body)
+
+        assert_equal("UTF-8", body.encoding.to_s)
+      end
+    end
   end
 end

data/spec/test_helpers/formats_helper_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
-require 'fog/test_helpers/formats_helper'
+require "spec_helper"
+require "fog/test_helpers/formats_helper"
 
 module Shindo
   class Tests
-    def test(str, &block)
+    def test(_str, &_block)
       yield
     end
   end
@@ -11,110 +11,110 @@ end
 
 describe "formats_helper" do
   let(:shindo) { Shindo::Tests.new }
-  
-  it 'comparing welcome data against schema' do
-    data = {:welcome => "Hello" }
+
+  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"} }
+  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]} }
+    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"}} }
+    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"}] }
+    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}) { [] }
+    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"} }
+    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} }
+    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
+    it "when value and schema match as hashes" do
       assert shindo.data_matches_schema({}) { {} }
     end
 
-    it 'when value and schema match as arrays' do
+    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} }
+    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}) { {} }
+    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}) { {} }
+    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
+  describe "#formats backwards compatible changes" do
 
-    it 'when value matches schema expectation' do
-      assert shindo.formats({"key" => String}) { {"key" => "Value"} }
+    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]} }
+    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"}} }
+    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"}] }
+    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}]) { [] }
+    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"} }
+    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} }
+    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
+    it "when value and schema match as hashes" do
       assert shindo.formats({}) { {} }
     end
 
-    it 'when value and schema match as arrays' do
+    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} }
+    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}) { {} }
+    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}) { {} }
+    it "when key is missing but value is nullable (#1477)" do
+      assert shindo.formats("key" => Fog::Nullable::String) { {} }
     end
   end
 end