brightbox-cli 0.14.1 → 0.15.0

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

@@ -0,0 +1,142 @@
+Shindo.tests('Fog::Compute[:openstack] | server requests', ['openstack']) do
+
+  @server_format = {
+    'id'         => String,
+    'addresses'  => Hash,
+    'flavor'     => Hash,
+    'hostId'     => String,
+    'image'      => Hash,
+    'metadata'   => Hash,
+    'name'       => String,
+    'progress'   => Integer,
+    'status'     => String,
+    'accessIPv4' => Fog::Nullable::String,
+    'accessIPv6' => Fog::Nullable::String,
+    'links' => Array
+  }
+
+  @image_format = {
+    'created'   => Fog::Nullable::String,
+    'id'        => String,
+    'name'      => String,
+    'progress'  => Fog::Nullable::Integer,
+    'status'    => String,
+    'updated'   => String,
+    'minRam'    => Integer,
+    'minDisk'   => Integer,
+    'server'    => Hash,
+    'metadata'  => Hash,
+    'links'     => Array
+  }
+
+  tests('success') do
+
+    @image_id = Fog::Compute[:openstack].images[0].id
+    @snapshot_id = nil
+    @flavor_id = 2
+
+    tests('#create_server("test", #{@image_id} , 19)').formats(@server_format.merge('adminPass' => String), false) do
+      data = Fog::Compute[:openstack].create_server("test", @image_id, @flavor_id).body['server']
+      @server_id = data['id']
+      data
+    end
+
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? }
+
+    #CREATE
+    tests("#get_server_details(#{@server_id})").formats(@server_format, false) do
+      Fog::Compute[:openstack].get_server_details(@server_id).body['server']
+    end
+
+    #LIST
+    #NOTE: we can remove strict=false if we remove uuid from GET /servers
+    tests('#list_servers').formats({'servers' => [OpenStack::Compute::Formats::SUMMARY]}, false) do
+      Fog::Compute[:openstack].list_servers.body
+    end
+
+    #DETAILS
+    tests('#list_servers_detail').formats({'servers' => [@server_format]}, false) do
+      Fog::Compute[:openstack].list_servers_detail.body
+    end
+
+    #CHANGE PASSWORD
+    tests("#change_password_server(#{@server_id}, 'fogupdatedserver')").succeeds do
+      Fog::Compute[:openstack].change_password_server(@server_id, 'foggy')
+    end
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? }
+
+    #UPDATE SERVER NAME
+    tests("#update_server(#{@server_id}, :name => 'fogupdatedserver')").succeeds do
+      Fog::Compute[:openstack].update_server(@server_id, :name => 'fogupdatedserver')
+    end
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? }
+
+    #CREATE IMAGE WITH METADATA
+    tests("#create_image(#{@server_id}, 'fog')").formats('image' => @image_format) do
+      data = Fog::Compute[:openstack].create_image(@server_id, 'fog', {"foo" => "bar"}).body
+      @snapshot_id = data['image']['id']
+      data
+    end
+    Fog::Compute[:openstack].images.get(@snapshot_id).wait_for { ready? }
+
+    #REBUILD
+    tests("#rebuild_server(#{@server_id}, #{@snapshot_id}, 'fog')").formats({'server' => @server_format}, false) do
+      Fog::Compute[:openstack].rebuild_server(@server_id, @snapshot_id, 'fog', 'newpass', {"foo" => "bar"}).body
+    end
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? } if not Fog.mocking?
+
+    #RESIZE
+    tests("#resize_server(#{@server_id}, '3')").succeeds do
+      Fog::Compute[:openstack].resize_server(@server_id, 3)
+    end
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { self.state == 'VERIFY_RESIZE' } if not Fog.mocking?
+
+    #RESIZE CONFIRM
+    tests("#resize_confirm(#{@server_id}, '3')").succeeds do
+      Fog::Compute[:openstack].confirm_resized_server(@server_id)
+    end
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? } if not Fog.mocking?
+
+    #REBOOT - HARD
+    tests("#reboot_server(#{@server_id}, 'HARD')").succeeds do
+      Fog::Compute[:openstack].reboot_server(@server_id, 'HARD')
+    end
+
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? } if not Fog.mocking?
+
+    #REBOOT - SOFT
+    tests("#reboot_server(#{@server_id}, 'SOFT')").succeeds do
+      Fog::Compute[:openstack].reboot_server(@server_id, 'SOFT')
+    end
+
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? } if not Fog.mocking?
+
+    #DELETE
+    tests("#delete_server(#{@server_id})").succeeds do
+      Fog::Compute[:openstack].delete_server(@server_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#delete_server(0)').raises(Fog::Compute::OpenStack::NotFound) do
+      Fog::Compute[:openstack].delete_server(0)
+    end
+
+    tests('#get_server_details(0)').raises(Fog::Compute::OpenStack::NotFound) do
+      Fog::Compute[:openstack].get_server_details(0)
+    end
+
+    tests("#update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')").raises(Fog::Compute::OpenStack::NotFound) do
+      Fog::Compute[:openstack].update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')
+    end
+
+    tests('#reboot_server(0)').raises(Fog::Compute::OpenStack::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:openstack].reboot_server(0)
+    end
+
+  end
+
+end

data/lib/brightbox-cli/vendor/fog/tests/rackspace/requests/dns/dns_tests.rb

@@ -1,31 +1,31 @@
 Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
 
-  @service = Fog::DNS[:rackspace]
+  pending if Fog.mocking?
 
   tests('success on simple domain') do
-    domain_tests(@service, {: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 => 'basictestdomain.com', :email => 'hostmaster@basictestdomain.com', :records => [{:ttl => 300, :name => 'basictestdomain.com', :type => 'A', :data => '192.168.1.1'}]}) do
 
-      tests('list_domains').formats(LIST_DOMAIN_FORMAT) do
-        @service.list_domains.body
+      tests('list_domains').formats(LIST_DOMAIN_FORMAT.reject {|key,value| key == 'links'}) do
+        Fog::DNS[:rackspace].list_domains.body
       end
 
       tests("list_domains :limit => 5, :offset => 10, :domain => #{@domain_details.first['name']} --> All possible attributes").formats(LIST_DOMAIN_FORMAT) do
-        @service.list_domains(:limit => 5, :offset => 10, :domain => @domain_details.first['name']).body
+        Fog::DNS[:rackspace].list_domains(:limit => 5, :offset => 10, :domain => @domain_details.first['name']).body
       end
 
       tests("list_domain_details('#{@domain_id}')").formats(LIST_DOMAIN_DETAILS_WITH_RECORDS) do
-        @service.list_domain_details(@domain_id).body
+        Fog::DNS[:rackspace].list_domain_details(@domain_id).body
       end
 
       tests("modify_domain('#{@domain_id}', :ttl => 500, :comment => 'woot', :email => 'randomemail@randomhost.com')").succeeds do
-        response = @service.modify_domain @domain_id, :ttl => 500, :comment => 'woot', :email => 'randomemail@randomhost.com'
-        wait_for @service, response
+        response = Fog::DNS[:rackspace].modify_domain @domain_id, :ttl => 500, :comment => 'woot', :email => 'randomemail@randomhost.com'
+        wait_for Fog::DNS[:rackspace], response
       end
     end
   end
 
   tests('success for domain with multiple records') do
-    domain_tests(@service,
+    domain_tests(Fog::DNS[:rackspace],
       {
         :name => 'testdomainwithmultiplerecords.com',
         :email => 'hostmaster@testdomainwithmultiplerecords.com',
@@ -49,7 +49,7 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
   end
 
   tests('success for multiple domains') do
-    domains_tests(@service,
+    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'}]}
@@ -57,7 +57,7 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
   end
 
   tests('success for domain with subdomain') do
-    domains_tests(@service,
+    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'}]}
@@ -66,7 +66,7 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
       @root_domain_id = @domain_details.find { |domain| domain['name'] == 'basictestdomain.com' }['id']
 
       tests("list_domain_details('#{@root_domain_id}', :show_records => false, :show_subdomains => false)") do
-        response = @service.list_domain_details(@root_domain_id, :show_records => false, :show_subdomains => false)
+        response = Fog::DNS[:rackspace].list_domain_details(@root_domain_id, :show_records => false, :show_subdomains => false)
 
         formats(LIST_DOMAIN_DETAILS_WITHOUT_RECORDS_AND_SUBDOMAINS_FORMAT) { response.body }
         returns(nil) { response.body['recordsList'] }
@@ -74,7 +74,7 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
       end
 
       tests("list_domain_details('#{@root_domain_id}', :show_records => true, :show_subdomains => true)") do
-        response = @service.list_domain_details(@root_domain_id, :show_records => true, :show_subdomains => true)
+        response = Fog::DNS[:rackspace].list_domain_details(@root_domain_id, :show_records => true, :show_subdomains => true)
 
         formats(LIST_DOMAIN_DETAILS_WITH_RECORDS_AND_SUBDOMAINS_FORMAT) { response.body }
         returns(false) { response.body['recordsList'].nil? }
@@ -82,14 +82,14 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
       end
 
       tests("list_subdomains('#{@root_domain_id}')").formats(LIST_SUBDOMAINS_FORMAT) do
-        @service.list_subdomains(@root_domain_id).body
+        Fog::DNS[:rackspace].list_subdomains(@root_domain_id).body
       end
 
       tests("remove_domain('#{@root_domain_id}', :delete_subdomains => true)") do
-        wait_for @service, @service.remove_domain(@root_domain_id, :delete_subdomains => true)
+        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_domain(@root_domain_id, :delete_subdomains => true)
 
         test('domain and subdomains were really deleted') do
-          (@service.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'] } & ['basictestdomain.com', 'subdomain.basictestdomain.com']).empty?
         end
       end
     end
@@ -98,22 +98,22 @@ Shindo.tests('Fog::DNS[:rackspace] | DNS requests', ['rackspace', 'dns']) do
   tests( 'failure') do
 
     tests('create_domain(invalid)').raises(Fog::Rackspace::Errors::BadRequest) do
-      wait_for @service, @service.create_domains([{:name => 'badtestdomain.com', :email => '', :records => [{:ttl => 300, :name => 'badtestdomain.com', :type => 'A', :data => '192.168.1.1'}]}])
+      wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].create_domains([{:name => 'badtestdomain.com', :email => '', :records => [{:ttl => 300, :name => 'badtestdomain.com', :type => 'A', :data => '192.168.1.1'}]}])
     end
 
     tests('list_domains :limit => 5, :offset => 8').raises(Fog::Rackspace::Errors::BadRequest) do
-      @service.list_domains :limit => 5, :offset => 8
+      Fog::DNS[:rackspace].list_domains :limit => 5, :offset => 8
     end
 
     tests('list_domain_details 34335353').raises(Fog::Rackspace::Errors::NotFound) do
-      @service.list_domain_details 34335353
+      Fog::DNS[:rackspace].list_domain_details 34335353
     end
 
     #tests('create_domains(#{domains})').raises(Fog::Rackspace::Errors::Conflict) do
-    #  wait_for @service.create_domains(domains)
+    #  wait_for Fog::DNS[:rackspace].create_domains(domains)
     #end
     #tests('remove_domain(34343435)').raises(Fog::DNS::Rackspace::DeleteFault) do
-    #  @service.remove_domain 34343435
+    #  Fog::DNS[:rackspace].remove_domain 34343435
     #end
   end
 end

data/lib/brightbox-cli/vendor/fog/tests/rackspace/requests/dns/helper.rb

@@ -66,8 +66,16 @@ LIST_DOMAIN_DETAILS_WITH_RECORDS = BASIC_DOMAIN_DETAIL_FORMAT.merge({
 })
 
 LIST_DOMAIN_DETAILS_WITH_RECORDS_AND_SUBDOMAINS_FORMAT = BASIC_DOMAIN_DETAIL_FORMAT.merge({
-  'recordsList' => RECORD_LIST_FORMAT,
-  'subdomains' => [SUBDOMAIN_FORMAT]
+  'recordsList'     => RECORD_LIST_FORMAT,
+  'subdomains'      => {
+    'domains'   => [{
+      'created' => String,
+      'name'    => String,
+      'id'      => Integer,
+      'updated' => String
+    }],
+    'totalEntries'  => Integer
+  }
 })
 
 LIST_DOMAIN_DETAILS_WITHOUT_RECORDS_AND_SUBDOMAINS_FORMAT = BASIC_DOMAIN_DETAIL_FORMAT
@@ -82,19 +90,19 @@ CREATE_DOMAINS_FORMAT = {
 
 def wait_for(service, response)
   job_id = response.body['jobId']
-  while true
+  Fog.wait_for do
     response = service.callback(job_id)
-    return response if response.status != 202
-    sleep 5
+    response.body['status'] != 'RUNNING'
   end
+  response
 end
 
 def domain_tests(service, domain_attributes)
   tests("create_domains([#{domain_attributes}])").formats(CREATE_DOMAINS_FORMAT) do
     response = wait_for service, service.create_domains([domain_attributes])
-    @domain_details = response.body['domains']
+    @domain_details = response.body['response']['domains']
     @domain_id = @domain_details[0]['id']
-    response.body
+    response.body['response']
   end
 
   begin
@@ -111,9 +119,9 @@ end
 def domains_tests(service, domains_attributes, custom_delete = false)
   tests("create_domains(#{domains_attributes})").formats(CREATE_DOMAINS_FORMAT) do
     response = wait_for service, service.create_domains(domains_attributes)
-    @domain_details = response.body['domains']
+    @domain_details = response.body['response']['domains']
     @domain_ids = @domain_details.collect { |domain| domain['id'] }
-    response.body
+    response.body['response']
   end
 
   begin

data/lib/brightbox-cli/vendor/fog/tests/rackspace/requests/dns/records_tests.rb

@@ -1,31 +1,31 @@
 Shindo.tests('Fog::DNS[:rackspace] | dns records requests', ['rackspace', 'dns']) do
 
-  @service = Fog::DNS[:rackspace]
+  pending if Fog.mocking?
 
-  domain_tests(@service, {: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 => 'basictestdomain.com', :email => 'hostmaster@basictestdomain.com', :records => [{:ttl => 300, :name => 'basictestdomain.com', :type => 'A', :data => '192.168.1.1'}]}) do
 
     tests('success on single record') do
 
       tests("list_records(#{@domain_id})").formats(RECORD_LIST_FORMAT) do
-        @service.list_records(@domain_id).body
+        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 @service, @service.add_records(@domain_id, [{ :name => 'test1.basictestdomain.com', :type => 'A', :data => '192.168.2.1'}])
+        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
       end
 
       tests("list_record_details(#{@domain_id}, #{@record_id})").formats(RECORD_FORMAT) do
-        @service.list_record_details(@domain_id, @record_id).body
+        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 @service, @service.modify_record(@domain_id, @record_id, { :ttl => 500, :name => 'test2.basictestdomain.com', :data => '192.168.3.1' })
+        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' })
       end
 
       tests("remove_record(#{@domain_id}, #{@record_id})").succeeds do
-        wait_for @service, @service.remove_record(@domain_id, @record_id)
+        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_record(@domain_id, @record_id)
       end
     end
 
@@ -38,43 +38,43 @@ Shindo.tests('Fog::DNS[:rackspace] | dns records requests', ['rackspace', 'dns']
         ]
 
       tests("add_records(#{@domain_id}, #{records_attributes})").formats(RECORD_LIST_FORMAT) do
-        response = wait_for @service, @service.add_records(@domain_id, records_attributes)
+        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
       end
 
       tests("remove_records(#{@domain_id}, #{@record_ids})").succeeds do
-        wait_for @service, @service.remove_records(@domain_id, @record_ids)
+        wait_for Fog::DNS[:rackspace], Fog::DNS[:rackspace].remove_records(@domain_id, @record_ids)
       end
     end
 
     tests( 'failure') do
       tests("list_records('')").raises(ArgumentError) do
-        @service.list_records('')
+        Fog::DNS[:rackspace].list_records('')
       end
 
       tests("list_records('abc')").raises(Fog::Rackspace::Errors::NotFound) do
-        @service.list_records('abc')
+        Fog::DNS[:rackspace].list_records('abc')
       end
 
       tests("list_record_details(#{@domain_id}, '')").raises(ArgumentError) do
-        @service.list_record_details(@domain_id, '')
+        Fog::DNS[:rackspace].list_record_details(@domain_id, '')
       end
 
       tests("list_record_details(#{@domain_id}, 'abc')").raises(Fog::Rackspace::Errors::NotFound) do
-        @service.list_record_details(@domain_id, 'abc')
+        Fog::DNS[:rackspace].list_record_details(@domain_id, 'abc')
       end
 
       tests("remove_record(#{@domain_id}, '')").raises(ArgumentError) do
-        @service.remove_record(@domain_id, '')
+        Fog::DNS[:rackspace].remove_record(@domain_id, '')
       end
 
       tests("remove_record(#{@domain_id}, 'abc')").raises(Fog::Rackspace::Errors::NotFound) do
-        @service.remove_record(@domain_id, 'abc')
+        Fog::DNS[:rackspace].remove_record(@domain_id, 'abc')
       end
 
       tests("add_record(#{@domain_id}, [{ :name => '', :type => '', :data => ''}])").raises(Fog::Rackspace::Errors::BadRequest) do
-        @service.add_records(@domain_id, [{ :name => '', :type => '', :data => ''}])
+        Fog::DNS[:rackspace].add_records(@domain_id, [{ :name => '', :type => '', :data => ''}])
       end
     end
   end

data/lib/brightbox-cli/vendor/fog/tests/rackspace/requests/{helper.rb → load_balancers/helper.rb}

@@ -14,7 +14,8 @@ LOAD_BALANCER_USAGE_FORMAT = {
       'numVips' => Fog::Nullable::Integer,
       'numPolls' => Fog::Nullable::Integer,
       'startTime' => Fog::Nullable::String,
-      'endTime' => Fog::Nullable::String
+      'endTime' => Fog::Nullable::String,
+      'vipType' => Fog::Nullable::String,
     }
   ]
 }
@@ -86,6 +87,11 @@ LOAD_BALANCERS_FORMAT = {
       'port' => Integer,
       'protocol' => String,
       'algorithm' => String,
+      'sourceAddresses' => {
+        'ipv4Servicenet'  => String,
+        'ipv4Public'      => String,
+        'ipv6Public'      => String,
+      },
       'status' => String,
       'virtualIps' => [VIRTUAL_IP_FORMAT],
       'nodes' => [SINGLE_NODE_FORMAT],
@@ -100,6 +106,11 @@ LOAD_BALANCER_FORMAT = {
     'port' => Integer,
     'protocol' => String,
     'algorithm' => String,
+    'sourceAddresses' => {
+      'ipv4Servicenet'  => String,
+      'ipv4Public'      => String,
+      'ipv6Public'      => String,
+    },
     'status' => String,
     'cluster' => { 'name' => String },
     'virtualIps' => [VIRTUAL_IP_FORMAT],

data/lib/brightbox-cli/vendor/fog/tests/rackspace/requests/{load_balancer_tests.rb → load_balancers/load_balancer_tests.rb}

@@ -52,7 +52,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer_tests', ['rackspace'
       tests('#get_load_balancer(0)').raises(Fog::Rackspace::LoadBalancers::NotFound) do
         @service.get_load_balancer(0)
       end
-      tests('#delete_load_balancer(0)').raises(Fog::Rackspace::LoadBalancers::NotFound) do
+      tests('#delete_load_balancer(0)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do
         @service.delete_load_balancer(0)
       end
       tests('#update_load_balancer(0)').raises(Fog::Rackspace::LoadBalancers::NotFound) do

data/lib/brightbox-cli/vendor/fog/tests/rackspace/requests/{virtual_ip_tests.rb → load_balancers/virtual_ip_tests.rb}

@@ -21,10 +21,10 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | virtual_ip_tests', ['rackspace'])
 
       tests('failure') do
         #TODO - I feel like this should really be a BadRequest, need to dig in
-        tests('create_virtual_ip(invalid type)').raises(Fog::Rackspace::LoadBalancers::InteralServerError) do
+        tests('create_virtual_ip(invalid type)').raises(Fog::Rackspace::LoadBalancers::InternalServerError) do
           @service.create_virtual_ip(@lb.id, 'badtype')
         end
-        tests('delete_virtual_ip(0)').raises(Fog::Rackspace::LoadBalancers::NotFound) do
+        tests('delete_virtual_ip(0)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do
           @service.delete_virtual_ip(@lb.id, 0)
         end
       end

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

@@ -1,5 +1,5 @@
 Shindo.tests("Fog::Compute[:servers] | vm_clone request") do
-  require 'guid'
+  #require 'guid'
   template = "50323f93-6835-1178-8b8f-9e2109890e1a"
   compute = Fog::Compute[:vsphere]
 
@@ -17,6 +17,7 @@ Shindo.tests("Fog::Compute[:servers] | vm_clone request") do
       compute.vm_clone('instance_uuid' => '123', 'name' => 'jefftest')
     end
     raises(Fog::Compute::Vsphere::NotFound, 'it should raise Fog::Compute::Vsphere::NotFound when the UUID is not a string') do
+      pending # require 'guid'
       compute.vm_clone('instance_uuid' => Guid.from_s(template), 'name' => 'jefftestfoo')
     end
   end

data/lib/brightbox-cli/version.rb

@@ -1,3 +1,3 @@
 module Brightbox
-  VERSION = "0.14.1" unless defined?(Brightbox::VERSION)
+  VERSION = "0.15.0" unless defined?(Brightbox::VERSION)
 end

data/lib/brightbox_cli.rb

@@ -17,22 +17,28 @@ require 'date'
 require 'gli'
 require 'fog/brightbox'
 
+module Brightbox
+  autoload :Server, "brightbox-cli/servers"
+  autoload :DetailedServer, "brightbox-cli/detailed_server"
+  autoload :Image, "brightbox-cli/images"
+  autoload :Type, "brightbox-cli/types"
+  autoload :Zone, "brightbox-cli/zones"
+  autoload :CloudIP, "brightbox-cli/cloud_ips"
+  autoload :User, "brightbox-cli/users"
+  autoload :Account, "brightbox-cli/accounts"
+  autoload :LoadBalancer, "brightbox-cli/load_balancers"
+  autoload :ServerGroup, "brightbox-cli/server_groups"
+  autoload :DetailedServerGroup, "brightbox-cli/detailed_server_group"
+  autoload :FirewallPolicy, "brightbox-cli/firewall_policy"
+  autoload :FirewallRule, "brightbox-cli/firewall_rule"
+  autoload :FirewallRules, "brightbox-cli/firewall_rules"
+end
 
 require 'brightbox-cli/tables'
 require "brightbox-cli/fog_extensions"
 require "brightbox-cli/logging"
 require "brightbox-cli/api"
-require "brightbox-cli/servers"
-require "brightbox-cli/images"
-require "brightbox-cli/types"
-require "brightbox-cli/zones"
-require "brightbox-cli/cloud_ips"
-require "brightbox-cli/users"
-require "brightbox-cli/accounts"
 require "brightbox-cli/config"
 require "brightbox-cli/version"
-require "brightbox-cli/load_balancers"
 require "brightbox-cli/ruby_core_ext"
 require "brightbox-cli/error_parser"
-
-

data/spec/cloud_ips_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "Cloud IP" do
+
+  describe "listing cloud ips" do
+    use_vcr_cassette("list_cloud_ip")
+
+    it "should list cloud ips" do
+      ips = Brightbox::CloudIP.find(:all)
+      output = capture_stdout {
+        Brightbox.render_table(ips.sort, :vertical => true)
+      }
+      output.should match(/cip-33fjw/)
+    end
+  end
+
+end

data/spec/firewall_policy_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+
+describe "Firewall Policy" do
+  describe "Creating firewall policy" do
+    use_vcr_cassette('create_firewall_policy')
+    it "should create firewall policy" do
+      params = { :name => "rspec_tests"}
+      @group = Brightbox::ServerGroup.create(params)
+      lambda do
+        firewall_options = {
+          :name => "rspec_firewall_policy",
+          :server_group_id => @group.id
+        }
+        @firewall_policy = Brightbox::FirewallPolicy.create(firewall_options)
+      end.should_not raise_error
+      output = capture_stdout {
+        Brightbox.render_table([@firewall_policy],:vertical => true)
+      }
+      output.should match(/rspec_firewall_policy/)
+      @group.destroy()
+    end
+  end
+
+  describe "Destroying firewall policy" do
+    use_vcr_cassette('destroy_firewall_policy')
+    it "should destroy firewall policy" do
+      params = { :name => "rspec_tests"}
+      @group = Brightbox::ServerGroup.create(params)
+      lambda do
+        firewall_options = {
+          :name => "rspec_firewall_policy",
+          :server_group_id => @group.id
+        }
+        @firewall_policy = Brightbox::FirewallPolicy.create(firewall_options)
+        @firewall_policy.destroy
+      end.should_not raise_error
+      @group.destroy()
+    end
+  end
+
+  describe "Listing firewall policy" do
+    use_vcr_cassette('list_firewall_policy')
+    it "should list firewall policy" do
+      output = capture_stdout {
+        firewall_policies = Brightbox::FirewallPolicy.find(:all)
+        Brightbox.render_table(firewall_policies,:vertical => true)
+      }
+      output.should match(/default_permissive_policy/)
+    end
+  end
+
+  describe "Displaying one firewall policy" do
+    use_vcr_cassette('show_firewall_policy')
+    it "should show firewall policy" do
+      output = capture_stdout {
+        firewall_policy = Brightbox::FirewallPolicy.find_or_call(["fwp-3q9jp"])
+        Brightbox.render_table(firewall_policy,:vertical => true)
+      }
+      output.should match(/default_permissive_policy/)
+    end
+  end
+
+  describe "apply firewall policy" do
+    use_vcr_cassette('apply_firewall_policy')
+    it "should apply firewall policy" do
+      lambda {
+        params = { :name => "rspec_tests_apply"}
+        group = Brightbox::ServerGroup.create(params)
+        firewall_options = {
+          :name => "rspec_firewall_policy_apply"
+        }
+        firewall_policy = Brightbox::FirewallPolicy.create(firewall_options)
+        firewall_policy.apply_to(group.id)
+        group.destroy
+      }.should_not raise_error
+    end
+  end
+end