fog-google 0.6.0 → 1.0.0

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,202 @@
+require "helpers/integration_test_helper"
+
+class TestMetricDescriptors < FogIntegrationTest
+  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)
+
+    series = @client.timeseries_collection.all(
+      :filter => "metric.type = \"#{metric_type}\"",
+      :interval => {
+        :start_time => start_time.to_datetime.rfc3339,
+        :end_time => Time.now.to_datetime.rfc3339
+      }
+    )
+    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
+
+    @client.create_timeseries(:timeseries => timeseries)
+    interval = {
+      :start_time => start_time.to_datetime.rfc3339,
+      :end_time => Time.now.to_datetime.rfc3339
+    }
+
+    # Wait for creation
+    Fog.wait_for(30) do
+      # Test all created timeseries are returned.
+      list_result = @client.list_timeseries(
+        :filter => "metric.type = \"#{metric_type}\"",
+        :interval => interval
+      ).time_series
+      !list_result.nil? && list_result.size == timeseries.size
+    end
+
+    # Test page size
+    resp = @client.list_timeseries(
+      :filter => "metric.type = \"#{metric_type}\"",
+      :interval => interval,
+      :page_size => 1
+    )
+    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
+    assert(labels != labels_next,
+           "expected different timeseries when using page_token")
+
+    # Test filter
+    series = @client.timeseries_collection.all(
+      :filter => %[
+        metric.type = "#{metric_type}" AND
+        metric.label.test_string_label = "first"
+      ],
+      :interval => interval
+    )
+    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(
+      :filter => "metric.type = starts_with(\"#{TEST_METRIC_PREFIX}\")"
+    )
+    unless list_resp.metric_descriptors.nil?
+      puts "Found #{list_resp.metric_descriptors.size} test metric descriptors."
+      list_resp.metric_descriptors.each do |md|
+        puts "deleting #{md.type}..."
+        @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(30, 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

@@ -0,0 +1,75 @@
+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_pubsub_models.rb

@@ -0,0 +1,135 @@
+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
+    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
+    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
+    assert_operator(result.length, :>, 0)
+
+    result[0].acknowledge
+  end
+end