brightbox-cli 0.16.0 → 0.17.0

data/lib/brightbox-cli/vendor/fog/tests/brightbox/requests/compute/server_tests.rb

@@ -2,58 +2,75 @@ Shindo.tests('Fog::Compute[:brightbox] | server requests', ['brightbox']) do
 
   tests('success') do
 
-    image_id = Brightbox::Compute::TestSupport::IMAGE_IDENTIFER
+    image_id = Brightbox::Compute::TestSupport.image_id
     server_id = nil
 
-    tests("#create_server(:image => '#{image_id}')").formats(Brightbox::Compute::Formats::Full::SERVER) do
+    tests("#create_server(:image => '#{image_id}')") do
       pending if Fog.mocking?
-      data = Fog::Compute[:brightbox].create_server(:image => image_id)
-      server_id = data["id"]
-      data
+      result = Fog::Compute[:brightbox].create_server(:image => image_id)
+      server_id = result["id"]
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
     end
 
     unless Fog.mocking?
       Fog::Compute[:brightbox].servers.get(server_id).wait_for { ready? }
     end
 
-    tests("#list_servers").formats(Brightbox::Compute::Formats::Collection::SERVERS) do
+    tests("#list_servers") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].list_servers
+      result = Fog::Compute[:brightbox].list_servers
+      formats(Brightbox::Compute::Formats::Collection::SERVERS) { result }
     end
 
-    tests("#get_server('#{server_id}')").formats(Brightbox::Compute::Formats::Full::SERVER) do
+    tests("#get_server('#{server_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].get_server(server_id)
+      result = Fog::Compute[:brightbox].get_server(server_id)
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
     end
 
-    tests("#update_server('#{server_id}')").formats(Brightbox::Compute::Formats::Full::SERVER) do
+    tests("#update_server('#{server_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].update_server(server_id, :name => "Fog@#{Time.now.iso8601}")
+      result = Fog::Compute[:brightbox].update_server(server_id, :name => "Fog@#{Time.now.iso8601}")
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
     end
 
-    tests("#activate_console_server('#{server_id}')").formats(Brightbox::Compute::Formats::Full::SERVER) do
+    tests("#activate_console_server('#{server_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].activate_console_server(server_id)
+      result = Fog::Compute[:brightbox].activate_console_server(server_id)
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
     end
 
-    tests("#stop_server('#{server_id}')").formats(Brightbox::Compute::Formats::Full::SERVER) do
+    tests("#stop_server('#{server_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].stop_server(server_id)
+      result = Fog::Compute[:brightbox].stop_server(server_id)
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
     end
 
-    tests("#start_server('#{server_id}')").formats(Brightbox::Compute::Formats::Full::SERVER) do
+    tests("#start_server('#{server_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].start_server(server_id)
+      result = Fog::Compute[:brightbox].start_server(server_id)
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
     end
 
-    tests("#shutdown_server('#{server_id}')").formats(Brightbox::Compute::Formats::Full::SERVER) do
+    tests("#shutdown_server('#{server_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].shutdown_server(server_id)
+      result = Fog::Compute[:brightbox].shutdown_server(server_id)
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
     end
 
-    tests("#destroy_server('#{server_id}')").formats(Brightbox::Compute::Formats::Full::SERVER) do
+    tests("#snapshot_server('#{server_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].destroy_server(server_id)
+      result = Fog::Compute[:brightbox].snapshot_server(server_id)
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
+      snapshot_id = result["id"]
+      @snapshot = Fog::Compute[:brightbox].images.get(snapshot_id)
+      @snapshot.destroy
+    end
+
+    tests("#destroy_server('#{server_id}')") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].destroy_server(server_id)
+      formats(Brightbox::Compute::Formats::Full::SERVER) { result }
     end
 
   end

data/lib/brightbox-cli/vendor/fog/tests/brightbox/requests/compute/server_type_tests.rb

@@ -2,16 +2,17 @@ Shindo.tests('Fog::Compute[:brightbox] | server type requests', ['brightbox']) d
 
   tests('success') do
 
-    tests("#list_server_types").formats(Brightbox::Compute::Formats::Collection::SERVER_TYPES) do
+    tests("#list_server_types") do
       pending if Fog.mocking?
-      data = Fog::Compute[:brightbox].list_server_types
-      @server_type_id = data.first["id"]
-      data
+      result = Fog::Compute[:brightbox].list_server_types
+      @server_type_id = result.first["id"]
+      formats(Brightbox::Compute::Formats::Collection::SERVER_TYPES) { result }
     end
 
-    tests("#get_server_type('#{@server_type_id}')").formats(Brightbox::Compute::Formats::Full::SERVER_TYPE) do
+    tests("#get_server_type('#{@server_type_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].get_server_type(@server_type_id)
+      result = Fog::Compute[:brightbox].get_server_type(@server_type_id)
+      formats(Brightbox::Compute::Formats::Full::SERVER_TYPE) { result }
     end
 
   end

data/lib/brightbox-cli/vendor/fog/tests/brightbox/requests/compute/user_tests.rb

@@ -2,29 +2,24 @@ Shindo.tests('Fog::Compute[:brightbox] | user requests', ['brightbox']) do
 
   tests('success') do
 
-    tests("#list_users").formats(Brightbox::Compute::Formats::Collection::USERS) do
+    tests("#list_users") do
       pending if Fog.mocking?
-      data = Fog::Compute[:brightbox].list_users
-      @user_id = data.first["id"]
-      data
+      result = Fog::Compute[:brightbox].list_users
+      @user_id = result.first["id"]
+      formats(Brightbox::Compute::Formats::Collection::USERS) { result }
     end
 
-    tests("#get_user('#{@user_id}')").formats(Brightbox::Compute::Formats::Full::USER) do
+    tests("#get_user('#{@user_id}')") do
       pending if Fog.mocking?
-      data = Fog::Compute[:brightbox].get_user(@user_id)
-      @original_name = data["name"]
-      data
+      result = Fog::Compute[:brightbox].get_user(@user_id)
+      formats(Brightbox::Compute::Formats::Full::USER) { result }
     end
 
-    update_options = { :name => "Fog@#{Time.now.iso8601}" }
-
-    tests("#update_user('#{@user_id}', #{update_options.inspect})").formats(Brightbox::Compute::Formats::Full::USER) do
+    update_options = { :name => "Example User" }
+    tests("#update_user('#{@user_id}', #{update_options.inspect})") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].update_user(@user_id, update_options)
-    end
-
-    unless Fog.mocking?
-      Fog::Compute[:brightbox].update_user(@user_id, :name => @original_name)
+      result = Fog::Compute[:brightbox].update_user(@user_id, update_options)
+      formats(Brightbox::Compute::Formats::Full::USER) { result }
     end
 
   end

data/lib/brightbox-cli/vendor/fog/tests/brightbox/requests/compute/zone_tests.rb

@@ -2,16 +2,17 @@ Shindo.tests('Fog::Compute[:brightbox] | zone requests', ['brightbox']) do
 
   tests('success') do
 
-    tests("#list_zones").formats(Brightbox::Compute::Formats::Collection::ZONES) do
+    tests("#list_zones") do
       pending if Fog.mocking?
-      data = Fog::Compute[:brightbox].list_zones
-      @zone_id = data.first["id"]
-      data
+      result = Fog::Compute[:brightbox].list_zones
+      @zone_id = result.first["id"]
+      formats(Brightbox::Compute::Formats::Collection::ZONES) { result }
     end
 
-    tests("#get_zone('#{@zone_id}')").formats(Brightbox::Compute::Formats::Full::ZONE) do
+    tests("#get_zone('#{@zone_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].get_zone(@zone_id)
+      result = Fog::Compute[:brightbox].get_zone(@zone_id)
+      formats(Brightbox::Compute::Formats::Full::ZONE) { result }
     end
 
   end

data/lib/brightbox-cli/vendor/fog/tests/compute/helper.rb

@@ -13,7 +13,7 @@ def compute_providers
     },
     :brightbox  => {
       :server_attributes => {
-        :image_id => 'img-2ab98' # Ubuntu Lucid 10.04 server (i686)
+        :image_id => 'img-4gqhs' # Ubuntu Lucid 10.04 server (i686)
       },
       :mocked => false
     },

data/lib/brightbox-cli/vendor/fog/tests/core/credential_tests.rb

@@ -18,12 +18,12 @@ Shindo.tests do
   tests('credential') do
     returns(:default, "is :default") { Fog.credential }
 
-    returns("foo", "can be set directly") do
+    returns(:foo, "can be set directly") do
       Fog.credential = "foo"
       Fog.credential
     end
 
-    returns("bar", "can be set with environment variable") do
+    returns(:bar, "can be set with environment variable") do
       ENV["FOG_CREDENTIAL"] = "bar"
       Fog.credential
     end

data/lib/brightbox-cli/vendor/fog/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/lib/brightbox-cli/vendor/fog/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/lib/brightbox-cli/vendor/fog/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/lib/brightbox-cli/vendor/fog/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/lib/brightbox-cli/vendor/fog/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/lib/brightbox-cli/vendor/fog/tests/glesys/requests/compute/helper.rb

@@ -7,7 +7,9 @@ class Glesys
           'arguments' => [],
           'servers' => [{
             'serverid' => String,
-            'hostname' => String
+            'hostname' => String,
+            'datacenter' => String,
+            'platform' => String,
           }],
           'status' => {
             'code' => String,
@@ -144,6 +146,7 @@ class Glesys
             'platform' => String,
             'ip'       => String,
             'version'  => String,
+            'PTR'      => String,
           }],
           'status' => {
             'code' => String,
@@ -172,7 +175,6 @@ class Glesys
         IPLIST_CATCH_RELEASE = {
           'arguments' => {
             'ipaddress' => String, 
-            'ipversion'=> String,
           }, 
           'status' => {
             'code' => String, 

data/lib/brightbox-cli/vendor/fog/tests/glesys/requests/compute/server_tests.rb

@@ -1,7 +1,7 @@
 Shindo.tests('Fog::Compute[:glesys] | server requests', ['glesys']) do
     
     @serverid = nil
-    @hostname = "fog.#{Time.now.to_i}"
+    @hostname = "fog-#{Time.now.to_i}"
 
     @create = ":hostname => #@hostname, :rootpw => 'pw#{Time.now.to_i}', "+
     ":datacenter => 'Falkenberg', :platform => 'Xen', :template => 'Debian-6 x64', "+

data/lib/brightbox-cli/vendor/fog/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/lib/brightbox-cli/vendor/fog/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/lib/brightbox-cli/vendor/fog/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/lib/brightbox-cli/vendor/fog/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?