fog-google 1.6.0 → 1.7.0

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_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/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_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_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_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_pools.rb

@@ -0,0 +1,55 @@
+require "helpers/integration_test_helper"
+require "integration/factories/target_pools_factory"
+
+class TestTargetPools < FogIntegrationTest
+  include TestCollection
+
+  def setup
+    @subject = Fog::Compute[:google].target_pools
+    @factory = TargetPoolsFactory.new(namespaced_name)
+    @servers = Fog::Compute[:google].servers
+  end
+
+  # Override to include zone in get request
+  def get_resource(identity)
+    @subject.get(identity, TEST_ZONE)
+  end
+
+  def test_get_health
+    target_pool = @factory.create
+    server = @servers.get(target_pool.instances[0].split("/").last)
+    server.wait_for { ready? }
+
+    # XXX This is not partucularly elegant but if the instance doesn't respond
+    # to the healthcheck at all (for example there's nothing listening) it'll
+    # enter "No instance health info was found." state, during which the API
+    # will return an empty health object instead of UNHEALTHY.
+    # To avoid setting up a brittle environment with a live healthcheck we just
+    # stop the instance so health check returns UNHEALTHY and we can test that
+    # all fields are returned correctly.
+    server.stop
+    server.wait_for { stopped? }
+
+    # There's no way to track the readiness of the instance resource in a target pool,
+    # so wrapping in a soft retry:
+    begin
+      retries ||= 0
+      target_pool.get_health
+    rescue ::Google::Apis::ClientError
+      sleep 25
+      retry if (retries += 1) < 3
+    end
+
+    refute_empty(target_pool.health_checks, "Target pool should have a health check")
+    assert_equal(2, target_pool.instances.count, "Target pool should have 2 instances")
+    assert_equal([{ :health_state => "UNHEALTHY",
+                    :instance => server.self_link }],
+                 target_pool.get_health[server.self_link],
+                 "Target pool should return a proper health check list")
+    assert_equal({ server.self_link =>
+                      [{ :health_state => "UNHEALTHY",
+                         :instance => server.self_link }] },
+                 target_pool.get_health(server.name),
+                 "target_pool should return instance health details when an instance is specified")
+  end
+end

data/test/integration/factories/addresses_factory.rb

@@ -0,0 +1,16 @@
+require "integration/factories/collection_factory"
+
+class AddressesFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Compute[:google].addresses, example)
+  end
+
+  def get(identity)
+    @subject.get(identity, TEST_REGION)
+  end
+
+  def params
+    { :name => resource_name,
+      :region => TEST_REGION }
+  end
+end

data/test/integration/factories/collection_factory.rb

@@ -7,14 +7,35 @@ class CollectionFactory
     @resource_counter = 0
   end
 
+  # Cleans up all objects created by the factory in the current test suite.
+  #
+  # @param async [FalseClass or TrueClass] perform resource destruction asynchronously
   def cleanup(async = false)
-    resources = @subject.all.select { |resource| resource.name.start_with? PREFIX }
+    suit_name = @example.gsub(/\W/, "").tr("_", "-").downcase.split('-')[0]
+    resources = @subject.all.select { |resource| resource.name.match /#{PREFIX}-[0-9]*-#{suit_name}/ }
+    if DEBUG
+      p "Cleanup invoked in #{self} for example: #{@example}"
+      p "Resources to be deleted: #{resources.map { |r| r.name }}"
+      p "All subject resources: #{@subject.all.map { |s| s.name }}"
+    end
     resources.each { |r| r.destroy(async) }
     resources.each { |r| Fog.wait_for { !@subject.all.map(&:identity).include? r.identity } }
   end
 
-  def create
-    @subject.create(params)
+  # Creates a collection object instance e.g. Fog::Compute::Google::Server
+  #
+  # @param custom_params [Hash] override factory creation parameters or provide
+  #   additional ones. Useful in tests where you need to create a slightly different
+  #   resource than the default one but still want to take advantage of the factory's
+  #   cleanup methods, etc.
+  #
+  # @example Create a custom factory
+  #   @factory = ServersFactory.new(namespaced_name)
+  #   server = @factory.create(:machine_type => "f1-micro")
+  #
+  # @return [Object] collection object instance
+  def create(custom_params = {})
+    @subject.create(params.merge(custom_params))
   end
 
   def get(identity)

data/test/integration/factories/disks_factory.rb

@@ -12,6 +12,7 @@ class DisksFactory < CollectionFactory
   def params
     { :name => resource_name,
       :zone_name => TEST_ZONE,
+      :source_image => TEST_IMAGE,
       :size_gb => TEST_SIZE_GB }
   end
 end

data/test/integration/factories/firewalls_factory.rb

@@ -0,0 +1,13 @@
+require "integration/factories/collection_factory"
+
+class FirewallsFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Compute[:google].firewalls, example)
+  end
+
+  def params
+    { :name => resource_name,
+      :allowed => [{ :ip_protocol => "TCP",
+                     :ports => ["201"] }] }
+  end
+end

data/test/integration/factories/global_addresses_factory.rb

@@ -0,0 +1,15 @@
+require "integration/factories/collection_factory"
+
+class GlobalAddressesFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Compute[:google].global_addresses, example)
+  end
+
+  def get(identity)
+    @subject.get(identity)
+  end
+
+  def params
+    { :name => resource_name }
+  end
+end

data/test/integration/factories/instance_groups_factory.rb

@@ -0,0 +1,16 @@
+require "integration/factories/collection_factory"
+
+class InstanceGroupsFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Compute[:google].instance_groups, example)
+  end
+
+  def get(identity)
+    @subject.get(identity, TEST_ZONE)
+  end
+
+  def params
+    { :name => resource_name,
+      :zone => TEST_ZONE }
+  end
+end

data/test/integration/factories/instance_template_factory.rb

@@ -13,6 +13,7 @@ class InstanceTemplateFactory < CollectionFactory
           :machine_type => TEST_MACHINE_TYPE,
           :disks => [{
                          :boot => true,
+                         :auto_delete => true,
                          :initialize_params =>
                           { :source_image => "projects/ubuntu-os-cloud/global/images/ubuntu-1804-bionic-v20180522" }
                      }],

data/test/integration/factories/networks_factory.rb

@@ -0,0 +1,16 @@
+require "integration/factories/collection_factory"
+
+class NetworksFactory < CollectionFactory
+  def initialize(example)
+    # We cannot have 2 networks with the same IP range so instantiating a
+    # class variable holding a generator, ensuring that the factory gives
+    # us a new network every time it's called
+    @octet_generator = (0..255).each
+    super(Fog::Compute[:google].networks, example)
+  end
+
+  def params
+    { :name => resource_name,
+      :ipv4_range => "172.16.#{@octet_generator.next}.0/24" }
+  end
+end

data/test/integration/factories/ssl_certificates_factory.rb

@@ -0,0 +1,13 @@
+require "integration/factories/collection_factory"
+
+class SslCertificatesFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Compute[:google].ssl_certificates, example)
+  end
+
+  def params
+    { :name => resource_name,
+      :certificate => TEST_PEM_CERTIFICATE,
+      :private_key => TEST_PEM_CERTIFICATE_PRIVATE_KEY }
+  end
+end

data/test/integration/factories/subnetworks_factory.rb

@@ -0,0 +1,22 @@
+require "integration/factories/collection_factory"
+
+class SubnetworksFactory < CollectionFactory
+  def initialize(example)
+    # We cannot have 2 subnetworks with the same CIDR range so instantiating a
+    # class variable holding a generator, ensuring that the factory gives us a
+    # new subnet every time it's called
+    @octet_generator = (0..255).each
+    super(Fog::Compute[:google].subnetworks, example)
+  end
+
+  def get(identity)
+    @subject.get(identity, TEST_REGION)
+  end
+
+  def params
+    { :name => resource_name,
+      :network => "default",
+      :region => TEST_REGION,
+      :ip_cidr_range => "192.168.#{@octet_generator.next}.0/24" }
+  end
+end

data/test/integration/factories/target_https_proxies_factory.rb

@@ -0,0 +1,26 @@
+require "integration/factories/collection_factory"
+require "integration/factories/url_maps_factory"
+require "integration/factories/ssl_certificates_factory"
+
+class TargetHttpsProxiesFactory < CollectionFactory
+  def initialize(example)
+    @ssl_certificates = SslCertificatesFactory.new(example)
+    @url_maps = UrlMapsFactory.new(example)
+    super(Fog::Compute[:google].target_https_proxies, example)
+  end
+
+  def cleanup
+    # Calling CollectionFactory#cleanup with forced async as
+    # Url Maps need the Https Proxy to be deleted before they
+    # can be destroyed
+    super(false)
+    @ssl_certificates.cleanup
+    @url_maps.cleanup
+  end
+
+  def params
+    { :name => resource_name,
+      :url_map => @url_maps.create.self_link,
+      :ssl_certificates => [@ssl_certificates.create.self_link] }
+  end
+end