fog-google 0.6.0 → 1.0.0

data/test/integration/sql/test_tiers.rb

@@ -0,0 +1,34 @@
+require "helpers/integration_test_helper"
+
+class TestTiers < 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)
+  end
+
+  def test_all
+    resp = @client.tiers.all
+
+    assert_operator(resp.size, :>, 0,
+                    "tier count should be positive")
+    _sanity_check_tier(resp.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/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

@@ -1,55 +1,112 @@
 require "helpers/integration_test_helper"
+require "integration/storage/storage_shared"
+require "securerandom"
+require "base64"
+require "tempfile"
 
-class TestBuckets < FogIntegrationTest
-  begin
-    @@connection = Fog::Storage::Google.new
-    @@connection.delete_bucket("fog-smoke-test")
-  rescue Exception => e
-    # puts e
-  end
+class TestStorageRequests < StorageShared
+  def test_put_bucket
+    bucket_name = new_bucket_name
+    bucket = @client.put_bucket(bucket_name)
 
-  def setup
-    @connection = @@connection
+    assert_equal(bucket.name, bucket_name)
   end
 
-  def teardown
-    @connection.delete_bucket("fog-smoke-test")
-  rescue
+  # 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
-    response = @connection.put_bucket("fog-smoke-test")
-    assert_equal response.status, 200
+  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_put_bucket_acl
-    response = @connection.put_bucket("fog-smoke-test", options: { "x-goog-acl" => "publicReadWrite" })
-    assert_equal response.status, 200
-    acl = { :entity => "domain-google.com",
-            :role => "READER" }
-    response = @connection.put_bucket_acl("fog-smoke-test", acl)
-    assert_equal response.status, 200
+  def test_get_bucket
+    bucket = @client.get_bucket(some_bucket_name)
+    assert_equal(bucket.name, some_bucket_name)
   end
 
   def test_delete_bucket
-    response = @connection.put_bucket("fog-smoke-test")
-    assert_equal response.status, 200
-    response = @connection.delete_bucket("fog-smoke-test")
-    assert_equal response.status, 204
+    # 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_get_bucket
-    response = @connection.put_bucket("fog-smoke-test")
-    assert_equal response.status, 200
-    response = @connection.get_bucket("fog-smoke-test")
-    assert_equal response.status, 200
+  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
-    response = @connection.put_bucket("fog-smoke-test",
-                                      options: { "acl" => [{ :entity => "user-fake@developer.gserviceaccount.com", :role => "OWNER" }] })
-    assert_equal response.status, 200
-    response = @connection.get_bucket_acl("fog-smoke-test")
-    assert_equal response.status, 200
+    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_directories.rb

@@ -1,60 +1,67 @@
 require "helpers/integration_test_helper"
+require "integration/storage/storage_shared"
+require "securerandom"
+require "base64"
+require "tempfile"
 
-class TestDirectories < FogIntegrationTest
-  begin
-    client_email = Fog.credentials[:google_client_email]
-    @@connection = Fog::Storage::Google.new
-    @@connection.put_bucket("fog-smoke-test", options: { "acl" => [{ :entity => "user-" + client_email, :role => "OWNER" }] })
-    @@connection.put_bucket_acl("fog-smoke-test", :entity => "allUsers", :role => "READER")
-    @@directory = @@connection.directories.get("fog-smoke-test")
-  rescue Exception => e
-    puts e
-  end
-
-  Minitest.after_run do
-    begin
-      @connection = Fog::Storage::Google.new
-      @connection.delete_bucket("fog-smoke-test")
-    rescue Exception => e
-      puts e
-    end
+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 setup
-    @connection = @@connection
-    @directory = @@directory
+  def test_directories_put_predefined_acl
+    @client.directories.create(
+      :key => new_bucket_name,
+      :predefined_acl => "publicRead"
+    )
   end
 
-  def test_all_directories
-    skip
+  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_get_directory
-    directory_get = @connection.directories.get("fog-smoke-test")
-    assert_instance_of Fog::Storage::Google::Directory, directory_get
+  def test_directories_get
+    directory = @client.directories.get(some_bucket_name)
+    assert_equal(directory.key, some_bucket_name)
   end
 
-  def test_create_destroy_directory
-    directory_create = @connection.directories.create(:key => "fog-smoke-test-create-destroy")
-    assert_instance_of Fog::Storage::Google::Directory, directory_create
-    assert directory_create.destroy
+  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_public_url
-    public_url = @directory.public_url
-    assert_match(/storage\.googleapis\.com/, public_url)
-    assert_match(/fog-smoke-test/, public_url)
+  def test_directory_public_url
+    url = @client.directories.get(some_bucket_name).public_url
+    assert_match(/storage.googleapis.com/, url)
   end
 
-  def test_public
-    skip
-  end
+  def test_directories_destroy
+    dir_name = new_bucket_name
+    @client.directories.create(:key => dir_name)
+
+    @client.directories.destroy(dir_name)
 
-  def test_files
-    skip
+    assert_nil(@client.directories.get(dir_name))
   end
 
-  def test_acl
-    skip
+  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

@@ -1,132 +1,168 @@
 require "helpers/integration_test_helper"
-
-class TestFiles < FogIntegrationTest
-  begin
-    client_email = Fog.credentials[:google_client_email]
-    @@connection = Fog::Storage::Google.new
-    @@connection.put_bucket("fog-smoke-test", "acl" => [{ :entity => "user-" + client_email, :role => "OWNER" }])
-    @@connection.put_bucket_acl("fog-smoke-test", :entity => "allUsers", :role => "READER")
-  rescue StandardError => e
-    puts e
-    puts e.backtrace
+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(Google::Apis::ClientError) do
+      @client.directories.get(some_bucket_name).files.create(
+        :key => new_object_name,
+        :body => some_temp_file,
+        :predefined_acl => "invalidAcl"
+      )
+    end
   end
 
-  begin
-    @directory = @@connection.directories.get("fog-smoke-test")
-    @@connection.put_object("fog-smoke-test", "fog-testfile", "THISISATESTFILE")
-    @file = @directory.files.get("fog-testfile")
-  rescue StandardError => e
-    puts e
-    puts e.backtrace
+  def test_files_get
+    content = @client.directories.get(some_bucket_name).files.get(some_object_name)
+    assert_equal(content.body, temp_file_content)
   end
 
-  Minitest.after_run do
-    begin
-      @connection = Fog::Storage::Google.new
-      @connection.delete_object("fog-smoke-test", "fog-testfile")
-      @connection.delete_bucket("fog-smoke-test")
-    rescue StandardError => e
-      puts e
-    end
-  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
+    )
 
-  def setup
-    @connection = @@connection
-  end
+    assert_equal(file.body, temp_file_content)
 
-  def test_all_files
-    skip
-  end
+    new_body = "Changed file body"
+    file.body = new_body
+    file.save
 
-  def test_each_files
-    skip
+    updated_file = directory.files.get(file_name)
+    assert_equal(updated_file.body, new_body)
   end
 
-  def test_get
-    get_file = @directory.files.get("fog-testfile")
-    assert_instance_of Fog::Storage::Google::File, get_file
-    assert_equal "THISISATESTFILE", get_file.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
+    )
 
-  def test_get_https_url
-    https_url = @directory.files.get_https_url("fog-testfile", (Time.now + 1.minute).to_i)
-    assert_match(/https/, https_url)
-    assert_match(/fog-smoke-test/, https_url)
-    assert_match(/fog-testfile/, https_url)
-  end
+    new_body = "Changed file body"
+    file.body = new_body
+    file.save
 
-  def test_head
-    assert_instance_of Fog::Storage::Google::File, @directory.files.head("fog-testfile")
+    updated_file = directory.files.get(file_name)
+    assert_equal(updated_file.body, new_body)
   end
 
-  def test_new
-    new_file = @directory.files.new(:key => "fog-testfile-new",
-                                    :body => "TESTFILENEW")
-    assert_instance_of Fog::Storage::Google::File, new_file
+  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_acl
-    skip
-  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
+    )
 
-  def test_body
-    assert_equal "THISISATESTFILE", @file.body
-  end
+    @client.directories.get(some_bucket_name).files.destroy(file_name)
 
-  def test_set_body
-    new_body = "FILEBODYCHANGED"
-    @file.body = new_body
-    assert_equal new_body, @file.body
-    @file.save
-    file_get = @directory.files.get("fog-testfile")
-    assert_instance_of Fog::Storage::Google::File, file_get
-    assert_equal new_body, file_get.body
-    @file.body = "THISISATESTFILE"
-    @file.save
+    assert_nil(@client.directories.get(some_bucket_name).files.get(file_name))
   end
 
-  def test_copy
-    copied_file = @file.copy("fog-smoke-test", "fog-testfile-copy")
-    assert_instance_of Fog::Storage::Google::File, copied_file
-    assert copied_file.destroy
-  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
+    )
 
-  def test_create_destroy
-    testfile = @directory.files.create(:key => "fog-testfile-create-destroy")
-    assert_instance_of Fog::Storage::Google::File, testfile
-    assert testfile.destroy
-  end
+    result = @client.directories.get(some_bucket_name).files.all
+    if result.nil?
+      raise StandardError.new("no files found")
+    end
 
-  def test_metadata
-    skip
+    unless result.any? { |file| file.key == file_name  }
+      raise StandardError.new("failed to find expected file")
+    end
   end
 
-  def test_set_metadata
-    skip
-  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
+    )
 
-  def test_set_owner
-    skip
+    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_set_public
-    skip
-  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)
 
-  def test_public_url
-    assert_nil @file.public_url
+    content = @client.directories.get(some_bucket_name).files.get(target_object_name)
+    assert_equal(content.body, temp_file_content)
+  end
 
-    # Setting an ACL still fails, but here's some tests that should work when it does.
-    # @file.acl.push({ "entity" => "allUsers", "role" => "READER" })
-    # public_url = @file.public_url
+  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
 
-    # assert_match /https/, public_url
-    # assert_match /storage\.googleapis\.com/, public_url
-    # assert_match /fog-smoke-test/, public_url
-    # assert_match /fog-testfile/, public_url
+  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_url
-    skip
+  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