gitlab-fog-google 1.13.0

data/test/helpers/test_collection.rb

@@ -0,0 +1,60 @@
+module TestCollection
+  # Anything that includes TestCollection must, during setup, assign @subject and @factory, where
+  #   @subject is the collection under test, (e.g. Fog::Compute[:google].servers)
+  #   @factory is a CollectionFactory
+
+  def test_lifecycle
+    one = @subject.new(@factory.params)
+    one.save
+    two = @subject.create(@factory.params)
+
+    # XXX HACK compares identities
+    # should be replaced with simple includes? when `==` is properly implemented in fog-core; see fog/fog-core#148
+    assert_includes @subject.all.map(&:identity), one.identity
+    assert_includes @subject.all.map(&:identity), two.identity
+
+    assert_equal one.identity, @subject.get(one.identity).identity
+    assert_equal two.identity, @subject.get(two.identity).identity
+
+    # Some factories that have scoped parameters (zone, region) have a special
+    # `get` method defined in the factory to pass the correct parameters in
+    if @factory.respond_to?(:get)
+      assert_equal one.identity, @factory.get(one.identity).identity
+      assert_equal two.identity, @factory.get(two.identity).identity
+    end
+
+    # Some factories that have scoped parameters (zone, region) have a special
+    # `all` method defined in the factory to pass the correct parameters in
+    if @factory.respond_to?(:all)
+      subject_list = @subject.all
+      scoped_subject_list = @factory.all
+
+      # Assert that whatever .all(scope) returns is a subset of .all
+      assert(scoped_subject_list.all? { |x| subject_list.include? x },
+             "Output of @factory.all must be a subset of @subject.all")
+    end
+
+    one.destroy
+    two.destroy
+
+    Fog.wait_for { !@subject.all.map(&:identity).include? one.identity }
+    Fog.wait_for { !@subject.all.map(&:identity).include? two.identity }
+  end
+
+  def test_get_returns_nil_if_resource_does_not_exist
+    assert_nil @factory.get("fog-test-fake-identity") if @factory.respond_to?(:get)
+    assert_nil @subject.get("fog-test-fake-identity")
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+
+  def test_nil_get
+    assert_nil @subject.get(nil)
+  end
+
+  def teardown
+    @factory.cleanup
+  end
+end

data/test/helpers/test_helper.rb

@@ -0,0 +1,24 @@
+# Configure simplecov for coverage tests
+# Note: needs to be done _before_ requiring minitest!
+if ENV["COVERAGE"]
+  require "simplecov"
+
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+  SimpleCov.skip_token('no-coverage')
+
+  SimpleCov.start do
+    add_filter "/test/"
+  end
+end
+
+# The next line was added to squelch a warning message in Ruby 1.9.
+# It ensures we're using the gem, not the built-in Minitest
+# See https://github.com/seattlerb/minitest/#install
+gem "minitest"
+require "minitest/autorun"
+# Custom formatters
+require "minitest/reporters"
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+require File.join(File.dirname(__FILE__), "../../lib/fog/google")

data/test/integration/compute/core_compute/test_client_options.rb

@@ -0,0 +1,12 @@
+require "helpers/integration_test_helper"
+
+class TestComputeClient < FogIntegrationTest
+  def test_client_options
+    # XXX This is a very rudimentary test checking that proxy option is applied
+    client_options = { proxy_url: "https://user:password@host:8080" }
+    connection = Fog::Compute::Google.new(google_client_options: client_options)
+
+    err = assert_raises(ArgumentError) { connection.servers.all }
+    assert_match(/unsupported proxy/, err.message)
+  end
+end

data/test/integration/compute/core_compute/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:compute-core_compute" if ENV["COVERAGE"]

data/test/integration/compute/core_compute/test_disk_types.rb

@@ -0,0 +1,43 @@
+require "helpers/integration_test_helper"
+
+class TestDiskTypes < FogIntegrationTest
+  NAMES = %w(local-ssd pd-ssd pd-standard).freeze
+  # Testing in one random zone per region (region list as of May 2018)
+  ZONES = %w(asia-east1-a asia-northeast1-b asia-south1-c asia-southeast1-a australia-southeast1-b
+             europe-west1-c europe-west2-a europe-west3-b europe-west4-c northamerica-northeast1-a
+             southamerica-east1-b us-central1-c us-east1-b us-east4-a us-west1-c).freeze
+
+  def setup
+    @subject = Fog::Compute[:google].disk_types
+  end
+
+  def test_all
+    assert_operator(@subject.all.size, :>=, NAMES.size * ZONES.size,
+                    "Number of all disk type references should be greater or equal to test zones * disk types")
+  end
+
+  def test_scoped_all
+    subject_list = @subject.all
+    scoped_subject_list = @subject.all(zone: TEST_ZONE)
+
+    # Assert that whatever .all(scope) returns is a subset of .all
+    assert(scoped_subject_list.all? { |x| subject_list.include? x },
+           "Output of @subject.all(zone:#{TEST_ZONE}) must be a subset of @subject.all")
+  end
+
+  def test_get
+    NAMES.each do |name|
+      ZONES.each do |zone|
+        refute_nil @subject.get(name, zone)
+      end
+    end
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name")
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+end

data/test/integration/compute/core_compute/test_disks.rb

@@ -0,0 +1,53 @@
+require "helpers/integration_test_helper"
+require "integration/factories/disks_factory"
+
+class TestDisks < FogIntegrationTest
+  include TestCollection
+
+  def setup
+    @subject = Fog::Compute[:google].disks
+    @factory = DisksFactory.new(namespaced_name)
+  end
+
+  def test_get_as_configs
+    disk = @factory.create
+    disk.wait_for { ready? }
+
+    example = disk.get_as_boot_disk
+    config = { :auto_delete => false,
+               :boot => true,
+               :source => disk.self_link,
+               :mode => "READ_WRITE",
+               :type => "PERSISTENT" }
+    assert_equal(example, config)
+
+    example_with_params = disk.get_as_boot_disk(false, true)
+    config_with_params = { :auto_delete => true,
+                           :boot => true,
+                           :source => disk.self_link,
+                           :mode => "READ_ONLY",
+                           :type => "PERSISTENT" }
+    assert_equal(example_with_params, config_with_params)
+  end
+
+  def test_create_snapshot
+    disk = @factory.create
+    disk.wait_for { ready? }
+
+    snapshot = disk.create_snapshot("fog-test-snapshot")
+
+    assert(snapshot.is_a?(Fog::Compute::Google::Snapshot),
+           "Resulting snapshot should be a snapshot object.")
+
+    assert_raises(ArgumentError) { snapshot.set_labels(["bar", "test"]) }
+
+    snapshot.set_labels(foo: "bar", fog: "test")
+
+    assert_equal(snapshot.labels[:foo], "bar")
+    assert_equal(snapshot.labels[:fog], "test")
+
+    # Clean up the snapshot
+    operation = snapshot.destroy
+    operation.wait_for { ready? }
+  end
+end

data/test/integration/compute/core_compute/test_images.rb

@@ -0,0 +1,32 @@
+require "helpers/integration_test_helper"
+require "integration/factories/images_factory"
+
+class TestImages < FogIntegrationTest
+  include TestCollection
+
+  def setup
+    @subject = Fog::Compute[:google].images
+    @factory = ImagesFactory.new(namespaced_name)
+  end
+
+  def test_get_specific_image
+    image = @subject.get(TEST_IMAGE)
+    refute_nil(image, "Images.get(#{TEST_IMAGE}) should not return nil")
+    assert_equal(image.family, TEST_IMAGE_FAMILY)
+    assert_equal(image.project, TEST_IMAGE_PROJECT)
+  end
+
+  def test_get_specific_image_from_project
+    image = @subject.get(TEST_IMAGE,TEST_IMAGE_PROJECT)
+    refute_nil(image, "Images.get(#{TEST_IMAGE}) should not return nil")
+    assert_equal(image.family, TEST_IMAGE_FAMILY)
+    assert_equal(image.project, TEST_IMAGE_PROJECT)
+  end
+
+  def test_get_from_family
+    image = @subject.get_from_family(TEST_IMAGE_FAMILY)
+    refute_nil(image,"Images.get_from_family(#{TEST_IMAGE_FAMILY}) should not return nil")
+    assert_equal(image.family, TEST_IMAGE_FAMILY)
+    assert_equal(image.project, TEST_IMAGE_PROJECT)
+  end
+end

data/test/integration/compute/core_compute/test_machine_types.rb

@@ -0,0 +1,55 @@
+require "helpers/integration_test_helper"
+
+class TestMachineTypes < FogIntegrationTest
+  # List of machine types - not a complete sampling since beefier ones do not
+  # exist in all zones (list last updated June 2018)
+  NAMES = %w(f1-micro g1-small n1-highcpu-16 n1-highcpu-2 n1-highcpu-4
+             n1-highcpu-8 n1-highmem-16 n1-highmem-2 n1-highmem-32 n1-highmem-4
+             n1-highmem-8 n1-standard-1 n1-standard-16 n1-standard-2
+             n1-standard-32 n1-standard-4 n1-standard-8 ).freeze
+
+  # Testing in one random zone per region (list last updated May 2018)
+  ZONES = %w(asia-east1-a asia-northeast1-b asia-south1-c asia-southeast1-a
+             australia-southeast1-b europe-west1-c europe-west2-a europe-west3-b
+             europe-west4-c northamerica-northeast1-a southamerica-east1-b
+             us-central1-c us-east1-b us-east4-a us-west1-c).freeze
+
+  def setup
+    @subject = Fog::Compute[:google].machine_types
+  end
+
+  def test_all
+    assert_operator(@subject.all.size, :>=, NAMES.size * ZONES.size,
+                    "Number of all machine types should be greater or equal to test zones * machine_types")
+  end
+
+  def test_scoped_all
+    subject_list = @subject.all
+    scoped_subject_list = @subject.all(zone: TEST_ZONE)
+
+    # Assert that whatever .all(scope) returns is a subset of .all
+    assert(scoped_subject_list.all? { |x| subject_list.include? x },
+           "Output of @subject.all(zone:#{TEST_ZONE}) must be a subset of @subject.all")
+  end
+
+  def test_get
+    # This tests only in last zone since not all zones contain all machine types
+    NAMES.each do |name|
+      ZONES.each do |zone|
+        refute_nil @subject.get(name, zone)
+      end
+    end
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name", ZONES.first)
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+
+  def test_nil_get
+    assert_nil @subject.get(nil)
+  end
+end

data/test/integration/compute/core_compute/test_operations.rb

@@ -0,0 +1,45 @@
+require "helpers/integration_test_helper"
+
+class TestOperations < FogIntegrationTest
+  def setup
+    @subject = Fog::Compute[:google].operations
+  end
+
+  def test_all
+    # TODO: what if this test runs first on a brand new project?
+    assert_operator(@subject.all.size, :>=, 2,
+                    "There should be at least 2 operations in the project")
+  end
+
+  def test_get
+    @subject.all do |operation|
+      refute_nil @subject.get(operation.name)
+    end
+  end
+
+  def test_zone_scoped_all
+    subject_list = @subject.all
+    scoped_subject_list = @subject.all(zone: TEST_ZONE)
+
+    # Assert that whatever .all(scope) returns is a subset of .all
+    assert(scoped_subject_list.all? { |x| subject_list.include? x },
+           "Output of @subject.all(zone:#{TEST_ZONE}) must be a subset of @subject.all")
+  end
+
+  def test_region_scoped_all
+    subject_list = @subject.all
+    scoped_subject_list = @subject.all(region: TEST_REGION)
+
+    # Assert that whatever .all(scope) returns is a subset of .all
+    assert(scoped_subject_list.all? { |x| subject_list.include? x },
+           "Output of @subject.all(region:#{TEST_REGION}) must be a subset of @subject.all")
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name")
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+end

data/test/integration/compute/core_compute/test_projects.rb

@@ -0,0 +1,19 @@
+require "helpers/integration_test_helper"
+
+class TestProjects < FogIntegrationTest
+  def setup
+    @subject = Fog::Compute[:google].projects
+  end
+
+  def test_get
+    assert @subject.get(TEST_PROJECT)
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name")
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+end

data/test/integration/compute/core_compute/test_regions.rb

@@ -0,0 +1,33 @@
+require "helpers/integration_test_helper"
+
+class TestRegions < FogIntegrationTest
+  EXAMPLE_NAMES = %w(asia-east1 asia-northeast1 europe-west1 us-central1 us-east1 us-west1).freeze
+
+  def setup
+    @subject = Fog::Compute[:google].regions
+  end
+
+  def test_all
+    assert_operator(@subject.all.size, :>=, EXAMPLE_NAMES.size)
+  end
+
+  def test_get
+    EXAMPLE_NAMES.each do |region|
+      refute_nil @subject.get(region)
+    end
+  end
+
+  def test_up
+    EXAMPLE_NAMES.each do |region|
+      assert @subject.get(region).up?
+    end
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name")
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+end

data/test/integration/compute/core_compute/test_servers.rb

@@ -0,0 +1,149 @@
+require "helpers/integration_test_helper"
+require "integration/factories/servers_factory"
+require "integration/factories/disks_factory"
+require "resolv"
+
+class TestServers < FogIntegrationTest
+  include TestCollection
+
+  # Cleanup is handled by TestCollection
+  def setup
+    @subject = Fog::Compute[:google].servers
+    @factory = ServersFactory.new(namespaced_name)
+    @servers = ServersFactory.new(namespaced_name)
+    @disks = DisksFactory.new(namespaced_name)
+  end
+
+  def teardown
+    # Clean up the server resources used in testing
+    @servers.cleanup
+    super
+  end
+
+  def test_set_machine_type
+    server = @factory.create
+    server.stop
+    server.wait_for { stopped? }
+    server.set_machine_type("n1-standard-2", false)
+    assert_equal "n1-standard-2", server.machine_type.split("/")[-1]
+  end
+
+  def test_set_machine_type_fail
+    server = @factory.create
+    server.wait_for { ready? }
+    assert_raises Fog::Errors::Error do
+      server.set_machine_type("n1-standard-2", false)
+    end
+  end
+
+  def test_set_metadata
+    server = @factory.create
+    server.wait_for { ready? }
+    server.set_metadata({ "foo" => "bar", "baz" => "foo" }, false)
+    assert_equal [{ :key => "foo", :value => "bar" },
+                  { :key => "baz", :value => "foo" }], server.metadata[:items]
+  end
+
+  def test_add_ssh_key
+    key = "ssh-rsa IAMNOTAREALSSHKEYAMA=="
+    username = "test_user"
+    server = @factory.create
+    server.add_ssh_key(username, key, false)
+    assert_equal [{ :key => "ssh-keys",
+                    :value => "test_user:ssh-rsa IAMNOTAREALSSHKEYAMA== test_user" }], server.metadata[:items]
+  end
+
+  def test_bootstrap
+    key = "ssh-rsa IAMNOTAREALSSHKEYAMA== user@host.subdomain.example.com"
+    user = "username"
+
+    File.stub :read, key do
+      # XXX Small hack - name is set this way so it will be cleaned up by CollectionFactory
+      # Bootstrap is special so this is something that needs to be done only for this method
+      # Public_key_path is set to avoid stubbing out File.exist?
+      server = @subject.bootstrap(:name => "#{CollectionFactory.new(nil,namespaced_name).resource_name}",
+                                  :username => user,
+                                  :public_key_path => "foo")
+      boot_disk = server.disks.detect { |disk| disk[:boot] }
+
+      assert_equal("RUNNING", server.status, "Bootstrapped server should be running")
+      assert_equal(key, server.public_key, "Bootstrapped server should have a public key set")
+      assert_equal(user, server.username, "Bootstrapped server should have user set to #{user}")
+      assert(boot_disk[:auto_delete], "Bootstrapped server should have disk set to autodelete")
+
+      network_adapter = server.network_interfaces.detect { |x| x.has_key?(:access_configs) }
+
+      refute_nil(network_adapter[:access_configs].detect { |x| x[:nat_ip] },
+                 "Bootstrapped server should have an external ip by default")
+    end
+  end
+
+  def test_bootstrap_fail
+    # Pretend the ssh key does not exist
+    File.stub :exist?, nil do
+      assert_raises(Fog::Errors::Error) {
+        # XXX Small hack - name is set this way so it will be cleaned up by CollectionFactory
+        # Bootstrap is special so this is something that needs to be done only for this method
+        @subject.bootstrap(:name => "#{CollectionFactory.new(nil,namespaced_name).resource_name}",
+                           :public_key_path => nil)
+      }
+    end
+  end
+
+  def test_image_name
+    server = @factory.create
+    assert_equal(TEST_IMAGE, server.image_name.split("/")[-1])
+  end
+
+  def test_ip_address_methods
+    # Create a server with ephemeral external IP address
+    server = @factory.create(:network_interfaces => [{ :network => "global/networks/default",
+                                                       :access_configs => [{
+                                                         :name => "External NAT",
+                                                         :type => "ONE_TO_ONE_NAT"
+                                                       }] }])
+    assert_match(Resolv::IPv4::Regex, server.public_ip_address,
+                 "Server.public_ip_address should return a valid IP address")
+    refute_empty(server.public_ip_addresses)
+    assert_match(Resolv::IPv4::Regex, server.public_ip_addresses.pop)
+
+    assert_match(Resolv::IPv4::Regex, server.private_ip_address,
+                 "Server.public_ip_address should return a valid IP address")
+    refute_empty(server.private_ip_addresses)
+    assert_match(Resolv::IPv4::Regex, server.private_ip_addresses.pop)
+  end
+
+  def test_start_stop_reboot
+    server = @factory.create
+
+    server.stop
+    server.wait_for { stopped? }
+
+    assert server.stopped?
+
+    server.start
+    server.wait_for { ready? }
+
+    assert server.ready?
+
+    server.reboot
+    server.wait_for { ready? }
+
+    assert server.ready?
+  end
+
+  def test_reset_windows_password
+    win_disk = @disks.create(
+      :name => "fog-test-1-testservers-test-reset-windows-password-2",
+      :source_image => "windows-server-1909-dc-core-v20200310",
+      :size_gb => 32
+    )
+    server = @factory.create(:disks => [win_disk])
+    server.wait_for { ready? }
+    server.reset_windows_password("test_user")
+    serial_output = server.serial_port_output(:port => 4)
+
+    assert_includes(serial_output, "encryptedPassword")
+    assert_includes(serial_output, "\"userName\":\"test_user\"")
+  end
+end