fog-google 1.24.1 → 1.26.0

data/test/integration/pubsub/test_pubsub_requests.rb

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

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

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

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

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

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

data/test/integration/sql/test_users.rb

@@ -1,37 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/factories/sql_instances_factory"
-require "integration/factories/sql_users_factory"
-
-class TestSQLUsers < FogIntegrationTest
-  # This test doesn't include TestCollection as Users is not a
-  # classical Fog model, as it's tied to a particular instance
-  # I.e.:
-  # - Fog::Google::SQL.users.all() requires an instance
-  # - API doesn't provide a GET request for Users model
-  # See: https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/users
-
-  def setup
-    @subject = Fog::Google[:sql].users
-    @factory = SqlUsersFactory.new(namespaced_name)
-  end
-
-  def teardown
-    @factory.cleanup
-  end
-
-  def test_users
-    # Create user
-    user = @factory.create
-
-    # Check user was created
-    users = @subject.all(user.instance).select { |u| u.name == user.name }
-    assert_equal(1, users.size, "expected user to have been created")
-
-    # Delete user
-    users.first.destroy(:async => false)
-    assert_empty(
-      @subject.all(user.instance).select { |u| u.name == user.name },
-      "expected no user #{user.name}"
-    )
-  end
-end

data/test/integration/storage/storage_shared.rb

@@ -1,101 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/pubsub/pubsub_shared"
-require "securerandom"
-require "base64"
-require "tempfile"
-
-class StorageShared < FogIntegrationTest
-  def setup
-    @client = Fog::Storage::Google.new
-    # Enable retries during the suite. This prevents us from
-    # having to manually rate limit our requests.
-    ::Google::Apis::RequestOptions.default.retries = 5
-    # Ensure any resources we create with test prefixes are removed
-    Minitest.after_run do
-      delete_test_resources
-      ::Google::Apis::RequestOptions.default.retries = 0
-    end
-  end
-
-  def delete_test_resources
-    unless @some_temp_file.nil?
-      @some_temp_file.unlink
-    end
-
-    buckets_result = @client.list_buckets
-
-    unless buckets_result.items.nil?
-      begin
-        buckets_result.items
-                      .map(&:name)
-                      .select { |t| t.start_with?(bucket_prefix) }
-                      .each do |t|
-          object_result = @client.list_objects(t)
-          unless object_result.items.nil?
-            object_result.items.each { |object| @client.delete_object(t, object.name) }
-          end
-
-          begin
-            @client.delete_bucket(t)
-          # Given that bucket operations are specifically rate-limited, we handle that
-          # by waiting a significant amount of time and trying.
-          rescue Google::Apis::RateLimitError
-            Fog::Logger.warning("encountered rate limit, backing off")
-            sleep(10)
-            @client.delete_bucket(t)
-          end
-        end
-      # We ignore errors here as list operations may not represent changes applied recently.
-      rescue Google::Apis::Error
-        Fog::Logger.warning("ignoring Google Api error during delete_test_resources")
-      end
-    end
-  end
-
-  def bucket_prefix
-    "fog-integration-test"
-  end
-
-  def object_prefix
-    "fog-integration-test-object"
-  end
-
-  def new_bucket_name
-    "#{bucket_prefix}-#{SecureRandom.uuid}"
-  end
-
-  def new_object_name
-    "#{object_prefix}-#{SecureRandom.uuid}"
-  end
-
-  def some_bucket_name
-    # create lazily to speed tests up
-    @some_bucket ||= new_bucket_name.tap do |t|
-      @client.put_bucket(t)
-    end
-  end
-
-  def some_object_name
-    # create lazily to speed tests up
-    @some_object ||= new_object_name.tap do |t|
-      @client.put_object(some_bucket_name, t, some_temp_file)
-    end
-  end
-
-  def temp_file_content
-    "hello world"
-  end
-
-  def binary_file_content
-    "PK\x03\x04\x14\x00\x00\x00\b\x00\x18\x89\x8AM\xE7!\xB7\x1C\x1C\x15j\x00\xB4\xB9".force_encoding(Encoding::ASCII_8BIT)
-  end
-
-  def some_temp_file(content = temp_file_content)
-    @some_temp_file ||= Tempfile.new("fog-google-storage").tap do |t|
-      t.binmode
-      t.write(content)
-      t.close
-    end
-    File.open(@some_temp_file.path, "r")
-  end
-end

data/test/integration/storage/test_buckets.rb

@@ -1,112 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/storage/storage_shared"
-require "securerandom"
-require "base64"
-require "tempfile"
-
-class TestStorageRequests < StorageShared
-  def test_put_bucket
-    bucket_name = new_bucket_name
-    bucket = @client.put_bucket(bucket_name)
-
-    assert_equal(bucket.name, bucket_name)
-  end
-
-  # We cannot test the state of the ACL as there are two cases to consider
-  # * The authenticated service account has Owner permisions, which allows
-  # it to read the ACLs after the predefined ACL is applied.
-  # * The authenticated service account does not have Owner  permissions,
-  # then, we cannot read the ACLs after the predefined ACL is applied.
-  #
-  # As we cannot control the service account used for testing, we'll
-  # just ensure that a valid operation succeeds and an invalid operation fails.
-  def test_put_bucket_predefined_acl
-    @client.put_bucket(new_bucket_name, :predefined_acl => "publicRead")
-  end
-
-  def test_put_bucket_invalid_predefined_acl
-    assert_raises(Google::Apis::ClientError) do
-      @client.put_bucket(new_bucket_name, :predefined_acl => "invalidAcl")
-    end
-  end
-
-  def test_get_bucket
-    bucket = @client.get_bucket(some_bucket_name)
-    assert_equal(bucket.name, some_bucket_name)
-  end
-
-  def test_delete_bucket
-    # Create a new bucket to delete it
-    bucket_to_delete = new_bucket_name
-    @client.put_bucket(bucket_to_delete)
-
-    @client.delete_bucket(bucket_to_delete)
-
-    assert_raises(Google::Apis::ClientError) do
-      @client.get_bucket(bucket_to_delete)
-    end
-  end
-
-  def test_list_buckets
-    # Create a new bucket to ensure at least one exists to find
-    bucket_name = new_bucket_name
-    @client.put_bucket(bucket_name)
-
-    result = @client.list_buckets
-    if result.items.nil?
-      raise StandardError.new("no buckets found")
-    end
-
-    contained = result.items.any? { |bucket| bucket.name == bucket_name }
-    assert_equal(true, contained, "expected bucket not present")
-  end
-
-  def test_put_bucket_acl
-    bucket_name = new_bucket_name
-    @client.put_bucket(bucket_name)
-
-    acl = {
-      :entity => "allUsers",
-      :role => "READER"
-    }
-    @client.put_bucket_acl(bucket_name, acl)
-  end
-
-  def test_list_bucket_acl
-    bucket_name = new_bucket_name
-    @client.put_bucket(bucket_name)
-
-    acl = {
-      :entity => "allUsers",
-      :role => "READER"
-    }
-    @client.put_bucket_acl(bucket_name, acl)
-
-    result = @client.list_bucket_acl(bucket_name)
-    if result.items.nil?
-      raise StandardError.new("no bucket access controls found")
-    end
-
-    contained = result.items.any? do |control|
-      control.entity == acl[:entity] && control.role == acl[:role]
-    end
-    assert_equal(true, contained, "expected bucket access control not present")
-  end
-
-  def test_get_bucket_acl
-    bucket_name = new_bucket_name
-    @client.put_bucket(bucket_name)
-
-    acl = {
-      :entity => "allUsers",
-      :role => "READER"
-    }
-    @client.put_bucket_acl(bucket_name, acl)
-    result = @client.get_bucket_acl(bucket_name, "allUsers")
-    if result.nil?
-      raise StandardError.new("no bucket access control found")
-    end
-
-    assert_equal(result.role, acl[:role], "incorrect bucket access control role")
-  end
-end

data/test/integration/storage/test_coverage.rb

@@ -1,6 +0,0 @@
-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:storage" if ENV["COVERAGE"]

data/test/integration/storage/test_directories.rb

@@ -1,67 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/storage/storage_shared"
-require "securerandom"
-require "base64"
-require "tempfile"
-
-class TestStorageRequests < StorageShared
-  def test_directories_put
-    dir_name = new_bucket_name
-    directory = @client.directories.create(:key => dir_name)
-    assert_equal(directory.key, dir_name)
-  end
-
-  def test_directories_put_predefined_acl
-    @client.directories.create(
-      :key => new_bucket_name,
-      :predefined_acl => "publicRead"
-    )
-  end
-
-  def test_directories_put_invalid_predefined_acl
-    assert_raises(Google::Apis::ClientError) do
-      @client.directories.create(
-        :key => new_bucket_name,
-        :predefined_acl => "invalidAcl"
-      )
-    end
-  end
-
-  def test_directories_get
-    directory = @client.directories.get(some_bucket_name)
-    assert_equal(directory.key, some_bucket_name)
-  end
-
-  def test_directory_files
-    file = @client.directories.get(some_bucket_name).files.get(some_object_name)
-    assert_equal(some_object_name, file.key)
-  end
-
-  def test_directory_public_url
-    url = @client.directories.get(some_bucket_name).public_url
-    assert_match(/storage.googleapis.com/, url)
-  end
-
-  def test_directories_destroy
-    dir_name = new_bucket_name
-    @client.directories.create(:key => dir_name)
-
-    @client.directories.destroy(dir_name)
-
-    assert_nil(@client.directories.get(dir_name))
-  end
-
-  def test_directories_all
-    dir_name = new_bucket_name
-    @client.directories.create(:key => dir_name)
-
-    result = @client.directories.all
-    if result.nil?
-      raise StandardError.new("no directories found")
-    end
-
-    unless result.any? { |directory| directory.key == dir_name }
-      raise StandardError.new("failed to find expected directory")
-    end
-  end
-end