fog-google 1.25.0 → 1.26.0

data/test/integration/factories/subnetworks_factory.rb

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

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

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

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

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

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

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

data/test/integration/monitoring/test_metric_descriptors.rb

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

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

@@ -1,253 +0,0 @@
-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)
-    # Retrying since this is prone to errors in test environment due to
-    # constant creation/deletion of resources
-    resp = retry_on(Google::Apis::ServerError) do
-      @client.create_timeseries(:timeseries => [expected])
-    end
-    assert_empty(resp.to_h)
-
-    # Wait for TimeSeries to be created
-    # Google Monitoring backend is not exactly designed for synchronous retrieval so this retry is necessary
-    Fog.wait_for(30) do
-      begin
-        test_ts = @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
-        return !test_ts.nil?
-      rescue
-        return false
-      end
-    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
-
-    # Retrying since this is prone to errors in test environment due to
-    # constant creation/deletion of resources
-    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 TimeSeries to be created
-    # Google Monitoring backend is not exactly designed for synchronous retrieval so this retry is necessary
-    Fog.wait_for(30) do
-      begin
-        test_ts = @client.list_timeseries(
-          :filter => "metric.type = \"#{metric_type}\"",
-          :interval => interval
-        ).time_series
-        return !test_ts.nil?
-      rescue
-        return false
-      end
-    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

data/test/integration/pubsub/pubsub_shared.rb

@@ -1,75 +0,0 @@
-require "helpers/integration_test_helper"
-require "securerandom"
-require "base64"
-
-class PubSubShared < FogIntegrationTest
-  def setup
-    @client = Fog::Google::Pubsub.new
-    # Ensure any resources we create with test prefixes are removed
-    Minitest.after_run do
-      delete_test_resources
-    end
-  end
-
-  def delete_test_resources
-    topics_result = @client.list_topics
-    unless topics_result.topics.nil?
-      begin
-        topics_result.topics
-                     .map(&:name)
-                     .select { |t| t.start_with?(topic_resource_prefix) }
-                     .each { |t| @client.delete_topic(t) }
-      # We ignore errors here as list operations may not represent changes applied recently.
-      # Hence, list operations can return a topic which has already been deleted but which we
-      # will attempt to delete again.
-      rescue Google::Apis::Error
-        Fog::Logger.warning("ignoring Google Api error during delete_test_resources")
-      end
-    end
-
-    subscriptions_result = @client.list_subscriptions
-    unless subscriptions_result.subscriptions.nil?
-      begin
-        subscriptions_result.subscriptions
-                            .map(&:name)
-                            .select { |s| s.start_with?(subscription_resource_prefix) }
-                            .each { |s| @client.delete_subscription(s) }
-      # We ignore errors here as list operations may not represent changes applied recently.
-      # Hence, list operations can return a topic which has already been deleted but which we
-      # will attempt to delete again.
-      rescue Google::Apis::Error
-        Fog::Logger.warning("ignoring Google Api error during delete_test_resources")
-      end
-    end
-  end
-
-  def topic_resource_prefix
-    "projects/#{@client.project}/topics/fog-integration-test"
-  end
-
-  def subscription_resource_prefix
-    "projects/#{@client.project}/subscriptions/fog-integration-test"
-  end
-
-  def new_topic_name
-    "#{topic_resource_prefix}-#{SecureRandom.uuid}"
-  end
-
-  def new_subscription_name
-    "#{subscription_resource_prefix}-#{SecureRandom.uuid}"
-  end
-
-  def some_topic_name
-    # create lazily to speed tests up
-    @some_topic ||= new_topic_name.tap do |t|
-      @client.create_topic(t)
-    end
-  end
-
-  def some_subscription_name
-    # create lazily to speed tests up
-    @some_subscription ||= new_subscription_name.tap do |s|
-      @client.create_subscription(s, some_topic_name)
-    end
-  end
-end

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