fog-google 1.25.0 → 1.26.0

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

data/test/integration/storage/test_files.rb

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

data/test/integration/storage/test_objects.rb

@@ -1,226 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/storage/storage_shared"
-require "securerandom"
-require "base64"
-require "tempfile"
-require "net/http"
-require "ostruct"
-
-class TestStorageRequests < StorageShared
-  def test_put_object_string
-    object_name = new_object_name
-    @client.put_object(some_bucket_name, object_name, some_temp_file)
-
-    object = @client.get_object(some_bucket_name, object_name)
-
-    assert_equal(object_name, object[:name])
-    assert_equal(temp_file_content, object[:body])
-  end
-
-  def test_put_object_nil
-    assert_raises(ArgumentError) do
-      @client.put_object(some_bucket_name, new_object_name, nil)
-    end
-  end
-
-  def test_put_object_file
-    object_name = new_object_name
-    expected_body = "A file body"
-    @client.put_object(some_bucket_name, object_name, expected_body)
-
-    object = @client.get_object(some_bucket_name, object_name)
-    assert_equal(object_name, object[:name])
-    assert_equal(expected_body, object[:body])
-  end
-
-  def test_put_object_paperclip
-    object_name = new_object_name
-    paperclip_file = OpenStruct.new(:path => some_temp_file(binary_file_content),
-                                    :content_type => "image/png")
-    @client.put_object(some_bucket_name, object_name, paperclip_file, :content_type => "image/png")
-
-    object = @client.get_object(some_bucket_name, object_name)
-
-    assert_equal(object_name, object[:name])
-    assert_equal(Encoding::ASCII_8BIT, object[:body].encoding)
-    assert_equal(binary_file_content, object[:body])
-    assert_equal("image/png", object[:content_type])
-  end
-
-  def test_put_object_contradictory_content_type
-    object_name = new_object_name
-    file = OpenStruct.new(:path => some_temp_file,
-                          :content_type => "text/plain")
-    @client.put_object(some_bucket_name, object_name, file, :content_type => "image/png")
-
-    object = @client.get_object(some_bucket_name, object_name)
-
-    assert_equal(object_name, object[:name])
-    assert_equal("image/png", object[:content_type])
-  end
-
-  def test_put_object_predefined_acl
-    @client.put_object(some_bucket_name, new_object_name, some_temp_file,
-                       :predefined_acl => "publicRead")
-  end
-
-  def test_put_object_invalid_predefined_acl
-    assert_raises(Google::Apis::ClientError) do
-      @client.put_object(some_bucket_name, new_object_name, some_temp_file,
-                         :predefined_acl => "invalidAcl")
-    end
-  end
-
-  def test_get_object
-    object = @client.get_object(some_bucket_name, some_object_name)
-    assert_equal(temp_file_content, object[:body])
-  end
-
-  def test_delete_object
-    object_name = new_object_name
-    @client.put_object(some_bucket_name, object_name, some_temp_file)
-    @client.delete_object(some_bucket_name, object_name)
-
-    assert_raises(Google::Apis::ClientError) do
-      @client.get_object(some_bucket_name, object_name)
-    end
-  end
-
-  def test_object_metadata
-    object = @client.get_object_metadata(some_bucket_name, some_object_name)
-    assert_equal(temp_file_content.length, object.size)
-    assert_equal(some_bucket_name, object.bucket)
-  end
-
-  def test_copy_object
-    target_object_name = new_object_name
-
-    @client.copy_object(some_bucket_name, some_object_name,
-                        some_bucket_name, target_object_name)
-
-    object = @client.get_object(some_bucket_name, target_object_name)
-
-    assert_equal(temp_file_content, object[:body])
-  end
-
-  def test_copy_object_predefined_acl
-    target_object_name = new_object_name
-
-    res = @client.copy_object(some_bucket_name, some_object_name,
-                              some_bucket_name, target_object_name, destination_predefined_acl: "publicRead")
-
-    result = @client.get_object(some_bucket_name, target_object_name)
-
-    response = Net::HTTP.get_response(URI(result[:self_link]))
-
-    assert_kind_of(Net::HTTPOK, response)
-  end
-
-  def test_copy_object_with_request_options
-    assert_raises(Google::Apis::AuthorizationError) do
-      target_object_name = new_object_name
-
-      @client.copy_object(some_bucket_name, some_object_name,
-                          some_bucket_name, target_object_name, authorization: false)
-    end
-  end
-
-  def test_copy_object_with_object_property
-    target_object_name = new_object_name
-
-    @client.copy_object(some_bucket_name, some_object_name,
-                        some_bucket_name, target_object_name, content_type: 'text/plain')
-
-    object = @client.get_object(some_bucket_name, target_object_name)
-
-    assert_equal("text/plain", object[:content_type])
-  end
-
-  def test_list_objects
-    expected_object = some_object_name
-
-    result = @client.list_objects(some_bucket_name)
-    if result.items.nil?
-      raise StandardError.new("no objects found")
-    end
-
-    contained = result.items.any? { |object| object.name == expected_object }
-    assert_equal(true, contained, "expected object not present")
-  end
-
-  def test_put_object_acl
-    object_name = new_object_name
-    @client.put_object(some_bucket_name, object_name, some_temp_file)
-
-    acl = {
-      :entity => "allUsers",
-      :role => "READER"
-    }
-    @client.put_object_acl(some_bucket_name, object_name, acl)
-  end
-
-  def test_list_object_acl
-    object_name = new_object_name
-    acls = [
-      {
-        :entity => "allUsers",
-        :role => "READER"
-      },
-      {
-        :entity => "allAuthenticatedUsers",
-        :role => "READER"
-      }
-    ]
-    @client.put_object(some_bucket_name, object_name, some_temp_file, :acl => acls)
-
-    result = @client.list_object_acl(some_bucket_name, object_name)
-    if result.items.nil?
-      raise StandardError.new("no object access controls found")
-    end
-
-    assert_operator(acls.length, :<=, result.items.length,
-                    "expected at least #{acls.length} ACL items")
-
-    expected_acls = Hash[acls.map { |acl| [acl[:entity], acl[:role]] }]
-    num_found = 0
-
-    result.items.each do |actual_acl|
-      if expected_acls[actual_acl.entity] == actual_acl.role
-        num_found += 1
-      end
-    end
-
-    assert_equal(acls.length, num_found, "only found #{num_found} of #{acls.length} expected ACLs")
-  end
-
-  def test_get_object_acl
-    object_name = new_object_name
-    @client.put_object(some_bucket_name, object_name, some_temp_file)
-
-    data = {
-      :entity => "allUsers",
-      :role => "READER"
-    }
-    @client.put_object_acl(some_bucket_name, object_name, data)
-
-    result = @client.get_object_acl(some_bucket_name, object_name, "allUsers")
-    if result.nil?
-      raise StandardError.new("expected object access control not found")
-    end
-  end
-
-  def test_get_object_https_url
-    result = @client.get_object_https_url(some_bucket_name, some_object_name, 0)
-    assert_operator(result.length, :>, 0)
-  end
-
-  def test_get_object_http_url
-    result = @client.get_object_http_url(some_bucket_name, some_object_name, 0)
-    assert_operator(result.length, :>, 0)
-  end
-
-  def test_put_object_url
-    result = @client.put_object_url(some_bucket_name, new_object_name, 0)
-    assert_operator(result.length, :>, 0)
-  end
-end

data/test/integration/test_authentication.rb

@@ -1,38 +0,0 @@
-require "helpers/integration_test_helper"
-
-# TODO: this is a port over from legacy tests.  It shouldn't be scoped under Google, but under Google::Shared.
-class TestAuthentication < FogIntegrationTest
-  def setup
-    @google_json_key_location = Fog.credentials[:google_json_key_location]
-    @google_json_key_string = File.open(File.expand_path(@google_json_key_location), "rb", &:read)
-  end
-
-  def test_authenticates_with_json_key_location
-    c = Fog::Google::Compute.new(:google_key_location => nil,
-                                 :google_key_string => nil,
-                                 :google_json_key_location => @google_json_key_location,
-                                 :google_json_key_string => nil)
-    assert_kind_of(Fog::Google::Compute::Real, c)
-  end
-
-  def test_authenticates_with_json_key_string
-    c = Fog::Google::Compute.new(:google_key_location => nil,
-                                 :google_key_string => nil,
-                                 :google_json_key_location => nil,
-                                 :google_json_key_string => @google_json_key_string)
-    assert_kind_of(Fog::Google::Compute::Real, c)
-  end
-
-  def test_raises_argument_error_when_google_project_is_missing
-    assert_raises(ArgumentError) { Fog::Google::Compute.new(:google_project => nil) }
-  end
-
-  def test_raises_argument_error_when_google_keys_are_given
-    assert_raises(ArgumentError) do
-      Fog::Google::Compute.new(:google_key_location => nil,
-                               :google_key_string => nil,
-                               :google_json_key_location => nil,
-                               :google_json_key_string => nil)
-    end
-  end
-end

data/test/unit/compute/test_common_collections.rb

@@ -1,42 +0,0 @@
-require "helpers/test_helper"
-
-class UnitTestCollections < Minitest::Test
-  def setup
-    Fog.mock!
-
-    @client = Fog::Compute.new(provider: "google",
-                               google_project: "foo")
-
-    # Exceptions that do not pass test_common_methods:
-    #
-    # Projects do not have a "list" method in compute API, so 'all' is not implemented
-    @common_method_exceptions = [Fog::Google::Compute::Projects]
-    # Enumerate all descendants of Fog::Collection
-    descendants = ObjectSpace.each_object(Fog::Collection.singleton_class).to_a
-
-    @collections = descendants.select { |d| d.name.match(/Fog::Google::Compute/) }
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  # This tests whether Fog::Google::Compute collections have common lifecycle methods
-  def test_common_methods
-    subjects = @collections - @common_method_exceptions
-    subjects.each do |klass|
-      obj = klass.new
-      assert obj.respond_to?(:all), "#{klass} should have an .all method"
-      assert obj.respond_to?(:get), "#{klass} should have a .get method"
-      assert obj.respond_to?(:each), "#{klass} should behave like Enumerable"
-    end
-  end
-
-  def test_collection_get_arguments
-    @collections.each do |klass|
-      obj = klass.new
-      assert_operator(obj.method(:get).arity, :<=, 1,
-                      "#{klass} should have at most 1 required parameter in get()")
-    end
-  end
-end

data/test/unit/compute/test_common_models.rb

@@ -1,35 +0,0 @@
-require "helpers/test_helper"
-
-class UnitTestModels < Minitest::Test
-  def setup
-    Fog.mock!
-    @client = Fog::Compute.new(provider: "google",
-                               google_project: "foo")
-
-    # Do not test models that do not have a create method in API
-    exceptions = [Fog::Google::Compute::MachineType,
-                  Fog::Google::Compute::Region,
-                  Fog::Google::Compute::DiskType,
-                  Fog::Google::Compute::Operation,
-                  Fog::Google::Compute::Zone,
-                  Fog::Google::Compute::Snapshot,
-                  Fog::Google::Compute::Project]
-    # Enumerate all descendants of Fog::Model
-    descendants = ObjectSpace.each_object(Fog::Model.singleton_class).to_a
-
-    @models = descendants.select { |d| d.name.match(/Fog::Google::Compute/) } - exceptions
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  def test_common_methods
-    # This tests whether Fog::Google::Compute models have common lifecycle methods
-    @models.each do |klass|
-      obj = klass.new
-      assert obj.respond_to?(:save), "#{klass} should have a .save method"
-      assert obj.respond_to?(:destroy), "#{klass} should have a .destroy method"
-    end
-  end
-end