gitlab-fog-google 1.13.0

data/test/integration/factories/sql_instances_factory.rb

@@ -0,0 +1,19 @@
+require "integration/factories/collection_factory"
+
+class SqlInstancesFactory < CollectionFactory
+  def initialize(example)
+    super(Fog::Google[:sql].instances, example)
+  end
+
+  def cleanup
+    super
+  end
+
+  def params
+    # Name has a time suffix due to SQL resources API objects having
+    # a _very_ long life on the backend (n(days)) after deletion.
+    { :name => "#{resource_name}-#{Time.now.to_i}",
+      :region => TEST_SQL_REGION,
+      :tier => TEST_SQL_TIER }
+  end
+end

data/test/integration/factories/sql_users_factory.rb

@@ -0,0 +1,23 @@
+require "integration/factories/collection_factory"
+require "integration/factories/sql_instances_factory"
+
+class SqlUsersFactory < CollectionFactory
+  def initialize(example)
+    @instances = SqlInstancesFactory.new(example)
+    super(Fog::Google[:sql].users, example)
+  end
+
+  def cleanup
+    # Users will be cleaned up with the test instance.
+    @instances.cleanup
+  end
+
+  def params
+    # Username should not be longer than 16 characters
+    { :name => resource_name[0..15],
+      # TODO: Consider removing host when Users.list API issue is resolved
+      # See https://github.com/fog/fog-google/issues/462
+      :host => "%",
+      :instance => @instances.create.name }
+  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,26 @@
+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 all
+    @subject.all(region: 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_http_proxies_factory.rb

@@ -0,0 +1,19 @@
+require "integration/factories/collection_factory"
+require "integration/factories/url_maps_factory"
+
+class TargetHttpProxiesFactory < CollectionFactory
+  def initialize(example)
+    @url_maps = UrlMapsFactory.new(example)
+    super(Fog::Compute[:google].target_http_proxies, example)
+  end
+
+  def cleanup
+    super
+    @url_maps.cleanup
+  end
+
+  def params
+    { :name => resource_name,
+      :url_map => @url_maps.create.self_link }
+  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

data/test/integration/factories/target_instances_factory.rb

@@ -0,0 +1,24 @@
+require "integration/factories/collection_factory"
+require "integration/factories/servers_factory"
+
+class TargetInstancesFactory < CollectionFactory
+  def initialize(example)
+    @servers = ServersFactory.new(example)
+    super(Fog::Compute[:google].target_instances, example)
+  end
+
+  def cleanup
+    super
+    @servers.cleanup
+  end
+
+  def all
+    @subject.all(zone: TEST_ZONE)
+  end
+
+  def params
+    { :name => resource_name,
+      :zone => TEST_ZONE,
+      :instance => @servers.create.self_link }
+  end
+end

data/test/integration/factories/target_pools_factory.rb

@@ -0,0 +1,28 @@
+require "integration/factories/collection_factory"
+require "integration/factories/servers_factory"
+require "integration/factories/http_health_checks_factory"
+
+class TargetPoolsFactory < CollectionFactory
+  def initialize(example)
+    @http_health_checks = HttpHealthChecksFactory.new(example)
+    @servers = ServersFactory.new(example)
+    super(Fog::Compute[:google].target_pools, example)
+  end
+
+  def cleanup
+    super
+    @servers.cleanup
+    @http_health_checks.cleanup
+  end
+
+  def all
+    @subject.all(region: TEST_REGION)
+  end
+
+  def params
+    { :name => resource_name,
+      :region => TEST_REGION,
+      :instances => [@servers.create.self_link, @servers.create.self_link],
+      :health_checks => [@http_health_checks.create.self_link] }
+  end
+end

data/test/integration/factories/url_maps_factory.rb

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

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

data/test/integration/monitoring/test_metric_descriptors.rb

@@ -0,0 +1,131 @@
+require "helpers/integration_test_helper"
+require "helpers/client_helper"
+
+class TestMetricDescriptors < FogIntegrationTest
+  TEST_METRIC_TYPE_PREFIX = "custom.googleapis.com/fog-google-test/test-metric-descriptors".freeze
+
+  def setup
+    @client = Fog::Google::Monitoring.new
+    # Ensure any resources we create with test prefixes are removed
+    Minitest.after_run do
+      delete_test_resources
+    end
+  end
+
+  def delete_test_resources
+    test_resources = @client.monitoring.list_project_metric_descriptors(
+      "projects/#{@project}",
+      :filter => "metric.type = starts_with(\"#{TEST_METRIC_TYPE_PREFIX}\")"
+    )
+    unless test_resources.metric_descriptors.nil?
+      test_resources.metric_descriptors.each do |md|
+        @client.monitoring.delete_project_metric_descriptors(md.name)
+      end
+    end
+  rescue
+    # Do nothing
+  end
+
+  def test_list_metric_descriptors
+    list_resp = @client.list_metric_descriptors
+    assert_operator(list_resp.metric_descriptors.size, :>, 0,
+                    "metric descriptor count should be positive")
+
+    resp = @client.list_metric_descriptors(
+      :filter => 'metric.type = starts_with("compute.googleapis.com")',
+      :page_size => 5
+    )
+    assert_operator(resp.metric_descriptors.size, :<=, 5,
+                    "metric descriptor count should be <= page size 5")
+
+    resp = @client.list_metric_descriptors(:page_size => 1)
+    assert_equal(resp.metric_descriptors.size, 1,
+                 "metric descriptor count should be page size 1")
+
+    next_resp = @client.list_metric_descriptors(
+      :page_size => 1,
+      :page_token => resp.next_page_token
+    )
+    assert_equal(next_resp.metric_descriptors.size, 1, "metric descriptor count should be page size 1")
+    assert(resp.metric_descriptors[0].name != next_resp.metric_descriptors[0].name,
+           "paginated result should not be the same value")
+  end
+
+  def test_create_custom_metric_descriptors
+    metric_type = "#{TEST_METRIC_TYPE_PREFIX}/test-create"
+    label = {
+      :key => "foo",
+      :value_type => "INT64",
+      :description => "test label for a metric descriptor"
+    }
+    options = {
+      :metric_type => metric_type,
+      :unit => "1",
+      :value_type => "INT64",
+      :description => "A custom metric descriptor for fog-google metric descriptor tests.",
+      :display_name => "fog-google/test-metric-descriptor",
+      :metric_kind => "GAUGE",
+      :labels => [label]
+    }
+
+    created = @client.create_metric_descriptor(options)
+
+    # Check created metric descriptor
+    assert_equal(_full_name(metric_type), created.name)
+    assert_equal(metric_type, created.type)
+    assert_equal(options[:metric_kind], created.metric_kind)
+    assert_equal(options[:value_type], created.value_type)
+    assert_equal(options[:unit], created.unit)
+    assert_equal(options[:description], created.description)
+    assert_equal(options[:display_name], created.display_name)
+
+    assert_equal(created.labels.size, 1, "expected 1 label, got #{created.labels.size}")
+    label_descriptor = created.labels.first
+    assert_equal(label[:key], label_descriptor.key)
+    assert_equal(label[:value_type], label_descriptor.value_type)
+    assert_equal(label[:description], label_descriptor.description)
+
+    Fog.wait_for(30) do
+      begin
+        get_resp = @client.get_metric_descriptor(metric_type)
+        return !get_resp.nil?
+      rescue
+        return false
+      end
+    end
+
+    list_resp = @client.list_metric_descriptor(:filter => "metric.type = \"#{metric_type}\"", :page_size => 1)
+    assert(!list_resp.metric_descriptors.nil?, "expected non-empty list request for metric descriptors")
+
+    assert_empty(@client.delete_metric_descriptor(metric_type))
+  end
+
+  def test_metric_descriptors_all
+    descriptors = @client.metric_descriptors.all
+    assert_operator(descriptors.size, :>, 0,
+                    "metric descriptor count should be positive")
+  end
+
+  def test_metric_descriptors_all_page_size
+    descriptors = @client.metric_descriptors.all(
+      :filter => 'metric.type = starts_with("compute.googleapis.com")',
+      :page_size => 5
+    )
+    assert_operator(descriptors.size, :<=, 5,
+                    "metric descriptor count should be <= page size 5")
+
+    descriptors = @client.metric_descriptors.all(:page_size => 2)
+    assert_equal(descriptors.size, 2, "metric descriptor count should be page size 2")
+  end
+
+  def test_metric_descriptors_get
+    builtin_test_type = "compute.googleapis.com/instance/cpu/usage_time"
+
+    descriptor = @client.metric_descriptors.get("compute.googleapis.com/instance/cpu/usage_time")
+    assert_equal(descriptor.type, builtin_test_type)
+  end
+
+  def _full_name(metric_type)
+    "projects/#{@client.project}/metricDescriptors/#{metric_type}"
+  end
+end

data/test/integration/monitoring/test_monitored_resource_descriptors.rb

@@ -0,0 +1,37 @@
+require "helpers/integration_test_helper"
+
+class TestMetricDescriptors < FogIntegrationTest
+  def setup
+    @client = Fog::Google::Monitoring.new
+  end
+
+  def test_list_and_get
+    resp = @client.list_monitored_resource_descriptors
+
+    assert_operator(resp.resource_descriptors.size, :>, 0,
+                    "resource descriptor count should be positive")
+
+    @client.get_monitored_resource_descriptor(
+      resp.resource_descriptors.first.type
+    )
+  end
+
+  def test_all
+    resp = @client.monitored_resource_descriptors.all
+
+    assert_operator(resp.size, :>, 0,
+                    "resource descriptor count should be positive")
+  end
+
+  def test_get
+    resource = "global"
+    descriptor = @client.monitored_resource_descriptors.get(resource)
+
+    assert_equal(
+      descriptor.name,
+      "projects/#{@client.project}/monitoredResourceDescriptors/#{resource}"
+    )
+    assert_equal(descriptor.labels.size, 1)
+    assert_equal(descriptor.labels.first[:key], "project_id")
+  end
+end

data/test/integration/monitoring/test_timeseries.rb

@@ -0,0 +1,238 @@
+require "helpers/integration_test_helper"
+
+class TestMetricDescriptors < FogIntegrationTest
+  # This module has a decent amount of retry wrappers as the Stackdriver API
+  # can be quite slow with metric propagation (sometimes 80+ seconds) and client
+  # returning errors, e.g. Google::Apis::ClientError: badRequest if the metric
+  # hasn't yet been created instead of a 404.
+
+  TEST_METRIC_PREFIX = "custom.googleapis.com/fog-google-test/timeseries".freeze
+  LABEL_DESCRIPTORS = [
+    {
+      :key => "test_string_label",
+      :value_type => "STRING",
+      :description => "test string label"
+    },
+    {
+      :key => "test_bool_label",
+      :value_type => "BOOL",
+      :description => "test boolean label"
+    },
+    {
+      :key => "test_int_label",
+      :value_type => "INT64",
+      :description => "test integer label"
+    }
+  ].freeze
+
+  def setup
+    @client = Fog::Google::Monitoring.new
+    # Ensure any resources we create with test prefixes are removed
+
+    Minitest.after_run do
+      _delete_test_resources
+    end
+  end
+
+  def test_timeseries_collection
+    metric_type = "#{TEST_METRIC_PREFIX}/test_requests"
+    _some_custom_metric_descriptor(metric_type)
+
+    start_time = Time.now
+    labels = {
+      :test_string_label => "foo",
+      :test_bool_label => "false",
+      :test_int_label => "1"
+    }
+
+    expected = _some_timeseries(start_time, metric_type, labels)
+    resp = @client.create_timeseries(:timeseries => [expected])
+    assert_empty(resp.to_h)
+
+    # Wait for metric to be created
+    retry_on(Google::Apis::ClientError) do
+      @client.list_timeseries(
+          :filter => "metric.type = \"#{metric_type}\"",
+          :interval => {
+            # Subtracting one second because timeSeries.list API
+            # doesn't return points that are exactly the same time
+            # as the interval for some reason.
+            :start_time => (start_time - 1).to_datetime.rfc3339,
+            :end_time => Time.now.to_datetime.rfc3339
+          }
+      ).time_series
+    end
+
+    series = retry_on(Google::Apis::ClientError) do
+      @client.timeseries_collection.all(
+        :filter => "metric.type = \"#{metric_type}\"",
+        :interval => {
+          # Subtracting one second because timeSeries.list API
+          # doesn't return points that are exactly the same time
+          # as the interval for some reason.
+          :start_time => (start_time - 1).to_datetime.rfc3339,
+          :end_time => Time.now.to_datetime.rfc3339
+        }
+      )
+    end
+
+    assert_equal(1, series.size)
+    actual = series.first
+    assert_equal(expected[:metric], actual.metric)
+    assert_equal(expected[:metric_kind], actual.metric_kind)
+
+    assert_equal(expected[:resource], actual.resource)
+    assert_equal(expected[:value_type], actual.value_type)
+    assert_equal(1, actual.points.size)
+    assert_equal(expected[:points].first[:value], actual.points.first[:value])
+  end
+
+  def test_multiple_timeseries
+    metric_type = "#{TEST_METRIC_PREFIX}/test_multiple"
+    _some_custom_metric_descriptor(metric_type)
+
+    start_time = Time.now
+    metric_labels = [
+      {
+        :test_string_label => "first",
+        :test_bool_label => "true",
+        :test_int_label => "1"
+      },
+      {
+        :test_string_label => "second",
+        :test_bool_label => "false",
+        :test_int_label => "2"
+      }
+    ]
+
+    timeseries = metric_labels.map do |labels|
+      _some_timeseries(start_time, metric_type, labels)
+    end
+
+    retry_on(Google::Apis::ServerError) do
+      @client.create_timeseries(:timeseries => timeseries)
+    end
+    interval = {
+      # Subtracting one second because timeSeries.list API
+      # doesn't return points that are exactly the same time
+      # as the interval for some reason.
+      :start_time => (start_time - 1).to_datetime.rfc3339,
+      :end_time => Time.now.to_datetime.rfc3339
+    }
+
+
+    # Wait for metric to be created
+    # Retriable is used instead of wait_for due to API client returning Google::Apis::ClientError: badRequest if the
+    # metric hasn't yet been created
+    retry_on(Google::Apis::ClientError) do
+      @client.list_timeseries(
+        :filter => "metric.type = \"#{metric_type}\"",
+        :interval => interval
+      ).time_series
+    end
+
+    # Test page size
+    resp = retry_on(Google::Apis::ClientError) do
+      @client.list_timeseries(
+        :filter => "metric.type = \"#{metric_type}\"",
+        :interval => interval,
+        :page_size => 1
+      )
+    end
+
+    refute_nil(resp.time_series, "expected timeseries to not be nil")
+    assert_equal(resp.time_series.size, 1,
+                 "expected timeseries count to be equal to page size 1")
+
+    next_resp = @client.list_timeseries(
+      :filter => "metric.type = \"#{metric_type}\"",
+      :interval => interval,
+      :page_size => 1,
+      :page_token => resp.next_page_token
+    )
+    assert_equal(next_resp.time_series.size, 1,
+                 "expected timeseries count to be equal to page size 1")
+    labels = resp.time_series.first.metric.labels
+    labels_next = next_resp.time_series.first.metric.labels
+    refute_equal(labels, labels_next,
+           "expected different timeseries when using page_token")
+
+    # Test filter
+    series = retry_on(Google::Apis::ClientError) do
+      @client.timeseries_collection.all(
+        :filter => %[
+          metric.type = "#{metric_type}" AND
+          metric.label.test_string_label = "first"
+        ],
+        :interval => interval
+      )
+    end
+    assert_equal(series.size, 1,
+                 "expected returned timeseries to be filtered to 1 value")
+    assert_equal("true", series.first.metric[:labels][:test_bool_label])
+    assert_equal("1", series.first.metric[:labels][:test_int_label])
+  end
+
+  def _delete_test_resources
+    list_resp = @client.monitoring.list_project_metric_descriptors(
+      "projects/#{@client.project}",
+      filter: "metric.type = starts_with(\"#{TEST_METRIC_PREFIX}\")"
+    )
+    unless list_resp.metric_descriptors.nil?
+      list_resp.metric_descriptors.each do |md|
+        @client.monitoring.delete_project_metric_descriptor(md.name)
+      end
+    end
+  rescue
+    # Do nothing
+  end
+
+  def _some_custom_metric_descriptor(metric_type)
+    # Create custom metric to write test timeseries for.
+    @client.create_metric_descriptor(
+      :labels => LABEL_DESCRIPTORS,
+      :metric_type => metric_type,
+      :unit => "1",
+      :value_type => "INT64",
+      :description => "A custom metric descriptor for fog-google timeseries test.",
+      :display_name => "fog-google-test/#{metric_type}",
+      :metric_kind => "GAUGE"
+    )
+
+    # Wait for metric descriptor to be created
+    Fog.wait_for(180, 2) do
+      begin
+        @client.get_metric_descriptor(metric_type)
+        true
+      rescue
+        false
+      end
+    end
+  end
+
+  def _some_timeseries(start_time, metric_type, labels)
+    {
+      :metric => {
+        :type => metric_type,
+        :labels => labels
+      },
+      :resource => {
+        :type => "global",
+        :labels => { :project_id => @client.project }
+      },
+      :metric_kind => "GAUGE",
+      :value_type => "INT64",
+      :points => [
+        {
+          :interval => {
+            :end_time => start_time.to_datetime.rfc3339,
+            :start_time => start_time.to_datetime.rfc3339
+          },
+          :value => {
+            :int64_value => rand(10)
+          }
+        }
+      ]
+    }
+  end
+end