fog-google 1.24.1 → 1.26.0

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::Compute::Google.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"]

data/test/integration/compute/instance_groups/test_instance_group_managers.rb

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

data/test/integration/compute/instance_groups/test_instance_groups.rb

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

data/test/integration/compute/instance_groups/test_instance_templates.rb

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

data/test/integration/compute/loadbalancing/test_backend_services.rb

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

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

data/test/integration/compute/loadbalancing/test_forwarding_rules.rb

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

data/test/integration/compute/loadbalancing/test_global_addresses.rb

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

data/test/integration/compute/loadbalancing/test_global_forwarding_rules.rb

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

data/test/integration/compute/loadbalancing/test_http_health_checks.rb

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

data/test/integration/compute/loadbalancing/test_ssl_certificates.rb

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

data/test/integration/compute/loadbalancing/test_target_http_proxies.rb

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

data/test/integration/compute/loadbalancing/test_target_https_proxies.rb

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

data/test/integration/compute/loadbalancing/test_target_instances.rb

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