fog-google 1.25.0 → 1.26.0

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

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

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

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

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

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

@@ -1,235 +0,0 @@
-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_start_stop_discard_local_ssd
-    server = @factory.create
-
-    async = true
-    discard_local_ssd = true
-
-    server.stop(async, discard_local_ssd)
-    server.wait_for { stopped? }
-
-    assert server.stopped?
-  end
-
-  def test_attach_disk
-    # Creating server
-    server = @factory.create
-    server.wait_for { ready? }
-
-    disk_name = "fog-test-1-testservers-test-attach-disk-attachable"  # suffix forces disk name to differ from the existing disk
-    # Creating disk #{disk_name}
-    disk = @disks.create(
-      :name => disk_name,
-      :source_image => TEST_IMAGE,
-      :size_gb => 64
-    )
-    device_name = "#{disk.name}-device"
-
-    # Attaching disk #{disk.name} as device #{device_name}
-    self_link = "https://www.googleapis.com/compute/v1/projects/#{TEST_PROJECT}/zones/#{TEST_ZONE}/disks/#{disk.name}"
-    server.attach_disk(self_link, true, device_name: device_name)
-
-    # Waiting for attachment
-    disk.wait_for { ! users.nil? && users != []}
-
-    assert_equal "https://www.googleapis.com/compute/v1/projects/#{TEST_PROJECT}/zones/#{TEST_ZONE}/instances/#{server.name}", disk.users[0]
-
-    server.reload
-    server_attached_disk = server.disks.select{|d| d[:boot] == false}[0]
-    assert_equal device_name, server_attached_disk[:device_name]
-  end
-
-  def test_detach_disk
-    # Creating server
-    server = @factory.create
-    server.wait_for { ready? }
-
-    disk_name = "fog-test-1-testservers-test-detach-attachable"  # suffix forces disk name to differ from the existing disk
-    # Creating disk #{disk_name}
-    disk = @disks.create(
-      :name => disk_name,
-      :source_image => TEST_IMAGE,
-      :size_gb => 64
-    )
-    device_name = "#{disk.name}-device"
-
-    # Attaching disk #{disk.name} as device #{device_name}
-    self_link = "https://www.googleapis.com/compute/v1/projects/#{TEST_PROJECT}/zones/#{TEST_ZONE}/disks/#{disk.name}"
-    server.attach_disk(self_link, true, device_name: device_name)
-    disk.wait_for { ! users.nil? && users != []}
-
-    server.reload
-    server_attached_disk = server.disks.select{|d| d[:boot] == false}[0]
-    assert_equal device_name, server_attached_disk[:device_name]
-
-    # Detaching (synchronous) disk #{disk.name}
-    server.detach_disk(device_name, false)
-
-    disk.reload
-    assert disk.users.nil? || disk.users == []
-
-    # Re-attaching disk #{disk.name} as device #{device_name}
-    server.attach_disk(self_link, true, device_name: device_name)
-    disk.wait_for { ! users.nil? && users != []}
-
-    server.reload
-    server_attached_disk = server.disks.select{|d| d[:boot] == false}[0]
-    assert_equal device_name, server_attached_disk[:device_name]
-
-    # Detaching (async) disk #{disk.name}
-    server.detach_disk(device_name, true)
-
-    # Waiting for detachment
-    disk.wait_for { users.nil? || users == []}
-
-    assert disk.users.nil? || disk.users == []
-  end
-
-  def test_reset_windows_password
-    win_disk = @disks.create(
-      :name => "fog-test-1-testservers-test-reset-windows-password-2",
-      :source_image => "windows-server-2019-dc-v20210713",
-      :size_gb => 64
-    )
-    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

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

@@ -1,21 +0,0 @@
-require "helpers/integration_test_helper"
-require "securerandom"
-require "base64"
-
-class TestComputeSnapshots < FogIntegrationTest
-  def setup
-    @client = Fog::Google::Compute.new
-    # Ensure any resources we create with test prefixes are removed
-    Minitest.after_run do
-      delete_test_resources
-    end
-  end
-
-  def test_list_empty_snapshots
-    assert_empty @client.snapshots.all
-  end
-
-  def delete_test_resources
-    # nothing to do
-  end
-end

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

@@ -1,35 +0,0 @@
-require "helpers/integration_test_helper"
-
-class TestZones < FogIntegrationTest
-  # Testing 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].zones
-  end
-
-  def test_all
-    assert_operator(@subject.all.size, :>=, ZONES.size,
-                    "Number of all zones should be greater than test zones")
-  end
-
-  def test_get
-    # This tests only in last zone since not all zones contain all machine types
-    ZONES.each do |name|
-      zone = @subject.get(name)
-      refute_nil(zone, "zones.get(#{name}) should not return nil")
-      assert(zone.up?, "zones.up? should return up, unless there's an outage")
-    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_networking/test_addresses.rb

@@ -1,107 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/factories/addresses_factory"
-require "integration/factories/servers_factory"
-
-class TestAddresses < FogIntegrationTest
-  include TestCollection
-
-  def setup
-    @subject = Fog::Compute[:google].addresses
-    @servers = ServersFactory.new(namespaced_name)
-    @factory = AddressesFactory.new(namespaced_name)
-  end
-
-  def teardown
-    # Clean up the server resources used in testing
-    @servers.cleanup
-    super
-  end
-
-  def test_run_instance
-    address = @factory.create
-    server = @servers.create(:external_ip => address.address)
-
-    assert_equal(
-      address.address,
-      server.network_interfaces[0][:access_configs][0][:nat_ip],
-      "Created server should have the correct address after initialization"
-    )
-
-    assert_equal(
-      "IN_USE",
-      @subject.get(address.name, TEST_REGION).status,
-      "Address should now be in use"
-    )
-
-    address.reload
-
-    assert_equal(
-      server,
-      address.server,
-      "Address.server should return an associated server object"
-    )
-
-    address.server = nil
-    address.reload
-    assert_nil(
-      address.server,
-      "Address should not be associated with a server after disassociation"
-    )
-
-    address.server = server
-    address.reload
-    assert_equal(
-        server,
-        address.server,
-        "Address should be associated with a server after association"
-    )
-  end
-
-  def test_bad_get
-    assert_nil @subject.get("bad-name", TEST_REGION)
-  end
-
-  def test_valid_range
-    address = @factory.create
-
-    octet = /\d{,2}|1\d{2}|2[0-4]\d|25[0-5]/
-    re = /\A#{octet}\.#{octet}\.#{octet}\.#{octet}\z/
-
-    assert_match(re, address.address,
-                 "Adress should be a valid ipv4 address")
-  end
-
-  def test_addresses_get_address_by_ip
-    address = @factory.create
-    found = @subject.get_by_ip_address(address.address)
-
-    assert_equal(address.name, found.name, "address should have same name")
-    assert_equal(address.address, found.address, "addresses should match")
-  end
-
-  def test_addresses_get_address_by_name
-    address = @factory.create
-    found = @subject.get_by_name(address.name)
-
-    assert_equal(address.name, found.name, "address should have same name")
-    assert_equal(address.address, found.address, "addresses should match")
-  end
-
-  def test_addresses_get_by_ip_address_or_name
-    # Ensure we find the same addresses through both codepaths
-    address = @factory.create
-    with_name = @subject.get_by_ip_address_or_name(address.name)
-    with_ip = @subject.get_by_ip_address_or_name(address.address)
-
-    assert_equal(address.name, with_name.name, "address should have same name")
-    assert_equal(address.address, with_name.address, "addresses should match")
-
-    assert_equal(address.name, with_ip.name, "address should have same name")
-    assert_equal(address.address, with_ip.address, "addresses should match")
-  end
-
-  def test_addresses_in_use
-    address = @factory.create
-    assert_equal(false, address.in_use?, "example address should not be in use")
-  end
-end

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

data/test/integration/compute/core_networking/test_firewalls.rb

@@ -1,11 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/factories/firewalls_factory"
-
-class TestFirewalls < FogIntegrationTest
-  include TestCollection
-
-  def setup
-    @subject = Fog::Compute[:google].firewalls
-    @factory = FirewallsFactory.new(namespaced_name)
-  end
-end

data/test/integration/compute/core_networking/test_networks.rb

@@ -1,30 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/factories/networks_factory"
-require "integration/factories/servers_factory"
-
-class TestNetworks < FogIntegrationTest
-  include TestCollection
-
-  def setup
-    @subject = Fog::Compute[:google].networks
-    @servers = ServersFactory.new(namespaced_name)
-    @factory = NetworksFactory.new(namespaced_name)
-  end
-
-  def teardown
-    # Clean up the server resources used in testing
-    @servers.cleanup
-    super
-  end
-
-  def test_run_instance
-    network = @factory.create
-    server = @servers.create(:network_interfaces => [network.get_as_interface_config])
-
-    assert_equal(
-      network.self_link,
-      server.network_interfaces[0][:network],
-      "Created server should have the network specified on boot"
-    )
-  end
-end

data/test/integration/compute/core_networking/test_routes.rb

@@ -1,26 +0,0 @@
-require "helpers/integration_test_helper"
-
-class TestRoutes < FogIntegrationTest
-  def setup
-    @subject = Fog::Compute[:google].routes
-  end
-
-  def test_all
-    assert_operator(@subject.all.size, :>=, 2,
-                    "Number of all routes should be greater or equal than 2 - default GW and default routes")
-  end
-
-  def test_get
-    @subject.all do |route|
-      refute_nil @subject.get(route.name)
-    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_networking/test_subnetworks.rb

@@ -1,11 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/factories/subnetworks_factory"
-
-class TestSubnetworks < FogIntegrationTest
-  include TestCollection
-
-  def setup
-    @subject = Fog::Compute[:google].subnetworks
-    @factory = SubnetworksFactory.new(namespaced_name)
-  end
-end

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