fog 1.0.0 → 1.1.0

data/tests/brightbox/requests/compute/helper.rb

@@ -110,7 +110,8 @@ class Brightbox
           "description"     => String,
           "source"          => String,
           "status"          => String,
-          "owner"           => String
+          "owner"           => String,
+          "username"        => Fog::Nullable::String,
         }
 
         INTERFACE = {
@@ -131,7 +132,8 @@ class Brightbox
           "hostname"        => String,
           "created_at"      => String,
           "started_at"      => Fog::Nullable::String,
-          "deleted_at"      => Fog::Nullable::String
+          "deleted_at"      => Fog::Nullable::String,
+          "username"        => Fog::Nullable::String
         }
 
         SERVER_GROUP = {
@@ -139,6 +141,7 @@ class Brightbox
           "resource_type"   => String,
           "url"             => String,
           "name"            => String,
+          "created_at"      => String,
           "default"         => Fog::Boolean,
           "description"     => Fog::Nullable::String
         }
@@ -237,7 +240,8 @@ class Brightbox
           "compatibility_mode" => Fog::Boolean,
           "virtual_size"    => Integer,
           "disk_size"       => Integer,
-          "ancestor"        => Fog::Brightbox::Nullable::Image
+          "ancestor"        => Fog::Brightbox::Nullable::Image,
+          "username"        => Fog::Nullable::String
         }
 
         LOAD_BALANCER = {
@@ -271,10 +275,12 @@ class Brightbox
           "server_groups"   => [Brightbox::Compute::Formats::Nested::SERVER_GROUP],
           "snapshots"       => [Brightbox::Compute::Formats::Nested::IMAGE],
           "interfaces"      => [Brightbox::Compute::Formats::Nested::INTERFACE],
-          "zone"            => Fog::Brightbox::Nullable::Zone
+          "zone"            => Fog::Brightbox::Nullable::Zone,
+          "username"        => Fog::Nullable::String
         }
 
         SERVER_GROUP = {
+          "created_at"      => String,
           "id"              => String,
           "resource_type"   => String,
           "url"             => String,
@@ -420,7 +426,8 @@ class Brightbox
           "compatibility_mode"   => Fog::Boolean,
           "virtual_size"    => Integer,
           "disk_size"       => Integer,
-          "ancestor"        => Fog::Brightbox::Nullable::Image
+          "ancestor"        => Fog::Brightbox::Nullable::Image,
+          "username"        => Fog::Nullable::String
         }
 
         INTERFACE = {
@@ -470,10 +477,12 @@ class Brightbox
           "snapshots"       => [Brightbox::Compute::Formats::Nested::IMAGE],
           "server_groups"   => [Brightbox::Compute::Formats::Nested::SERVER_GROUP],
           "interfaces"      => [Brightbox::Compute::Formats::Nested::INTERFACE],
-          "zone"            => Brightbox::Compute::Formats::Nested::ZONE
+          "zone"            => Brightbox::Compute::Formats::Nested::ZONE,
+          "username"        => Fog::Nullable::String
         }
 
         SERVER_GROUP = {
+          "created_at"      => String,
           "id"              => String,
           "resource_type"   => String,
           "url"             => String,

data/tests/core/attribute_tests.rb

@@ -1,6 +1,7 @@
 class FogAttributeTestModel < Fog::Model
   attribute :key, :aliases => 'keys', :squash => "id"
   attribute :time, :type => :time
+  attribute :bool, :type => :boolean
 end
 
 Shindo.tests('Fog::Attributes', 'core') do
@@ -51,4 +52,32 @@ Shindo.tests('Fog::Attributes', 'core') do
 
   end
 
+  tests(':type => :boolean') do
+    tests(':bool => "true"').returns(true) do
+      @model.merge_attributes(:bool => 'true')
+      @model.bool
+    end
+
+    tests(':bool => true').returns(true) do
+      @model.merge_attributes(:bool => true)
+      @model.bool
+    end
+    
+    tests(':bool => "false"').returns(false) do
+      @model.merge_attributes(:bool => 'false')
+      @model.bool
+    end
+
+    tests(':bool => false').returns(false) do
+      @model.merge_attributes(:bool => false)
+      @model.bool
+    end
+
+    tests(':bool => "foo"').returns(nil) do
+      @model.merge_attributes(:bool => "foo")
+      @model.bool
+    end
+  
+  end
+
 end

data/tests/core/mocking_tests.rb

@@ -0,0 +1,60 @@
+Shindo.tests('Fog mocking', 'core') do
+  before do
+    @fog_was_mocked = Fog.mock?
+    Fog.unmock! if @fog_was_mocked
+  end
+
+  after do
+    Fog.mock! if @fog_was_mocked
+  end
+
+  tests('Fog.mock!') do
+    tests('Fog.mock!').returns(true) do
+      Fog.mock!
+    end
+
+    tests('Fog.mock? without Fog.mock!').returns(false) do
+      Fog.mock?
+    end
+
+    tests('Fog.mock? with Fog.mock!').returns(true) do
+      Fog.mock!
+      Fog.mock?
+    end
+
+    tests('Fog.mocking? without Fog.mock!').returns(false) do
+      Fog.mocking?
+    end
+
+    tests('Fog.mocking? with Fog.mock!').returns(true) do
+      Fog.mock!
+      Fog.mocking?
+    end
+  end
+
+  tests('Fog::Mock.delay') do
+    tests('Fog::Mock.delay').returns(1, "defaults to 1") do
+      Fog::Mock.delay
+    end
+
+    tests('Fog::Mock.delay = 2').returns(2, "changes Fog::Mock.delay to 2") do
+      Fog::Mock.delay = 2
+      Fog::Mock.delay
+    end
+
+    tests('Fog::Mock.delay = 0').returns(0, "changes Fog::Mock.delay to 0") do
+      Fog::Mock.delay = 0
+      Fog::Mock.delay
+    end
+
+    tests('Fog::Mock.delay = -1').raises(ArgumentError) do
+      Fog::Mock.delay = -1
+    end
+  end
+
+  tests('Fog::Mock.not_implemented').raises(Fog::Errors::MockNotImplemented) do
+    Fog::Mock.not_implemented
+  end
+
+  
+end

data/tests/dns/models/record_tests.rb

@@ -3,17 +3,19 @@ for provider, config in dns_providers
   # FIXME: delay/timing breaks things :(
   next if [:dnsmadeeasy].include?(provider)
 
+  domain_name = uniq_id + '.com'
+
   Shindo.tests("Fog::DNS[:#{provider}] | record", [provider.to_s]) do
 
     record_attributes = {
-      :name   => 'www.fogrecordtests.com',
+      :name   => 'www.' + domain_name,
       :type   => 'A',
       :value  => '1.2.3.4'
     }.merge!(config[:record_attributes] || {})
 
     if !Fog.mocking? || config[:mocked]
       zone_attributes = {
-        :domain => 'fogrecordtests.com'
+        :domain => domain_name
       }.merge(config[:zone_attributes] || {})
 
       @zone = Fog::DNS[provider].zones.create(zone_attributes)

data/tests/dns/models/records_tests.rb

@@ -3,17 +3,19 @@ for provider, config in dns_providers
   # FIXME: delay/timing breaks things :(
   next if [:dnsmadeeasy].include?(provider)
 
+  domain_name = uniq_id + '.com'
+
   Shindo.tests("Fog::DNS[:#{provider}] | records", [provider.to_s]) do
 
     record_attributes = {
-      :name   => 'www.fogrecordstests.com',
+      :name   => 'www.' + domain_name,
       :type   => 'A',
       :value  => '1.2.3.4'
     }.merge!(config[:record_attributes] || {})
 
     if !Fog.mocking? || config[:mocked]
       zone_attributes = {
-        :domain => 'fogrecordstests.com'
+        :domain => domain_name
       }.merge(config[:zone_attributes] || {})
 
       @zone = Fog::DNS[provider].zones.create(zone_attributes)

data/tests/dns/models/zone_tests.rb

@@ -3,10 +3,12 @@ for provider, config in dns_providers
   # FIXME: delay/timing breaks things :(
   next if [:dnsmadeeasy].include?(provider)
 
+  domain_name = uniq_id + '.com'
+
   Shindo.tests("Fog::DNS[:#{provider}] | zone", [provider.to_s]) do
 
     zone_attributes = {
-      :domain => 'fogzonetests.com'
+      :domain => domain_name
     }.merge!(config[:zone_attributes] || {})
 
     model_tests(Fog::DNS[provider].zones, zone_attributes, config[:mocked])

data/tests/dns/models/zones_tests.rb

@@ -3,14 +3,16 @@ for provider, config in dns_providers
   # FIXME: delay/timing breaks things :(
   next if [:dnsmadeeasy].include?(provider)
 
+  domain_name = uniq_id + '.com'
+
   Shindo.tests("Fog::DNS[:#{provider}] | zones", [provider.to_s]) do
 
     zone_attributes = {
-      :domain => 'fogzonestests.com'
+      :domain => domain_name
     }.merge!(config[:zone_attributes] || {})
 
     collection_tests(Fog::DNS[provider].zones, zone_attributes, config[:mocked])
 
   end
 
-end
+end

data/tests/helper.rb

@@ -7,6 +7,10 @@ def lorem_file
   File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
 end
 
+def array_differences(array_a, array_b)
+  (array_a - array_b) | (array_b - array_a)
+end
+
 # check to see which credentials are available and add others to the skipped tags list
 all_providers = ['aws', 'bluebox', 'brightbox', 'dnsimple', 'dnsmadeeasy', 'dynect', 'ecloud', 'glesys', 'gogrid', 'google', 'linode', 'local', 'ninefold', 'newservers', 'openstack', 'rackspace', 'slicehost', 'stormondemand', 'voxel', 'zerigo']
 available_providers = Fog.available_providers.map {|provider| provider.downcase}

data/tests/rackspace/requests/dns/dns_tests.rb

@@ -1,9 +1,10 @@
 Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
 
   pending if Fog.mocking?
+  domain_name = uniq_id + '.com'
 
   tests('success on simple domain') do
-    domain_tests(Fog::DNS[:rackspace], {:name => 'basictestdomain.com', :email => 'hostmaster@basictestdomain.com', :records => [{:ttl => 300, :name => 'basictestdomain.com', :type => 'A', :data => '192.168.1.1'}]}) do
+    domain_tests(Fog::DNS[:rackspace], {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]}) do
 
       tests('list_domains').formats(LIST_DOMAIN_FORMAT.reject {|key,value| key == 'links'}) do
         Fog::DNS[:rackspace].list_domains.body
@@ -27,21 +28,21 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
   tests('success for domain with multiple records') do
     domain_tests(Fog::DNS[:rackspace],
       {
-        :name => 'testdomainwithmultiplerecords.com',
-        :email => 'hostmaster@testdomainwithmultiplerecords.com',
+        :name => domain_name,
+        :email => 'hostmaster@' + domain_name,
         :records =>
           [
             {
               :ttl => 300,
-              :name => 'testdomainwithmultiplerecords.com',
+              :name => domain_name,
               :type => 'A',
               :data => '192.168.1.1'
             },
             {
               :ttl => 3600,
-              :name => 'testdomainwithmultiplerecords.com',
+              :name => domain_name,
               :type => 'MX',
-              :data => 'mx.testdomainwithmultiplerecords.com',
+              :data => 'mx.' + domain_name,
               :priority => 10
             }
           ]
@@ -49,21 +50,24 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
   end
 
   tests('success for multiple domains') do
+    domain1_name = uniq_id + '-1.com'
+    domain2_name = uniq_id + '-2.com'
+
     domains_tests(Fog::DNS[:rackspace],
       [
-        {:name => 'basictestdomain1.com', :email => 'hostmaster@basictestdomain1.com', :records => [{:ttl => 300, :name =>'basictestdomain1.com', :type => 'A', :data => '192.168.1.1'}]},
-        {:name => 'basictestdomain2.com', :email => 'hostmaster@basictestdomain2.com', :records => [{:ttl => 300, :name =>'basictestdomain2.com', :type => 'A', :data => '192.168.1.1'}]}
+        {:name => domain1_name, :email => 'hostmaster@' + domain1_name, :records => [{:ttl => 300, :name => domain1_name, :type => 'A', :data => '192.168.1.1'}]},
+        {:name => domain2_name, :email => 'hostmaster@' + domain2_name, :records => [{:ttl => 300, :name => domain2_name, :type => 'A', :data => '192.168.1.1'}]}
       ])
   end
 
   tests('success for domain with subdomain') do
     domains_tests(Fog::DNS[:rackspace],
       [
-        {:name => 'basictestdomain.com', :email => 'hostmaster@basictestdomain.com', :records => [{:ttl => 300, :name =>'basictestdomain.com', :type => 'A', :data => '192.168.1.1'}]},
-        {:name => 'subdomain.basictestdomain.com', :email => 'hostmaster@subdomain.basictestdomain.com', :records => [{:ttl => 300, :name =>'subdomain.basictestdomain.com', :type => 'A', :data => '192.168.1.1'}]}
+        {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]},
+        {:name => 'subdomain.' + domain_name, :email => 'hostmaster@subdomain.' + domain_name, :records => [{:ttl => 300, :name =>'subdomain.' + domain_name, :type => 'A', :data => '192.168.1.1'}]}
       ], true) do
 
-      @root_domain_id = @domain_details.find { |domain| domain['name'] == 'basictestdomain.com' }['id']
+      @root_domain_id = @domain_details.find { |domain| domain['name'] == domain_name }['id']
 
       tests("list_domain_details('#{@root_domain_id}', :show_records => false, :show_subdomains => false)") do
         response = Fog::DNS[:rackspace].list_domain_details(@root_domain_id, :show_records => false, :show_subdomains => false)
@@ -89,7 +93,7 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
         wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_domain(@root_domain_id, :delete_subdomains => true)
 
         test('domain and subdomains were really deleted') do
-          (Fog::DNS[:rackspace].list_domains.body['domains'].collect { |domain| domain['name'] } & ['basictestdomain.com', 'subdomain.basictestdomain.com']).empty?
+          (Fog::DNS[:rackspace].list_domains.body['domains'].collect { |domain| domain['name'] } & [domain_name, 'subdomain.' + domain_name]).empty?
         end
       end
     end

data/tests/rackspace/requests/dns/records_tests.rb

@@ -2,7 +2,9 @@ Shindo.tests('Fog::DNS[:rackspace] | dns records requests', ['rackspace', 'dns']
 
   pending if Fog.mocking?
 
-  domain_tests(Fog::DNS[:rackspace], {:name => 'basictestdomain.com', :email => 'hostmaster@basictestdomain.com', :records => [{:ttl => 300, :name => 'basictestdomain.com', :type => 'A', :data => '192.168.1.1'}]}) do
+  domain_name = uniq_id + '.com'
+
+  domain_tests(Fog::DNS[:rackspace], {:name => domain_name, :email => 'hostmaster@' + domain_name, :records => [{:ttl => 300, :name => domain_name, :type => 'A', :data => '192.168.1.1'}]}) do
 
     tests('success on single record') do
 
@@ -10,18 +12,18 @@ Shindo.tests('Fog::DNS[:rackspace] | dns records requests', ['rackspace', 'dns']
         Fog::DNS[:rackspace].list_records(@domain_id).body
       end
 
-      tests("add_records(#{@domain_id}, [{ :name => 'test1.basictestdomain.com', :type => 'A', :data => '192.168.2.1'}])").formats(RECORD_LIST_FORMAT) do
-        response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => 'test1.basictestdomain.com', :type => 'A', :data => '192.168.2.1'}])
-        @record_id = response.body['records'].first['id']
-        response.body
+      tests("add_records(#{@domain_id}, [{ :name => 'test1.#{domain_name}', :type => 'A', :data => '192.168.2.1'}])").formats(RECORD_LIST_FORMAT) do
+        response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => 'test1.' + domain_name, :type => 'A', :data => '192.168.2.1'}])
+        @record_id = response.body['response']['records'].first['id']
+        response.body['response']
       end
 
       tests("list_record_details(#{@domain_id}, #{@record_id})").formats(RECORD_FORMAT) do
         Fog::DNS[:rackspace].list_record_details(@domain_id, @record_id).body
       end
 
-      tests("modify_record(#{@domain_id}, #{@record_id}, { :ttl => 500, :name => 'test2.basictestdomain.com', :data => '192.168.3.1' })").succeeds do
-        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].modify_record(@domain_id, @record_id, { :ttl => 500, :name => 'test2.basictestdomain.com', :data => '192.168.3.1' })
+      tests("modify_record(#{@domain_id}, #{@record_id}, { :ttl => 500, :name => 'test2.#{domain_name}', :data => '192.168.3.1' })").succeeds do
+        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].modify_record(@domain_id, @record_id, { :ttl => 500, :name => 'test2.' + domain_name, :data => '192.168.3.1' })
       end
 
       tests("remove_record(#{@domain_id}, #{@record_id})").succeeds do
@@ -33,14 +35,14 @@ Shindo.tests('Fog::DNS[:rackspace] | dns records requests', ['rackspace', 'dns']
 
       records_attributes =
         [
-          { :name => 'test1.basictestdomain.com', :type => 'A', :data => '192.168.2.1'},
-          { :name => 'basictestdomain.com', :type => 'MX', :priority => 10, :data => 'mx.basictestdomain.com'}
+          { :name => 'test1.' + domain_name, :type => 'A', :data => '192.168.2.1'},
+          { :name => domain_name, :type => 'MX', :priority => 10, :data => 'mx.' + domain_name}
         ]
 
       tests("add_records(#{@domain_id}, #{records_attributes})").formats(RECORD_LIST_FORMAT) do
         response = wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].add_records(@domain_id, records_attributes)
-        @record_ids = response.body['records'].collect { |record| record['id'] }
-        response.body
+        @record_ids = response.body['response']['records'].collect { |record| record['id'] }
+        response.body['response']
       end
 
       tests("remove_records(#{@domain_id}, #{@record_ids})").succeeds do

data/tests/slicehost/requests/dns/dns_tests.rb

@@ -183,11 +183,11 @@ Shindo.tests('Fog::DNS[:slicehost] | DNS requests', ['slicehost', 'dns']) do
       response = Fog::DNS[:slicehost].get_record(@record_id)
       if response.status == 200
         mail_domain = 'mail.' + @domain
-        record = response.body['records'][0]
-        if (record['record-type'] == 'MX') and (record['name'] == @domain) and
-          (record['data'] == mail_domain) and (record['ttl'] == 3600) and (record['active'] == 'N') and
+        record = response.body
+        if (record['record_type'] == 'MX') and (record['name'] == @domain) and
+          (record['value'] == mail_domain) and (record['ttl'] == 3600) and (record['active'] == 'N') and
           (record['aux'] == "10")
-          result= true
+          result = true
         end
       end
               
@@ -197,7 +197,7 @@ Shindo.tests('Fog::DNS[:slicehost] | DNS requests', ['slicehost', 'dns']) do
     test('get records - verify all parameters for one record') do
       pending if Fog.mocking?
 
-      result= false
+      result = false
       
       response = Fog::DNS[:slicehost].get_records()
       if response.status == 200
@@ -205,22 +205,69 @@ Shindo.tests('Fog::DNS[:slicehost] | DNS requests', ['slicehost', 'dns']) do
         
         #find mx record
         records.each {|record|
-          if record['record-type'] == 'MX'
+          if (record['record_type'] == 'MX') and (record['name'] == @domain)
 
             mail_domain = 'mail.' + @domain
-            if (record['record-type'] == 'MX') and (record['name'] == @domain) and
-              (record['data'] == mail_domain) and (record['ttl'] == 3600) and (record['active'] == 'N') and
+            if (record['record_type'] == 'MX') and (record['name'] == @domain) and
+              (record['value'] == mail_domain) and (record['ttl'] == 3600) and (record['active'] == 'N') and
               (record['aux'] == "10")
-              result= true
-              break
+              result = true
             end
-
+            break
           end
         }
       end
               
       result
     end
+
+    test('update record - verify all parameters for one record') do
+      pending if Fog.mocking?
+
+      result = false
+
+      specific_record = nil
+
+      response = Fog::DNS[:slicehost].get_records()
+      if response.status == 200
+        records = response.body['records']
+
+        #find mx record
+        records.each {|record|
+          if (record['record_type'] == 'MX') and (record['name'] == @domain)
+            specific_record = record
+            break
+          end
+        }
+      end
+
+      if (specific_record)  #Try to change the TTL for this MX record if we've successfully created it.
+        response = Fog::DNS[:slicehost].update_record(specific_record['id'], specific_record['record_type'], specific_record['zone_id'],
+                                          specific_record['name'], specific_record['value'], {:ttl => 7200, :active => "N", :aux => "10"})
+
+        mail_domain = 'mail.' + @domain
+
+        record = Fog::DNS[:slicehost].get_record(specific_record['id']).body
+
+        if (record['record_type'] == 'MX') and (record['name'] == @domain) and
+              (record['value'] == mail_domain) and (record['ttl'] == 7200) and (record['active'] == 'N') and
+              (record['aux'] == "10")
+              result = true
+        end
+
+      end
+
+      result
+    end
+
+    test("newly created zone returns only records which we added to it, not other records already in account") do
+      pending if Fog.mocking?
+
+      @new_zone = Fog::DNS[:slicehost].zones.get(@zone_id)
+      
+      records = @new_zone.records
+      records.length == @new_records.length
+    end
     
     test("delete #{@new_records.count} records created") do
       pending if Fog.mocking?