fog-google 0.1.3 → 0.2.0

data/tests/helpers/compute/server_helper.rb

@@ -1,6 +1,5 @@
 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? }
@@ -17,9 +16,6 @@ def server_tests(connection, params = {}, mocks_implemented = true)
       @instance.reboot
     end
 
-    if !Fog.mocking? || mocks_implemented
-      @instance.wait_for { ready? }
-    end
-
+    @instance.wait_for { ready? } if !Fog.mocking? || mocks_implemented
   end
 end

data/tests/helpers/compute/servers_helper.rb

@@ -1,10 +1,8 @@
 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

@@ -15,14 +15,14 @@ module Fog
     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)}
+[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
@@ -72,7 +72,7 @@ module Shindo
     #
     # @return [Boolean]
     def data_matches_schema(schema, options = {})
-      test('data matches schema') do
+      test("data matches schema") do
         validator = Fog::Schema::DataValidator.new
         valid = validator.validate(yield, schema, options)
         @message = validator.message unless valid
@@ -82,11 +82,11 @@ module Shindo
 
     # @deprecated #formats is deprecated. Use #data_matches_schema instead
     def formats(format, strict = true)
-      test('has proper format') do
+      test("has proper format") do
         if strict
-          options = {:allow_extra_keys => false, :allow_optional_rules => true}
+          options = { :allow_extra_keys => false, :allow_optional_rules => true }
         else
-          options = {:allow_extra_keys => true, :allow_optional_rules => true}
+          options = { :allow_extra_keys => true, :allow_optional_rules => true }
         end
         validator = Fog::Schema::DataValidator.new
         valid = validator.validate(yield, format, options)

data/tests/helpers/formats_helper_tests.rb

@@ -1,110 +1,106 @@
-Shindo.tests('test_helper', 'meta') do
-
-  tests('comparing welcome data against schema') do
-    data = {:welcome => "Hello" }
+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"} }
+    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]} }
+    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"}} }
+    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"}] }
+    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}) { [] }
+    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"} }
+    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} }
+    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
+    tests("when value and schema match as hashes") do
       data_matches_schema({}) { {} }
     end
 
-    tests('when value and schema match as arrays') do
+    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} }
+    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}) { {} }
+      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}) { {} }
+      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"} }
+    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]} }
+    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"}} }
+    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"}] }
+    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}]) { [] }
+    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"} }
+    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} }
+    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
+    tests("when value and schema match as hashes") do
       formats({}) { {} }
     end
 
-    tests('when value and schema match as arrays') do
+    tests("when value and schema match as arrays") do
       formats([]) { [] }
     end
 
-    tests('when value is a Time') do
-      formats({"time" => Time}) { {"time" => Time.now} }
+    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}) { {} }
+      formats("key" => NilClass) { {} }
     end
 
     tests('when key is missing but value is nullable (#1477)') do
-      formats({"key" => Fog::Nullable::String}) { {} }
+      formats({ "key" => Fog::Nullable::String }) { {} }
     end
-
   end
-
 end

data/tests/helpers/mock_helper.rb

@@ -2,17 +2,15 @@
 #
 # FOG_MOCK=true fog
 
-if ENV["FOG_MOCK"] == "true"
-  Fog.mock!
-end
+Fog.mock! if ENV["FOG_MOCK"] == "true"
 
 # if in mocked mode, fill in some fake credentials for us
 if Fog.mock?
   Fog.credentials = {
-    :google_storage_access_key_id     => 'google_storage_access_key_id',
-    :google_storage_secret_access_key => 'google_storage_secret_access_key',
-    :google_project                   => 'google_project_name',
-    :google_client_email              => 'fake@developer.gserviceaccount.com',
-    :google_key_location              => '~/fake.p12',
+    :google_storage_access_key_id     => "google_storage_access_key_id",
+    :google_storage_secret_access_key => "google_storage_secret_access_key",
+    :google_project                   => "google_project_name",
+    :google_client_email              => "fake@developer.gserviceaccount.com",
+    :google_key_location              => "~/fake.p12"
   }.merge(Fog.credentials)
 end

data/tests/helpers/model_helper.rb

@@ -1,8 +1,7 @@
-# TODO REMOVE this testing functionality is now covered in `spec/helpers/model_helper.rb`
+# TODO: REMOVE this testing functionality is now covered in `spec/helpers/model_helper.rb`
 
 def model_tests(collection, params = {}, mocks_implemented = true)
-  tests('success') do
-
+  tests("success") do
     @instance = collection.new(params)
 
     tests("#save").succeeds do
@@ -10,15 +9,12 @@ def model_tests(collection, params = {}, mocks_implemented = true)
       @instance.save
     end
 
-    if block_given?
-      yield(@instance)
-    end
+    yield(@instance) if block_given?
 
     tests("#destroy").succeeds do
       pending if Fog.mocking? && !mocks_implemented
       @instance.destroy
     end
-
   end
 end
 
@@ -26,8 +22,8 @@ end
 # Useful when rapidly re-running tests, so we don't have to wait
 # serveral minutes for deleted objects to disappear from the API
 # E.g. 'fog-test-1234'
-def uniq_id(base_name = 'fog-test')
+def uniq_id(base_name = "fog-test")
   # random_differentiator
-  suffix = rand(65536).to_s(16).rjust(4, '0')
-  [base_name, suffix] * '-'
+  suffix = rand(65_536).to_s(16).rjust(4, "0")
+  [base_name, suffix].join("-")
 end

data/tests/helpers/schema_validator_tests.rb

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

data/tests/helpers/succeeds_helper.rb

@@ -1,7 +1,7 @@
 module Shindo
   class Tests
     def succeeds
-      test('succeeds') do
+      test("succeeds") do
         !!instance_eval(&Proc.new)
       end
     end