fog-google 1.24.1 → 1.26.0

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::Compute::Google.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::Compute::Google::Real, c)
-  end
-
-  def test_authenticates_with_json_key_string
-    c = Fog::Compute::Google.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::Compute::Google::Real, c)
-  end
-
-  def test_raises_argument_error_when_google_project_is_missing
-    assert_raises(ArgumentError) { Fog::Compute::Google.new(:google_project => nil) }
-  end
-
-  def test_raises_argument_error_when_google_keys_are_given
-    assert_raises(ArgumentError) do
-      Fog::Compute::Google.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::Compute::Google::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::Compute::Google/) }
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  # This tests whether Fog::Compute::Google 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::Compute::Google::MachineType,
-                  Fog::Compute::Google::Region,
-                  Fog::Compute::Google::DiskType,
-                  Fog::Compute::Google::Operation,
-                  Fog::Compute::Google::Zone,
-                  Fog::Compute::Google::Snapshot,
-                  Fog::Compute::Google::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::Compute::Google/) } - exceptions
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  def test_common_methods
-    # This tests whether Fog::Compute::Google 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

data/test/unit/compute/test_disk.rb

@@ -1,26 +0,0 @@
-require "helpers/test_helper"
-
-class UnitTestDisk < Minitest::Test
-  def setup
-    Fog.mock!
-    @client = Fog::Compute.new(provider: "google",
-                               google_project: "foo")
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  def test_new_disk
-    disk = Fog::Compute::Google::Disk.new(
-      :name         => "fog-1",
-      :size_gb      => 10,
-      :zone         => "us-central1-a",
-      :source_image => "debian-7-wheezy-v20131120"
-    )
-    assert_equal("fog-1",                     disk.name,         "Fog::Compute::Google::Disk name is incorrect: #{disk.name}")
-    assert_equal(10,                          disk.size_gb,      "Fog::Compute::Google::Disk size_gb is incorrect: #{disk.size_gb}")
-    assert_equal("us-central1-a",             disk.zone,         "Fog::Compute::Google::Disk zone is incorrect: #{disk.zone}")
-    assert_equal("debian-7-wheezy-v20131120", disk.source_image, "Fog::Compute::Google::Disk source_image is incorrect: #{disk.source_image}")
-  end
-end

data/test/unit/compute/test_server.rb

@@ -1,29 +0,0 @@
-require "helpers/test_helper"
-
-class UnitTestServer < Minitest::Test
-  def setup
-    Fog.mock!
-    @client = Fog::Compute.new(provider: "google",
-                               google_project: "foo")
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  def test_if_server_accepts_ssh_keys
-    key = "ssh-rsa IAMNOTAREALSSHKEYAMA== user@host.subdomain.example.com"
-
-    File.stub :read, key do
-      server = Fog::Compute::Google::Server.new(
-        :name => "foo",
-        :machine_type => "bar",
-        :disks => ["baz"],
-        :zone => "foo",
-        :public_key_path => key
-      )
-      assert_equal(server.public_key, key,
-                   "Fog::Compute::Google::Server loads public_key properly")
-    end
-  end
-end

data/test/unit/dns/test_common_collections.rb

@@ -1,43 +0,0 @@
-require "helpers/test_helper"
-
-class UnitTestDNSCollections < Minitest::Test
-  def setup
-    Fog.mock!
-    @client = Fog::DNS.new(provider: "google",
-                           google_project: "foo")
-
-    # Exceptions that do not pass test_common_methods:
-    #
-    # DNS Projects API does not support 'list', so 'all' method is not possible
-    @common_methods_exceptions = [Fog::DNS::Google::Projects]
-    # Enumerate all descendants of Fog::Collection
-    descendants = ObjectSpace.each_object(Fog::Collection.singleton_class)
-
-    @collections = descendants.select { |d| d.name.match(/Fog::DNS::Google/) }
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  # This tests whether Fog::Compute::Google collections have common lifecycle methods
-  def test_common_methods
-    subjects = @collections - @common_methods_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
-    # TODO: Fixture for #352
-    skip
-    @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/monitoring/test_comon_collections.rb

@@ -1,44 +0,0 @@
-require "helpers/test_helper"
-
-class UnitTestMonitoringCollections < Minitest::Test
-  def setup
-    Fog.mock!
-    @client = Fog::Monitoring.new(provider: "google",
-                                  google_project: "foo")
-
-    # Exceptions that do not pass test_common_methods:
-    #
-    # TimeSeries API has no 'get' method
-    @common_method_exceptions = [Fog::Google::Monitoring::TimeseriesCollection]
-    # 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::Monitoring/) }
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  # This tests whether Fog::Compute::Google 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
-      if obj.respond_to?(:get)
-        assert_operator(obj.method(:get).arity, :<=, 1,
-                        "#{klass} should have at most 1 required parameter in get()")
-      end
-    end
-  end
-end

data/test/unit/pubsub/test_common_collections.rb

@@ -1,35 +0,0 @@
-require "helpers/test_helper"
-
-class UnitTestPubsubCollections < Minitest::Test
-  def setup
-    Fog.mock!
-    @client = Fog::Google::Pubsub.new(google_project: "foo")
-
-    # Enumerate all descendants of Fog::Collection
-    descendants = ObjectSpace.each_object(Fog::Collection.singleton_class)
-
-    @collections = descendants.select { |d| d.name.match(/Fog::Google::Pubsub/) }
-  end
-
-  def teardown
-    Fog.unmock!
-  end
-
-  def test_common_methods
-    # This tests whether Fog::Compute::Google collections have common lifecycle methods
-    @collections.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