fog-google 1.24.1 → 1.26.0

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"]

data/test/integration/pubsub/test_pubsub_models.rb

@@ -1,135 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/pubsub/pubsub_shared"
-require "securerandom"
-require "base64"
-
-class TestPubsubModels < PubSubShared
-  def test_topics_create
-    name = new_topic_name
-    result = @client.topics.create(:name => name)
-    assert_equal(result.name, name)
-  end
-
-  def test_topics_get
-    result = @client.topics.get(some_topic_name)
-    assert_equal(result.name, some_topic_name)
-  end
-
-  def test_topics_all
-    # Force a topic to be created just so we have at least 1 to list
-    name = new_topic_name
-    @client.create_topic(name)
-
-    Fog.wait_for(5) do
-      result = @client.topics.all
-      if result.nil?
-        false
-      end
-
-      result.any? { |topic| topic.name == name }
-    end
-  end
-
-  def test_topic_publish_string
-    @client.topics.get(some_topic_name)
-    message_ids = @client.topics.get(some_topic_name).publish(["apples"])
-    assert_operator(message_ids.length, :>, 0)
-  end
-
-  def test_topic_publish_hash
-    @client.topics.get(some_topic_name)
-    message_ids = @client.topics.get(some_topic_name).publish(["data" => "apples"])
-    assert_operator(message_ids.length, :>, 0)
-  end
-
-  def test_topic_delete
-    topic_to_delete = new_topic_name
-    topic = @client.topics.create(:name => topic_to_delete)
-
-    topic.destroy
-  end
-
-  def test_subscriptions_create
-    push_config = {}
-    ack_deadline_seconds = 18
-
-    subscription_name = new_subscription_name
-    result = @client.subscriptions.create(:name => subscription_name,
-                                          :topic => some_topic_name,
-                                          :push_config => push_config,
-                                          :ack_deadline_seconds => ack_deadline_seconds)
-    assert_equal(result.name, subscription_name)
-  end
-
-  def test_subscriptions_get
-    subscription_name = some_subscription_name
-    result = @client.subscriptions.get(subscription_name)
-
-    assert_equal(result.name, subscription_name)
-  end
-
-  def test_subscriptions_list
-    # Force a subscription to be created just so we have at least 1 to list
-    subscription_name = new_subscription_name
-    @client.subscriptions.create(:name => subscription_name, :topic => some_topic_name)
-
-    Fog.wait_for(5) do
-      result = @client.subscriptions.all
-      if result.nil?
-        false
-      end
-
-      result.any? { |subscription| subscription.name == subscription_name }
-    end
-  end
-
-  def test_subscription_delete
-    push_config = {}
-    ack_deadline_seconds = 18
-
-    subscription_name = new_subscription_name
-    subscription = @client.subscriptions.create(:name => subscription_name,
-                                                :topic => some_topic_name,
-                                                :push_config => push_config,
-                                                :ack_deadline_seconds => ack_deadline_seconds)
-    subscription.destroy
-  end
-
-  def test_subscription_pull
-    subscription_name = new_subscription_name
-    message_bytes = Base64.strict_encode64("some message")
-    subscription = @client.subscriptions.create(:name => subscription_name,
-                                                :topic => some_topic_name)
-    @client.topics.get(some_topic_name).publish(["data" => message_bytes])
-
-    result = subscription.pull(:return_immediately => false)
-    assert_operator(result.length, :>, 0)
-
-    contained = result.any? { |received| received.message[:data] == message_bytes }
-    assert_equal(true, contained, "sent messsage not contained within pulled responses")
-  end
-
-  def test_subscription_acknowledge
-    subscription_name = new_subscription_name
-    subscription = @client.subscriptions.create(:name => subscription_name,
-                                                :topic => some_topic_name)
-    @client.topics.get(some_topic_name).publish(["data" => Base64.strict_encode64("some message")])
-
-    result = subscription.pull(:return_immediately => false)
-    assert_operator(result.length, :>, 0)
-
-    subscription.acknowledge([result[0].ack_id])
-  end
-
-  def test_message_acknowledge
-    subscription_name = new_subscription_name
-    subscription = @client.subscriptions.create(:name => subscription_name,
-                                                :topic => some_topic_name)
-    @client.topics.get(some_topic_name).publish(["data" => Base64.strict_encode64("some message")])
-
-    result = subscription.pull(:return_immediately => false)
-    assert_operator(result.length, :>, 0)
-
-    result[0].acknowledge
-  end
-end