fog 1.24.0 → 1.25.0

data/tests/fogdocker/compute_tests.rb

@@ -10,7 +10,7 @@ Shindo.tests('Fog::Compute[:fogdocker]', ['fogdocker']) do
 
   tests("Compute requests") do
     %w{ api_version container_all container_create container_delete container_get
-        container_action image_all image_create image_delete image_get }.each do |collection|
+        container_action image_all image_create image_delete image_get image_search }.each do |collection|
       test("it should respond to #{collection}") { compute.respond_to? collection }
     end
   end

data/tests/fogdocker/models/compute/server_tests.rb

@@ -22,12 +22,22 @@ Shindo.tests('Fog::Compute[:fogdocker] | server model', ['fogdocker']) do
                      :created,
                      :ipaddress,
                      :state_running,
-                     :cores,
                      :memory,
+                     :cores,
+                     :cpu_shares,
                      :hostname,
                      :image,
-                     #:exposed_ports,
-                     #:volumes
+                     :attach_stdin,
+                     :attach_stdout,
+                     :attach_stderr,
+                     :state_exit_code,
+                     :state_pid,
+                     :port_bindings,
+                     :links,
+                     :privileged,
+                     :tty,
+                     :exposed_ports,
+                     :volumes
       ]
       tests("The server model should respond to") do
         attributes.each do |attribute|

data/tests/fogdocker/requests/compute/container_action_tests.rb

@@ -2,23 +2,34 @@ Shindo.tests("Fog::Compute[:fogdocker] | container_action request", 'fogdocker')
 
   compute = Fog::Compute[:fogdocker]
   name = "fog-#{Time.now.to_i}"
-  response = compute.container_create(:name => name, 'image' => 'mattdm/fedora:f19','Cmd' => ['date'] )
+  response = compute.container_create(:name => name, 'image' => 'mattdm/fedora:f19','Cmd' => ['date'])
   id = response['id']
 
   tests("Start Container") do
-    response = compute.container_action(:id => id, :action => 'start' )
-    test("should be a kind of Hash") { response.kind_of?  Hash}
+    response = compute.container_action(:id => id, :action => :start)
+    test("should be a kind of Hash") { response.kind_of? Hash }
+    test("should be running") { response['state_running'] == true }
   end
 
   tests("Stop Container") do
-    response = compute.container_action(:id => id, :action => 'stop' )
-    test("should be a kind of Hash") { response.kind_of? Hash}
+    response = compute.container_action(:id => id, :action => :stop)
+    test("should be a kind of Hash") { response.kind_of? Hash }
   end
 
   tests("Kill Container") do
-    response = compute.container_action(:id => id, :action => 'kill' )
-    test("should be a kind of Hash") { response.kind_of?  Hash}
-    test("should be stopped") { response['state_running'] == false}
+    response = compute.container_action(:id => id, :action => :kill)
+    test("should be a kind of Hash") { response.kind_of? Hash }
+    test("should be stopped") { response['state_running'] == false }
   end
 
+  tests("Top Container") do
+    response = compute.container_action(:id => id, :action => :top)
+    test("should be an Array") { response.kind_of? Array }
+    test("should be an array of processes") { !!(response.first['PID'] =~ /^\d+$/) }
+  end
+
+  tests("Logs Container") do
+    response = compute.container_action(:id => id, :action => :logs)
+    test("should be a String") { response.kind_of? String }
+  end
 end

data/tests/fogdocker/requests/compute/image_search_tests.rb

@@ -0,0 +1,11 @@
+Shindo.tests("Fog::Compute[:fogdocker] | image_search request", 'fogdocker') do
+
+  compute = Fog::Compute[:fogdocker]
+
+  tests("Search images") do
+    response = compute.image_search('term' => 'test')
+    test("should be a kind of Array") { response.kind_of?  Array}
+    test("Array elements should be a kind of Hash") { response.first.kind_of?  Hash}
+    test("response elemetns should have a name") { !response.first['name'].nil? && !response.first['name'].empty? }
+  end
+end

data/tests/google/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/google/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/google/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/google/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/google/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/google/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/google/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/google/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/google/requests/dns/managed_zone_tests.rb

@@ -33,7 +33,7 @@ Shindo.tests('Fog::DNS[:google] | managed_zone requests', ['google']) do
 
     tests("#create_managed_zone").data_matches_schema(
         @managed_zone_schema, {:allow_extra_keys => false}) do
-      @google.create_managed_zone(zone_name, zone_dns_name).body
+      @google.create_managed_zone(zone_name, zone_dns_name, 'Fog test domain').body
     end
 
     tests("#get_managed_zone") do

data/tests/google/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/google/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