gitlab-fog-google 1.13.0

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/compute/loadbalancing/test_url_maps.rb

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

data/test/integration/factories/addresses_factory.rb

@@ -0,0 +1,20 @@
+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 all
+    @subject.all(region: TEST_REGION)
+  end
+
+  def params
+    { :name => resource_name,
+      :region => TEST_REGION }
+  end
+end

data/test/integration/factories/backend_services_factory.rb

@@ -0,0 +1,19 @@
+require "integration/factories/collection_factory"
+require "integration/factories/http_health_checks_factory"
+
+class BackendServicesFactory < CollectionFactory
+  def initialize(example)
+    @http_health_checks = HttpHealthChecksFactory.new(example)
+    super(Fog::Compute[:google].backend_services, example)
+  end
+
+  def cleanup
+    super
+    @http_health_checks.cleanup
+  end
+
+  def params
+    { :name => resource_name,
+      :health_checks => [@http_health_checks.create.self_link] }
+  end
+end

data/test/integration/factories/collection_factory.rb

@@ -0,0 +1,52 @@
+class CollectionFactory
+  PREFIX = "fog-test".freeze
+
+  def initialize(subject, example)
+    @subject = subject
+    @example = example
+    @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)
+    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
+
+  # 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)
+    @subject.get(identity)
+  end
+
+  def resource_name(base = @example, prefix = PREFIX)
+    index = @resource_counter += 1
+    # In prefix, convert - to _ to make sure that it doesn't get stripped by the \W strip below.
+    # Then, concatenate prefix, index, and base; strip all non-alphanumerics except _;
+    # convert _ to -; downcase; truncate to 62 characters; delete trailing -
+    [prefix.tr("-", "_"), index, base].join("_").gsub(/\W/, "").tr("_", "-").downcase[0..61].chomp("-")
+  end
+end

data/test/integration/factories/disks_factory.rb

@@ -0,0 +1,22 @@
+require "integration/factories/collection_factory"
+
+class DisksFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Compute[:google].disks, example)
+  end
+
+  def get(identity)
+    @subject.get(identity, TEST_ZONE)
+  end
+
+  def all
+    @subject.all(zone: TEST_ZONE)
+  end
+
+  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/forwarding_rules_factory.rb

@@ -0,0 +1,25 @@
+require "integration/factories/collection_factory"
+require "integration/factories/target_pools_factory"
+
+class ForwardingRulesFactory < CollectionFactory
+  def initialize(example)
+    @target_pools = TargetPoolsFactory.new(example)
+    super(Fog::Compute[:google].forwarding_rules, example)
+  end
+
+  def cleanup
+    super
+    @target_pools.cleanup
+  end
+
+  def all
+    @subject.all(region: TEST_REGION)
+  end
+
+  def params
+    { :name => resource_name,
+      :port_range => "80-80",
+      :region => TEST_REGION,
+      :target => @target_pools.create.self_link }
+  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/global_forwarding_rules_factory.rb

@@ -0,0 +1,20 @@
+require "integration/factories/collection_factory"
+require "integration/factories/target_http_proxies_factory"
+
+class GlobalForwardingRulesFactory < CollectionFactory
+  def initialize(example)
+    @targets = TargetHttpProxiesFactory.new(example)
+    super(Fog::Compute[:google].global_forwarding_rules, example)
+  end
+
+  def cleanup
+    super
+    @targets.cleanup
+  end
+
+  def params
+    { :name => resource_name,
+      :port_range => "80-80",
+      :target => @targets.create.self_link }
+  end
+end

data/test/integration/factories/http_health_checks_factory.rb

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

data/test/integration/factories/images_factory.rb

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

data/test/integration/factories/instance_group_manager_factory.rb

@@ -0,0 +1,30 @@
+require "integration/factories/collection_factory"
+require "integration/factories/instance_template_factory"
+
+class InstanceGroupManagerFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Compute[:google].instance_group_managers, example)
+    @instance_template = InstanceTemplateFactory.new(example)
+  end
+
+  def cleanup
+    super
+    @instance_template.cleanup
+  end
+
+  def get(identity)
+    @subject.get(identity, TEST_ZONE)
+  end
+
+  def all
+    @subject.all(zone: TEST_ZONE)
+  end
+
+  def params
+    { :name => resource_name,
+      :zone => TEST_ZONE,
+      :base_instance_name => resource_name,
+      :target_size => 1,
+      :instance_template => @instance_template.create }
+  end
+end

data/test/integration/factories/instance_groups_factory.rb

@@ -0,0 +1,20 @@
+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 all
+    @subject.all(zone: TEST_ZONE)
+  end
+
+  def params
+    { :name => resource_name,
+      :zone => TEST_ZONE }
+  end
+end

data/test/integration/factories/instance_template_factory.rb

@@ -0,0 +1,24 @@
+require "integration/factories/collection_factory"
+
+class InstanceTemplateFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Compute[:google].instance_templates, example)
+  end
+
+  def params
+    {
+      :name => resource_name,
+      # TODO: Properties config is convoluted, needs to be refactored
+      :properties => {
+          :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" }
+                     }],
+          :network_interfaces => [{ :network => "global/networks/default" }]
+      }
+    }
+  end
+end

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/servers_factory.rb

@@ -0,0 +1,30 @@
+require "integration/factories/collection_factory"
+require "integration/factories/disks_factory"
+
+class ServersFactory < CollectionFactory
+  def initialize(example)
+    @disks = DisksFactory.new(example)
+    super(Fog::Compute[:google].servers, example)
+  end
+
+  def cleanup
+    # Disk cleanup sometimes fails if server deletion has not been completed
+    super(false)
+    @disks.cleanup
+  end
+
+  def get(identity)
+    @subject.get(identity, TEST_ZONE)
+  end
+
+  def all
+    @subject.all(zone: TEST_ZONE)
+  end
+
+  def params
+    { :name => resource_name,
+      :zone => TEST_ZONE,
+      :machine_type => TEST_MACHINE_TYPE,
+      :disks => [@disks.create] }
+  end
+end

data/test/integration/factories/sql_certs_factory.rb

@@ -0,0 +1,20 @@
+require "integration/factories/collection_factory"
+require "integration/factories/sql_instances_factory"
+
+class SqlCertsFactory < CollectionFactory
+  def initialize(example)
+    @instances = SqlInstancesFactory.new(example)
+    super(Fog::Google[:sql].ssl_certs, example)
+  end
+
+  def cleanup
+    # Certs will be cleaned up with the test instance.
+    @instances.cleanup
+  end
+
+  def params
+    # Certificate name should not be longer than 16 characters
+    { :common_name => resource_name,
+      :instance => @instances.create.name }
+  end
+end