fog-google 1.6.0 → 1.7.0

data/test/helpers/integration_test_helper.rb

@@ -5,12 +5,19 @@ require "helpers/test_collection"
 # XXX not sure if this will work on Travis CI or not
 Fog.credential = :test
 
+# Enable test debugging, providing additional information in some methods
+DEBUG = ENV['FOG_TEST_DEBUG'] || false
+
 # Helpers
 
+TEST_PROJECT = Fog.credentials[:google_project]
+
 TEST_ZONE = "us-central1-f".freeze
 TEST_REGION = "us-central1".freeze
 TEST_SIZE_GB = 10
 TEST_MACHINE_TYPE = "n1-standard-1".freeze
+TEST_IMAGE = "debian-9-stretch-v20180611".freeze
+
 # XXX This depends on a public image in gs://fog-test-bucket; there may be a better way to do this
 # The image was created like so: https://cloud.google.com/compute/docs/images#export_an_image_to_google_cloud_storage
 TEST_RAW_DISK_SOURCE = "http://storage.googleapis.com/fog-test-bucket/fog-test-raw-disk-source.image.tar.gz".freeze
@@ -21,6 +28,66 @@ TEST_SQL_REGION_FIRST = "us-central".freeze
 TEST_SQL_TIER_SECOND = "db-n1-standard-1".freeze
 TEST_SQL_REGION_SECOND = TEST_REGION
 
+# Test certificate/key for SSL Proxy tests, generated via:
+# $ openssl genrsa -out example.key 2048
+# $ openssl req -new -key example.key -out example.csr
+# ...
+# Common Name (eg, fully qualified host name) []:example.com
+# Email Address []:admin@example.com
+# ...
+# $ openssl x509 -req -in example.csr -signkey example.key -out example.crt
+
+TEST_PEM_CERTIFICATE = <<CERT
+-----BEGIN CERTIFICATE-----
+MIIC7DCCAdQCCQCDSZQ3PYJW6zANBgkqhkiG9w0BAQUFADA4MRQwEgYDVQQDDAtl
+eGFtcGxlLmNvbTEgMB4GCSqGSIb3DQEJARYRYWRtaW5AZXhhbXBsZS5jb20wHhcN
+MTgwNjI4MDEzMzA5WhcNMTgwNzI4MDEzMzA5WjA4MRQwEgYDVQQDDAtleGFtcGxl
+LmNvbTEgMB4GCSqGSIb3DQEJARYRYWRtaW5AZXhhbXBsZS5jb20wggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQC2DQkr6HBIoVsi7I+uHtmmge1KvbWP4nwg
+tmKe8FtprjyaBcY729Sc0LTgkOh0krVem9nsxd/Lea47jHTV/vM03xsOuEKRKy3S
+Horlr0TBRvB7tSmZCH0jn4x+V/k2qdLKhiDAtbLZ1UC3SWu3OjbE9ozf3fNPmssT
+bK2sNesa2XlydzL8wyZMajGLs8CEHVqpZwLSPTeGB3LAhdRjfzJLijqe124otVIb
+3+tbxYZVY5GLVQIIR/DlwRzZLxptPALvHq3t3eOfC3eZImXqUzGmoug6nDrdKuEs
+C8yaoCNC3sSecoaV5Kyy70Hae+wFV7ocZGejm9AtuHXF1pgM4outAgMBAAEwDQYJ
+KoZIhvcNAQEFBQADggEBAFRYuOe7nwR8Sn7TDyzPcqau3yF2qYATtrDIzo7xmh3o
+T18FYCeX9gu/M9ytziM2lb/+WRqvcu55FrQiBz434E4wYH/IGUZK849V03dCro10
+Po5Hhayt5+tv5Ti0JqmJoC/HN0hNF+WQA8kikiteTTohIDj9rVX2uULA61rnHXSZ
+h6ZZRce3PdRKIUjOcQ4pIoI8QXSIToBsdY+Cieg9PHCt8mZhevU7COE1lfPFtdlY
+HJhg5xhHVUt40qsahpvUjnPBU8rJPPE06ougf5qjr0D8ZoYeuUQT0VJYwwacfpeb
+hs6AFOH5IAj6gjdIRhOWzYSxBYeyzJGfiPSbK4rowFM=
+-----END CERTIFICATE-----
+CERT
+
+TEST_PEM_CERTIFICATE_PRIVATE_KEY = <<KEY
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAtg0JK+hwSKFbIuyPrh7ZpoHtSr21j+J8ILZinvBbaa48mgXG
+O9vUnNC04JDodJK1XpvZ7MXfy3muO4x01f7zNN8bDrhCkSst0h6K5a9EwUbwe7Up
+mQh9I5+Mflf5NqnSyoYgwLWy2dVAt0lrtzo2xPaM393zT5rLE2ytrDXrGtl5cncy
+/MMmTGoxi7PAhB1aqWcC0j03hgdywIXUY38yS4o6ntduKLVSG9/rW8WGVWORi1UC
+CEfw5cEc2S8abTwC7x6t7d3jnwt3mSJl6lMxpqLoOpw63SrhLAvMmqAjQt7EnnKG
+leSssu9B2nvsBVe6HGRno5vQLbh1xdaYDOKLrQIDAQABAoIBAD5GA0cjwZT2rQgr
+R5LWNrmAZD1W246WeMNv4BhiO8LQuSYup3q+XeIuelD/AKUvsh7kzQzzOvSNcQ4p
+o6W4ClWho83LNeoWjRv9GqIq7Cf5LjYC6HHSt4vB/fsR+Mu8F8DzVKzW+pENI5AO
+62vH3AhQFixV7e7jEmhYmqf34a5S9U3+0OkzRRbFVA5rBxKK4xLqrX/app4/TKs6
+msn+qCJUAVxggcKIACF0slzbGuKfCSOyfPM4dmKV1n857wDu2YB9QwaaI+aHtR9S
+rassm1TCcqirUIOsTcAaZ5szjkhAhH+pg/xVjl/2ppz1W/m9cfNQ4zwle1YuUmpS
+OxyqUcECgYEA8jQ0zZG4J7MOX29o2F+D4VI5I1kp6uLsfhb8KztEgpgdMy+nGNsK
+wlOd2fJU3hK51dg82HKSSEzHHPud7O39pWEo3iSmgdZ+pXhjXe95x+bVPfP01eSp
+CSyMP8t6c9RxVtpVU1IbrjMXROuwEIxaIzMhT4YYDGOoSj2xLn43N9kCgYEAwGuv
+MJeCDMI2Zr+OA1N3FUk6Py8q1zxJN3Wt3CwSjp57K3g2LaqN6gwgIbN3d1fEV9cM
+ATtjjsFC+toFrP8BZ1wj3DY8Q4OsOmXng1V4bw4Y5xsT6SxXh7E0gU2L8MCjUdri
+WUUu++yRRcUpWUGRRMYx6cN529HPNbAPm5Y8QfUCgYAGpCHShS1cgU9ilIZ2cGAI
+XJ3Od1Jr6176shyl/tEJF6ytS6A0UUVBQNOyNy/WiwLndy9r6/BQ5TIMfGW/KmNr
+FnftZ2ndY4lDdkKbP8bCEXVFZpwPBV8RLlSGJ0krReb5r7DpQPYbV7FKpX/FZGPQ
+VUWTjaS5Kj5iEsD5+mH/OQKBgQCKhftc8/V/0eDwHz7RTikQfeMc0Yv530CmWGWN
+d3z0h0sMhEIcpgf8UjZfjJ+YnuqOghX2XRbTEnZxuLsVS49rJX37bl/8CrLWZ74/
+YiyNZoyu82NmHbH10bCG1ZjE/SmWKAmDUrb8TdZXcBTQWM+Hv1b3fu4fPe/6KoFR
+9Nn0cQKBgQC8BViTyfPTSuTEb8z7uzLEQk13MH+LTHFngFevWoq3OStEsmsIYK1K
+GcF1N9ZzPH024uwdcLjjwpul/avUHqzfp5ZILuI83Z/OqYYLiCQ0BbAQno7Cp5Be
+wLjafhPTSAIS0jijglJ7uzaSbFUW11fw1/EIqIFNe0R0Xf9lsyPxFA==
+-----END RSA PRIVATE KEY-----
+KEY
+
 class FogIntegrationTest < MiniTest::Test
   def namespaced_name
     "#{self.class}_#{name}"

data/test/helpers/test_helper.rb

@@ -1,19 +1,23 @@
-# The next line was added to squelch a warning message in Ruby 1.9.
-# It ensures we're using the gem, not the built-in Minitest
-# See https://github.com/seattlerb/minitest/#install
-gem "minitest"
-
-require "minitest/autorun"
-
+# Configure simplecov for coverage tests
+# Note: needs to be done _before_ requiring minitest!
 if ENV["COVERAGE"]
-  require "coveralls"
   require "simplecov"
 
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+
   SimpleCov.start do
     add_filter "/test/"
   end
 end
 
-require File.join(File.dirname(__FILE__), "../../lib/fog/google")
+# The next line was added to squelch a warning message in Ruby 1.9.
+# It ensures we're using the gem, not the built-in Minitest
+# See https://github.com/seattlerb/minitest/#install
+gem "minitest"
+require "minitest/autorun"
+# Custom formatters
+require "minitest/reporters"
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
-Coveralls.wear! if ENV["COVERAGE"]
+require File.join(File.dirname(__FILE__), "../../lib/fog/google")

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

data/test/integration/compute/core_compute/test_machine_types.rb

@@ -0,0 +1,42 @@
+require "helpers/integration_test_helper"
+
+class TestMachineTypes < FogIntegrationTest
+  # List of machine types - not a complete sampling since beefier ones do not
+  # exist in all zones (list last updated June 2018)
+  NAMES = %w(f1-micro g1-small n1-highcpu-16 n1-highcpu-2 n1-highcpu-4
+             n1-highcpu-8 n1-highmem-16 n1-highmem-2 n1-highmem-32 n1-highmem-4
+             n1-highmem-8 n1-standard-1 n1-standard-16 n1-standard-2
+             n1-standard-32 n1-standard-4 n1-standard-8 ).freeze
+
+  # Testing in one random zone per region (list last updated May 2018)
+  ZONES = %w(asia-east1-a asia-northeast1-b asia-south1-c asia-southeast1-a
+             australia-southeast1-b europe-west1-c europe-west2-a europe-west3-b
+             europe-west4-c northamerica-northeast1-a southamerica-east1-b
+             us-central1-c us-east1-b us-east4-a us-west1-c).freeze
+
+  def setup
+    @subject = Fog::Compute[:google].machine_types
+  end
+
+  def test_all
+    assert_operator(@subject.all.size, :>=, NAMES.size * ZONES.size,
+                    "Number of all machine types should be greater or equal to test zones * machine_types")
+  end
+
+  def test_get
+    # This tests only in last zone since not all zones contain all machine types
+    NAMES.each do |name|
+      ZONES.each do |zone|
+        refute_nil @subject.get(name, zone)
+      end
+    end
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name", ZONES.first)
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+end

data/test/integration/compute/core_compute/test_operations.rb

@@ -0,0 +1,27 @@
+require "helpers/integration_test_helper"
+
+class TestRoutes < FogIntegrationTest
+  def setup
+    @subject = Fog::Compute[:google].operations
+  end
+
+  def test_all
+    # TODO: what if this test runs first on a brand new project?
+    assert_operator(@subject.all.size, :>=, 2,
+                    "There should be at least 2 operations in the project")
+  end
+
+  def test_get
+    @subject.all do |operation|
+      refute_nil @subject.get(operation.name)
+    end
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name")
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+end

data/test/integration/compute/core_compute/test_projects.rb

@@ -0,0 +1,19 @@
+require "helpers/integration_test_helper"
+
+class TestProjects < FogIntegrationTest
+  def setup
+    @subject = Fog::Compute[:google].projects
+  end
+
+  def test_get
+    assert @subject.get(TEST_PROJECT)
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name")
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+end

data/test/integration/compute/core_compute/test_servers.rb

@@ -0,0 +1,109 @@
+require "helpers/integration_test_helper"
+require "integration/factories/servers_factory"
+require "integration/factories/disks_factory"
+require "resolv"
+
+class TestServers < FogIntegrationTest
+  include TestCollection
+
+  # Cleanup is handled by TestCollection
+  def setup
+    @subject = Fog::Compute[:google].servers
+    @factory = ServersFactory.new(namespaced_name)
+    @servers = ServersFactory.new(namespaced_name)
+    @disks = DisksFactory.new(namespaced_name)
+  end
+
+  def teardown
+    # Clean up the server resources used in testing
+    @servers.cleanup
+    super
+  end
+
+  def test_set_metadata
+    server = @factory.create
+    server.wait_for { ready? }
+    server.set_metadata({ "foo" => "bar", "baz" => "foo" }, false)
+    assert_equal [{ :key => "foo", :value => "bar" },
+                  { :key => "baz", :value => "foo" }], server.metadata[:items]
+  end
+
+  def test_bootstrap
+    key = "ssh-rsa IAMNOTAREALSSHKEYAMA== user@host.subdomain.example.com"
+    user = "username"
+
+    File.stub :read, key do
+      # XXX Small hack - name is set this way so it will be cleaned up by CollectionFactory
+      # Bootstrap is special so this is something that needs to be done only for this method
+      # Public_key_path is set to avoid stubbing out File.exist?
+      server = @subject.bootstrap(:name => "#{CollectionFactory.new(nil,namespaced_name).resource_name}",
+                                  :username => user,
+                                  :public_key_path => "foo")
+      boot_disk = server.disks.detect { |disk| disk[:boot] }
+
+      assert_equal("RUNNING", server.status, "Bootstrapped server should be running")
+      assert_equal(key, server.public_key, "Bootstrapped server should have a public key set")
+      assert_equal(user, server.username, "Bootstrapped server should have user set to #{user}")
+      assert(boot_disk[:auto_delete], "Bootstrapped server should have disk set to autodelete")
+
+      network_adapter = server.network_interfaces.detect { |x| x.has_key?(:access_configs) }
+
+      refute_nil(network_adapter[:access_configs].detect { |x| x[:nat_ip] },
+                 "Bootstrapped server should have an external ip by default")
+    end
+  end
+
+  def test_bootstrap_fail
+    # Pretend the ssh key does not exist
+    File.stub :exist?, nil do
+      assert_raises(Fog::Errors::Error) {
+        # XXX Small hack - name is set this way so it will be cleaned up by CollectionFactory
+        # Bootstrap is special so this is something that needs to be done only for this method
+        @subject.bootstrap(:name => "#{CollectionFactory.new(nil,namespaced_name).resource_name}",
+                           :public_key_path => nil)
+      }
+    end
+  end
+
+  def test_image_name
+    server = @factory.create
+    assert_equal(TEST_IMAGE, server.image_name.split("/")[-1])
+  end
+
+  def test_ip_address_methods
+    # Create a server with ephemeral external IP address
+    server = @factory.create(:network_interfaces => [{ :network => "global/networks/default",
+                                                       :access_configs => [{
+                                                         :name => "External NAT",
+                                                         :type => "ONE_TO_ONE_NAT"
+                                                       }] }])
+    assert_match(Resolv::IPv4::Regex, server.public_ip_address,
+                 "Server.public_ip_address should return a valid IP address")
+    refute_empty(server.public_ip_addresses)
+    assert_match(Resolv::IPv4::Regex, server.public_ip_addresses.pop)
+
+    assert_match(Resolv::IPv4::Regex, server.private_ip_address,
+                 "Server.public_ip_address should return a valid IP address")
+    refute_empty(server.private_ip_addresses)
+    assert_match(Resolv::IPv4::Regex, server.private_ip_addresses.pop)
+  end
+
+  def test_start_stop_reboot
+    server = @factory.create
+
+    server.stop
+    server.wait_for { stopped? }
+
+    assert server.stopped?
+
+    server.start
+    server.wait_for { ready? }
+
+    assert server.ready?
+
+    server.reboot
+    server.wait_for { ready? }
+
+    assert server.ready?
+  end
+end

data/test/integration/compute/core_compute/test_zones.rb

@@ -0,0 +1,35 @@
+require "helpers/integration_test_helper"
+
+class TestZones < FogIntegrationTest
+  # Testing one random zone per region (list last updated May 2018)
+  ZONES = %w(asia-east1-a asia-northeast1-b asia-south1-c asia-southeast1-a
+             australia-southeast1-b europe-west1-c europe-west2-a europe-west3-b
+             europe-west4-c northamerica-northeast1-a southamerica-east1-b
+             us-central1-c us-east1-b us-east4-a us-west1-c).freeze
+
+  def setup
+    @subject = Fog::Compute[:google].zones
+  end
+
+  def test_all
+    assert_operator(@subject.all.size, :>=, ZONES.size,
+                    "Number of all zones should be greater than test zones")
+  end
+
+  def test_get
+    # This tests only in last zone since not all zones contain all machine types
+    ZONES.each do |name|
+      zone = @subject.get(name)
+      refute_nil(zone, "zones.get() should not return nil")
+      assert(zone.up?, "zones.up? should return up, unless there's an outage")
+    end
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name")
+  end
+
+  def test_enumerable
+    assert_respond_to @subject, :each
+  end
+end

data/test/integration/compute/core_networking/test_addresses.rb

@@ -0,0 +1,84 @@
+require "helpers/integration_test_helper"
+require "integration/factories/addresses_factory"
+require "integration/factories/servers_factory"
+
+class TestAddresses < FogIntegrationTest
+  include TestCollection
+
+  def setup
+    @subject = Fog::Compute[:google].addresses
+    @servers = ServersFactory.new(namespaced_name)
+    @factory = AddressesFactory.new(namespaced_name)
+  end
+
+  def teardown
+    # Clean up the server resources used in testing
+    @servers.cleanup
+    super
+  end
+
+  def test_run_instance
+    address = @factory.create
+    server = @servers.create(:external_ip => address.address)
+
+    assert_equal(
+      address.address,
+      server.network_interfaces[0][:access_configs][0][:nat_ip],
+      "Created server should have the correct address after initialization"
+    )
+
+    assert_equal(
+      "IN_USE",
+      @subject.get(address.name, TEST_REGION).status,
+      "Address should now be in use"
+    )
+  end
+
+  def test_bad_get
+    assert_nil @subject.get("bad-name", TEST_REGION)
+  end
+
+  def test_valid_range
+    address = @factory.create
+
+    octet = /\d{,2}|1\d{2}|2[0-4]\d|25[0-5]/
+    re = /\A#{octet}\.#{octet}\.#{octet}\.#{octet}\z/
+
+    assert_match(re, address.address,
+                 "Adress should be a valid ipv4 address")
+  end
+
+  def test_addresses_get_address_by_ip
+    address = @factory.create
+    found = @subject.get_by_ip_address(address.address)
+
+    assert_equal(address.name, found.name, "address should have same name")
+    assert_equal(address.address, found.address, "addresses should match")
+  end
+
+  def test_addresses_get_address_by_name
+    address = @factory.create
+    found = @subject.get_by_name(address.name)
+
+    assert_equal(address.name, found.name, "address should have same name")
+    assert_equal(address.address, found.address, "addresses should match")
+  end
+
+  def test_addresses_get_by_ip_address_or_name
+    # Ensure we find the same addresses through both codepaths
+    address = @factory.create
+    with_name = @subject.get_by_ip_address_or_name(address.name)
+    with_ip = @subject.get_by_ip_address_or_name(address.address)
+
+    assert_equal(address.name, with_name.name, "address should have same name")
+    assert_equal(address.address, with_name.address, "addresses should match")
+
+    assert_equal(address.name, with_ip.name, "address should have same name")
+    assert_equal(address.address, with_ip.address, "addresses should match")
+  end
+
+  def test_addresses_in_use
+    address = @factory.create
+    assert_equal(false, address.in_use?, "example address should not be in use")
+  end
+end