gitlab-fog-google 1.13.0

data/test/integration/sql/test_users.rb

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

@@ -0,0 +1,96 @@
+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 some_temp_file
+    @some_temp_file ||= Tempfile.new("fog-google-storage").tap do |t|
+      t.write(temp_file_content)
+      t.close
+    end
+    File.open(@some_temp_file.path, "r")
+  end
+end

data/test/integration/storage/test_buckets.rb

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

@@ -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:storage" if ENV["COVERAGE"]

data/test/integration/storage/test_directories.rb

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

data/test/integration/storage/test_files.rb

@@ -0,0 +1,168 @@
+require "helpers/integration_test_helper"
+require "integration/storage/storage_shared"
+require "securerandom"
+require "base64"
+require "tempfile"
+
+class TestStorageRequests < StorageShared
+  def test_files_create_file
+    file_name = new_object_name
+    @client.directories.get(some_bucket_name).files.create(
+      :key => file_name,
+      :body => some_temp_file
+    )
+
+    object = @client.get_object(some_bucket_name, file_name)
+    assert_equal(object[:body], temp_file_content)
+  end
+
+  def test_files_create_string
+    expected_body = "A file body"
+    file_name = new_object_name
+    @client.directories.get(some_bucket_name).files.create(
+      :key => file_name,
+      :body => expected_body
+    )
+
+    object = @client.get_object(some_bucket_name, file_name)
+    assert_equal(object[:body], expected_body)
+  end
+
+  def test_files_create_predefined_acl
+    @client.directories.get(some_bucket_name).files.create(
+      :key => new_object_name,
+      :body => some_temp_file,
+      :predefined_acl => "publicRead"
+    )
+  end
+
+  def test_files_create_invalid_predefined_acl
+    assert_raises(ArgumentError) do
+      @client.directories.get(some_bucket_name).files.create(
+        :key => new_object_name,
+        :body => some_temp_file,
+        :predefined_acl => "invalidAcl"
+      )
+    end
+  end
+
+  def test_files_get
+    content = @client.directories.get(some_bucket_name).files.get(some_object_name)
+    assert_equal(content.body, temp_file_content)
+  end
+
+  def test_files_set_body_string
+    file_name = new_object_name
+    directory = @client.directories.get(some_bucket_name)
+    file = directory.files.create(
+      :key => file_name,
+      :body => temp_file_content
+    )
+
+    assert_equal(file.body, temp_file_content)
+
+    new_body = "Changed file body"
+    file.body = new_body
+    file.save
+
+    updated_file = directory.files.get(file_name)
+    assert_equal(updated_file.body, new_body)
+  end
+
+  def test_files_set_body_file
+    file_name = new_object_name
+    directory = @client.directories.get(some_bucket_name)
+    file = directory.files.create(
+      :key => file_name,
+      :body => some_temp_file
+    )
+
+    new_body = "Changed file body"
+    file.body = new_body
+    file.save
+
+    updated_file = directory.files.get(file_name)
+    assert_equal(updated_file.body, new_body)
+  end
+
+  def test_files_metadata
+    content = @client.directories.get(some_bucket_name).files.metadata(some_object_name)
+    assert_equal(content.content_length, temp_file_content.length)
+    assert_equal(content.key, some_object_name)
+  end
+
+  def test_files_destroy
+    file_name = new_object_name
+    @client.directories.get(some_bucket_name).files.create(
+      :key => file_name,
+      :body => some_temp_file
+    )
+
+    @client.directories.get(some_bucket_name).files.destroy(file_name)
+
+    assert_nil(@client.directories.get(some_bucket_name).files.get(file_name))
+  end
+
+  def test_files_all
+    file_name = new_object_name
+    @client.directories.get(some_bucket_name).files.create(
+      :key => file_name,
+      :body => some_temp_file
+    )
+
+    result = @client.directories.get(some_bucket_name).files.all
+    if result.nil?
+      raise StandardError.new("no files found")
+    end
+
+    unless result.any? { |file| file.key == file_name  }
+      raise StandardError.new("failed to find expected file")
+    end
+  end
+
+  def test_files_each
+    file_name = new_object_name
+    @client.directories.get(some_bucket_name).files.create(
+      :key => file_name,
+      :body => some_temp_file
+    )
+
+    found_file = false
+    @client.directories.get(some_bucket_name).files.each do |file|
+      if file.key == file_name
+        found_file = true
+      end
+    end
+    assert_equal(true, found_file, "failed to find expected file while iterating")
+  end
+
+  def test_files_copy
+    target_object_name = new_object_name
+    @client.directories.get(some_bucket_name).files.get(some_object_name).copy(some_bucket_name,
+                                                                               target_object_name)
+
+    content = @client.directories.get(some_bucket_name).files.get(target_object_name)
+    assert_equal(content.body, temp_file_content)
+  end
+
+  def test_files_public_url
+    url = @client.directories.get(some_bucket_name).files.get(some_object_name).public_url
+    assert_match(/storage.googleapis.com/, url)
+  end
+
+  def test_files_get_https_url
+    directory = @client.directories.get(some_bucket_name)
+    https_url = directory.files.get_https_url("fog-testfile", (Time.now + 60).to_i)
+    assert_match(/https/, https_url)
+    assert_match(/#{bucket_prefix}/, https_url)
+    assert_match(/fog-testfile/, https_url)
+  end
+
+  def test_files_get_https_url_whitespace
+    directory = @client.directories.get(some_bucket_name)
+    https_url = directory.files.get_https_url("fog -testfile", (Time.now + 60).to_i)
+    assert_match(/https/, https_url)
+    assert_match(/#{bucket_prefix}/, https_url)
+    assert_match(/fog\%20-testfile/, https_url)
+  end
+end