fog-google 0.0.2

data/tests/requests/dns/change_tests.rb

@@ -0,0 +1,86 @@
+Shindo.tests('Fog::DNS[:google] | change requests', ['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]
+
+  @get_change_format = {
+    'kind' => String,
+    'id' => String,
+    'startTime' => String,
+    'status' => String,
+    'additions' => Fog::Nullable::Array,
+    'deletions' => Fog::Nullable::Array,
+  }
+
+  @list_changes_format = {
+    'kind' => String,
+    'changes' => [@get_change_format],
+  }
+
+  @zone = @dns.zones.create(
+    :name => Fog::Mock.random_letters(16),
+    :domain => ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || generate_unique_domain,
+    :description => 'Fog test domain'
+  )
+
+  rrset_resource = {
+    :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
+
+    tests('#create_change.additions').formats(@get_change_format) do
+      @dns.create_change(@zone.identity, [rrset_resource], []).body
+    end
+
+    tests('#create_change.additions.deletions').formats(@get_change_format) do
+      @dns.create_change(@zone.identity, [rrset_resource], [rrset_resource]).body
+    end
+
+    tests('#create_change.deletions').formats(@get_change_format) do
+      @dns.create_change(@zone.identity, [], [rrset_resource]).body
+    end
+
+    tests('#list_changes').formats(@list_changes_format) do
+      @dns.list_changes(@zone.identity).body
+    end
+
+    tests('#get_change').formats(@get_change_format) do
+      @dns.get_change(@zone.identity, '0').body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#list_changes').raises(Fog::Errors::NotFound) do
+      @dns.list_changes(generate_unique_domain).body
+    end
+
+    tests('#get_change').raises(Fog::Errors::NotFound) do
+      @dns.get_change(generate_unique_domain, Fog::Mock.random_letters_and_numbers(16)).body
+    end
+
+    tests('#get_change').raises(Fog::Errors::NotFound) do
+      @dns.get_change(@zone.identity, Fog::Mock.random_letters_and_numbers(16)).body
+    end
+
+    tests('#create_change').raises(Fog::Errors::NotFound) do
+      @dns.create_change(generate_unique_domain, [], [rrset_resource]).body
+    end
+
+    tests('#create_change').raises(Fog::Errors::NotFound) do
+      @dns.create_change(@zone.identity, [], [rrset_resource]).body
+    end
+
+  end
+
+  @zone.destroy
+end

data/tests/requests/dns/managed_zone_tests.rb

@@ -0,0 +1,66 @@
+Shindo.tests('Fog::DNS[:google] | managed_zone requests', ['google']) do
+
+  @google = Fog::DNS[:google]
+
+  @managed_zone_schema = {
+      'kind' => String,
+      'id' => String,
+      'creationTime' => String,
+      'name' => String,
+      'dnsName' => String,
+      'description' => String,
+      'nameServers' => [String],
+  }
+
+  @list_managed_zones_schema = {
+      'kind' => String,
+      'managedZones' => [@managed_zone_schema],
+  }
+
+  tests('success') do
+
+    zone_name = 'new-zone-test'
+    DEFAULT_ZONE_DNS_NAME = 'fog-test.your-own-domain.com.'
+    # 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.
+    zone_dns_name = ENV['FOG_TEST_GOOGLE_DNS_ZONE'] || DEFAULT_ZONE_DNS_NAME
+    unless Fog.mocking? or zone_dns_name != DEFAULT_ZONE_DNS_NAME
+      tests('Needs a verified domain, set $FOG_TEST_GOOGLE_DNS_ZONE').pending
+    end
+
+    tests("$FOG_TEST_GOOGLE_DNS_ZONE ends with dot").pending unless zone_dns_name.end_with?('.')
+
+    tests("#create_managed_zone").data_matches_schema(
+        @managed_zone_schema, {:allow_extra_keys => false}) do
+      @google.create_managed_zone(zone_name, zone_dns_name, 'Fog test domain').body
+    end
+
+    tests("#get_managed_zone") do
+      response = @google.get_managed_zone(zone_name).body
+      tests('schema').data_matches_schema(@managed_zone_schema, {:allow_extra_keys => false}) { response }
+      tests('test zone present').returns(zone_name) { response['name'] }
+    end
+
+    tests("#list_managed_zones") do
+      response = @google.list_managed_zones().body
+      tests('schema').data_matches_schema(@list_managed_zones_schema, {:allow_extra_keys => false}) { response }
+      tests('test zone present').returns(true) { response['managedZones'].one? { |zone| zone['name'] == zone_name } }
+    end
+
+    tests("#delete_managed_zone").returns(nil) do
+      @google.delete_managed_zone(zone_name).body
+    end
+  end
+
+  tests('failure') do
+    tests("#delete_managed_zone").raises(Fog::Errors::NotFound) do
+      @google.delete_managed_zone('zone-which-does-not-exist').body
+    end
+
+    tests("#get_managed_zone").raises(Fog::Errors::NotFound) do
+      @google.get_managed_zone('zone-which-does-not-exist').body
+    end
+  end
+
+end

data/tests/requests/dns/project_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests('Fog::DNS[:google] | project requests', ['google']) do
+  @dns = Fog::DNS[:google]
+
+  @project_quota_format = {
+    'kind' => String,
+    'managedZones' => Integer,
+    'rrsetsPerManagedZone' => Integer,
+    'rrsetAdditionsPerChange' => Integer,
+    'rrsetDeletionsPerChange'=>Integer,
+    'totalRrdataSizePerChange' => Integer,
+    'resourceRecordsPerRrset' => Integer,
+  }
+
+  @get_project_format = {
+    'kind' => String,
+    'number' => String,
+    'id' => String,
+    'quota' => @project_quota_format,
+  }
+
+  tests('success') do
+
+    tests('#get_project').formats(@get_project_format) do
+      @dns.get_project(@dns.project).body
+    end
+
+  end
+
+end

data/tests/requests/dns/record_tests.rb

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::DNS[:google] | record requests', ['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]
+
+  @get_resource_record_sets_format = {
+    'kind' => String,
+    'name' => String,
+    'type' => String,
+    'ttl' => Integer,
+    'rrdatas' => Array,
+  }
+
+  @list_resource_record_sets_format = {
+    'kind' => String,
+    'rrsets' => [@get_resource_record_sets_format],
+  }
+
+  tests('success') do
+    @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('#list_resource_record_sets').formats(@list_resource_record_sets_format) do
+      @dns.list_resource_record_sets(@zone.identity).body
+    end
+
+    tests('#list_resource_record_sets (with name and type)').formats(@list_resource_record_sets_format) do
+      @dns.list_resource_record_sets(@zone.identity, { :name => @zone.domain, :type => 'NS' }).body
+    end
+
+    @zone.destroy
+  end
+
+  tests('failure') do
+
+    tests('#list_resource_record_sets').raises(Fog::Errors::NotFound) do
+      @dns.list_resource_record_sets(generate_unique_domain).body
+    end
+
+  end
+
+end

data/tests/requests/monitoring/metric_descriptor_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Google[:monitoring] | metric_descriptor requests', ['google']) do
+  @monitoring = Fog::Google[:monitoring]
+
+  @get_metric_descriptor_format = {
+    'name' => String,
+    'description' => String,
+    'labels' => Array,
+    'project' => String,
+    'typeDescriptor' => Hash,
+  }
+
+  @list_metric_descriptors_format = {
+    'kind' => String,
+    'metrics' => [@get_metric_descriptor_format],
+  }
+
+  tests('success') do
+
+    tests('#list_metric_descriptors').formats(@list_metric_descriptors_format) do
+      @monitoring.list_metric_descriptors.body
+    end
+
+  end
+
+end

data/tests/requests/monitoring/timeseries_collection_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Google[:monitoring] | timeseries_collection requests', ['google']) do
+  @monitoring = Fog::Google[:monitoring]
+
+  @get_timeseries_format = {
+    'timeseriesDesc' => Hash,
+    'points' => Array,
+  }
+
+  @list_timeseries_format = {
+    'kind' => String,
+    'youngest' => String,
+    'oldest' => String,
+    'timeseries' => [@get_timeseries_format],
+  }
+
+  tests('success') do
+
+    tests('#list_timeseries').formats(@list_timeseries_format) do
+      @monitoring.list_timeseries('compute.googleapis.com/instance/uptime',
+                                  Time.now.strftime("%Y-%m-%dT%H:%M:%S%:z")).body
+    end
+
+  end
+
+end

data/tests/requests/monitoring/timeseries_descriptor_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests('Fog::Google[:monitoring] | timeseries_descriptor requests', ['google']) do
+  @monitoring = Fog::Google[:monitoring]
+
+  @get_timeseries_descriptor_format = {
+    'metric' => String,
+    'project' => String,
+    'labels' => Hash,
+  }
+
+  @list_timeseries_descriptors_format = {
+    'kind' => String,
+    'youngest' => String,
+    'oldest' => String,
+    'timeseries' => [@get_timeseries_descriptor_format],
+  }
+
+  tests('success') do
+
+    tests('#list_timeseries_descriptors').formats(@list_timeseries_descriptors_format) do
+      @monitoring.list_timeseries_descriptors('compute.googleapis.com/instance/uptime',
+                                              Time.now.strftime("%Y-%m-%dT%H:%M:%S%:z")).body
+    end
+
+  end
+
+end

data/tests/requests/sql/flag_tests.rb

@@ -0,0 +1,27 @@
+Shindo.tests('Fog::Google[:sql] | flag requests', ['google']) do
+  @sql = Fog::Google[:sql]
+
+  @get_flag_format = {
+    'name' => String,
+    'allowedStringValues' => Fog::Nullable::Array,
+    'appliesTo' => Array,
+    'kind' => String,
+    'maxValue' => Fog::Nullable::String,
+    'minValue' => Fog::Nullable::String,
+    'type' => String,
+  }
+
+  @list_flags_format = {
+    'kind' => String,
+    'items' => [@get_flag_format],
+  }
+
+  tests('success') do
+
+    tests('#list_flags').formats(@list_flags_format) do
+      @sql.list_flags.body
+    end
+
+  end
+
+end

data/tests/requests/sql/instance_tests.rb

@@ -0,0 +1,129 @@
+Shindo.tests('Fog::Google[:sql] | instance requests', ['google']) do
+  @sql = Fog::Google[:sql]
+  @instance_id = Fog::Mock.random_letters(16)
+
+  @insert_instance_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  @get_instance_format = {
+    'instance' => String,
+    'currentDiskSize' => Fog::Nullable::String,
+    'databaseVersion' => String,
+    'etag' => String,
+    'ipAddresses' => Fog::Nullable::String,
+    'kind' => String,
+    'maxDiskSize' => String,
+    'project' => String,
+    'region' => String,
+    'serverCaCert' => Hash,
+    'settings' => Hash,
+    'state' => String,
+  }
+
+  @list_instances_format = {
+    'kind' => String,
+    'items' => [@get_instance_format],
+  }
+
+  @clone_instance_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  @export_instance_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  @import_instance_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  @reset_instance_ssl_config_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  @restart_instance_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  @set_instance_root_password_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  @update_instance_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  @delete_instance_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  tests('success') do
+
+    tests('#insert_instance').formats(@insert_instance_format) do
+      result = @sql.insert_instance(@instance_id, 'D1').body
+      @sql.instances.get(@instance_id).wait_for { ready? }
+      result
+    end
+
+    tests('#list_instances').formats(@list_instances_format) do
+      @sql.list_instances.body
+    end
+
+    tests('#get_instance').formats(@get_instance_format) do
+      @sql.get_instance(@instance_id).body
+    end
+
+    tests('#update_instance').formats(@update_instance_format) do
+      instance = @sql.instances.get(@instance_id)
+      @sql.update_instance(instance.instance, instance.settings_version, instance.tier, instance.attributes).body
+    end
+
+    tests('#clone_instance').formats(@clone_instance_format) do
+      pending unless Fog.mocking? # Binary log must be activated
+      instance_cloned_id = Fog::Mock.random_letters(16)
+      clone_instance_format = @sql.clone_instance(@instance_id, instance_cloned_id).body
+      @sql.delete_instance(instance_cloned_id)
+      clone_instance_format
+    end
+
+    tests('#export_instance').formats(@export_instance_format) do
+      pending unless Fog.mocking? # We don't have access to a Google Cloud Storage bucket
+      @sql.export_instance(@instance_id, "gs://#{Fog::Mock.random_letters_and_numbers(16)}/mysql-export").body
+    end
+
+    tests('#import_instance').formats(@import_instance_format) do
+      pending unless Fog.mocking? # We don't have access to a Google Cloud Storage bucket
+      @sql.import_instance(@instance_id, "gs://#{Fog::Mock.random_letters_and_numbers(16)}/mysql-export").body
+    end
+
+    tests('#reset_instance_ssl_config').formats(@reset_instance_ssl_config_format) do
+      @sql.reset_instance_ssl_config(@instance_id).body
+    end
+
+    tests('#set_instance_root_password').formats(@set_instance_root_password_format) do
+      @sql.set_instance_root_password(@instance_id, Fog::Mock.random_letters_and_numbers(8)).body
+    end
+
+    tests('#restart_instance').formats(@restart_instance_format) do
+      result = @sql.restart_instance(@instance_id).body
+      @sql.operations.get(@instance_id, result['operation']).wait_for { ready? }
+      result
+    end
+
+    tests('#delete_instance').formats(@delete_instance_format) do
+      @sql.delete_instance(@instance_id).body
+    end
+
+  end
+
+end