fog-google 0.6.0 → 1.0.0

data/test/integration/pubsub/test_pubsub_requests.rb

@@ -1,166 +1,105 @@
 require "helpers/integration_test_helper"
+require "integration/pubsub/pubsub_shared"
 require "securerandom"
 require "base64"
 
-class TestPubsubRequests < FogIntegrationTest
-  def setup
-    @client = Fog::Google::Pubsub.new
-    # Ensure any resources we create with test prefixes are removed
-    Minitest.after_run do
-      delete_test_resources
-    end
-  end
-
-  def delete_test_resources
-    topics = @client.list_topics[:body]["topics"]
-    unless topics.nil?
-      topics.
-        map { |t| t["name"] }.
-        select { |t| t.start_with?(topic_resource_prefix) }.
-        each { |t| @client.delete_topic(t) }
-    end
-
-    subscriptions = @client.list_subscriptions[:body]["subscriptions"]
-    unless subscriptions.nil?
-      subscriptions.
-        map { |s| s["name"] }.
-        select { |s| s.start_with?(subscription_resource_prefix) }.
-        each { |s| @client.delete_subscription(s) }
-    end
-  end
-
-  def topic_resource_prefix
-    "projects/#{@client.project}/topics/fog-integration-test"
-  end
-
-  def subscription_resource_prefix
-    "projects/#{@client.project}/subscriptions/fog-integration-test"
-  end
-
-  def new_topic_name
-    "#{topic_resource_prefix}-#{SecureRandom.uuid}"
-  end
-
-  def new_subscription_name
-    "#{subscription_resource_prefix}-#{SecureRandom.uuid}"
-  end
-
-  def some_topic_name
-    # create lazily to speed tests up
-    @some_topic ||= new_topic_name.tap do |t|
-      @client.create_topic(t)
-    end
-    @some_topic
-  end
-
-  def some_subscription_name
-    # create lazily to speed tests up
-    @some_subscription ||= new_subscription_name.tap do |s|
-      @client.create_subscription(s, some_topic_name)
-    end
-    @some_subscription
-  end
-
+class TestPubsubRequests < PubSubShared
   def test_create_topic
-    result = @client.create_topic(new_topic_name)
-
-    assert_equal(200, result.status, "request should be successful")
-    assert_includes(result[:body].keys, "name", "resulting body should contain expected keys")
+    name = new_topic_name
+    result = @client.create_topic(name)
+    assert_equal(result.name, name)
   end
 
   def test_get_topic
     result = @client.get_topic(some_topic_name)
-
-    assert_equal(200, result.status, "request should be successful")
-    assert_includes(result[:body].keys, "name", "resulting body should contain expected keys")
+    assert_equal(result.name, some_topic_name)
   end
 
   def test_list_topics
     # Force a topic to be created just so we have at least 1 to list
-    @client.create_topic(new_topic_name)
-    result = @client.list_topics
+    name = new_topic_name
+    @client.create_topic(name)
+
+    Fog.wait_for(5) do
+      result = @client.list_topics
+      if result.topics.nil?
+        false
+      end
 
-    assert_equal(200, result.status, "request should be successful")
-    assert_includes(result[:body].keys, "topics", "resulting body should contain expected keys")
-    assert_operator(result[:body]["topics"].size, :>, 0, "topic count should be positive")
+      result.topics.any? { |topic| topic.name == name }
+    end
   end
 
   def test_delete_topic
     topic_to_delete = new_topic_name
     @client.create_topic(topic_to_delete)
 
-    result = @client.delete_topic(topic_to_delete)
-    assert_equal(200, result.status, "request should be successful")
+    @client.delete_topic(topic_to_delete)
   end
 
   def test_publish_topic
-    result = @client.publish_topic(some_topic_name, [:data => Base64.strict_encode64("some message")])
-
-    assert_equal(200, result.status, "request should be successful")
-    assert_includes(result[:body].keys, "messageIds", "resulting body should contain expected keys")
+    @client.publish_topic(some_topic_name, [:data => Base64.strict_encode64("some message")])
   end
 
   def test_create_subscription
     push_config = {}
     ack_deadline_seconds = 18
 
-    result = @client.create_subscription(new_subscription_name, some_topic_name, push_config, ack_deadline_seconds)
-
-    assert_equal(200, result.status, "request should be successful")
-    assert((%w{name topic pushConfig ackDeadlineSeconds} - result[:body].keys).empty?,
-           "resulting body should contain expected keys")
-    assert_equal(18, result[:body]["ackDeadlineSeconds"], "ackDeadlineSeconds should be 18")
+    subscription_name = new_subscription_name
+    result = @client.create_subscription(subscription_name, some_topic_name,
+                                         push_config, ack_deadline_seconds)
+    assert_equal(result.name, subscription_name)
   end
 
   def test_get_subscription
-    result = @client.get_subscription(some_subscription_name)
+    subscription_name = some_subscription_name
+    result = @client.get_subscription(subscription_name)
 
-    assert_equal(200, result.status, "request should be successful")
-    assert(%w{name topic pushConfig ackDeadlineSeconds} - result[:body].keys,
-           "resulting body should contain expected keys")
+    assert_equal(result.name, subscription_name)
   end
 
   def test_list_subscriptions
     # Force a subscription to be created just so we have at least 1 to list
-    @client.create_subscription(new_subscription_name, some_topic_name)
-    result = @client.list_subscriptions
+    subscription_name = new_subscription_name
+    @client.create_subscription(subscription_name, some_topic_name)
 
-    assert_equal(200, result.status, "request should be successful")
-    assert_includes(result[:body].keys, "subscriptions", "resulting body should contain expected keys")
-    assert_operator(result[:body]["subscriptions"].size, :>, 0, "subscription count should be positive")
+    Fog.wait_for(5) do
+      result = @client.list_subscriptions
+      if result.subscriptions.nil?
+        false
+      end
+
+      result.subscriptions.any? { |sub| sub.name == subscription_name }
+    end
   end
 
   def test_delete_subscription
     subscription_to_delete = new_subscription_name
     @client.create_subscription(subscription_to_delete, some_topic_name)
 
-    result = @client.delete_subscription(subscription_to_delete)
-    assert_equal(200, result.status, "request should be successful")
+    @client.delete_subscription(subscription_to_delete)
   end
 
   def test_pull_subscription
-    subscription = new_subscription_name
-    @client.create_subscription(subscription, some_topic_name)
-    @client.publish_topic(some_topic_name, [:data => Base64.strict_encode64("some message")])
+    subscription_name = new_subscription_name
+    message_bytes = Base64.strict_encode64("some message")
+    @client.create_subscription(subscription_name, some_topic_name)
+    @client.publish_topic(some_topic_name, [:data => message_bytes])
 
-    result = @client.pull_subscription(subscription)
+    result = @client.pull_subscription(subscription_name)
 
-    assert_equal(200, result.status, "request should be successful")
-    assert_includes(result[:body].keys, "receivedMessages", "resulting body should contain expected keys")
-    assert_equal(1, result[:body]["receivedMessages"].size, "we should have received a message")
-    assert_equal("some message",
-                 Base64.strict_decode64(result[:body]["receivedMessages"][0]["message"]["data"]),
-                 "received message should be the same as what we sent")
+    contained = result.received_messages.any? { |received| received.message.data == message_bytes }
+    assert_equal(true, contained, "sent messsage not contained within pulled responses")
   end
 
   def test_acknowledge_subscription
-    subscription = new_subscription_name
-    @client.create_subscription(subscription, some_topic_name)
+    subscription_name = new_subscription_name
+    @client.create_subscription(subscription_name, some_topic_name)
     @client.publish_topic(some_topic_name, [:data => Base64.strict_encode64("some message")])
-    pull_result = @client.pull_subscription(subscription)
-
-    result = @client.acknowledge_subscription(subscription, pull_result[:body]["receivedMessages"][0]["ackId"])
+    pull_result = @client.pull_subscription(subscription_name)
+    assert_operator(pull_result.received_messages.length, :>, 0)
 
-    assert_equal(200, result.status, "request should be successful")
+    @client.acknowledge_subscription(subscription_name,
+                                     pull_result.received_messages[0].ack_id)
   end
 end

data/test/integration/sql/sql_instances_shared.rb

@@ -0,0 +1,57 @@
+require "helpers/integration_test_helper"
+require "helpers/client_helper"
+
+class TestSqlInstancesShared < FogIntegrationTest
+  include ClientHelper
+  attr_reader :client
+
+  INSTANCE_NAME = "fogtest-#{Fog::Mock.random_letters(8)}".freeze
+
+  def setup
+    @client = Fog::Google::SQL.new
+    Minitest.after_run do
+      delete_test_resources
+    end
+  end
+
+  def delete_test_resources
+    try_delete_instance(INSTANCE_NAME)
+  end
+
+  def some_instance_name
+    # Create one test instance per generation per test suite.
+    INSTANCE_NAME.tap do |name|
+      begin
+        @client.get_instance(name)
+      rescue ::Google::Apis::ClientError
+        create_test_instance(INSTANCE_NAME,
+                             TEST_SQL_TIER_FIRST,
+                             TEST_SQL_REGION_FIRST)
+      end
+    end
+  end
+
+  def some_clone_name
+    "#{INSTANCE_NAME}-clone"
+  end
+
+  def create_test_instance(instance_name, tier, region)
+    # Create one test instance per generation per test suite.
+    Fog::Logger.debug("creating test SQL instance...")
+    # Create test instance if it hasn't been created yet
+    @client = Fog::Google::SQL.new
+    wait_until_complete do
+      @client.insert_instance(instance_name, tier, :region => region)
+    end
+  end
+
+  def try_delete_instance(instance)
+    @client = Fog::Google::SQL.new
+    wait_until_complete { @client.delete_instance(instance) }
+  rescue ::Google::Apis::ClientError => e
+    # 409: Invalid state
+    # 404: Not found
+    raise e unless e.status_code == 404 || e.status_code == 409
+    Fog::Logger.warning("ignoring error in try_delete_instance")
+  end
+end

data/test/integration/sql/test_flags.rb

@@ -0,0 +1,31 @@
+require "helpers/integration_test_helper"
+
+class TestFlags < FogIntegrationTest
+  def setup
+    @client = Fog::Google::SQL.new
+  end
+
+  def test_list
+    resp = @client.list_flags
+
+    assert_operator(resp.items.size, :>, 0,
+                    "resource descriptor count should be positive")
+
+    _sanity_check_flag(resp.items.first)
+  end
+
+  def test_all
+    resp = @client.flags.all
+
+    assert_operator(resp.size, :>, 0,
+                    "resource descriptor count should be positive")
+
+    _sanity_check_flag(resp.first)
+  end
+
+  def _sanity_check_flag(flag)
+    assert_equal(flag.kind, "sql#flag")
+    refute(flag.name.nil?, "flag name should not be empty")
+    refute_empty(flag.applies_to, "flag should apply to some database version")
+  end
+end

data/test/integration/sql/test_instances.rb

@@ -0,0 +1,97 @@
+require "helpers/integration_test_helper"
+require "helpers/client_helper"
+require "integration/sql/sql_instances_shared"
+
+class TestFirstGenInstances < TestSqlInstancesShared
+  def test_all
+    test_name = some_instance_name
+    instances = @client.instances.all
+    assert_operator(instances.size, :>=, 1,
+                    "expected at least one instance")
+
+    filtered = instances.select { |i| i.name == test_name }
+    assert_equal(1, filtered.size, "expected instance with name #{test_name}")
+  end
+
+  def test_update
+    instance = @client.instances.get(some_instance_name)
+    settings_version = instance.settings_version
+    labels = {
+      :foo => "bar"
+    }
+    instance.settings[:user_labels] = labels
+    instance.save
+
+    updated = @client.instances.get(some_instance_name)
+    assert_equal(labels, updated.settings[:user_labels])
+    assert_operator(updated.settings_version, :>, settings_version)
+  end
+
+  def test_users
+    # Create user
+    username = "test_user"
+
+    wait_until_complete do
+      @client.insert_user(some_instance_name, :name => username)
+    end
+
+    # Check user was created
+    users = @client.users.all(some_instance_name)
+                   .select { |u| u.name == username }
+    assert_equal(1, users.size, "expected user to have been created")
+
+    # Delete user
+    users.first.destroy(:async => false)
+    assert_empty(
+      @client.users.all(some_instance_name).select { |u| u.name == username },
+      "expected no user #{username}"
+    )
+  end
+
+  def test_operations
+    operations = @client.operations.all(some_instance_name)
+    operations.select do |op|
+      op.operation_type == "CREATE"
+    end
+
+    create_op = @client.operations.get(operations.first.name)
+    assert(create_op.ready?)
+  end
+
+  def test_ssl_certs
+    list_result = @client.ssl_certs.all(some_instance_name)
+    # initial Count
+    cert_cnt = list_result.size
+    assert_equal(0, cert_cnt, "new instance should have 0 initial ssl certs")
+
+    # create new certs
+    ssl_certs = (0..1).map do
+      name = Fog::Mock.random_letters(16)
+      create_resp = @client.insert_ssl_cert(some_instance_name, name)
+      wait_until_complete { create_resp.operation }
+      fingerprint = create_resp.client_cert.cert_info.sha1_fingerprint
+      # verify it was created
+      @client.ssl_certs.get(some_instance_name, fingerprint).tap do |result|
+        assert_equal(name, result.common_name)
+        assert_equal("sql#sslCert", result.kind)
+      end
+    end
+
+    # check i1 was created
+    list_result = @client.ssl_certs.all(some_instance_name)
+    assert_equal(ssl_certs.size, list_result.size,
+                 "expected #{ssl_certs.size} SSL certs")
+
+    # delete one cert
+    ssl_certs.first.destroy(:async => false)
+    list_result = @client.ssl_certs.all(some_instance_name)
+    assert_equal(ssl_certs.size - 1, list_result.size,
+                 "expected one less SSL cert after deletion")
+
+    # Reset SSL config
+    instance = @client.instances.get(some_instance_name)
+    instance.reset_ssl_config(:async => false)
+    assert_equal(0, @client.ssl_certs.all(some_instance_name).size,
+                 "expected no SSL certs after reset")
+  end
+end

data/test/integration/sql/test_instances_second_gen.rb

@@ -0,0 +1,88 @@
+require "helpers/integration_test_helper"
+require "helpers/client_helper"
+require "integration/sql/sql_instances_shared"
+
+##
+# Tests requests and resources specific to 2nd generation instances.
+
+class TestSecondGenInstances < TestSqlInstancesShared
+  # Test
+  INSTANCE_NAME = "fogtest2ndgen-#{Fog::Mock.random_letters(8)}".freeze
+
+  def some_clone_name
+    "#{INSTANCE_NAME}-clone"
+  end
+
+  def some_instance_name
+    # Create one test instance per generation per test suite.
+    INSTANCE_NAME.tap do |name|
+      begin
+        @client.get_instance(name)
+      rescue ::Google::Apis::ClientError
+        create_test_instance(INSTANCE_NAME,
+                             TEST_SQL_TIER_SECOND,
+                             TEST_SQL_REGION_SECOND)
+      end
+    end
+  end
+
+  def delete_test_resources
+    super
+    try_delete_instance(some_clone_name)
+  end
+
+  def test_restore_backup_run
+    data = { :description => "test", :instance => some_instance_name }
+    wait_until_complete { @client.insert_backup_run(some_instance_name, data) }
+
+    backup_run = @client.backup_runs.all(some_instance_name).first
+    instance = @client.instances.get(some_instance_name)
+
+    # Wait for backup operation to be finished
+    # or fail if it never finishes.
+    instance.restore_backup(backup_run.id, :async => false)
+  end
+
+  def test_backup_runs
+    description = "test backup run"
+    op = wait_until_complete do
+      @client.insert_backup_run(
+        some_instance_name,
+        :description => description
+      )
+    end
+
+    assert_equal(op.operation_type, "BACKUP_VOLUME")
+    runs = @client.backup_runs.all(some_instance_name)
+    assert_operator(runs.size, :>, 0, "expected at least one backup run")
+    assert_equal(description, runs.first.description)
+
+    created_run = @client.backup_runs.get(some_instance_name, runs.first.id)
+    assert_equal(created_run, runs.first)
+
+    wait_until_complete do
+      @client.delete_backup_run(some_instance_name, runs.first.id)
+    end
+
+    deleted_run = @client.backup_runs.get(some_instance_name, runs.first.id)
+    assert_equal("DELETED", deleted_run.status)
+  end
+
+  def test_clone
+    instance = @client.instances.get(some_instance_name)
+    instance.clone(some_clone_name, :async => false)
+    cloned = @client.instances.get(some_clone_name)
+
+    # Sanity check some attributes
+    compare = %i(current_disk_size tier project region ip_configuration_require_ssl activation_policy)
+    compare.each do |k|
+      v = instance.attributes[k]
+      cloned_v = cloned.attributes[k]
+      if v.nil?
+        assert_nil(cloned_v)
+      else
+        assert_equal(v, cloned_v, "attribute #{k} in original instance is #{v}, cloned = #{cloned_v}")
+      end
+    end
+  end
+end