fog-google 1.6.0 → 1.7.0

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

@@ -1,59 +0,0 @@
-require "helpers/integration_test_helper"
-require "helpers/client_helper"
-require "securerandom"
-
-class TestComputeAddressShared < FogIntegrationTest
-  DEFAULT_REGION = "us-central1".freeze
-  ADDRESS_RESOURCE_PREFIX = "fog-int-test-address".freeze
-
-  include ClientHelper
-
-  def delete_test_resources
-    client = Fog::Compute::Google.new
-    addresses = client.addresses.all(:region => DEFAULT_REGION)
-    unless addresses.nil?
-      addresses
-        .select { |a| a.name.start_with?(ADDRESS_RESOURCE_PREFIX) }
-        .each do |a|
-          Fog.wait_for do
-            unless a.ready?
-              false
-            end
-
-            begin
-              client.delete_address(a.name, DEFAULT_REGION)
-            rescue ::Google::Apis::ClientError => e
-              if e.status_code == 400 || e.status_code == 404
-                return e.status_code == 404
-              end
-              raise e
-            else
-              true
-            end
-          end
-        end
-    end
-  end
-
-  attr_reader :client
-
-  def setup
-    @client = Fog::Compute::Google.new
-  end
-
-  def teardown
-    delete_test_resources
-  end
-
-  def new_address_name
-    "#{ADDRESS_RESOURCE_PREFIX}-#{SecureRandom.uuid}"
-  end
-
-  def some_address_name
-    # created lazily to speed tests up
-    @some_address ||= new_address_name.tap do |a|
-      result = @client.insert_address(a, DEFAULT_REGION)
-      Fog.wait_for { operation_finished?(result) }
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-require "helpers/integration_test_helper"
-require "integration/compute/addresses/addresses_shared"
-require "helpers/client_helper"
-require "securerandom"
-
-class TestComputeAddressModels < TestComputeAddressShared
-  def test_addresses_create
-    address_name = new_address_name
-    address = @client.addresses.create(
-      :name => address_name,
-      :region => DEFAULT_REGION
-    )
-    assert_equal(address_name, address.name, "address should have same name")
-    assert_nil(address.users, "new address should have no users")
-  end
-
-  def test_addresses_get
-    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
-
-    assert_equal(some_address_name, address.name, "address should have same name")
-  end
-
-  def test_addresses_get_address_by_ip
-    # Fetch a preexisting address to learn its IP
-    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
-
-    found = @client.addresses.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
-    # Fetch a preexisting address to learn its IP
-    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
-
-    found = @client.addresses.get_by_name(some_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
-    # Fetch a preexisting address to learn its IP
-    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
-
-    # Ensure we find the same addresses through both codepaths
-    with_name = @client.addresses.get_by_ip_address_or_name(some_address_name)
-    with_ip = @client.addresses.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(with_name.name, with_ip.name, "address should have same name")
-    assert_equal(with_name.address, with_ip.address, "addresses should match")
-  end
-
-  def test_addresses_all
-    # Fetch a preexisting address to learn its IP
-    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
-
-    found = @client.addresses.all
-
-    assert_operator(found.size, :>, 0, "address count should be positive")
-    assert_includes(found.map(&:name), address.name, "pre-existing address should be present")
-  end
-
-  def test_addresses_destroy
-    # Make a existing address to delete
-    address_name = new_address_name
-    address = @client.addresses.create(
-      :name => address_name,
-      :region => DEFAULT_REGION
-    )
-
-    # Force synchronous for easier testing
-    address.destroy(false)
-
-    assert_raises(Google::Apis::ClientError) do
-      @client.get_address(address_name, DEFAULT_REGION)
-    end
-  end
-
-  def test_addresses_in_use
-    # Make a existing address to delete
-    address = @client.addresses.get(some_address_name, DEFAULT_REGION)
-
-    assert_equal(false, address.in_use?, "address should not be in use")
-  end
-
-  def test_address_associate
-    # TODO: implement when servers are implemented @everlag
-    skip
-  end
-
-  def test_address_disassociate
-    # TODO: implement when servers are implemented @everlag
-    skip
-  end
-
-  def test_address_server_set
-    # TODO: implement when servers are implemented @everlag
-    skip
-  end
-end

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

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

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

@@ -1,75 +0,0 @@
-require "helpers/integration_test_helper"
-require "securerandom"
-
-class TestComputeAddressesCollection < FogIntegrationTest
-  DEFAULT_REGION = "us-central1".freeze
-  DEFAULT_ZONE = "us-central1-b".freeze
-  RESOURCE_PREFIX = "fog-test-addresscol".freeze
-  TEST_ASYNC = false
-
-  # Ensure we clean up any created resources
-  Minitest.after_run do
-    client = Fog::Compute::Google.new
-    client.addresses.each { |a| a.destroy(TEST_ASYNC) if a.name.start_with?(RESOURCE_PREFIX) }
-    client.servers.each { |s| s.destroy(TEST_ASYNC) if s.name.start_with?(RESOURCE_PREFIX) }
-  end
-
-  def test_address_workflow
-    client = Fog::Compute::Google.new
-
-    my_address_name = new_resource_name
-    # An address can be created by specifying a name and a region
-    my_address = client.addresses.create(
-      :name => my_address_name,
-      :region => DEFAULT_REGION
-    )
-    # TODO: Shouldn't this be returning an operation object that we have to explicitly wait for?
-    assert_equal(my_address_name, my_address.name, "My address should have the provided name")
-    assert_equal("RESERVED", my_address.status, "My address should not be in use")
-
-    # It should also be visible when listing addresses
-    assert_includes(client.addresses.all.map(&:name), my_address_name)
-
-    # Be aware that although the address resource is created, it might not yet
-    # have an ip address. You can poll until the address has been assigned.
-    my_address.wait_for { !my_address.address.nil? }
-    assert_match(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/,
-                 my_address.address,
-                 "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,
-      :machine_type => "f1-micro",
-      :zone => client.zones.get(DEFAULT_ZONE).self_link,
-      :disks => [
-        :boot => true,
-        :auto_delete => true,
-        :initialize_params => {
-          :source_image => "projects/debian-cloud/global/images/family/debian-8"
-        }
-      ],
-      :external_ip => my_address.address
-    )
-    my_server.wait_for { staging? }
-
-    # And verify that it's correctly assigned
-    assert_equal(
-      my_address.address,
-      my_server.network_interfaces[0][:access_configs][0][:nat_ip],
-      "My created server should have the same ip as my address"
-    )
-
-    # If we look up the address again by name, we should see that it is now
-    # in use
-    assert_equal(
-      "IN_USE",
-      client.addresses.get(my_address_name, DEFAULT_REGION).status,
-      "Address should now be in use"
-    )
-  end
-
-  def new_resource_name
-    "#{RESOURCE_PREFIX}-#{SecureRandom.uuid}"
-  end
-end

data/test/integration/compute/test_compute_networks_collection.rb

@@ -1,69 +0,0 @@
-require "helpers/integration_test_helper"
-require "securerandom"
-
-class TestComputeNetworksCollection < FogIntegrationTest
-  DEFAULT_REGION = "us-central1".freeze
-  DEFAULT_ZONE = "us-central1-b".freeze
-  RESOURCE_PREFIX = "fog-test-networkscol".freeze
-  TEST_ASYNC = false
-
-  # Ensure we clean up any created resources
-  Minitest.after_run do
-    client = Fog::Compute::Google.new
-    client.networks.each { |a| a.destroy(TEST_ASYNC) if a.name.start_with?(RESOURCE_PREFIX) }
-    client.servers.each { |s| s.destroy(TEST_ASYNC) if s.name.start_with?(RESOURCE_PREFIX) }
-  end
-
-  def test_network_workflow
-    client = Fog::Compute::Google.new
-
-    my_network_name = new_resource_name
-    # An address can be created by specifying a name and a region
-    my_network = client.networks.create(
-      :name => my_network_name,
-      :ipv4_range => "10.240.#{rand(255)}.0/24"
-    )
-
-    assert_equal(my_network_name, my_network.name, "My network should have the provided name")
-
-    # It should also be visible when listing addresses
-    assert_includes(client.networks.all.map(&:name), my_network_name)
-
-    # Be aware that although the address resource is created, it might not yet
-    # have an ip address. You can poll until the address has been assigned.
-    my_network.wait_for(60) { !my_network.ipv4_range.nil? }
-    assert_match(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\/\d{1,2}/,
-                 my_network.ipv4_range,
-                 "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
-    server_name = new_resource_name
-
-    my_server = client.servers.create(
-      :name => server_name,
-      :machine_type => "f1-micro",
-      :zone => client.zones.get(DEFAULT_ZONE).self_link,
-      :disks => [
-        :boot => true,
-        :auto_delete => true,
-        :initialize_params => {
-          :source_image => "projects/debian-cloud/global/images/family/debian-8"
-        }
-      ],
-      :network_interfaces => [my_network.get_as_interface_config]
-    )
-
-    my_server.wait_for { ready? }
-
-    # We need to verify that the network has been correctly assigned
-    assert_equal(
-      my_network.self_link,
-      my_server.network_interfaces[0][:network],
-      "My created server should have the network specified as the network"
-    )
-  end
-
-  def new_resource_name
-    "#{RESOURCE_PREFIX}-#{SecureRandom.uuid}"
-  end
-end