fog-google 0.0.2

data/tests/helpers/formats_helper_tests.rb

@@ -0,0 +1,110 @@
+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"} }
+    end
+
+    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"}} }
+    end
+
+    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}) { [] }
+    end
+
+    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} }
+    end
+
+    tests('when value and schema match as hashes') do
+      data_matches_schema({}) { {} }
+    end
+
+    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} }
+    end
+
+    tests('when key is missing but value should be NilClass (#1477)') do
+      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}) { {} }
+    end
+  end
+
+  tests('#formats backwards compatible changes') do
+
+    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]} }
+    end
+
+    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"}] }
+    end
+
+    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"} }
+    end
+
+    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
+      formats({}) { {} }
+    end
+
+    tests('when value and schema match as arrays') do
+      formats([]) { [] }
+    end
+
+    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}) { {} }
+    end
+
+    tests('when key is missing but value is nullable (#1477)') do
+      formats({"key" => Fog::Nullable::String}) { {} }
+    end
+
+  end
+
+end

data/tests/helpers/mock_helper.rb

@@ -0,0 +1,18 @@
+# Use so you can run in mock mode from the command line
+#
+# FOG_MOCK=true fog
+
+if ENV["FOG_MOCK"] == "true"
+  Fog.mock!
+end
+
+# 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',
+  }.merge(Fog.credentials)
+end

data/tests/helpers/model_helper.rb

@@ -0,0 +1,31 @@
+def model_tests(collection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    @instance = collection.new(params)
+
+    tests("#save").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.save
+    end
+
+    if block_given?
+      yield(@instance)
+    end
+
+    tests("#destroy").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.destroy
+    end
+
+  end
+end
+
+# Generates a unique identifier with a random differentiator.
+# 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')
+  # random_differentiator
+  suffix = rand(65536).to_s(16).rjust(4, '0')
+  [base_name, suffix] * '-'
+end

data/tests/helpers/responds_to_helper.rb

@@ -0,0 +1,11 @@
+module Shindo
+  class Tests
+    def responds_to(method_names)
+      for method_name in [*method_names]
+        tests("#respond_to?(:#{method_name})").returns(true) do
+          @instance.respond_to?(method_name)
+        end
+      end
+    end
+  end
+end

data/tests/helpers/schema_validator_tests.rb

@@ -0,0 +1,107 @@
+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})
+      end
+
+      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}})
+      end
+
+      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}])
+      end
+
+      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})
+      end
+
+      returns(true, 'when value and schema match as hashes') do
+        validator.validate({}, {})
+      end
+
+      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})
+      end
+
+      returns(true, 'when key is missing but value should be NilClass (#1477)') do
+        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})
+      end
+
+    end
+
+    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})
+      end
+
+      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})
+      end
+
+      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}])
+      end
+
+      returns(false, 'when hash and array are compared') do
+        validator.validate({}, [])
+      end
+
+      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 => {}}})
+      end
+
+      returns(false, 'when key is missing but value should be NilClass (#1477)') do
+        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})
+      end
+
+    end
+  end
+end

data/tests/helpers/succeeds_helper.rb

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

data/tests/lorem.txt

@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/tests/models/compute/backend_service_tests.rb

@@ -0,0 +1,6 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | backend service model", ['google']) do
+  random_string = SecureRandom.hex
+  model_tests(Fog::Compute[:google].backend_services, {:name => "fog-test-backend-service-#{random_string}",
+      :health_checks => [@health_check]})
+end

data/tests/models/compute/backend_services_tests.rb

@@ -0,0 +1,8 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | backend_services model", ['google']) do
+  random_string = SecureRandom.hex
+  @health_check = create_test_http_health_check(Fog::Compute[:google])
+  collection_tests(Fog::Compute[:google].backend_services, {:name => "fog-backend-services-test-#{random_string}", 
+      :health_checks => [@health_check]})
+
+end

data/tests/models/compute/disk_tests.rb

@@ -0,0 +1,9 @@
+Shindo.tests("Fog::Compute[:google] | disk model", ['google']) do
+
+  model_tests(Fog::Compute[:google].disks, {:name => 'fog-disk-model-tests',
+                                            :zone => 'us-central1-a',
+                                            :size_gb => 10}) do |model|
+    model.wait_for { ready? }
+  end
+
+end

data/tests/models/compute/disk_types_tests.rb

@@ -0,0 +1,22 @@
+Shindo.tests("Fog::Compute[:google] | disk_types model", ['google']) do
+  @disk_types = Fog::Compute[:google].disk_types
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      @disk_types.all
+    end
+
+    tests('#get').succeeds do
+      disk_type = @disk_types.all.first
+      @disk_types.get(disk_type.name)
+    end
+
+    tests('failure') do
+      tests('#get').returns(nil) do
+        @disk_types.get(Fog::Mock.random_letters_and_numbers(16))
+      end
+    end
+
+  end
+end

data/tests/models/compute/disks_tests.rb

@@ -0,0 +1,9 @@
+Shindo.tests("Fog::Compute[:google] | disks", ['google']) do
+
+  collection_tests(Fog::Compute[:google].disks, {:name => 'fog-disks-collections-tests',
+                                                 :zone => 'us-central1-a',
+                                                 :size_gb => 10}) do |instance|
+  	instance.wait_for { ready? }
+  end
+
+end

data/tests/models/compute/forwarding_rule_tests.rb

@@ -0,0 +1,8 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | forwarding rule model", ['google']) do
+  random_string = SecureRandom.hex
+  region = 'us-central1'
+  target_pool = create_test_target_pool(Fog::Compute[:google], region)
+  model_tests(Fog::Compute[:google].forwarding_rules, {:name => "fog-test-forwarding-rules-#{random_string}", :region => region, :target => target_pool.self_link})
+
+end

data/tests/models/compute/forwarding_rules_tests.rb

@@ -0,0 +1,8 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | forwarding rules model", ['google']) do
+  random_string = SecureRandom.hex
+  region = 'us-central1'
+  target_pool = create_test_target_pool(Fog::Compute[:google], region)
+  collection_tests(Fog::Compute[:google].forwarding_rules, {:name => "fog-test-forwarding-rule-#{random_string}", :region => region, :target => target_pool.self_link})
+
+end

data/tests/models/compute/global_forwarding_rule_tests.rb

@@ -0,0 +1,7 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | global forwarding rule model", ['google']) do
+  random_string = SecureRandom.hex
+  proxy = create_test_target_http_proxy(Fog::Compute[:google])
+  model_tests(Fog::Compute[:google].global_forwarding_rules, {:name => "fog-test-global-forwarding-rule-#{random_string}", :target => proxy.self_link})
+
+end

data/tests/models/compute/global_forwarding_rules_tests.rb

@@ -0,0 +1,7 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | global forwarding rules model", ['google']) do
+  random_string = SecureRandom.hex
+  proxy = create_test_target_http_proxy(Fog::Compute[:google])
+  collection_tests(Fog::Compute[:google].global_forwarding_rules, {:name => "fog-test-global-forwarding-rule-#{random_string}", :target => proxy.self_link})
+
+end

data/tests/models/compute/http_health_check_tests.rb

@@ -0,0 +1,5 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | HTTP health check model", ['google']) do
+  random_string = SecureRandom.hex
+  model_tests(Fog::Compute[:google].http_health_checks, {:name => "fog-test-http-health-check-#{random_string}"})
+end

data/tests/models/compute/http_health_checks_tests.rb

@@ -0,0 +1,5 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | HTTP health checks model", ['google']) do
+  random_string = SecureRandom.hex
+  collection_tests(Fog::Compute[:google].http_health_checks, {:name => "fog-test-http-health-check-#{random_string}"})
+end

data/tests/models/compute/image_tests.rb

@@ -0,0 +1,6 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | image model", ['google']) do
+  random_string = SecureRandom.hex
+  source = 'https://www.google.com/images/srpr/logo4w.png'
+  model_tests(Fog::Compute[:google].images, {:name => "fog-test-images-#{random_string}", "rawDisk" => { "source" => source } })
+end

data/tests/models/compute/images_tests.rb

@@ -0,0 +1,6 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | images model", ['google']) do
+  random_string = SecureRandom.hex
+  source = 'https://www.google.com/images/srpr/logo4w.png'
+  collection_tests(Fog::Compute[:google].images, {:name => "fog-test-images-#{random_string}", "rawDisk" => { "source" => source } })
+end

data/tests/models/compute/region_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests("Fog::Compute[:google] | region model", ['google']) do
+  @regions = Fog::Compute[:google].regions
+
+  tests('success') do
+    tests('#up').succeeds do
+      region = @regions.get @regions.all.first.name
+      region.up?
+    end
+  end
+end

data/tests/models/compute/regions_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests("Fog::Compute[:google] | regions model", ['google']) do
+  @regions = Fog::Compute[:google].regions
+
+  tests('success') do
+    tests('#all').succeeds do
+      @regions.all
+    end
+
+    tests('#get').succeeds do
+      @regions.get @regions.all.first.name
+    end
+  end
+
+  tests('failure') do
+    tests('#get').returns(nil) do
+      @regions.get 'unicorn'
+    end
+  end
+end