fog-google 0.0.2

data/lib/fog/google/version.rb

@@ -0,0 +1,5 @@
+module Fog
+  module Google
+    VERSION = "0.0.2"
+  end
+end

data/spec/minitest_helper.rb

@@ -0,0 +1,31 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'turn'
+
+Turn.config do |c|
+  # use one of output formats:
+  # :outline  - turn's original case/test outline mode [default]
+  # :progress - indicates progress with progress bar
+  # :dotted   - test/unit's traditional dot-progress mode
+  # :pretty   - new pretty reporter
+  # :marshal  - dump output as YAML (normal run mode only)
+  # :cue      - interactive testing
+  # c.format  = :outline
+  # turn on invoke/execute tracing, enable full backtrace
+  c.trace   = 20
+  # use humanized test names (works only with :outline format)
+  c.natural = true
+end
+
+if ENV['COVERAGE']
+  require 'coveralls'
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+end
+
+require File.join(File.dirname(__FILE__), '../lib/fog/google.rb')
+
+Coveralls.wear! if ENV['COVERAGE']

data/tests/credentials_tests.rb

@@ -0,0 +1,73 @@
+require 'google/api_client'
+
+Shindo.tests('Google | credentials', ['google']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    google_key_location = Fog.credentials[:google_key_location]
+    if google_key_location.nil?
+      tests('Needs a :google_key_location credentials key').pending
+    end
+    google_key_string = File.open(File.expand_path(google_key_location), 'rb') { |io| io.read }
+
+    tests("#using_p12_key_file").succeeds do
+      Fog::Compute::Google.new(:google_key_location => google_key_location,
+                               :google_key_string => nil,
+                               :google_json_key_location => nil,
+                               :google_json_key_string => nil)
+    end
+
+    tests("#using_p12_key_string").succeeds do
+      Fog::Compute::Google.new(:google_key_location => nil,
+                               :google_key_string => google_key_string,
+                               :google_json_key_location => nil,
+                               :google_json_key_string => nil)
+    end
+  end
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    google_json_key_location = Fog.credentials[:google_json_key_location]
+    if google_json_key_location.nil?
+      tests('Needs a :google_json_key_location credentials key').pending
+    end
+    google_json_key_string = File.open(File.expand_path(google_json_key_location), 'rb') { |io| io.read }
+
+    tests("#using_json_key_file").succeeds do
+      Fog::Compute::Google.new(:google_key_location => nil,
+                               :google_key_string => nil,
+                               :google_json_key_location => google_json_key_location,
+                               :google_json_key_string => nil)
+    end
+
+    tests("#using_json_key_string").succeeds do
+      Fog::Compute::Google.new(:google_key_location => nil,
+                               :google_key_string => nil,
+                               :google_json_key_location => nil,
+                               :google_json_key_string => google_json_key_string)
+    end
+  end
+
+  tests('failure') do
+    tests("#missing_google_project").raises(ArgumentError, 'raises ArgumentError when google_project is missing') do
+       Fog::Compute::Google.new(:google_project => nil)
+    end
+
+    tests("#missing_google_client_email").raises(ArgumentError, 'raises ArgumentError when google_client_email is missing') do
+      pending if Fog.mocking? # Mock doesn't check google_client_email
+      Fog::Compute::Google.new(:google_client_email => nil,
+                               :google_json_key_location => nil) # JSON key overrides google_client_email
+    end
+
+    tests("#missing_keys").raises(ArgumentError, 'raises ArgumentError when google keys are missing') do
+      pending if Fog.mocking? # Mock doesn't check missing keys
+      Fog::Compute::Google.new(:google_key_location => nil,
+                               :google_key_string => nil,
+                               :google_json_key_location => nil,
+                               :google_json_key_string => nil)
+    end
+  end
+
+end

data/tests/helper.rb

@@ -0,0 +1,126 @@
+ENV['FOG_RC']         = ENV['FOG_RC'] || File.expand_path('../.fog', __FILE__)
+ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
+
+require 'fog/google'
+require 'securerandom'
+
+Excon.defaults.merge!(:debug_request => true, :debug_response => true)
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper'))
+
+# This overrides the default 600 seconds timeout during live test runs
+if Fog.mocking?
+  FOG_TESTING_TIMEOUT = ENV['FOG_TEST_TIMEOUT'] || 2000
+  Fog.timeout = 2000
+  Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
+else
+  FOG_TESTING_TIMEOUT = Fog.timeout
+end
+
+def lorem_file
+  File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
+end
+
+def array_differences(array_a, array_b)
+  (array_a - array_b) | (array_b - array_a)
+end
+
+# create a disk to be used in tests
+def create_test_disk(connection, zone)
+  zone = 'us-central1-a'
+  random_string = SecureRandom.hex
+
+  disk = connection.disks.create({
+                                     :name => "fog-test-disk-#{random_string}",
+                                     :size_gb => "10",
+                                     :zone => zone,
+                                     :source_image => "debian-7-wheezy-v20140408",
+                                 })
+  disk.wait_for { ready? }
+  disk
+end
+
+def create_test_http_health_check(connection)
+  random_string = SecureRandom.hex
+  health_check = connection.http_health_checks.create({
+                                                          :name => "fog-test-check-#{random_string}"
+                                                      })
+  health_check
+end
+
+def create_test_backend_service(connection)
+  random_string = SecureRandom.hex
+  health_check = create_test_http_health_check(connection)
+  backend_service = connection.backend_services.create({
+                                                           :name => "fog-test-backend-service-#{random_string}",
+                                                           :health_checks => [health_check]
+                                                       })
+end
+
+def create_test_url_map(connection)
+  random_string = SecureRandom.hex
+  backend_service = create_test_backend_service(connection)
+  url_map = connection.url_maps.create({
+                                           :name => "fog-test-url-map-#{random_string}",
+                                           :defaultService => backend_service.self_link
+                                       })
+end
+
+def create_test_server(connection, zone)
+  random_string = SecureRandom.hex
+  disk = create_test_disk(connection,zone)
+  server = connection.servers.create({
+                                         :name => "fog-test-server-#{random_string}",
+                                         :disks => [disk],
+                                         :zone => zone,
+                                         :machine_type => 'n1-standard-1'
+                                     })
+end
+
+def create_test_target_http_proxy(connection)
+  random_string = SecureRandom.hex
+  url_map = create_test_url_map(connection)
+  proxy = connection.target_http_proxies.create({
+                                                    :name => "fog-test-target-http-proxy-#{random_string}",
+                                                    :urlMap => url_map.self_link
+                                                })
+end
+
+def create_test_zone_view(connection, zone)
+  random_string = SecureRandom.hex
+  zone_view = connection.zone_views.create({
+                                               :name => "fog-test-zone-view-#{random_string}",
+                                               :zone => zone
+                                           })
+  zone_view.wait_for {ready?}
+  zone_view
+end
+
+def create_test_target_pool(connection, region)
+  random_string = SecureRandom.hex
+  http_health_check = create_test_http_health_check(connection)
+  instance = create_test_server(connection, 'us-central1-a')
+  target_pool = connection.target_pools.create({
+                                                   :name => "fog-test-target-pool-#{random_string}",
+                                                   :region => region,
+                                                   :healthChecks => [http_health_check.self_link],
+                                                   :instances => [instance.self_link]\
+      })
+end
+
+def wait_operation(connection, response)
+  operation = connection.operations.get(response['name'], response['zone'], response['region'])
+  operation.wait_for { ready? }
+end
+
+def generate_unique_domain( with_trailing_dot = false)
+  #get time (with 1/100th of sec accuracy)
+  #want unique domain name and if provider is fast, this can be called more than once per second
+  time= (Time.now.to_f * 100).to_i
+  domain = 'test-' + time.to_s + '.com'
+  if with_trailing_dot
+    domain+= '.'
+  end
+
+  domain
+end

data/tests/helpers/collection_helper.rb

@@ -0,0 +1,97 @@
+def collection_tests(collection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    tests("#new(#{params.inspect})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.new(params)
+    end
+
+    tests("#create(#{params.inspect})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance = collection.create(params)
+    end
+    # FIXME: work around for timing issue on AWS describe_instances mocks
+
+    if Fog.mocking? && @instance.respond_to?(:ready?)
+      @instance.wait_for { ready? }
+    end
+
+    tests("#all").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.all
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = @instance.identity
+    end
+
+    tests("#get(#{@identity})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.get(@identity)
+    end
+
+    tests('Enumerable') do
+      pending if Fog.mocking? && !mocks_implemented
+
+      methods = [
+        'all?', 'any?', 'find',  'detect', 'collect', 'map',
+        'find_index', 'flat_map', 'collect_concat', 'group_by',
+        'none?', 'one?'
+      ]
+
+      # JRuby 1.7.5+ issue causes a SystemStackError: stack level too deep
+      # https://github.com/jruby/jruby/issues/1265
+      if RUBY_PLATFORM == "java" and JRUBY_VERSION =~ /1\.7\.[5-8]/
+        methods.delete('all?')
+      end
+
+      methods.each do |enum_method|
+        if collection.respond_to?(enum_method)
+          tests("##{enum_method}").succeeds do
+            block_called = false
+            collection.send(enum_method) {|x| block_called = true }
+            block_called
+          end
+        end
+      end
+
+      [
+        'max_by','min_by'
+      ].each do |enum_method|
+        if collection.respond_to?(enum_method)
+          tests("##{enum_method}").succeeds do
+            block_called = false
+            collection.send(enum_method) {|x| block_called = true; 0 }
+            block_called
+          end
+        end
+
+      end
+
+    end
+
+    if block_given?
+      yield(@instance)
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.destroy
+    end
+  end
+
+  tests('failure') do
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = @identity.to_s
+      @identity = @identity.gsub(/[a-zA-Z]/) { Fog::Mock.random_letters(1) }
+      @identity = @identity.gsub(/\d/)       { Fog::Mock.random_numbers(1) }
+      @identity
+    end
+
+    tests("#get('#{@identity}')").returns(nil) do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.get(@identity)
+    end
+
+  end
+end

data/tests/helpers/compute/flavors_helper.rb

@@ -0,0 +1,32 @@
+def flavors_tests(connection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    tests("#all").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.all
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = connection.flavors.first.identity
+    end
+
+    tests("#get('#{@identity}')").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.get(@identity)
+    end
+
+  end
+
+  tests('failure') do
+
+    if !Fog.mocking? || mocks_implemented
+      invalid_flavor_identity = connection.flavors.first.identity.to_s.gsub(/\w/, '0')
+    end
+
+    tests("#get('#{invalid_flavor_identity}')").returns(nil) do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.get(invalid_flavor_identity)
+    end
+
+  end
+end

data/tests/helpers/compute/server_helper.rb

@@ -0,0 +1,25 @@
+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? }
+      identity = @instance.identity
+      !identity.nil? && identity == @instance.reload.identity
+    end
+
+    responds_to([:ready?, :state])
+    yield if block_given?
+
+    tests('#reboot').succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.wait_for { ready? }
+      @instance.reboot
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.wait_for { ready? }
+    end
+
+  end
+end

data/tests/helpers/compute/servers_helper.rb

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

@@ -0,0 +1,98 @@
+require "fog/schema/data_validator"
+
+# format related hackery
+# allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean)
+# allows both nil.is_a?(Fog::Nullable::String) and ''.is_a?(Fog::Nullable::String)
+module Fog
+  module Boolean; end
+  module Nullable
+    module Boolean; end
+    module Integer; end
+    module String; end
+    module Time; end
+    module Float; end
+    module Hash; end
+    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)}
+
+module Shindo
+  class Tests
+    # Generates a Shindo test that compares a hash schema to the result
+    # of the passed in block returning true if they match.
+    #
+    # The schema that is passed in is a Hash or Array of hashes that
+    # have Classes in place of values. When checking the schema the
+    # value should match the Class.
+    #
+    # Strict mode will fail if the data has additional keys. Setting
+    # +strict+ to +false+ will allow additional keys to appear.
+    #
+    # @param [Hash] schema A Hash schema
+    # @param [Hash] options Options to change validation rules
+    # @option options [Boolean] :allow_extra_keys
+    #     If +true+ does not fail when keys are in the data that are
+    #     not specified in the schema. This allows new values to
+    #     appear in API output without breaking the check.
+    # @option options [Boolean] :allow_optional_rules
+    #     If +true+ does not fail if extra keys are in the schema
+    #     that do not match the data. Not recommended!
+    # @yield Data to check with schema
+    #
+    # @example Using in a test
+    #     Shindo.tests("comparing welcome data against schema") do
+    #       data = {:welcome => "Hello" }
+    #       data_matches_schema(:welcome => String) { data }
+    #     end
+    #
+    #     comparing welcome data against schema
+    #     + data matches schema
+    #
+    # @example Example schema
+    #     {
+    #       "id" => String,
+    #       "ram" => Integer,
+    #       "disks" => [
+    #         {
+    #           "size" => Float
+    #         }
+    #       ],
+    #       "dns_name" => Fog::Nullable::String,
+    #       "active" => Fog::Boolean,
+    #       "created" => DateTime
+    #     }
+    #
+    # @return [Boolean]
+    def data_matches_schema(schema, options = {})
+      test('data matches schema') do
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, schema, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+
+    # @deprecated #formats is deprecated. Use #data_matches_schema instead
+    def formats(format, strict = true)
+      test('has proper format') do
+        if strict
+          options = {:allow_extra_keys => false, :allow_optional_rules => true}
+        else
+          options = {:allow_extra_keys => true, :allow_optional_rules => true}
+        end
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, format, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+  end
+end