fog-google 0.6.0 → 1.0.0

data/test/integration/compute/addresses/test_compute_address_requests.rb

@@ -0,0 +1,52 @@
+require "helpers/integration_test_helper"
+require "integration/compute/addresses/addresses_shared"
+require "helpers/client_helper"
+require "securerandom"
+
+class TestComputeAddressRequests < TestComputeAddressShared
+  def test_insert_address
+    result = wait_until_complete { @client.insert_address(new_address_name, DEFAULT_REGION) }
+
+    assert_equal("DONE", result.status, "request should be successful")
+    assert_nil(result.error, "result should contain no errors")
+  end
+
+  def test_get_address
+    result = @client.get_address(some_address_name, DEFAULT_REGION)
+
+    assert_equal("RESERVED", result.status, "request should be successful")
+    assert_includes(result.name, some_address_name, "resulting address should have expected name")
+  end
+
+  def test_list_address
+    # Let's create at least one address so there's something to view
+    known_address = new_address_name
+    wait_until_complete { @client.insert_address(known_address, DEFAULT_REGION) }
+
+    result = @client.list_addresses(DEFAULT_REGION)
+    assert_operator(result.items.size, :>, 0, "address count should be positive")
+    assert_includes(result.items.map(&:name), known_address, "pre-existing address should be present")
+  end
+
+  def test_delete_address
+    # Create something to delete
+    address_to_delete = new_address_name
+    wait_until_complete { @client.insert_address(address_to_delete, DEFAULT_REGION) }
+
+    result = wait_until_complete { @client.delete_address(address_to_delete, DEFAULT_REGION) }
+
+    assert_nil(result.error, "result should contain no errors")
+
+    assert_raises(Google::Apis::ClientError) do
+      @client.get_address(address_to_delete, DEFAULT_REGION)
+    end
+  end
+
+  def test_list_aggregated_addresses
+    @client.get_address(some_address_name, DEFAULT_REGION)
+    result = @client.list_aggregated_addresses
+
+    assert_operator(result.items.size, :>, 0, "address count should be positive")
+    assert_includes(result.items.keys, "global", "'items' subset should contain global keyword")
+  end
+end

data/test/integration/compute/disks/test_compute_disk_requests.rb

@@ -0,0 +1,92 @@
+require "helpers/integration_test_helper"
+require "helpers/client_helper"
+require "securerandom"
+
+class TestComputeDiskRequests < FogIntegrationTest
+  DEFAULT_ZONE = "us-central1-a".freeze
+  DISK_RESOURCE_PREFIX = "fog-test-disk".freeze
+
+  include ClientHelper
+
+  def delete_test_resources
+    client = Fog::Compute::Google.new
+    disks = client.disks.all(:zone => DEFAULT_ZONE)
+    unless disks.nil?
+      disks
+        .select { |d| d.name.start_with?(DISK_RESOURCE_PREFIX) }
+        .each do |d|
+          d.wait_for { ready? }
+          client.delete_disk(d.name, DEFAULT_ZONE)
+        end
+    end
+  end
+
+  attr_reader :client
+
+  def setup
+    @client = Fog::Compute::Google.new
+  end
+
+  def teardown
+    delete_test_resources
+  end
+
+  def new_disk_name
+    "#{DISK_RESOURCE_PREFIX}-#{SecureRandom.uuid}"
+  end
+
+  def some_disk_name
+    # created lazily to speed tests up
+    @some_disk ||= new_disk_name.tap do |a|
+      result = @client.insert_disk(a, DEFAULT_ZONE, nil, :size_gb => 10)
+      Fog.wait_for { operation_finished?(result) }
+    end
+  end
+
+  def test_insert_disk
+    result = wait_until_complete do
+      @client.insert_disk(new_disk_name, DEFAULT_ZONE, nil, :size_gb => 10)
+    end
+
+    assert_equal("DONE", result.status, "request should be successful")
+    assert_nil(result.error, "result should contain no errors")
+  end
+
+  def test_get_disk
+    result = @client.get_disk(some_disk_name, DEFAULT_ZONE)
+
+    assert_equal("READY", result.status, "request should be successful")
+    assert_includes(result.name, some_disk_name, "resulting disk should have expected name")
+  end
+
+  def test_list_disks
+    # Let's create at least one disk so there's something to view
+    known_disk = some_disk_name
+
+    result = @client.list_disks(DEFAULT_ZONE)
+    assert_operator(result.items.size, :>, 0, "disk count should be positive")
+    assert_includes(result.items.map(&:name), known_disk, "pre-existing disk should be present")
+  end
+
+  def test_delete_disk
+    # Create something to delete
+    disk_to_delete = new_disk_name
+    wait_until_complete { @client.insert_disk(disk_to_delete, DEFAULT_ZONE, nil, :size_gb => 10) }
+
+    result = wait_until_complete { @client.delete_disk(disk_to_delete, DEFAULT_ZONE) }
+
+    assert_nil(result.error, "result should contain no errors")
+
+    assert_raises(Google::Apis::ClientError) do
+      @client.get_disk(disk_to_delete, DEFAULT_ZONE)
+    end
+  end
+
+  def test_list_aggregated_disks
+    @client.get_disk(some_disk_name, DEFAULT_ZONE)
+    result = @client.list_aggregated_disks
+
+    assert_operator(result.items.size, :>, 0, "address count should be positive")
+    assert_includes(result.items.keys, "zones/#{DEFAULT_ZONE}", "'items' subset should contain zones/#{DEFAULT_ZONE} keyword")
+  end
+end

data/test/integration/compute/test_compute_addresses_collection.rb

@@ -40,12 +40,12 @@ class TestComputeAddressesCollection < FogIntegrationTest
     my_server = client.servers.create(
       :name => new_resource_name,
       :machine_type => "f1-micro",
-      :zone_name => DEFAULT_ZONE,
+      :zone => client.zones.get(DEFAULT_ZONE).self_link,
       :disks => [
         :boot => true,
-        :autoDelete => true,
-        :initializeParams => {
-          :sourceImage => "projects/debian-cloud/global/images/family/debian-8"
+        :auto_delete => true,
+        :initialize_params => {
+          :source_image => "projects/debian-cloud/global/images/family/debian-8"
         }
       ],
       :external_ip => my_address.address
@@ -55,7 +55,7 @@ class TestComputeAddressesCollection < FogIntegrationTest
     # And verify that it's correctly assigned
     assert_equal(
       my_address.address,
-      my_server.network_interfaces[0]["accessConfigs"][0]["natIP"],
+      my_server.network_interfaces[0][:access_configs][0][:nat_ip],
       "My created server should have the same ip as my address"
     )
 

data/test/integration/compute/test_compute_networks_collection.rb

@@ -36,40 +36,28 @@ class TestComputeNetworksCollection < FogIntegrationTest
                  "My address's address should have a valid ipv4 address")
 
     # Now that we have an address, we can create a server using the static ip
-    my_server = client.servers.create(
-      :name => new_resource_name,
+    server_name = new_resource_name
+    client.servers.create(
+      :name => server_name,
       :machine_type => "f1-micro",
-      :zone_name => DEFAULT_ZONE,
+      :zone => client.zones.get(DEFAULT_ZONE).self_link,
       :disks => [
         :boot => true,
-        :autoDelete => true,
-        :initializeParams => {
-          :sourceImage => "projects/debian-cloud/global/images/family/debian-8"
+        :auto_delete => true,
+        :initialize_params => {
+          :source_image => "projects/debian-cloud/global/images/family/debian-8"
         }
       ],
-      :network => my_network
-    )
-    my_server.wait_for { provisioning? }
+      :network_interfaces => [my_network.get_as_interface_config]
+    ).wait_for { ready? }
 
+    my_server = client.servers.get(server_name, DEFAULT_ZONE)
     # We need to verify that the network has been correctly assigned
     assert_equal(
       my_network.self_link,
-      my_server.network_interfaces[0]["network"],
+      my_server.network_interfaces[0][:network],
       "My created server should have the network specified as the network"
     )
-
-    # Access config needs to be correctly populated
-    assert_equal(
-      "ONE_TO_ONE_NAT",
-      my_server.network_interfaces[0]["accessConfigs"][0]["type"],
-      "Access config type matches the correct default"
-    )
-
-    assert_equal(
-      "External NAT",
-      my_server.network_interfaces[0]["accessConfigs"][0]["name"],
-      "Access config name matches the correct default"
-    )
   end
 
   def new_resource_name

data/test/integration/compute/test_disk_types.rb

@@ -1,7 +1,7 @@
 require "helpers/integration_test_helper"
 
 class TestDiskTypes < FogIntegrationTest
-  NAMES = %w(local-ssd pd-ssd pd-standard)
+  NAMES = %w(local-ssd pd-ssd pd-standard).freeze
   ZONES = %w(https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/us-central1-a
              https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/us-central1-b
              https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/us-central1-c
@@ -11,14 +11,14 @@ class TestDiskTypes < FogIntegrationTest
              https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/europe-west1-d
              https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/asia-east1-a
              https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/asia-east1-b
-             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/asia-east1-c)
+             https://www.googleapis.com/compute/v1/projects/graphite-fog/zones/asia-east1-c).freeze
 
   def setup
     @subject = Fog::Compute[:google].disk_types
   end
 
   def test_all
-    assert_equal (NAMES.size * ZONES.size), @subject.all.size
+    assert_operator(@subject.all.size, :>=, 1, "expected multiple disk types")
   end
 
   def test_get

data/test/integration/compute/test_regions.rb

@@ -1,25 +1,25 @@
 require "helpers/integration_test_helper"
 
 class TestRegions < FogIntegrationTest
-  NAMES = %w(asia-east1 asia-northeast1 europe-west1 us-central1 us-east1 us-west1).freeze
+  EXAMPLE_NAMES = %w(asia-east1 asia-northeast1 europe-west1 us-central1 us-east1 us-west1).freeze
 
   def setup
     @subject = Fog::Compute[:google].regions
   end
 
   def test_all
-    assert_equal NAMES.size, @subject.all.size
+    assert_operator(@subject.all.size, :>=, EXAMPLE_NAMES.size)
   end
 
   def test_get
-    NAMES.each do |name|
-      refute_nil @subject.get(name)
+    EXAMPLE_NAMES.each do |region|
+      refute_nil @subject.get(region)
     end
   end
 
   def test_up
-    NAMES.each do |name|
-      assert @subject.get(name).up?
+    EXAMPLE_NAMES.each do |region|
+      assert @subject.get(region).up?
     end
   end
 

data/test/integration/compute/test_servers.rb

@@ -8,21 +8,4 @@ class TestServers < FogIntegrationTest
     @subject = Fog::Compute[:google].servers
     @factory = ServersFactory.new(namespaced_name)
   end
-
-  def test_bootstrap_ssh_destroy
-    resource_name = @factory.resource_name
-    instance = @subject.bootstrap(:name => resource_name)
-    assert instance.ready?
-    instance.wait_for { sshable? }
-    assert_match(/Linux/, instance.ssh("uname").first.stdout)
-    assert_equal instance.destroy.operation_type, "delete"
-    Fog.wait_for { !@subject.all.map(&:identity).include? instance.identity }
-    # XXX clean up after bootstrap's automatic creation of disks
-    # This should be removed when
-    #     https://github.com/fog/fog-google/issues/17
-    # is solved
-    disk = Fog::Compute[:google].disks.get(resource_name)
-    disk.destroy
-    Fog.wait_for { !Fog::Compute[:google].disks.all.map(&:identity).include? disk.identity }
-  end
 end

data/test/integration/compute/test_target_pools.rb

@@ -8,4 +8,9 @@ class TestTargetPools < FogIntegrationTest
     @subject = Fog::Compute[:google].target_pools
     @factory = TargetPoolsFactory.new(namespaced_name)
   end
+
+  # Override to include zone in get request
+  def get_resource(identity)
+    @subject.get(identity, TEST_ZONE)
+  end
 end

data/test/integration/factories/collection_factory.rb

@@ -1,5 +1,5 @@
 class CollectionFactory
-  PREFIX = "fog-test"
+  PREFIX = "fog-test".freeze
 
   def initialize(subject, example)
     @subject = subject
@@ -7,9 +7,9 @@ class CollectionFactory
     @resource_counter = 0
   end
 
-  def cleanup
+  def cleanup(async = true)
     resources = @subject.all.select { |resource| resource.name.start_with? PREFIX }
-    resources.each(&:destroy)
+    resources.each { |r| r.destroy(async) }
     resources.each { |r| Fog.wait_for { !@subject.all.map(&:identity).include? r.identity } }
   end
 
@@ -17,11 +17,15 @@ class CollectionFactory
     @subject.create(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("-")
+    [prefix.tr("-", "_"), index, base].join("_").gsub(/\W/, "").tr("_", "-").downcase[0..61].chomp("-")
   end
 end

data/test/integration/factories/disks_factory.rb

@@ -5,6 +5,10 @@ class DisksFactory < CollectionFactory
     super(Fog::Compute[:google].disks, example)
   end
 
+  def get(identity)
+    @subject.get(identity, TEST_ZONE)
+  end
+
   def params
     { :name => resource_name,
       :zone_name => TEST_ZONE,

data/test/integration/factories/forwarding_rules_factory.rb

@@ -14,6 +14,7 @@ class ForwardingRulesFactory < CollectionFactory
 
   def params
     { :name => resource_name,
+      :port_range => "80-80",
       :region => TEST_REGION,
       :target => @target_pools.create.self_link }
   end

data/test/integration/factories/global_forwarding_rules_factory.rb

@@ -14,6 +14,7 @@ class GlobalForwardingRulesFactory < CollectionFactory
 
   def params
     { :name => resource_name,
+      :port_range => "80-80",
       :target => @targets.create.self_link }
   end
 end

data/test/integration/factories/servers_factory.rb

@@ -8,13 +8,14 @@ class ServersFactory < CollectionFactory
   end
 
   def cleanup
-    super
+    # Disk cleanup sometimes fails if server deletion has not been completed
+    super(false)
     @disks.cleanup
   end
 
   def params
     { :name => resource_name,
-      :zone_name => TEST_ZONE,
+      :zone => TEST_ZONE,
       :machine_type => TEST_MACHINE_TYPE,
       :disks => [@disks.create] }
   end

data/test/integration/factories/target_instances_factory.rb

@@ -15,6 +15,6 @@ class TargetInstancesFactory < CollectionFactory
   def params
     { :name => resource_name,
       :zone => TEST_ZONE,
-      :instance => @servers.create }
+      :instance => @servers.create.self_link }
   end
 end

data/test/integration/monitoring/test_metric_descriptors.rb

@@ -0,0 +1,129 @@
+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")
+
+    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