gitlab-fog-google 1.13.0

data/test/integration/pubsub/pubsub_shared.rb

@@ -0,0 +1,75 @@
+require "helpers/integration_test_helper"
+require "securerandom"
+require "base64"
+
+class PubSubShared < 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_result = @client.list_topics
+    unless topics_result.topics.nil?
+      begin
+        topics_result.topics
+                     .map(&:name)
+                     .select { |t| t.start_with?(topic_resource_prefix) }
+                     .each { |t| @client.delete_topic(t) }
+      # We ignore errors here as list operations may not represent changes applied recently.
+      # Hence, list operations can return a topic which has already been deleted but which we
+      # will attempt to delete again.
+      rescue Google::Apis::Error
+        Fog::Logger.warning("ignoring Google Api error during delete_test_resources")
+      end
+    end
+
+    subscriptions_result = @client.list_subscriptions
+    unless subscriptions_result.subscriptions.nil?
+      begin
+        subscriptions_result.subscriptions
+                            .map(&:name)
+                            .select { |s| s.start_with?(subscription_resource_prefix) }
+                            .each { |s| @client.delete_subscription(s) }
+      # We ignore errors here as list operations may not represent changes applied recently.
+      # Hence, list operations can return a topic which has already been deleted but which we
+      # will attempt to delete again.
+      rescue Google::Apis::Error
+        Fog::Logger.warning("ignoring Google Api error during delete_test_resources")
+      end
+    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
+  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
+  end
+end

data/test/integration/pubsub/test_coverage.rb

@@ -0,0 +1,6 @@
+require "helpers/integration_test_helper"
+
+# This is a simple coverage helper that helps differentiate
+# the tests when run in parallel so the final coverage report
+# can be properly combined together from multiple runners
+SimpleCov.command_name "test:pubsub" if ENV["COVERAGE"]

data/test/integration/pubsub/test_pubsub_models.rb

@@ -0,0 +1,135 @@
+require "helpers/integration_test_helper"
+require "integration/pubsub/pubsub_shared"
+require "securerandom"
+require "base64"
+
+class TestPubsubModels < PubSubShared
+  def test_topics_create
+    name = new_topic_name
+    result = @client.topics.create(:name => name)
+    assert_equal(result.name, name)
+  end
+
+  def test_topics_get
+    result = @client.topics.get(some_topic_name)
+    assert_equal(result.name, some_topic_name)
+  end
+
+  def test_topics_all
+    # Force a topic to be created just so we have at least 1 to list
+    name = new_topic_name
+    @client.create_topic(name)
+
+    Fog.wait_for(5) do
+      result = @client.topics.all
+      if result.nil?
+        false
+      end
+
+      result.any? { |topic| topic.name == name }
+    end
+  end
+
+  def test_topic_publish_string
+    @client.topics.get(some_topic_name)
+    message_ids = @client.topics.get(some_topic_name).publish(["apples"])
+    assert_operator(message_ids.length, :>, 0)
+  end
+
+  def test_topic_publish_hash
+    @client.topics.get(some_topic_name)
+    message_ids = @client.topics.get(some_topic_name).publish(["data" => "apples"])
+    assert_operator(message_ids.length, :>, 0)
+  end
+
+  def test_topic_delete
+    topic_to_delete = new_topic_name
+    topic = @client.topics.create(:name => topic_to_delete)
+
+    topic.destroy
+  end
+
+  def test_subscriptions_create
+    push_config = {}
+    ack_deadline_seconds = 18
+
+    subscription_name = new_subscription_name
+    result = @client.subscriptions.create(:name => subscription_name,
+                                          :topic => some_topic_name,
+                                          :push_config => push_config,
+                                          :ack_deadline_seconds => ack_deadline_seconds)
+    assert_equal(result.name, subscription_name)
+  end
+
+  def test_subscriptions_get
+    subscription_name = some_subscription_name
+    result = @client.subscriptions.get(subscription_name)
+
+    assert_equal(result.name, subscription_name)
+  end
+
+  def test_subscriptions_list
+    # Force a subscription to be created just so we have at least 1 to list
+    subscription_name = new_subscription_name
+    @client.subscriptions.create(:name => subscription_name, :topic => some_topic_name)
+
+    Fog.wait_for(5) do
+      result = @client.subscriptions.all
+      if result.nil?
+        false
+      end
+
+      result.any? { |subscription| subscription.name == subscription_name }
+    end
+  end
+
+  def test_subscription_delete
+    push_config = {}
+    ack_deadline_seconds = 18
+
+    subscription_name = new_subscription_name
+    subscription = @client.subscriptions.create(:name => subscription_name,
+                                                :topic => some_topic_name,
+                                                :push_config => push_config,
+                                                :ack_deadline_seconds => ack_deadline_seconds)
+    subscription.destroy
+  end
+
+  def test_subscription_pull
+    subscription_name = new_subscription_name
+    message_bytes = Base64.strict_encode64("some message")
+    subscription = @client.subscriptions.create(:name => subscription_name,
+                                                :topic => some_topic_name)
+    @client.topics.get(some_topic_name).publish(["data" => message_bytes])
+
+    result = subscription.pull(:return_immediately => false)
+    assert_operator(result.length, :>, 0)
+
+    contained = result.any? { |received| received.message[:data] == message_bytes }
+    assert_equal(true, contained, "sent messsage not contained within pulled responses")
+  end
+
+  def test_subscription_acknowledge
+    subscription_name = new_subscription_name
+    subscription = @client.subscriptions.create(:name => subscription_name,
+                                                :topic => some_topic_name)
+    @client.topics.get(some_topic_name).publish(["data" => Base64.strict_encode64("some message")])
+
+    result = subscription.pull(:return_immediately => false)
+    assert_operator(result.length, :>, 0)
+
+    subscription.acknowledge([result[0].ack_id])
+  end
+
+  def test_message_acknowledge
+    subscription_name = new_subscription_name
+    subscription = @client.subscriptions.create(:name => subscription_name,
+                                                :topic => some_topic_name)
+    @client.topics.get(some_topic_name).publish(["data" => Base64.strict_encode64("some message")])
+
+    result = subscription.pull(:return_immediately => false)
+    assert_operator(result.length, :>, 0)
+
+    result[0].acknowledge
+  end
+end

data/test/integration/pubsub/test_pubsub_requests.rb

@@ -0,0 +1,105 @@
+require "helpers/integration_test_helper"
+require "integration/pubsub/pubsub_shared"
+require "securerandom"
+require "base64"
+
+class TestPubsubRequests < PubSubShared
+  def test_create_topic
+    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(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
+    name = new_topic_name
+    @client.create_topic(name)
+
+    Fog.wait_for(5) do
+      result = @client.list_topics
+      if result.topics.nil?
+        false
+      end
+
+      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)
+
+    @client.delete_topic(topic_to_delete)
+  end
+
+  def test_publish_topic
+    @client.publish_topic(some_topic_name, [:data => Base64.strict_encode64("some message")])
+  end
+
+  def test_create_subscription
+    push_config = {}
+    ack_deadline_seconds = 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
+    subscription_name = some_subscription_name
+    result = @client.get_subscription(subscription_name)
+
+    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
+    subscription_name = new_subscription_name
+    @client.create_subscription(subscription_name, some_topic_name)
+
+    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)
+
+    @client.delete_subscription(subscription_to_delete)
+  end
+
+  def test_pull_subscription
+    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_name, {:return_immediately => false})
+
+    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_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_name, {:return_immediately => false})
+    assert_operator(pull_result.received_messages.length, :>, 0)
+
+    @client.acknowledge_subscription(subscription_name,
+                                     pull_result.received_messages[0].ack_id)
+  end
+end

data/test/integration/sql/test_certs.rb

@@ -0,0 +1,50 @@
+require "helpers/integration_test_helper"
+require "integration/factories/sql_certs_factory"
+
+class TestSQLCerts < FogIntegrationTest
+  # This test doesn't include TestCollection as certs are not an independent resource.
+
+  def setup
+    @subject = Fog::Google[:sql].ssl_certs
+    @factory = SqlCertsFactory.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_common_flags.rb

@@ -0,0 +1,31 @@
+require "helpers/integration_test_helper"
+
+class TestCommonFlags < 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_common_tiers.rb

@@ -0,0 +1,26 @@
+require "helpers/integration_test_helper"
+
+class TestCommonTiers < FogIntegrationTest
+  def setup
+    @subject = Fog::Google[:sql].tiers
+  end
+
+  def test_all
+    tiers = @subject.all
+
+    assert_operator(tiers.size, :>, 0,
+                    "tier count should be positive")
+    _sanity_check_tier(tiers.first)
+  end
+
+  def _sanity_check_tier(tier)
+    assert_equal(tier.kind, "sql#tier")
+    refute(tier.tier.nil?, "tier name should not be empty")
+    assert_operator(tier.disk_quota, :>, 0,
+                    "tier disk quota should be positive")
+    assert_operator(tier.ram, :>, 0,
+                    "tier ram should be positive")
+    assert_operator(tier.region.size, :>, 0,
+                    "tier should have regions")
+  end
+end

data/test/integration/sql/test_coverage.rb

@@ -0,0 +1,6 @@
+require "helpers/integration_test_helper"
+
+# This is a simple coverage helper that helps differentiate
+# the tests when run in parallel so the final coverage report
+# can be properly combined together from multiple runners
+SimpleCov.command_name "test:sql" if ENV["COVERAGE"]

data/test/integration/sql/test_instances.rb

@@ -0,0 +1,101 @@
+require "helpers/integration_test_helper"
+require "integration/factories/sql_instances_factory"
+# Client helper is imported for `wait_until_complete`
+# TODO: Remove when fog-google#339 or fog-google#340 is resolved
+require "helpers/client_helper"
+
+class TestSQLV2Instances < FogIntegrationTest
+  include TestCollection
+  # TODO: Remove when fog-google#339 or fog-google#340 is resolved
+  include ClientHelper
+  attr_reader :client
+
+  def setup
+    @subject = Fog::Google[:sql].instances
+    @factory = SqlInstancesFactory.new(namespaced_name)
+    @backup_runs = Fog::Google[:sql].backup_runs
+    # TODO: Remove after BackupRuns get save/reload - fog-google#339
+    # See https://github.com/fog/fog-google/issues/339
+    @client = Fog::Google::SQL.new
+  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
+
+  def test_restore_backup_run
+    instance = @factory.create
+
+    data = { :description => "test", :instance => instance.name }
+    wait_until_complete { @client.insert_backup_run(instance.name, data) }
+
+    backup_run = @backup_runs.all(instance.name).first
+
+    # 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
+    # TODO: This probably can get pulled into the test above as those tests
+    # very expensive time-wize (5 minutes or so each)
+    instance = @factory.create
+
+    description = "test backup run"
+    operation = wait_until_complete do
+      @client.insert_backup_run(
+        instance.name,
+        :description => description
+      )
+    end
+
+    assert_equal(operation.operation_type, "BACKUP_VOLUME")
+    runs = @backup_runs.all(instance.name)
+    assert_operator(runs.size, :>, 0, "expected at least one backup run")
+    assert_equal(description, runs.first.description)
+
+    created_run = @backup_runs.get(instance.name, runs.first.id)
+    assert_equal(created_run, runs.first)
+
+    wait_until_complete do
+      @client.delete_backup_run(instance.name, runs.first.id)
+    end
+
+    deleted_run = @backup_runs.get(instance.name, runs.first.id)
+    assert_equal("DELETED", deleted_run.status)
+  end
+
+  def test_clone
+    instance = @factory.create
+    instance.clone("#{instance.name}-clone", :async => false)
+    cloned = @client.instances.get("#{instance.name}-clone")
+
+    # Sanity check some attributes
+    compare = %i(current_disk_size 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