fog-google 1.5.0 → 1.6.0

data/lib/fog/google/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Google
-    VERSION = "1.5.0".freeze
+    VERSION = "1.6.0".freeze
   end
 end

data/lib/fog/storage/google_xml/utils.rb

@@ -30,7 +30,7 @@ module Fog
 
         def host_path_query(params, expires)
           params[:headers]["Date"] = expires.to_i
-          params[:path] = CGI.escape(params[:path]).gsub("%2F", "/")
+          params[:path] = Fog::Google.escape(params[:path]).gsub("%2F", "/")
           query = [params[:query]].compact
           query << "GoogleAccessId=#{@google_storage_access_key_id}"
           query << "Signature=#{CGI.escape(signature(params))}"

data/tasks/lint.rake

@@ -1,3 +1,9 @@
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new(:lint)
+
+namespace :lint do
+  task :changed do
+    sh("git status --porcelain | cut -c4- | grep '.rb' | xargs rubocop")
+  end
+end

data/tasks/test.rake

@@ -17,7 +17,8 @@ namespace :test do
   multitask :parallel => ["test:compute",
                           "test:monitoring",
                           "test:pubsub",
-                          "test:sql",
+                          "test:sqlv1",
+                          "test:sqlv2",
                           "test:storage"]
 
   Rake::TestTask.new do |t|
@@ -33,7 +34,7 @@ namespace :test do
     t.name = "compute"
     t.description = "Run Compute API tests"
     t.libs << "test"
-    t.pattern = FileList['test/integration/compute/test_*.rb']
+    t.pattern = FileList["test/integration/compute/test_*.rb"]
     t.warning = false
     t.verbose = true
   end
@@ -42,7 +43,7 @@ namespace :test do
     t.name = "monitoring"
     t.description = "Run Monitoring API tests"
     t.libs << "test"
-    t.pattern = FileList['test/integration/monitoring/test_*.rb']
+    t.pattern = FileList["test/integration/monitoring/test_*.rb"]
     t.warning = false
     t.verbose = true
   end
@@ -51,16 +52,28 @@ namespace :test do
     t.name = "pubsub"
     t.description = "Run PubSub API tests"
     t.libs << "test"
-    t.pattern = FileList['test/integration/pubsub/test_*.rb']
+    t.pattern = FileList["test/integration/pubsub/test_*.rb"]
+    t.warning = false
+    t.verbose = true
+  end
+
+  desc "Run all SQL API tests"
+  task :sql => [:sqlv1, :sqlv2]
+
+  Rake::TestTask.new do |t|
+    t.name = "sqlv1"
+    t.description = "Run SQLv1 API tests"
+    t.libs << "test"
+    t.pattern = FileList["test/integration/sql/test_common*.rb", "test/integration/sql/test_v1*.rb"]
     t.warning = false
     t.verbose = true
   end
 
   Rake::TestTask.new do |t|
-    t.name = "sql"
-    t.description = "Run SQL API tests"
+    t.name = "sqlv2"
+    t.description = "Run SQLv2 API tests"
     t.libs << "test"
-    t.pattern = FileList['test/integration/sql/test_*.rb']
+    t.pattern = FileList["test/integration/sql/test_v2*.rb"]
     t.warning = false
     t.verbose = true
   end
@@ -69,7 +82,7 @@ namespace :test do
     t.name = "storage"
     t.description = "Run Storage API tests"
     t.libs << "test"
-    t.pattern = FileList['test/integration/storage/test_*.rb']
+    t.pattern = FileList["test/integration/storage/test_*.rb"]
     t.warning = false
     t.verbose = true
   end

data/test/helpers/integration_test_helper.rb

@@ -18,7 +18,7 @@ TEST_RAW_DISK_SOURCE = "http://storage.googleapis.com/fog-test-bucket/fog-test-r
 TEST_SQL_TIER_FIRST = "D1".freeze
 TEST_SQL_REGION_FIRST = "us-central".freeze
 
-TEST_SQL_TIER_SECOND = "db-f1-micro".freeze
+TEST_SQL_TIER_SECOND = "db-n1-standard-1".freeze
 TEST_SQL_REGION_SECOND = TEST_REGION
 
 class FogIntegrationTest < MiniTest::Test

data/test/integration/compute/test_disk_types.rb

@@ -2,23 +2,18 @@ require "helpers/integration_test_helper"
 
 class TestDiskTypes < FogIntegrationTest
   NAMES = %w(local-ssd pd-ssd pd-standard).freeze
-  ZONES = %w(https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/us-central1-a
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/us-central1-b
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/us-central1-c
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/us-central1-f
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/europe-west1-b
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/europe-west1-c
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/europe-west1-d
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/asia-east1-a
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/asia-east1-b
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/asia-east1-c).freeze
+  # Testing in one random zone per region (region list as of May 2018)
+  ZONES = %w(asia-east1-a asia-northeast1-b asia-south1-c asia-southeast1-a australia-southeast1-b
+             europe-west1-c europe-west2-a europe-west3-b europe-west4-c northamerica-northeast1-a
+             southamerica-east1-b us-central1-c us-east1-b us-east4-a us-west1-c).freeze
 
   def setup
     @subject = Fog::Compute[:google].disk_types
   end
 
   def test_all
-    assert_operator(@subject.all.size, :>=, 1, "expected multiple disk types")
+    assert_operator(@subject.all.size, :>=, NAMES.size * ZONES.size,
+                    "Number of all disk type references should be greater or equal to test zones * disk types")
   end
 
   def test_get

data/test/integration/compute/test_servers.rb

@@ -15,6 +15,40 @@ class TestServers < FogIntegrationTest
     server.wait_for { ready? }
     server.set_metadata({ "foo" => "bar", "baz" => "foo" }, false)
     assert_equal [{ :key => "foo", :value => "bar" },
-                  { :key=>"baz", :value=>"foo" }], server.metadata[:items]
+                  { :key => "baz", :value => "foo" }], server.metadata[:items]
+  end
+
+  def test_bootstrap
+    key = "ssh-rsa IAMNOTAREALSSHKEYAMA== user@host.subdomain.example.com"
+    user = "username"
+
+    File.stub :read, key do
+      # Name is set this way so it will be cleaned up by CollectionFactory
+      # Public_key_path is set to avoid stubbing out File.exist?
+      server = @subject.bootstrap(:name => "#{CollectionFactory::PREFIX}-#{Time.now.to_i}",
+                                  :username => user,
+                                  :public_key_path => "foo")
+      boot_disk = server.disks.detect { |disk| disk[:boot] }
+
+      assert_equal("RUNNING", server.status, "Bootstrapped server should be running")
+      assert_equal(key, server.public_key, "Bootstrapped server should have a public key set")
+      assert_equal(user, server.username, "Bootstrapped server should have user set to #{user}")
+      assert(boot_disk[:auto_delete], "Bootstrapped server should have disk set to autodelete")
+
+      network_adapter = server.network_interfaces.detect { |x| x.has_key?(:access_configs) }
+
+      refute_nil(network_adapter[:access_configs].detect { |x| x[:nat_ip] },
+                 "Bootstrapped server should have an external ip by default")
+    end
+  end
+
+  def test_bootstrap_fail
+    # Pretend the ssh key does not exist
+    File.stub :exist?, nil do
+      assert_raises(Fog::Errors::Error) {
+        @subject.bootstrap(:name => "#{CollectionFactory::PREFIX}-#{Time.now.to_i}",
+                           :public_key_path => nil)
+      }
+    end
   end
 end

data/test/integration/factories/sql_v1_certs_factory.rb

@@ -0,0 +1,20 @@
+require "integration/factories/collection_factory"
+require "integration/factories/sql_v1_instances_factory"
+
+class SqlV1CertsFactory < CollectionFactory
+  def initialize(example)
+    @instances = SqlV1InstancesFactory.new(example)
+    super(Fog::Google[:sql].ssl_certs, example)
+  end
+
+  def cleanup
+    # Certs will be cleaned up with the test instance.
+    @instances.cleanup
+  end
+
+  def params
+    # Certificate name should not be longer than 16 characters
+    { :common_name => resource_name,
+      :instance => @instances.create.name }
+  end
+end

data/test/integration/factories/sql_v1_instances_factory.rb

@@ -0,0 +1,19 @@
+require "integration/factories/collection_factory"
+
+class SqlV1InstancesFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Google[:sql].instances, example)
+  end
+
+  def cleanup
+    super
+  end
+
+  def params
+    # Name has a time suffix due to SQL resources API objects having
+    # a _very_ long life on the backend (n(days)) after deletion.
+    { :name => "#{resource_name}-#{Time.now.to_i}",
+      :region => TEST_SQL_REGION_FIRST,
+      :tier => TEST_SQL_TIER_FIRST }
+  end
+end

data/test/integration/factories/sql_v1_users_factory.rb

@@ -0,0 +1,20 @@
+require "integration/factories/collection_factory"
+require "integration/factories/sql_v1_instances_factory"
+
+class SqlV1UsersFactory < CollectionFactory
+  def initialize(example)
+    @instances = SqlV1InstancesFactory.new(example)
+    super(Fog::Google[:sql].users, example)
+  end
+
+  def cleanup
+    # Users will be cleaned up with the test instance.
+    @instances.cleanup
+  end
+
+  def params
+    # Username should not be longer than 16 characters
+    { :name => resource_name[0..15],
+      :instance => @instances.create.name }
+  end
+end

data/test/integration/factories/sql_v2_instances_factory.rb

@@ -0,0 +1,19 @@
+require "integration/factories/collection_factory"
+
+class SqlV2InstancesFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Google[:sql].instances, example)
+  end
+
+  def cleanup
+    super
+  end
+
+  def params
+    # Name has a time suffix due to SQL resources API objects having
+    # a _very_ long life on the backend (n(days)) after deletion.
+    { :name => "#{resource_name}-#{Time.now.to_i}",
+      :region => TEST_SQL_REGION_SECOND,
+      :tier => TEST_SQL_TIER_SECOND }
+  end
+end

data/test/integration/monitoring/test_timeseries.rb

@@ -5,7 +5,6 @@ class TestMetricDescriptors < FogIntegrationTest
   # Retriable is used to wrap each request in this test due to Stackdriver API being slow with
   # metric propagation (sometimes 80+ seconds) and client returning
   # Google::Apis::ClientError: badRequest if the metric hasn't yet been created instead of a 404.
-  NOT_READY_REGEX = /The provided filter doesn't refer to any known metric./
   RETRIABLE_TRIES = 3
   RETRIABLE_BASE_INTERVAL = 30
   TEST_METRIC_PREFIX = "custom.googleapis.com/fog-google-test/timeseries".freeze
@@ -52,7 +51,8 @@ class TestMetricDescriptors < FogIntegrationTest
     assert_empty(resp.to_h)
 
     # Wait for metric to be created
-    Retriable.retriable(on: {Google::Apis::ClientError => NOT_READY_REGEX},
+    # TODO: Dedup retries into a helper method
+    Retriable.retriable(on: Google::Apis::ClientError,
                         tries: RETRIABLE_TRIES,
                         base_interval: RETRIABLE_BASE_INTERVAL) do
       @client.list_timeseries(
@@ -67,7 +67,7 @@ class TestMetricDescriptors < FogIntegrationTest
       ).time_series
     end
 
-    series = Retriable.retriable(on: { Google::Apis::ClientError => NOT_READY_REGEX },
+    series = Retriable.retriable(on: Google::Apis::ClientError,
                                  tries: RETRIABLE_TRIES,
                                  base_interval: RETRIABLE_BASE_INTERVAL) do
       @client.timeseries_collection.all(
@@ -132,7 +132,7 @@ class TestMetricDescriptors < FogIntegrationTest
     # Wait for metric to be created
     # Retriable is used instead of wait_for due to API client returning Google::Apis::ClientError: badRequest if the
     # metric hasn't yet been created
-    Retriable.retriable(on: { Google::Apis::ClientError => NOT_READY_REGEX },
+    Retriable.retriable(on: Google::Apis::ClientError,
                         tries: RETRIABLE_TRIES,
                         base_interval: RETRIABLE_BASE_INTERVAL) do
       @client.list_timeseries(
@@ -142,7 +142,7 @@ class TestMetricDescriptors < FogIntegrationTest
     end
 
     # Test page size
-    resp = Retriable.retriable(on: { Google::Apis::ClientError => NOT_READY_REGEX },
+    resp = Retriable.retriable(on: Google::Apis::ClientError,
                                tries: RETRIABLE_TRIES,
                                base_interval: RETRIABLE_BASE_INTERVAL) do
       @client.list_timeseries(
@@ -168,7 +168,7 @@ class TestMetricDescriptors < FogIntegrationTest
            "expected different timeseries when using page_token")
 
     # Test filter
-    series = Retriable.retriable(on: { Google::Apis::ClientError => NOT_READY_REGEX },
+    series = Retriable.retriable(on: Google::Apis::ClientError,
                                  tries: RETRIABLE_TRIES,
                                  base_interval: RETRIABLE_BASE_INTERVAL) do
       @client.timeseries_collection.all(
@@ -191,9 +191,7 @@ class TestMetricDescriptors < FogIntegrationTest
       filter: "metric.type = starts_with(\"#{TEST_METRIC_PREFIX}\")"
     )
     unless list_resp.metric_descriptors.nil?
-      puts "Found #{list_resp.metric_descriptors.size} test metric descriptors."
       list_resp.metric_descriptors.each do |md|
-        puts "deleting #{md.type}..."
         @client.monitoring.delete_project_metric_descriptor(md.name)
       end
     end

data/test/integration/sql/{test_flags.rb → test_common_flags.rb}

@@ -1,6 +1,6 @@
 require "helpers/integration_test_helper"
 
-class TestFlags < FogIntegrationTest
+class TestCommonFlags < FogIntegrationTest
   def setup
     @client = Fog::Google::SQL.new
   end

data/test/integration/sql/{test_tiers.rb → test_common_tiers.rb}

@@ -1,24 +1,16 @@
 require "helpers/integration_test_helper"
 
-class TestTiers < FogIntegrationTest
+class TestCommonTiers < FogIntegrationTest
   def setup
-    @client = Fog::Google::SQL.new
-  end
-
-  def test_list
-    resp = @client.list_tiers
-
-    assert_operator(resp.items.size, :>, 0,
-                    "response tiers count should be positive")
-    _sanity_check_tier(resp.items.first)
+    @subject = Fog::Google[:sql].tiers
   end
 
   def test_all
-    resp = @client.tiers.all
+    tiers = @subject.all
 
-    assert_operator(resp.size, :>, 0,
+    assert_operator(tiers.size, :>, 0,
                     "tier count should be positive")
-    _sanity_check_tier(resp.first)
+    _sanity_check_tier(tiers.first)
   end
 
   def _sanity_check_tier(tier)

data/test/integration/sql/test_v1_certs.rb

@@ -0,0 +1,50 @@
+require "helpers/integration_test_helper"
+require "integration/factories/sql_v1_certs_factory"
+
+class TestSQLV1Certs < FogIntegrationTest
+  # This test doesn't include TestCollection as certs are not an independent resource.
+
+  def setup
+    @subject = Fog::Google[:sql].ssl_certs
+    @factory = SqlV1CertsFactory.new(namespaced_name)
+    @client  = Fog::Google::SQL.new
+  end
+
+  def teardown
+    @factory.cleanup
+  end
+
+  def test_ssl_certs
+    # Create an instance and an SSL cert
+    ssl_cert = @factory.create
+    instance_name = ssl_cert.instance
+
+    # Create a second cert and attach to the same instance
+    ssl_cert2 = @subject.new(:common_name => "#{ssl_cert.common_name}-2",
+                             :instance => instance_name)
+    ssl_cert2.save
+
+    # Verify it can be retrieved
+    @subject.get(instance_name, ssl_cert2.sha1_fingerprint).tap do |result|
+      assert_equal(ssl_cert2.common_name, result.common_name)
+      assert_equal("sql#sslCert", result.kind)
+    end
+
+    # Verify instance returns 2 certs
+    list_result = @subject.all(instance_name)
+    assert_equal(2, list_result.size,
+                 "expected 2 SSL certs")
+
+    # Delete one cert
+    ssl_cert2.destroy(:async => false)
+    list_result = @subject.all(instance_name)
+    assert_equal(1, list_result.size,
+                 "expected one less SSL cert after deletion")
+
+    # Test if SSL config is reset correctly
+    instance = @client.instances.get(instance_name)
+    instance.reset_ssl_config(:async => false)
+    assert_equal(0, @subject.all(instance_name).size,
+                 "expected no SSL certs after reset")
+  end
+end

data/test/integration/sql/test_v1_instances.rb

@@ -0,0 +1,31 @@
+require "helpers/integration_test_helper"
+require "integration/factories/sql_v1_instances_factory"
+
+class TestSQLV1Instances < FogIntegrationTest
+  include TestCollection
+
+  def setup
+    @subject = Fog::Google[:sql].instances
+    @factory = SqlV1InstancesFactory.new(namespaced_name)
+  end
+
+  def test_update
+    instance = @factory.create
+
+    settings_version = instance.settings_version
+    labels = {
+      :foo => "bar"
+    }
+    instance.settings[:user_labels] = labels
+    instance.save
+
+    updated = @subject.get(instance.name)
+    assert_equal(labels, updated.settings[:user_labels])
+    assert_operator(updated.settings_version, :>, settings_version)
+  end
+
+  def test_default_settings
+    instance = @factory.create
+    assert_equal([], instance.ssl_certs, "new instance should have 0 initial ssl certs")
+  end
+end