gitlab-fog-google 1.13.0

data/test/integration/storage/test_objects.rb

@@ -0,0 +1,203 @@
+require "helpers/integration_test_helper"
+require "integration/storage/storage_shared"
+require "securerandom"
+require "base64"
+require "tempfile"
+require "net/http"
+
+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,
+                                    :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("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_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

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

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

@@ -0,0 +1,35 @@
+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_server.rb

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

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

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

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