fog-google 0.0.2

data/tests/models/compute/server_tests.rb

@@ -0,0 +1,37 @@
+require 'securerandom'
+
+Shindo.tests("Fog::Compute[:google] | server model", ['google']) do
+
+  @zone = 'us-central1-a'
+  @disk = create_test_disk(Fog::Compute[:google], @zone)
+  random_string = SecureRandom.hex
+
+  model_tests(Fog::Compute[:google].servers, {:name => "fog-test-server-#{random_string}",
+                                              :zone_name => @zone,
+                                              :machine_type => 'n1-standard-1',
+                                              :disks => [@disk]})
+
+  tests('servers') do
+    @instance = nil
+    test('#bootstrap') do
+      attributes = Fog.mocking? ? {:public_key_path => nil, :private_key_path => nil} : {}
+      @instance = Fog::Compute[:google].servers.bootstrap(attributes)
+      @instance.ready?
+    end
+
+    test('#sshable?') do
+      @instance.wait_for { sshable? }
+      @instance.sshable?
+    end
+
+    test('#ssh') do
+      pending if Fog.mocking?
+      !!(@instance.ssh("uname").first.stdout =~ /Linux/)
+    end
+
+    test('#destroy') do
+      response = @instance.destroy
+      response.operation_type == 'delete'
+    end
+  end
+end

data/tests/models/compute/servers_tests.rb

@@ -0,0 +1,14 @@
+require 'securerandom'
+
+Shindo.tests("Fog::Compute[:google] | servers", ['google']) do
+
+  @zone = 'us-central1-a'
+  @disk = create_test_disk(Fog::Compute[:google], @zone)
+  random_string = SecureRandom.hex
+
+  collection_tests(Fog::Compute[:google].servers, {:name => "fog-test-server-#{random_string}",
+                                                   :zone_name => @zone,
+                                                   :machine_type => 'n1-standard-1',
+                                                   :disks => [@disk]})
+
+end

data/tests/models/compute/target_http_proxies_tests.rb

@@ -0,0 +1,7 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | target HTTP proxies model", ['google']) do
+  url_map = create_test_url_map(Fog::Compute[:google])  
+  random_string = SecureRandom.hex
+  collection_tests(Fog::Compute[:google].target_http_proxies, {:name => "fog-target-http-proxies-test-#{random_string}", :urlMap => url_map.self_link})
+
+end

data/tests/models/compute/target_http_proxy_test.rb

@@ -0,0 +1,6 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | target HTTP proxy model", ['google']) do
+  random_string = SecureRandom.hex
+  url_map = create_test_url_map(Fog::Compute[:google])
+  model_tests(Fog::Compute[:google].target_http_proxies, {:name => "fog-test-target-http-proxy-#{random_string}", :urlMap => url_map.self_link})
+end

data/tests/models/compute/target_instance_tests.rb

@@ -0,0 +1,7 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | target instance model", ['google']) do
+  random_string = SecureRandom.hex
+  @zone = 'us-central1-a'
+  instance = create_test_server(Fog::Compute[:google], @zone)  
+  model_tests(Fog::Compute[:google].target_instances, {:name => "fog-test-target-instance-#{random_string}", :instance => instance.self_link, :zone => @zone})
+end

data/tests/models/compute/target_instances_tests.rb

@@ -0,0 +1,7 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | target instances model", ['google']) do
+  @zone= 'us-central1-a'
+  random_string = SecureRandom.hex
+  instance = create_test_server(Fog::Compute[:google], @zone)
+  collection_tests(Fog::Compute[:google].target_instances, {:name => "fog-test-target-instances-#{random_string}", :instance => instance.self_link, :zone => @zone})
+end

data/tests/models/compute/target_pool_tests.rb

@@ -0,0 +1,12 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | target pool model", ['google']) do
+
+  pending
+
+  random_string = SecureRandom.hex
+  region = 'us-central1'
+  instance = create_test_server(Fog::Compute[:google], 'us-central1-a')
+  health_check = create_test_http_health_check(Fog::Compute[:google])
+  model_tests(Fog::Compute[:google].target_pools, {:name => "fog-test-target-pool-#{random_string}", :region => region, :instances => [instance.self_link], :healthChecks => [health_check.self_link]})
+
+end

data/tests/models/compute/target_pools_tests.rb

@@ -0,0 +1,11 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | target pools model", ['google']) do
+  random_string = SecureRandom.hex
+  region = 'us-central1'
+  instance = create_test_server(Fog::Compute[:google], 'us-central1-a')
+  health_check = create_test_http_health_check(Fog::Compute[:google])
+  collection_tests(
+    Fog::Compute[:google].target_pools,
+    {:name => "fog-test-target-pool-#{random_string}", :region => region, :instances => [instance.self_link], :healthChecks => [health_check.self_link]}
+  )
+end

data/tests/models/compute/url_map_tests.rb

@@ -0,0 +1,6 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | url map model", ['google']) do
+  random_string = SecureRandom.hex
+  backend_service = create_test_backend_service(Fog::Compute[:google])  
+  model_tests(Fog::Compute[:google].url_maps, {:name => "fog-test-url-map-#{random_string}", :defaultService => backend_service.self_link})
+end

data/tests/models/compute/url_maps_tests.rb

@@ -0,0 +1,7 @@
+require 'securerandom'
+Shindo.tests("Fog::Compute[:google] | url maps model", ['google']) do
+  backend_service = create_test_backend_service(Fog::Compute[:google])  
+  random_string = SecureRandom.hex
+  collection_tests(Fog::Compute[:google].url_maps, {:name => "fog-url-maps-test-#{random_string}", :defaultService => backend_service.self_link})
+
+end

data/tests/models/dns/change_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('Fog::DNS[:google] | change model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+  @zone = @dns.zones.create(
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  )
+
+  tests('success') do
+
+    tests('#pending?').succeeds do
+      @dns.changes(:service => @dns, :zone => @zone).get('0').pending? == false
+    end
+
+    tests('#ready?').succeeds do
+      @dns.changes(:service => @dns, :zone => @zone).get('0').ready? == true
+    end
+
+  end
+
+  @zone.destroy
+end

data/tests/models/dns/changes_tests.rb

@@ -0,0 +1,36 @@
+Shindo.tests('Fog::DNS[:google] | changes model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+  @zone = @dns.zones.create(
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  )
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      @dns.changes(:service => @dns, :zone => @zone).all
+    end
+
+    tests('#get').succeeds do
+      @dns.changes(:service => @dns, :zone => @zone).get('0')
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get').returns(nil) do
+      @dns.changes(:service => @dns, :zone => @zone).get(Fog::Mock.random_letters_and_numbers(16))
+    end
+
+  end
+
+  @zone.destroy
+end

data/tests/models/dns/projects_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests('Fog::DNS[:google] | projects model', ['google']) do
+  @projects = Fog::DNS[:google].projects
+
+  tests('success') do
+
+    tests('#get').succeeds do
+      @projects.get(Fog::DNS[:google].project)
+    end
+
+  end
+
+end

data/tests/models/dns/record_tests.rb

@@ -0,0 +1,42 @@
+Shindo.tests('Fog::DNS[:google] | record model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+  params = {
+    :name => "#{Fog::Mock.random_letters(16)}.#{ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain}",
+    :type => 'A',
+    :ttl => 3600,
+    :rrdatas => ['192.168.1.1'],
+  }
+
+  tests('success') do
+    @zone = @dns.zones.create(
+      :name => Fog::Mock.random_letters(8),
+      :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+      :description => 'Fog test domain'
+    )
+
+    tests('#save').succeeds do
+      @record = @zone.records.create(params)
+    end
+
+    tests('#modify').succeeds do
+      @record.modify({ :ttl => 2600 })
+    end
+
+    tests('#reload').succeeds do
+      @record.reload
+    end
+
+    tests('#destroy').succeeds do
+      @record.destroy
+    end
+
+    @zone.destroy
+  end
+
+end

data/tests/models/dns/records_tests.rb

@@ -0,0 +1,36 @@
+Shindo.tests('Fog::DNS[:google] | records model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  @dns = Fog::DNS[:google]
+  @zone = @dns.zones.create(
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  )
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      @dns.records(:service => @dns, :zone => @zone).all
+    end
+
+    tests('#get').succeeds do
+      @dns.records(:service => @dns, :zone => @zone).get(@zone.domain, 'NS')
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get').returns(nil) do
+      @dns.records(:service => @dns, :zone => @zone).get(@zone.domain, 'A')
+    end
+
+  end
+
+  @zone.destroy
+end

data/tests/models/dns/zone_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('Fog::DNS[:google] | zone model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  params = {
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  }
+  model_tests(Fog::DNS[:google].zones, params)
+
+  tests('success') do
+    @zone = Fog::DNS[:google].zones.create(params)
+
+    tests('#changes').succeeds do
+      @zone.changes
+    end
+
+    tests('#records').succeeds do
+      @zone.records
+    end
+
+    @zone.destroy
+  end
+end

data/tests/models/dns/zones_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::DNS[:google] | zones model', ['google']) do
+  # Google requires confirmation of ownership for created domains in some cases.
+  # If you want to run tests in non-mocked mode, set the environment variable to a domain you own.
+  unless Fog.mocking? || ENV['FOG_TEST_GOOGLE_DNS_ZONE']
+    tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+  end
+
+  params = {
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  }
+  collection_tests(Fog::DNS[:google].zones, params)
+end

data/tests/models/monitoring/metric_descriptors_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests('Fog::Google[:monitoring] | metric_descriptors model', ['google']) do
+  @metric_descriptors = Fog::Google[:monitoring].metric_descriptors
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      @metric_descriptors.all
+    end
+
+  end
+
+end

data/tests/models/monitoring/timeseries_collection_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests('Fog::Google[:monitoring] | timeseries_collection model', ['google']) do
+  @timeseries_collection = Fog::Google[:monitoring].timeseries_collection
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      @timeseries_collection.all('compute.googleapis.com/instance/uptime', Time.now.strftime("%Y-%m-%dT%H:%M:%S%:z"))
+    end
+
+  end
+
+end

data/tests/models/monitoring/timeseries_descriptors_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests('Fog::Google[:monitoring] | timeseries_descriptors model', ['google']) do
+  @timeseries_descriptors = Fog::Google[:monitoring].timeseries_descriptors
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      @timeseries_descriptors.all('compute.googleapis.com/instance/uptime',
+                                  Time.now.strftime("%Y-%m-%dT%H:%M:%S%:z"))
+    end
+
+  end
+
+end

data/tests/models/sql/flags_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests('Fog::Google[:sql] | flags model', ['google']) do
+  @flags = Fog::Google[:sql].tiers
+
+  tests('success') do
+
+    tests('#all').succeeds do
+      @flags.all
+    end
+
+  end
+
+end

data/tests/models/sql/instance_tests.rb

@@ -0,0 +1,56 @@
+Shindo.tests('Fog::Google[:sql] | instance model', ['google']) do
+  @instances = Fog::Google[:sql].instances
+
+  tests('success') do
+
+    tests('#create').succeeds do
+      @instance = @instances.create(:instance => Fog::Mock.random_letters(16), :tier => 'D1')
+      @instance.wait_for { ready? }
+    end
+
+    tests('#update').succeeds do
+      @instance.activation_policy = 'ALWAYS'
+      @instance.update
+      @instance.wait_for { ready? }
+    end
+
+    tests('#clone').succeeds do
+      pending unless Fog.mocking? # Binary log must be activated
+      instance_cloned_id = Fog::Mock.random_letters(16)
+      @instance.clone(instance_cloned_id, :async => false)
+      @instances.get(instance_cloned_id).destroy
+    end
+
+    tests('#export').succeeds do
+      pending unless Fog.mocking? # We don't have access to a Google Cloud Storage bucket
+      @instance.export("gs://#{Fog::Mock.random_letters_and_numbers(16)}/mysql-export", :async => false)
+    end
+
+    tests('#import').succeeds do
+      pending unless Fog.mocking? # We don't have access to a Google Cloud Storage bucket
+      @instance.import("gs://#{Fog::Mock.random_letters_and_numbers(16)}/mysql-export", :async => false)
+    end
+
+    tests('#ready?').succeeds do
+      @instance.ready? == true
+    end
+
+    tests('#reset_ssl_config').succeeds do
+      @instance.reset_ssl_config(:async => false)
+    end
+
+    tests('#restart').succeeds do
+      @instance.restart(:async => false)
+    end
+
+    tests('#set_root_password').succeeds do
+      @instance.set_root_password(Fog::Mock.random_letters_and_numbers(8), :async => false)
+    end
+
+    tests('#destroy').succeeds do
+      @instance.destroy
+    end
+
+  end
+
+end