fog-google 0.1.3 → 0.2.0

data/test/integration/storage/test_objects.rb

@@ -0,0 +1,111 @@
+require "helpers/integration_test_helper"
+
+class TestObjects < FogIntegrationTest
+  def setup
+    @connection = Fog::Storage::Google.new
+
+    begin
+      @connection.put_bucket("fog-smoke-test", options = { "x-goog-acl" => "publicReadWrite" })
+    rescue
+    end
+  end
+
+  def teardown
+    begin
+      @connection.delete_object("fog-smoke-test", "my file")
+    rescue
+    end
+    begin
+      @connection.delete_object("fog-smoke-test", "my file copy")
+    rescue
+    end
+    begin
+      @connection.delete_bucket("fog-smoke-test")
+    rescue
+    end
+  end
+
+  def test_put_object
+    response = @connection.put_object("fog-smoke-test", "my file", "THISISATESTFILE")
+    assert_equal response.status, 200
+  end
+
+  def test_put_object_acl
+    skip
+    response = @connection.put_object("fog-smoke-test", "my file", "THISISATESTFILE")
+    assert_equal response.status, 200
+    acl = { :entity => "domain-example.com",
+            :role => "READER" }
+    response = @connection.put_object_acl("fog-smoke-test", "my file", acl)
+    assert_equal response.status, 200
+  end
+
+  def test_put_object_url
+    skip
+    # Doesn't actually work
+    response = @connection.put_object_url("fog-smoke-test", "my file url")
+    puts response.inspect
+    assert_equal response.status, 200
+  end
+
+  def test_copy_object
+    response = @connection.put_object("fog-smoke-test", "my file", "THISISATESTFILE")
+    assert_equal response.status, 200
+    response = @connection.copy_object("fog-smoke-test", "my file", "fog-smoke-test", "my file copy")
+    assert_equal response.status, 200
+  end
+
+  def test_delete_object
+    response = @connection.put_object("fog-smoke-test", "my file", "THISISATESTFILE")
+    assert_equal response.status, 200
+    response = @connection.delete_object("fog-smoke-test", "my file")
+    assert_equal response.status, 204
+  end
+
+  def test_get_object
+    skip
+    response = @connection.put_object("fog-smoke-test", "my file", "THISISATESTFILE")
+    assert_equal response.status, 200
+    response = @connection.get_object("fog-smoke-test", "my file")
+    assert_equal response.status, 200
+  end
+
+  def test_get_object_acl
+    skip
+    response = @connection.put_object("fog-smoke-test", "my file", "THISISATESTFILE")
+    assert_equal response.status, 200
+    response = @connection.get_object_acl("fog-smoke-test", "my file")
+    assert_equal response.status, 200
+    assert_equal response.body["kind"], "storage#objectAccessControls"
+  end
+
+  def test_get_object_http_url
+    skip
+  end
+
+  def test_get_object_https_url
+    skip
+    response = @connection.put_object("fog-smoke-test", "my file", "THISISATESTFILE", options = { :predefinedAcl => "publicRead" })
+    assert_equal response.status, 200
+    https_url = @connection.get_object_https_url("fog-smoke-test", "my file")
+    assert_match /https/, https_url
+    assert_match /fog-smoke-test/, https_url
+    assert_match /my%20file/, https_url
+  end
+
+  def test_get_object_url
+    skip
+    response = @connection.put_object("fog-smoke-test", "my file", "THISISATESTFILE")
+    assert_equal response.status, 200
+    https_url = @connection.get_object_url("fog-smoke-test", "my file")
+    assert_equal https_url, "https://www.googleapis.com/storage/v1/b/fog-smoke-test/o/my%20file"
+  end
+
+  def test_get_object_torrent
+    skip
+  end
+
+  def test_head_object
+    skip
+  end
+end

data/test/integration/test_authentication.rb

@@ -1,12 +1,12 @@
-require 'helpers/integration_test_helper'
+require "helpers/integration_test_helper"
 
-# TODO this is a port over from legacy tests.  It shouldn't be scoped under Google, but under Google::Shared.
+# TODO: this is a port over from legacy tests.  It shouldn't be scoped under Google, but under Google::Shared.
 class TestAuthentication < FogIntegrationTest
   def setup
     @google_key_location = Fog.credentials[:google_key_location]
-    @google_key_string = File.open(File.expand_path(@google_key_location), 'rb') { |io| io.read }
+    @google_key_string = File.open(File.expand_path(@google_key_location), "rb", &:read)
     @google_json_key_location = Fog.credentials[:google_json_key_location]
-    @google_json_key_string = File.open(File.expand_path(@google_json_key_location), 'rb') { |io| io.read }
+    @google_json_key_string = File.open(File.expand_path(@google_json_key_location), "rb", &:read)
   end
 
   def test_authenticates_with_p12_key_location
@@ -46,14 +46,18 @@ class TestAuthentication < FogIntegrationTest
   end
 
   def test_raises_argument_error_when_google_client_email_is_missing
-    assert_raises(ArgumentError) { Fog::Compute::Google.new(:google_client_email => nil,
-                                                            :google_json_key_location => nil) } # JSON key overrides google_client_email
+    assert_raises(ArgumentError) do
+      Fog::Compute::Google.new(:google_client_email => nil,
+                               :google_json_key_location => nil)
+    end # JSON key overrides google_client_email
   end
 
   def test_raises_argument_error_when_google_keys_are_given
-    assert_raises(ArgumentError) { Fog::Compute::Google.new(:google_key_location => nil,
-                                                            :google_key_string => nil,
-                                                            :google_json_key_location => nil,
-                                                            :google_json_key_string => nil) }
+    assert_raises(ArgumentError) do
+      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

@@ -1,16 +1,16 @@
-ENV['FOG_RC']         = ENV['FOG_RC'] || File.expand_path('../.fog', __FILE__)
-ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
+ENV["FOG_RC"]         = ENV["FOG_RC"] || File.expand_path("../.fog", __FILE__)
+ENV["FOG_CREDENTIAL"] = ENV["FOG_CREDENTIAL"] || "default"
 
-require 'fog/google'
-require 'securerandom'
+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'))
+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_TESTING_TIMEOUT = ENV["FOG_TEST_TIMEOUT"] || 2000
   Fog.timeout = 2000
   Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
 else
@@ -18,7 +18,7 @@ else
 end
 
 def lorem_file
-  File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
+  File.open(File.dirname(__FILE__) + "/lorem.txt", "r")
 end
 
 def array_differences(array_a, array_b)
@@ -27,14 +27,14 @@ end
 
 # create a disk to be used in tests
 def create_test_disk(connection, zone)
-  zone = 'us-central1-a'
+  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",
+                                   :name => "fog-test-disk-#{random_string}",
+                                   :size_gb => "10",
+                                   :zone => zone,
+                                   :source_image => "debian-7-wheezy-v20140408"
                                  })
   disk.wait_for { ready? }
   disk
@@ -43,7 +43,7 @@ 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}"
+                                                        :name => "fog-test-check-#{random_string}"
                                                       })
   health_check
 end
@@ -52,8 +52,8 @@ 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]
+                                                         :name => "fog-test-backend-service-#{random_string}",
+                                                         :health_checks => [health_check]
                                                        })
 end
 
@@ -61,19 +61,19 @@ 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
+                                         :name => "fog-test-url-map-#{random_string}",
+                                         :default_service => backend_service.self_link
                                        })
 end
 
 def create_test_server(connection, zone)
   random_string = SecureRandom.hex
-  disk = create_test_disk(connection,zone)
+  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'
+                                       :name => "fog-test-server-#{random_string}",
+                                       :disks => [disk],
+                                       :zone => zone,
+                                       :machine_type => "n1-standard-1"
                                      })
 end
 
@@ -81,46 +81,44 @@ 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
+                                                  :name => "fog-test-target-http-proxy-#{random_string}",
+                                                  :url_map => 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
+                                             :name => "fog-test-zone-view-#{random_string}",
+                                             :zone => zone
                                            })
-  zone_view.wait_for {ready?}
+  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')
+  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]\
-      })
+                                                 :name => "fog-test-target-pool-#{random_string}",
+                                                 :region => region,
+                                                 :health_checks => [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 = 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
+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"
+  domain += "." if with_trailing_dot
 
   domain
 end

data/tests/helpers/collection_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 collection_tests(collection, params = {}, mocks_implemented = true)
-  tests('success') do
-
+  tests("success") do
     tests("#new(#{params.inspect})").succeeds do
       pending if Fog.mocking? && !mocks_implemented
       collection.new(params)
@@ -23,66 +22,57 @@ def collection_tests(collection, params = {}, mocks_implemented = true)
       collection.all
     end
 
-    if !Fog.mocking? || mocks_implemented
-      @identity = @instance.identity
-    end
+    @identity = @instance.identity if !Fog.mocking? || mocks_implemented
 
     tests("#get(#{@identity})").succeeds do
       pending if Fog.mocking? && !mocks_implemented
       collection.get(@identity)
     end
 
-    tests('Enumerable') do
+    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?'
+        "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?')
+      if RUBY_PLATFORM == "java" && 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
+        next unless collection.respond_to?(enum_method)
+        tests("##{enum_method}").succeeds do
+          block_called = false
+          collection.send(enum_method) { |_| block_called = true }
+          block_called
         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
+      %w(
+        max_by min_by).each do |enum_method|
+        next unless collection.respond_to?(enum_method)
+        tests("##{enum_method}").succeeds do
+          block_called = false
+          collection.send(enum_method) do |_|
+            block_called = true
+            0
           end
+          block_called
         end
-
       end
-
     end
 
-    if block_given?
-      yield(@instance)
-    end
+    yield(@instance) if block_given?
 
-    if !Fog.mocking? || mocks_implemented
-      @instance.destroy
-    end
+    @instance.destroy if !Fog.mocking? || mocks_implemented
   end
 
-  tests('failure') do
-
+  tests("failure") do
     if !Fog.mocking? || mocks_implemented
       @identity = @identity.to_s
       @identity = @identity.gsub(/[a-zA-Z]/) { Fog::Mock.random_letters(1) }
@@ -94,6 +84,5 @@ def collection_tests(collection, params = {}, mocks_implemented = true)
       pending if Fog.mocking? && !mocks_implemented
       collection.get(@identity)
     end
-
   end
 end

data/tests/helpers/compute/flavors_helper.rb

@@ -1,6 +1,5 @@
-def flavors_tests(connection, params = {}, mocks_implemented = true)
-  tests('success') do
-
+def flavors_tests(connection, _params = {}, mocks_implemented = true)
+  tests("success") do
     tests("#all").succeeds do
       pending if Fog.mocking? && !mocks_implemented
       connection.flavors.all
@@ -14,19 +13,16 @@ def flavors_tests(connection, params = {}, mocks_implemented = true)
       pending if Fog.mocking? && !mocks_implemented
       connection.flavors.get(@identity)
     end
-
   end
 
-  tests('failure') do
-
+  tests("failure") do
     if !Fog.mocking? || mocks_implemented
-      invalid_flavor_identity = connection.flavors.first.identity.to_s.gsub(/\w/, '0')
+      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