gitlab-fog-google 1.13.0

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

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

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

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

@@ -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_networking" if ENV["COVERAGE"]

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

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

@@ -0,0 +1,41 @@
+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_valid_range
+    network = @factory.create
+
+    octet = /\d{,2}|1\d{2}|2[0-4]\d|25[0-5]/
+    netmask = /(\d{1}|1[0-9]|2[0-9]|3[0-2])/
+    re = /\A#{octet}\.#{octet}\.#{octet}\.#{octet}\/#{netmask}\z/
+
+    assert_match(re, network.ipv4_range,
+                 "Network range should be valid")
+  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

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

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

@@ -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-instance_groups" if ENV["COVERAGE"]

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

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

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

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

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

@@ -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-loadbalancing" if ENV["COVERAGE"]

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

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

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

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

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

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

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

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

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