fog-profitbricks 4.0.0 → 4.1.0

data/lib/fog/profitbricks/requests/compute/get_datacenter.rb

@@ -49,7 +49,7 @@ module Fog
             datacenter["id"] == datacenter_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_firewall_rule.rb

@@ -54,7 +54,7 @@ module Fog
             fwr["datacenter_id"] == datacenter_id && fwr["server_id"] == server_id && fwr["nic_id"] == nic_id && fwr["id"] == firewall_rule_id
           end
           else
-            raise Fog::Errors::NotFound, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_group.rb

@@ -50,7 +50,7 @@ module Fog
             grp["id"] == group_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_image.rb

@@ -55,7 +55,7 @@ module Fog
             image["id"] == image_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_ip_block.rb

@@ -42,7 +42,7 @@ module Fog
             ipb["id"] == ip_block_id
           end
           else
-            raise Fog::Errors::NotFound, "The requested IP Block could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_lan.rb

@@ -104,7 +104,7 @@ module Fog
             ln["datacenter_id"] == datacenter_id && ln["id"] == lan_id
           end
           else
-            raise Fog::Errors::NotFound, "The requested lan could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_load_balanced_nic.rb

@@ -81,7 +81,7 @@ module Fog
             lb["datacenter_id"] == datacenter_id && lb["id"] == load_balancer_id
           end
           else
-            raise Fog::Errors::NotFound, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           load_balanced_nic = nil
@@ -92,6 +92,12 @@ module Fog
                                 load_balancer['balancednics']['items'][0]
                               end
 
+          load_balanced_nic['mac'] = '01:23:45:67:89:00'
+          load_balanced_nic['nat'] = false
+          load_balanced_nic['firewall_active'] = true
+          load_balanced_nic['lan'] = load_balanced_nic[:lan]
+          load_balanced_nic['ips'] = load_balanced_nic[:ips]
+
           response        = Excon::Response.new
           response.status = 200
           response.body   = load_balanced_nic

data/lib/fog/profitbricks/requests/compute/get_load_balancer.rb

@@ -100,7 +100,7 @@ module Fog
             lb["datacenter_id"] == datacenter_id && lb["id"] == load_balancer_id
           end
           else
-            raise Fog::Errors::NotFound, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_location.rb

@@ -33,7 +33,7 @@ module Fog
             lo["id"] == location_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_nic.rb

@@ -76,12 +76,12 @@ module Fog
       end
 
       class Mock
-        def get_nic(_datacenter_id, _server_id, nic_id)
+        def get_nic(datacenter_id, server_id, nic_id)
           if nic = data[:nics]['items'].find do |nic|
             nic["id"] == nic_id
           end
           else
-            raise Fog::Errors::NotFound, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_request.rb

@@ -46,7 +46,14 @@ module Fog
       end
 
       class Mock
-        def get_request(_request_id)
+        def get_request(request_id)
+          if request = data[:requests]["items"].find do |req|
+            req["id"] == request_id
+          end
+          else
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
+          end
+
           response        = Excon::Response.new
           response.status = 200
           response.body   = data[:requests]['items'][0]

data/lib/fog/profitbricks/requests/compute/get_resource_by_type.rb

@@ -61,9 +61,16 @@ module Fog
 
       class Mock
         def get_resource_by_type(resource_type, resource_id)
+          if resource = data[:resources]['items'].find do |r|
+            r["type"] == resource_type && r["id"] == resource_id
+          end
+          else
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
+          end
+
           response        = Excon::Response.new
           response.status = 200
-          response.body   = data[:resources]
+          response.body   = resource
 
           response
         end

data/lib/fog/profitbricks/requests/compute/get_resources_by_type.rb

@@ -32,10 +32,16 @@ module Fog
 
       class Mock
         def get_resources_by_type(resource_type)
-          response        = Excon::Response.new
-          response.status = 200
-          response.body   = data[:resources]
+          if resources = data[:resources]['items'].select {|resource| resource['type'] == resource_type}
+            result = data[:resources].dup
+            result['items'] = resources
+          else
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
+          end
 
+          response = Excon::Response.new
+          response.status = 200
+          response.body = result
           response
         end
       end

data/lib/fog/profitbricks/requests/compute/get_server.rb

@@ -116,7 +116,7 @@ module Fog
             serv['datacenter_id'] == datacenter_id && serv['id'] == server_id
           end
           else
-            raise Fog::Errors::NotFound, "The server resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_share.rb

@@ -38,7 +38,7 @@ module Fog
             shr["id"] == resource_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_snapshot.rb

@@ -54,7 +54,7 @@ module Fog
             attrib["id"] == snapshot_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, 'Resource does not exist'
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_user.rb

@@ -58,7 +58,7 @@ module Fog
             usr["id"] == user_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/get_volume.rb

@@ -57,7 +57,7 @@ module Fog
             vlm["id"] == volume_id && vlm["datacenter_id"] == datacenter_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/list_attached_cdroms.rb

@@ -60,9 +60,11 @@ module Fog
             serv['datacenter_id'] == datacenter_id && serv['id'] == server_id
           end
           else
-            raise Fog::Errors::NotFound, "The server resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
+          data[:images]['items'] = data[:images]['items'].select {|img| img['imageType'] == 'CDROM'}
+
           response        = Excon::Response.new
           response.status = 200
           response.body   = data[:images]

data/lib/fog/profitbricks/requests/compute/list_attached_volumes.rb

@@ -61,13 +61,13 @@ module Fog
             serv['datacenter_id'] == datacenter_id && serv['id'] == server_id
           end
           else
-            raise Fog::Errors::NotFound, "The server resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new
           response.status = 200
-          response.body = if server['entities'] && server['entities']['volumes']
-                            server['entities']['volumes']
+          response.body = if server['volumes']
+                            server['volumes']
                           else
                             {
                               'id' => "#{server_id}/volumes",

data/lib/fog/profitbricks/requests/compute/remove_user_from_group.rb

@@ -31,14 +31,14 @@ module Fog
             grp["id"] == group_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           if user = data[:users]['items'].find do |usr|
             usr["id"] == user_id
           end
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response

data/lib/fog/profitbricks/requests/compute/update_datacenter.rb

@@ -50,20 +50,15 @@ module Fog
           if dc = data[:datacenters]["items"].find do |datacenter|
             datacenter["id"] == datacenter_id
           end
-            options.each do |key, value|
-              dc[key] = value
-            end
 
             dc['properties']['version'] += 1 if dc['properties']
             dc['version'] += 1 if dc['version']
 
-            dc['properties']['name'] += ' - updated' if dc['properties']
-            dc['name'] += ' - updated' if dc['name']
-            dc['properties']['description'] += ' - updated' if dc['properties']
-            dc['description'] += ' - updated' if dc['description']
+            dc['properties']['name'] = options[:properties][:name] if dc['properties']
+            dc['name'] = options[:name] if dc['name']
 
           else
-            raise Excon::Error::HTTPStatus, "The requested resource could not be found"
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/update_firewall_rule.rb

@@ -70,7 +70,7 @@ module Fog
               firewall_rule[key] = value
             end
           else
-            raise Fog::Errors::NotFound, 'The requested resource could not be found'
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/update_group.rb

@@ -65,12 +65,12 @@ module Fog
             grp["id"] == group_id
           end
             group['name']               = options[:name]
-            group['createDataCenter']   = options[:create_data_center] if options[:create_data_center]
-            group['createSnapshot']     = options[:create_snapshot] if options[:create_snapshot]
-            group['reserveIp']          = options[:reserve_ip] if options[:reserve_ip]
-            group['accessActivityLog']  = options[:access_activity_log] if options[:access_activity_log]
+            group['createDataCenter']   = options[:createDataCenter] if [true, false].include?(options[:createDataCenter])
+            group['createSnapshot']     = options[:createSnapshot] if [true, false].include?(options[:createSnapshot])
+            group['reserveIp']          = options[:reserveIp] if [true, false].include?(options[:reserveIp])
+            group['accessActivityLog']  = options[:accessActivityLog] if [true, false].include?(options[:accessActivityLog])
           else
-            raise Excon::Error::HTTPStatus, 'The requested resource could not be found'
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/update_nic.rb

@@ -86,11 +86,9 @@ module Fog
           if nic = data[:nics]['items'].find do |attribute|
             attribute["datacenter_id"] == datacenter_id && attribute["server_id"] == server_id && attribute["id"] == nic_id
           end
-            options.each do |key, value|
-              nic[key] = value
-            end
+            nic['name'] = options[:name]
           else
-            raise Fog::Errors::NotFound, 'The requested resource could not be found'
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/update_server.rb

@@ -126,13 +126,12 @@ module Fog
           if server = data[:servers]['items'].find do |attrib|
             attrib['id'] == server_id
           end
-            properties.each do |key, value|
-              server[key] = value
-            end
           else
-            raise Fog::Errors::NotFound, 'The requested server resource could not be found'
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
+          server['name'] = properties[:name]
+
           response        = Excon::Response.new
           response.status = 202
           response.body   = server

data/lib/fog/profitbricks/requests/compute/update_share.rb

@@ -49,10 +49,10 @@ module Fog
           if share = data[:shares]['items'].find do |shr|
             shr["id"] == resource_id
           end
-            share['editPrivilege']   = options[:edit_privilege] if options[:edit_privilege]
-            share['sharePrivilege']  = options[:share_privilege] if options[:share_privilege]
+            share['editPrivilege']   = options[:editPrivilege] if [true, false].include?(options[:editPrivilege])
+            share['sharePrivilege']  = options[:sharePrivilege] if [true, false].include?(options[:sharePrivilege])
           else
-            raise Excon::Error::HTTPStatus, 'The requested resource could not be found'
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/requests/compute/update_user.rb

@@ -77,9 +77,9 @@ module Fog
             user['lastname']      = options[:lastname]
             user['email']         = options[:email]
             user['administrator'] = options[:administrator]
-            user['forceSecAuth']  = options[:force_sec_auth]
+            user['forceSecAuth']  = options[:force_sec_auth] || false
           else
-            raise Excon::Error::HTTPStatus, 'The requested resource could not be found'
+            raise Excon::Error::HTTPStatus, "Resource does not exist"
           end
 
           response        = Excon::Response.new

data/lib/fog/profitbricks/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module ProfitBricks
-    VERSION = "4.0.0".freeze
+    VERSION = "4.1.0".freeze
   end
 end

data/tests/profitbricks/models/compute/compute_tests.rb

@@ -1,535 +1,1339 @@
 Shindo.tests('Fog::Compute[:profitbricks] | compute models', %w(profitbricks compute)) do
-  compute = Fog::Compute[:profitbricks]
+  compute = Fog::Compute.new(:provider => 'ProfitBricks', :profitbricks_username => ENV['PROFITBRICKS_USERNAME'], :profitbricks_password => ENV['PROFITBRICKS_PASSWORD'])
 
   tests('success') do
     Excon.defaults[:connection_timeout] = 500
-
-    tests('should retrieve contract resources').succeeds do
+    tests('List Contract Resources').succeeds do
       contract_resources = compute.contract_resources.all
 
-      !contract_resources.empty?
+      contract_resources.count > 0 &&
+        contract_resources[0].contract_number !~ /\D/
+    end
+
+    tests('List Requests').succeeds do
+      requests = compute.requests.all
+      @request_id = requests[0].id
+
+      requests.count > 0 &&
+        requests[0].type == 'request'
     end
 
-    tests('should create a datacenter').succeeds do
-      datacenter = compute.datacenters.create(:name => 'fog-demo',
-                                              :location => 'de/fra',
-                                              :description => 'testing fog rest implementation')
-      datacenter.wait_for { ready? }
+    tests('Get Request').succeeds do
+      request = compute.requests.get(@request_id)
+
+      request.id == @request_id &&
+        request.type == 'request'
+    end
+
+    tests('Get Request Status').succeeds do
+      request_status = compute.requests.get_status(@request_id)
+
+      request_status.id == "#{@request_id}/status" &&
+        request_status.type == 'request-status'
+    end
+
+    tests('List Locations').succeeds do
+      locations = compute.locations.all
+
+      locations.count > 0 &&
+        locations[0].type == 'location' &&
+        locations.find {|item| item.id == 'us/las'} != nil
+    end
+
+    tests('Get Location').succeeds do
+      location = compute.locations.get('us/las')
+
+      location.id == 'us/las' &&
+        location.type == 'location'
+    end
+
+    tests('Create Datacenter Simple').succeeds do
+      datacenter = compute.datacenters.create(:name => 'Fog Test',
+                                              :location => 'us/las',
+                                              :description => 'Fog test datacenter')
+      datacenter.wait_for {ready?}
 
       @datacenter_id = datacenter.id
 
-      datacenter.name == 'fog-demo'
-      datacenter.location == 'de/fra'
-      datacenter.description == 'testing fog rest implementation'
+      datacenter.type == 'datacenter' &&
+        datacenter.name == 'Fog Test' &&
+        datacenter.location == 'us/las' &&
+        datacenter.description == 'Fog test datacenter'
+    end
+
+    tests('Create Datacenter Composite').succeeds do
+      servers = [
+        {
+          name: 'Fog Test',
+          ram: 1024,
+          cores: 1
+        }
+      ]
+
+      volumes = [
+        {
+          name: 'Fog Test',
+          size: 2,
+          bus: 'VIRTIO',
+          type: 'HDD',
+          licenceType: 'UNKNOWN',
+          availabilityZone: 'ZONE_3'
+        }
+      ]
+      datacenter = compute.datacenters.create(:name => 'Fog Test Composite',
+                                              :location => 'us/las',
+                                              :description => 'Fog test composite datacenter',
+                                              :servers => servers,
+                                              :volumes => volumes)
+      datacenter.wait_for {ready?}
+
+      @composite_dc_id = datacenter.id
+
+      datacenter.type == 'datacenter' &&
+        datacenter.name == 'Fog Test Composite' &&
+        datacenter.location == 'us/las' &&
+        datacenter.description == 'Fog test composite datacenter' &&
+        datacenter.servers.count > 0 &&
+        datacenter.volumes.count > 0
+    end
+
+    tests('List Datacenters').succeeds do
+      datacenters = compute.datacenters.all
+
+      datacenters.count > 0 &&
+        datacenters[0].type == 'datacenter'
     end
 
-    tests('should retrieve a datacenter by id').succeeds do
+    tests('Get Datacenter').succeeds do
       datacenter = compute.datacenters.get(@datacenter_id)
 
-      datacenter.name == 'fog-demo'
-      datacenter.location == 'de/fra'
-      datacenter.description == 'testing fog rest implementation'
+      datacenter.id == @datacenter_id &&
+        datacenter.type == 'datacenter' &&
+        datacenter.name == 'Fog Test' &&
+        datacenter.location == 'us/las' &&
+        datacenter.description == 'Fog test datacenter'
     end
 
-    tests('should update a datacenter').succeeds do
+    tests('Update Datacenter').succeeds do
       datacenter = compute.datacenters.get(@datacenter_id)
-      datacenter.name = datacenter.name + ' - updated'
-      datacenter.description = datacenter.description + ' - updated'
+      datacenter.name = datacenter.name + ' - RENAMED'
       datacenter.update
+      datacenter.wait_for {ready?}
+      datacenter.reload
+
+      datacenter.name == 'Fog Test - RENAMED' &&
+        datacenter.version > 1
+    end
+
+    tests('Create LAN').succeeds do
+      lan = compute.lans.create(:datacenter_id => @datacenter_id,
+                                :name => 'Fog Test',
+                                :public => true)
 
-      datacenter.wait_for { ready? }
+      @lan_id = lan.id
+      sleep(120) if ENV["FOG_MOCK"] != "true"
 
-      datacenter.name == 'fog-demo - updated'
-      datacenter.description == 'testing fog rest implementation - updated'
+      lan.name == 'Fog Test' &&
+        lan.public
     end
 
-    tests('should retrieve all datacenters').succeeds do
-      datacenters = compute.datacenters.all
+    tests('List LANs').succeeds do
+      lans = compute.lans.all(@datacenter_id)
 
-      !datacenters.empty?
+      lans.count > 0 &&
+        lans[0].type == 'lan'
     end
 
-    tests('should retrieve all locations').succeeds do
-      locations = compute.locations.all
+    tests('Get LAN').succeeds do
+      lan = compute.lans.get(@datacenter_id, @lan_id)
 
-      !locations.empty?
+      lan.id == @lan_id &&
+        lan.type == 'lan' &&
+        lan.name == 'Fog Test' &&
+        lan.public
     end
 
-    tests('should retrieve a location by id').succeeds do
-      location = compute.locations.get('us/las')
+    tests('Update LAN').succeeds do
+      lan = compute.lans.get(@datacenter_id, @lan_id)
+      lan.name = lan.name + ' - RENAME'
+      lan.public = false
+      lan.update
 
-      location.name == 'lasvegas'
+      lan.id == @lan_id &&
+        lan.type == 'lan' &&
+        lan.name == 'Fog Test - RENAME'
     end
 
-    tests('should create a volume').succeeds do
+    tests('List Images').succeeds do
+      images = compute.images.all
+
+      images.count > 0
+      images[0].type == 'image'
+
+      image = images.find do |img|
+        img.image_type == 'HDD' &&
+          img.licence_type == 'LINUX' &&
+          img.location == 'us/las'
+      end
+
+      @image_id = image.id
+    end
+
+
+    tests('Get Image').succeeds do
+      image = compute.images.get(@image_id)
+
+      image.id == @image_id &&
+        image.type == 'image' &&
+        !image.name.empty? &&
+        image.description.to_s.empty? &&
+        !image.location.to_s.empty? &&
+        image.size > 0 &&
+        ['true', 'false', true, false].include?(image.cpu_hot_plug) &&
+        ['true', 'false', true, false].include?(image.cpu_hot_unplug) &&
+        ['true', 'false', true, false].include?(image.ram_hot_plug) &&
+        ['true', 'false', true, false].include?(image.ram_hot_unplug) &&
+        ['true', 'false', true, false].include?(image.nic_hot_plug) &&
+        ['true', 'false', true, false].include?(image.nic_hot_unplug) &&
+        ['true', 'false', true, false].include?(image.disc_virtio_hot_plug) &&
+        ['true', 'false', true, false].include?(image.disc_virtio_hot_unplug) &&
+        ['true', 'false', true, false].include?(image.disc_scsi_hot_plug) &&
+        ['true', 'false', true, false].include?(image.disc_scsi_hot_unplug) &&
+        ['true', 'false', true, false].include?(image.public) &&
+        !image.licence_type.to_s.empty? &&
+        !image.image_type.to_s.empty?
+    end
+
+    tests('Create Volume').succeeds do
       volume = compute.volumes.create(:datacenter_id => @datacenter_id,
-                                      :name => 'fog-demo-volume',
-                                      :size => 5,
-                                      :licence_type => 'OTHER',
+                                      :name => 'Fog Test',
+                                      :size => 2,
+                                      :bus => 'VIRTIO',
                                       :type => 'HDD',
-                                      :availability_zone => 'AUTO')
-      volume.wait_for { ready? }
+                                      :availability_zone => 'ZONE_3',
+                                      :image => @image_id,
+                                      :ssh_keys => ['ssh-rsa AAAAB3NzaC1'])
+      volume.wait_for {ready?}
 
       @volume_id = volume.id
 
-      volume.name     == 'fog-demo-volume'
-      volume.size     == 5
-      volume.type     == 'HDD'
-      volume.licence_type == 'OTHER'
+      volume.name == 'Fog Test' &&
+        volume.size == 2 &&
+        volume.bus == 'VIRTIO' &&
+        volume.type == 'HDD' &&
+        volume.availability_zone == 'ZONE_3' &&
+        volume.image == @image_id &&
+        volume.ssh_keys.kind_of?(Array)
     end
 
-    tests('should retrieve a volume by id').succeeds do
-      volume = compute.volumes.get(@datacenter_id, @volume_id)
+    tests('List Volumes').succeeds do
+      volumes = compute.volumes.all(@datacenter_id)
 
-      volume.name     == 'fog-demo-volume'
-      volume.size     == 5
-      volume.type     == 'HDD'
-      volume.licence_type == 'OTHER'
+      volumes.count > 0 &&
+        volumes[0].type == 'HDD'
     end
 
-    tests('should update a volume').succeeds do
+    tests('Get Volume').succeeds do
       volume = compute.volumes.get(@datacenter_id, @volume_id)
-      volume.name = volume.name + ' - updated'
-      volume.update
-
-      volume.wait_for { ready? }
 
-      volume.name == 'fog-demo-volume - updated'
+      volume.id == @volume_id &&
+        volume.name == 'Fog Test' &&
+        volume.size == 2 &&
+        volume.type == 'HDD' &&
+        volume.availability_zone == 'ZONE_3' &&
+        volume.image == @image_id
     end
 
-    tests('should retrieve all volumes').succeeds do
-      volumes = compute.volumes.all(@datacenter_id)
+    tests('Update Volume').succeeds do
+      volume = compute.volumes.get(@datacenter_id, @volume_id)
+      volume.size = 5
+      volume.name = volume.name + ' - RENAME'
+      volume.update
+
+      volume.wait_for {ready?}
+      volume.reload
 
-      !volumes.empty?
+      volume.id == @volume_id &&
+        volume.name == 'Fog Test - RENAME' &&
+        volume.size == 5
     end
 
-    tests('should create a volume snapshot').succeeds do
+    tests('Create Snapshot').succeeds do
       volume = compute.volumes.get(@datacenter_id, @volume_id)
 
-      volume.create_snapshot('fog-demo-snapshot', 'part of fog models test suite') == true
+      volume.create_snapshot('Fog Test', 'Fog test snapshot') == true
       volume.reload
     end
 
-    tests('should retrieve all snapshots').succeeds do
-      sleep(60) if ENV["FOG_MOCK"] != "true"
+    tests('List Snapshots').succeeds do
+      sleep(30) if ENV["FOG_MOCK"] != "true"
 
       snapshots = compute.snapshots.all
-
-      !snapshots.empty?
-
       snapshot = snapshots.find do |snp|
-        snp.name == 'fog-demo-snapshot'
+        snp.name == 'Fog Test'
       end
 
       @snapshot_id = snapshot.id
-    end
-
-    tests('should retrieve a snapshot by id').succeeds do
-      snapshot = compute.snapshots.get(@snapshot_id)
 
-      snapshot.name == 'fog-demo-snapshot'
+      snapshots.count > 0 &&
+        snapshots[0].type == 'snapshot'
     end
 
-    tests('should update a snapshot').succeeds do
+    tests('Get Snapshot').succeeds do
+      volume = compute.volumes.get(@datacenter_id, @volume_id)
       snapshot = compute.snapshots.get(@snapshot_id)
 
-      snapshot.name = snapshot.name + ' - updated'
-      snapshot.update
-
-      snapshot.name == 'fog-demo-snapshot - updated'
-    end
-
-    tests('should restore a volume snapshot').succeeds do
+      snapshot.id == @snapshot_id &&
+        snapshot.name == 'Fog Test' &&
+        snapshot.description.include?('Fog') &&
+        snapshot.type == 'snapshot' &&
+        snapshot.location == 'us/las' &&
+        snapshot.size == volume.size &&
+        snapshot.cpu_hot_plug == volume.cpu_hot_plug &&
+        snapshot.cpu_hot_unplug == volume.cpu_hot_unplug &&
+        snapshot.ram_hot_plug == volume.ram_hot_plug &&
+        snapshot.ram_hot_unplug == volume.ram_hot_unplug &&
+        snapshot.nic_hot_plug == volume.nic_hot_plug &&
+        snapshot.nic_hot_unplug == volume.nic_hot_unplug &&
+        snapshot.disc_virtio_hot_plug == volume.disc_virtio_hot_plug &&
+        snapshot.disc_virtio_hot_unplug == volume.disc_virtio_hot_unplug &&
+        snapshot.disc_scsi_hot_plug == volume.disc_scsi_hot_plug &&
+        snapshot.disc_scsi_hot_unplug == volume.disc_scsi_hot_unplug &&
+        snapshot.licence_type == volume.licence_type
+    end
+
+    tests('Restore Snapshot').succeeds do
       volume = compute.volumes.get(@datacenter_id, @volume_id)
 
-      volume.restore_snapshot(@snapshot_id) == true
+      volume.restore_snapshot(@snapshot_id)
     end
 
-    tests('should retrieve all images').succeeds do
-      images = compute.images.all
+    tests('Update Snapshot').succeeds do
+      snapshot = compute.snapshots.get(@snapshot_id)
 
-      !images.empty?
+      snapshot.name = snapshot.name + ' - RENAME'
+      snapshot.description = snapshot.description + ' - RENAME'
+      snapshot.update
 
-      image = images.find do |img|
-        img.image_type == 'CDROM' &&
-          img.licence_type == 'LINUX'
-      end
+      sleep(30) if ENV["FOG_MOCK"] != "true"
+      snapshot = compute.snapshots.get(@snapshot_id)
 
-      @image_id = image.id
+      snapshot.name == 'Fog Test - RENAME' &&
+        snapshot.description.include?('Fog') &&
+        snapshot.description.include?('- RENAME')
     end
 
-    tests('should retrieve an image by id').succeeds do
-      image = compute.images.get(@image_id)
-
-      image.image_type   == 'CDROM'
-      image.licence_type == 'LINUX'
-    end
+    tests('Create Server').succeeds do
+      server = compute.servers.create(:datacenter_id => @datacenter_id,
+                                      :name => 'Fog Test',
+                                      :ram => 1024,
+                                      :cores => 1,
+                                      :availability_zone => 'ZONE_1',
+                                      :cpu_family => 'INTEL_XEON')
+      server.wait_for {ready?}
 
-    if ENV["FOG_MOCK"] == "true"
-      tests('should update an image').succeeds do
-        image = compute.images.get(@image_id)
-        image.licence_type = 'UNKNOWN'
-        image.update
+      @server_id = server.id
 
-        image.licence_type == 'UNKNOWN'
-      end
-    end
+      server.type == 'server' &&
+        server.name == 'Fog Test' &&
+        server.ram == 1024 &&
+        server.cores == 1 &&
+        server.availability_zone == 'ZONE_1' &&
+        server.cpu_family == 'INTEL_XEON'
+    end
+
+    tests('Create Server Composite').succeeds do
+      volumes = [
+        {
+          name: 'Fog Test',
+          size: 2,
+          bus: 'VIRTIO',
+          type: 'HDD',
+          licence_type: 'UNKNOWN',
+          availability_zone: 'ZONE_3'
+        }
+      ]
+      nics = [
+        {
+          name: 'Fog Test',
+          dhcp: 'true',
+          lan: 1,
+          firewallActive: true,
+          nat: false,
+          firewallrules: [
+            {
+              name: 'SSH',
+              protocol: 'TCP',
+              sourceMac: '01:23:45:67:89:00',
+              portRangeStart: 22,
+              portRangeEnd: 22
+            }
+          ]
+        }
+      ]
 
-    tests('should create a server').succeeds do
       server = compute.servers.create(:datacenter_id => @datacenter_id,
-                                      :name => 'fog-demo-server',
-                                      :cores => 2,
-                                      :ram => 2048,
-                                      :licenceType => 'OTHER')
-      server.wait_for { ready? }
+                                      :name => 'Fog Test Composite',
+                                      :ram => 1024,
+                                      :cores => 1,
+                                      :volumes => volumes,
+                                      :nics => nics)
+      server.wait_for {ready?}
 
-      @server_id = server.id
+      @composite_server_id = server.id
 
-      server.name  == 'fog-demo-server'
-      server.cores == 2
-      server.ram   == 2048
+      server.type == 'server' &&
+        server.name == 'Fog Test Composite' &&
+        server.ram == 1024 &&
+        server.cores == 1 &&
+        server.nics.count > 0 &&
+        server.volumes.count > 0
     end
 
-    tests('should retrieve a server by id').succeeds do
-      server = compute.servers.get(@datacenter_id, @server_id)
+    tests('List Servers').succeeds do
+      servers = compute.servers.all(@datacenter_id)
 
-      server.name  == 'fog-demo-server'
-      server.cores == 2
-      server.ram   == 2048
+      servers.count > 0 &&
+        servers[0].type == 'server'
     end
 
-    tests('should retrieve all servers').succeeds do
-      servers = compute.servers.all(@datacenter_id)
+    tests('Get Server').succeeds do
+      server = compute.servers.get(@datacenter_id, @server_id)
 
-      !servers.empty?
+      server.id == @server_id &&
+        server.type == 'server' &&
+        server.name == 'Fog Test' &&
+        server.cores == 1 &&
+        server.ram == 1024 &&
+        server.availability_zone == 'ZONE_1' &&
+        server.cpu_family == 'INTEL_XEON'
     end
 
-    tests('should update a server').succeeds do
+    tests('Update Server').succeeds do
       server = compute.servers.get(@datacenter_id, @server_id)
 
-      server.name = server.name + ' - updated'
+      server.name = server.name + ' RENAME'
       server.update
 
-      server.wait_for { ready? }
+      server.wait_for {ready?}
 
-      server.name == 'fog-demo-server - updated'
+      server.id == @server_id &&
+        server.name == 'Fog Test RENAME'
     end
 
-    tests('should attach a volume to the server').succeeds do
-      server = compute.servers.get(@datacenter_id, @server_id)
-
-      volume = server.attach_volume(@volume_id)
+    tests('Attach Volume').succeeds do
+      volume = compute.attach_volume(@datacenter_id, @server_id, @volume_id)
 
       sleep(60) if ENV["FOG_MOCK"] != "true"
 
-      volume['id'] == @volume_id
+      volume.body['id'] == @volume_id &&
+        volume.body['properties']['name'] == 'Fog Test - RENAME' &&
+        volume.body['properties']['size'] == 5 &&
+        volume.body['properties']['type'] == 'HDD' &&
+        volume.body['properties']['licenceType'] == 'LINUX'
     end
 
-    tests('should retrieve all attached volumes').succeeds do
+    tests('List Attached Volumes').succeeds do
       server = compute.servers.get(@datacenter_id, @server_id)
 
       volumes = server.list_volumes
+
+      volumes['items'].count > 0
     end
 
-    tests('should retrieve an attached volume').succeeds do
+    tests('Get Attached Volume').succeeds do
       server = compute.servers.get(@datacenter_id, @server_id)
 
       volume = server.get_attached_volume(@volume_id)
+
+      volume['name'] == 'Fog Test - RENAME' &&
+        volume['size'] == 5 &&
+        volume['bus'] == 'VIRTIO' &&
+        volume['type'] == 'HDD'
     end
 
-    tests('should detach a volume from the server').succeeds do
+    tests('Detach Volume').succeeds do
       server = compute.servers.get(@datacenter_id, @server_id)
 
       server.detach_volume(@volume_id)
     end
 
-    tests('should attach a CD-ROM to the server').succeeds do
-      server = compute.servers.get(@datacenter_id, @server_id)
-
-      sleep(60) if ENV["FOG_MOCK"] != "true"
+    tests('Attach CDROM').succeeds do
+      images = compute.images.all
+      cd_image = images.find do |img|
+        img.image_type == 'CDROM' &&
+          img.licence_type == 'LINUX'
+      end
+      @cd_image_id = cd_image.id
 
-      cdrom = server.attach_cdrom(@image_id)
+      server = compute.servers.get(@datacenter_id, @server_id)
+      sleep(30) if ENV["FOG_MOCK"] != "true"
 
-      sleep(60) if ENV["FOG_MOCK"] != "true"
+      cdrom = server.attach_cdrom(@cd_image_id)
+      sleep(120) if ENV["FOG_MOCK"] != "true"
 
       @cdrom_id = cdrom['id']
+
+      cdrom['id'] == @cd_image_id &&
+        !cdrom['name'].to_s.empty?
     end
 
-    tests('should retrieve all attached CD-ROMs').succeeds do
+    tests('List Attached CDROMs').succeeds do
       server = compute.servers.get(@datacenter_id, @server_id)
 
-      cdroms = server.list_cdroms
+      server.list_cdroms.count > 0
     end
 
-    if ENV["FOG_MOCK"] != "true"
-      tests('should detach a CD-ROM from the server').succeeds do
+    if ENV["FOG_MOCK"] == "true"
+      tests('Get Attached CDROM').succeeds do
         server = compute.servers.get(@datacenter_id, @server_id)
 
-        if !server.list_cdroms['items'].empty?
-          server.detach_cdrom(@image_id)
-        else
-          server.list_cdroms
-        end
+        cdrom = server.get_attached_cdrom(@cdrom_id)
+
+        cdrom['id'] == @cdrom_id &&
+          !cdrom['name'].empty?
       end
     end
 
-    tests('should reboot a server').succeeds do
+    tests('Detach CDROM').succeeds do
       server = compute.servers.get(@datacenter_id, @server_id)
 
-      server.reboot
+      if !server.list_cdroms['items'].empty?
+        server.detach_cdrom(@image_id)
+      else
+        server.list_cdroms
+      end
     end
 
-    tests('should stop a server').succeeds do
+    tests('Stop Server').succeeds do
       server = compute.servers.get(@datacenter_id, @server_id)
 
       server.stop
     end
 
-    tests('should start a server').succeeds do
+    tests('Start Server').succeeds do
       server = compute.servers.get(@datacenter_id, @server_id)
 
       server.stop
     end
 
-    tests('should create a lan').succeeds do
-      lan = compute.lans.create(:datacenter_id => @datacenter_id,
-                                :name => 'fog-demo-lan',
-                                :public => false)
-
-      @lan_id = lan.id
+    tests('Reset Server').succeeds do
+      server = compute.servers.get(@datacenter_id, @server_id)
 
-      lan.name == 'fog-demo-lan'
+      server.reboot
     end
 
-    tests('should retrieve all lans').succeeds do
+    tests('Reserve IP Block').succeeds do
+      ip_block = compute.ip_blocks.create(:location => 'us/las',
+                                          :size => 2,
+                                          :name => 'Fog Test')
+
       sleep(60) if ENV["FOG_MOCK"] != "true"
 
-      lans = compute.lans.all(@datacenter_id)
+      @ip_block_id = ip_block.id
+
+      ip_block.name == 'Fog Test' &&
+        ip_block.size == 2 &&
+        ip_block.location == 'us/las'
     end
 
-    tests('should retrieve a lan by id').succeeds do
-      lan = compute.lans.get(@datacenter_id, @lan_id)
+    tests('List IP Blocks').succeeds do
+      ip_blocks = compute.ip_blocks.all
 
-      lan.name == 'fog-demo-lan'
+      ip_blocks.count > 0 &&
+        ip_blocks[0].type == 'ipblock'
     end
 
-    tests('should update a lan').succeeds do
-      lan = compute.lans.get(@datacenter_id, @lan_id)
-      lan.name == lan.name + ' - updated'
-      lan.update
+    tests('Get IP Block').succeeds do
+      ip_block = compute.ip_blocks.get(@ip_block_id)
+
+      ip_block.id == @ip_block_id &&
+        ip_block.type == 'ipblock' &&
+        ip_block.name == 'Fog Test' &&
+        ip_block.size == 2 &&
+        ip_block.location == 'us/las' &&
+        ip_block.ips.count == 2
     end
 
-    tests('should create a NIC').succeeds do
+    tests('Create NIC').succeeds do
+      sleep(60) if ENV["FOG_MOCK"] != "true"
       nic = compute.nics.create(:datacenter_id => @datacenter_id,
-                                :server_id     => @server_id,
-                                :lan           => @lan_id,
-                                :name          => 'fog-demo-nic',
-                                :nat           => false)
+                                :server_id => @composite_server_id,
+                                :lan => @lan_id,
+                                :name => 'Fog Test',
+                                :dhcp => true,
+                                :firewall_active => true,
+                                :ips => ['10.0.0.1'],
+                                :nat => false)
+      nic.type == 'nic' &&
+        nic.name == 'Fog Test' &&
+        nic.lan.to_s == @lan_id.to_s &&
+        nic.firewall_active &&
+        nic.ips.is_a?(Array)
+    end
 
-      @nic_id = nic.id
+    tests('List NICs').succeeds do
+      nics = compute.nics.all(@datacenter_id, @composite_server_id)
 
-      nic.name == 'fog-demo-nic'
+      @nic_id = nics[0].id
+
+      nics.count > 0 &&
+        nics[0].type == 'nic'
     end
 
-    tests('should retrieve all NICs').succeeds do
+    tests('Get NIC').succeeds do
+      nic = compute.nics.get(@datacenter_id, @composite_server_id, @nic_id)
+
+      nic.id == @nic_id &&
+        nic.type == 'nic' &&
+        nic.name == 'Fog Test' &&
+        nic.dhcp &&
+        nic.lan.to_s == @lan_id.to_s &&
+        nic.ips.is_a?(Array)
+    end
+
+    tests('Update NIC').succeeds do
+      nic = compute.nics.get(@datacenter_id, @composite_server_id, @nic_id)
+      nic.name = nic.name + ' - RENAME'
+      nic.update
+
+      nic.name == 'Fog Test - RENAME'
+    end
+
+    tests('Create Firewall Rule').succeeds do
+      firewall_rule = compute.firewall_rules.create(:datacenter_id => @datacenter_id,
+                                                    :server_id => @composite_server_id,
+                                                    :nic_id => @nic_id,
+                                                    :name => 'SSH',
+                                                    :protocol => 'TCP',
+                                                    :source_mac => '01:23:45:67:89:00',
+                                                    :port_range_start => '22',
+                                                    :port_range_end => '22')
+
       sleep(60) if ENV["FOG_MOCK"] != "true"
 
-      nics = compute.nics.all(@datacenter_id, @server_id)
+      @firewall_rule_id = firewall_rule.id
+
+      firewall_rule.type == 'firewall-rule' &&
+        firewall_rule.name == 'SSH' &&
+        firewall_rule.protocol == 'TCP' &&
+        firewall_rule.source_mac == '01:23:45:67:89:00' &&
+        firewall_rule.source_ip.nil? &&
+        firewall_rule.target_ip.nil? &&
+        firewall_rule.port_range_start.to_s == '22' &&
+        firewall_rule.port_range_end.to_s == '22' &&
+        firewall_rule.icmp_type.nil? &&
+        firewall_rule.icmp_code.nil?
     end
 
-    tests('should retrieve a NIC by id').succeeds do
-      nic = compute.nics.get(@datacenter_id, @server_id, @nic_id)
+    tests('List Firewall Rules').succeeds do
+      firewall_rules = compute.firewall_rules.all(@datacenter_id, @composite_server_id, @nic_id)
 
-      nic.name == 'fog-demo-nic'
+      firewall_rules.count > 0 &&
+        firewall_rules[0].type == 'firewall-rule'
     end
 
-    tests('should update a NIC').succeeds do
-      nic = compute.nics.get(@datacenter_id, @server_id, @nic_id)
-      nic.name = nic.name + ' - updated'
-      nic.update
+    tests('Get Firewall Rule').succeeds do
+      firewall_rule = compute.firewall_rules.get(@datacenter_id, @composite_server_id, @nic_id, @firewall_rule_id)
+
+      firewall_rule.id == @firewall_rule_id &&
+        firewall_rule.type == 'firewall-rule' &&
+        firewall_rule.name == 'SSH' &&
+        firewall_rule.protocol == 'TCP' &&
+        firewall_rule.source_mac == '01:23:45:67:89:00' &&
+        firewall_rule.source_ip.nil? &&
+        firewall_rule.target_ip.nil? &&
+        firewall_rule.port_range_start.to_s == '22' &&
+        firewall_rule.port_range_end.to_s == '22' &&
+        firewall_rule.icmp_type.nil? &&
+        firewall_rule.icmp_code.nil?
     end
 
-    tests('should create a load balancer').succeeds do
+    tests('Create Load Balancer').succeeds do
       load_balancer = compute.load_balancers.create(:datacenter_id => @datacenter_id,
-                                                    :name          => 'fog-demo-load-balancer')
+                                                    :name => 'Fog Test',
+                                                    :dhcp => true)
 
       sleep(60) if ENV["FOG_MOCK"] != "true"
 
       @load_balancer_id = load_balancer.id
 
-      load_balancer.name == 'fog-demo-load-balancer'
+      load_balancer.type == 'loadbalancer' &&
+        load_balancer.name == 'Fog Test' &&
+        load_balancer.dhcp
     end
 
-    tests('should retrieve a load balancer by id').succeeds do
-      load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
+    tests('List Load Balancers').succeeds do
+      load_balancers = compute.load_balancers.all(@datacenter_id)
 
-      load_balancer.name == 'fog-demo-load-balancer'
+      load_balancers.count > 0 &&
+        load_balancers[0].type == 'loadbalancer'
     end
 
-    tests('should retrieve all load balancers').succeeds do
-      load_balancers = compute.load_balancers.all(@datacenter_id)
+    tests('Get Load Balancer').succeeds do
+      load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
 
-      !load_balancers.empty?
+      load_balancer.id == @load_balancer_id &&
+        load_balancer.type == 'loadbalancer' &&
+        load_balancer.name == 'Fog Test' &&
+        load_balancer.dhcp == true
     end
 
-    tests('should update a load balancer').succeeds do
+    tests('Update Load Balancer').succeeds do
       load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
-      load_balancer.name = load_balancer.name + ' - updated'
+      load_balancer.name = load_balancer.name + ' - RENAME'
       load_balancer.update
+
+      sleep(60) if ENV["FOG_MOCK"] != "true"
+
+      load_balancer.id == @load_balancer_id &&
+        load_balancer.type == 'loadbalancer' &&
+        load_balancer.name == 'Fog Test - RENAME'
     end
 
-    tests('should associate a NIC to a load balancer').succeeds do
+    tests('Associate Balanced NIC').succeeds do
       load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
       nic = load_balancer.associate_nic(@nic_id)
 
       sleep(60) if ENV["FOG_MOCK"] != "true"
 
-      nic
+      nic['id'] == @nic_id &&
+        nic['name'] == 'Fog Test - RENAME'
     end
 
-    tests('should retrieve all load balanced NICs').succeeds do
+    tests('List Balanced NICs').succeeds do
       load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
+      balanced_nics = load_balancer.list_nics
 
-      load_balancer.list_nics
+      balanced_nics.count > 0 &&
+        balanced_nics[0]['type'] == 'nic'
     end
 
-    tests('should retrieve a load balanced NIC').succeeds do
+    tests('Get Balanced NIC').succeeds do
       load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
-      nic = load_balancer.get_nic(@nic_id)
+      balanced_nic = load_balancer.get_nic(@nic_id)
 
-      nic['id'] == @nic_id
+      balanced_nic['id'].to_s == @nic_id.to_s &&
+        balanced_nic['type'] == 'nic' &&
+        balanced_nic['name'] == 'Fog Test - RENAME' &&
+        ((balanced_nic['mac'] =~ /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/) == 0) &&
+        balanced_nic['ips'].count > 0 &&
+        ['true', 'false', true, false].include?(balanced_nic['nat'])
     end
 
-    tests('should remove a NIC association from a load balancer').succeeds do
-      load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
-      result = load_balancer.remove_nic_association(@nic_id)
+    tests('List Resources').succeeds do
+      resources = compute.resources.all
 
-      sleep(60) if ENV["FOG_MOCK"] != "true"
+      datacenter = resources.find do |r|
+        r.type == 'datacenter'
+      end
 
-      result
+      image = resources.find do |r|
+        r.type == 'image'
+      end
+
+      snapshot = resources.find do |r|
+        r.type == 'snapshot'
+      end
+
+      ipblock = resources.find do |r|
+        r.type == 'ipblock'
+      end
+
+      @dc_id = datacenter.id
+      @img_id = image.id
+      @snp_id = snapshot.id
+      @ipb_id = ipblock.id
+
+      resources.count > 0
     end
 
-    tests('should update a load balancer').succeeds do
-      load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
-      load_balancer.name = load_balancer.name + ' - updated'
-      load_balancer.update
+    tests('List Datacenter Resources').succeeds do
+      resources = compute.resources.get_by_type('datacenter')
+
+      resources.count > 0 &&
+        resources[0].type == 'datacenter'
     end
 
-    tests('should create an ip block').succeeds do
-      ip_block = compute.ip_blocks.create(:location => 'de/fra',
-                                          :size     => 1,
-                                          :name     => 'fog-demo-ip-block')
+    tests('List Image Resources').succeeds do
+      resources = compute.resources.get_by_type('image')
 
-      sleep(60) if ENV["FOG_MOCK"] != "true"
+      resources.count > 0 &&
+        resources[0].type == 'image'
+    end
 
-      @ip_block_id = ip_block.id
-      ip_block.name == 'fog-demo-ip-block'
+    tests('List Snapshot Resources').succeeds do
+      resources = compute.resources.get_by_type('snapshot')
+
+      resources.count > 0 &&
+        resources[0].type == 'snapshot'
     end
 
-    tests('should retrieve an ip block by id').succeeds do
-      ip_block = compute.ip_blocks.get(@ip_block_id)
+    tests('List IP Block Resources').succeeds do
+      resources = compute.resources.get_by_type('ipblock')
 
-      ip_block.name == 'fog-demo-ip-block'
+      resources.count > 0 &&
+        resources[0].type == 'ipblock'
     end
 
-    tests('should retrieve all ip blocks').succeeds do
-      ip_blocks = compute.ip_blocks.all
+    tests('Get Datacenter Resource').succeeds do
+      resource = compute.resources.get_resource_by_type('datacenter', @dc_id)
 
-      !ip_blocks.empty?
+      resource.id == @dc_id &&
+        resource.type == 'datacenter'
     end
 
-    tests('should create a firewall rule').succeeds do
-      firewall_rule = compute.firewall_rules.create(:datacenter_id => @datacenter_id,
-                                                    :server_id => @server_id,
-                                                    :nic_id => @nic_id,
-                                                    :name           => 'fog-demo-firewall-rule',
-                                                    :protocol       => 'TCP')
+    tests('Get Image Resource').succeeds do
+      resource = compute.resources.get_resource_by_type('image', @img_id)
 
-      sleep(60) if ENV["FOG_MOCK"] != "true"
+      resource.id == @img_id &&
+        resource.type == 'image'
+    end
 
-      @firewall_rule_id = firewall_rule.id
+    tests('Get Snapshot Resource').succeeds do
+      resource = compute.resources.get_resource_by_type('snapshot', @snp_id)
 
-      firewall_rule.name == 'fog-demo-firewall-rule'
+      resource.id == @snp_id &&
+        resource.type == 'snapshot'
     end
 
-    tests('should retrieve a firewall rule').succeeds do
-      firewall_rule = compute.firewall_rules.get(@datacenter_id, @server_id, @nic_id, @firewall_rule_id)
+    tests('Get IP Block Resource').succeeds do
+      resource = compute.resources.get_resource_by_type('ipblock', @ipb_id)
 
-      firewall_rule.name == 'fog-demo-firewall-rule'
+      resource.id == @ipb_id &&
+        resource.type == 'ipblock'
     end
+  end
+
+  tests('user management success') do
+    Excon.defaults[:connection_timeout] = 500
+
+    tests('Create Group').succeeds do
+      group = compute.groups.create(:name => 'Fog Test',
+                                    :create_datacenter => true,
+                                    :create_snapshot => true,
+                                    :reserve_ip => true,
+                                    :access_activity_log => true)
+      group.wait_for {ready?}
 
-    tests('should retrieve all firewall rules').succeeds do
-      firewall_rules = compute.firewall_rules.all(@datacenter_id, @server_id, @nic_id)
+      @group_id = group.id
 
-      !firewall_rules.empty?
+      group.type == 'group' &&
+        group.name == 'Fog Test' &&
+        group.create_datacenter == true &&
+        group.create_snapshot == true &&
+        group.reserve_ip == true &&
+        group.access_activity_log == true
     end
 
-    tests('should update a firewall rule').succeeds do
-      firewall_rule = compute.firewall_rules.get(@datacenter_id, @server_id, @nic_id, @firewall_rule_id)
-      firewall_rule.name = firewall_rule.name + ' - updated'
-      firewall_rule.update
+    tests('List Groups').succeeds do
+      groups = compute.groups.all
+
+      groups.count > 0 &&
+        groups[0].type = 'group'
     end
 
-    tests('should delete a firewall rule').succeeds do
-      firewall_rule = compute.firewall_rules.get(@datacenter_id, @server_id, @nic_id, @firewall_rule_id)
+    tests('Get Group').succeeds do
+      group = compute.groups.get(@group_id)
 
-      firewall_rule.delete
+      group.id == @group_id &&
+        group.type == 'group' &&
+        group.name == 'Fog Test' &&
+        group.create_datacenter == true &&
+        group.create_snapshot == true &&
+        group.reserve_ip == true &&
+        group.access_activity_log == true
     end
 
-    tests('should delete a NIC').succeeds do
-      nic = compute.nics.get(@datacenter_id, @server_id, @nic_id)
+    tests('Update Group').succeeds do
+      group = compute.groups.get(@group_id)
+      group.name = group.name + ' - RENAME'
+      group.create_datacenter = false
+      group.update
+      group.wait_for {ready?}
+      group.reload
 
-      nic.delete
+      group.id == @group_id &&
+        group.type == 'group' &&
+        group.name == 'Fog Test - RENAME' &&
+        group.create_datacenter == false
     end
 
-    tests('should delete a lan').succeeds do
-      lan = compute.lans.get(@datacenter_id, @lan_id)
+    tests('Create Share').succeeds do
+      share = compute.shares.create(:group_id => @group_id,
+                                    :resource_id => @image_id,
+                                    :edit_privilege => true,
+                                    :share_privilege => true)
+      @share_id = share.id
 
-      lan.delete
+      share.type == 'resource' &&
+        share.edit_privilege == true &&
+        share.share_privilege == true
+    end
+
+    tests('List Shares').succeeds do
+      shares = compute.shares.all(@group_id)
+
+      shares.count > 0 &&
+        shares[0].type = 'resource'
+    end
+
+    tests('Get Share').succeeds do
+      share = compute.shares.get(@group_id, @image_id)
+
+      share.id == @image_id &&
+        share.type == 'resource' &&
+        share.edit_privilege == true &&
+        share.share_privilege == true
+    end
+
+    tests('Update Share').succeeds do
+      share = compute.shares.get(@group_id, @image_id)
+      share.edit_privilege = false
+      share.update
+
+      share.id == @image_id &&
+        share.type == 'resource' &&
+        share.edit_privilege == false
+    end
+
+    tests('Create User').succeeds do
+      user = compute.users.create(:firstname => 'John',
+                                  :lastname => 'Doe',
+                                  :email => 'no-reply@example.com',
+                                  :password => 'secretpassword123',
+                                  :administrator => true,
+                                  :force_sec_auth => false)
+      user.wait_for {ready?}
+
+      @user_id = user.id
+
+      user.type == 'user' &&
+        user.firstname == 'John' &&
+        user.lastname == 'Doe' &&
+        user.email == 'no-reply@example.com' &&
+        user.administrator == true &&
+        user.force_sec_auth == false
+    end
+
+    tests('List Users').succeeds do
+      users = compute.users.all
+
+      users.count > 0 &&
+        users[0].type = 'user'
+    end
+
+    tests('Get User').succeeds do
+      user = compute.users.get(@user_id)
+
+      user.id == @user_id &&
+        user.type == 'user' &&
+        user.firstname == 'John' &&
+        user.lastname == 'Doe' &&
+        user.email == 'no-reply@example.com' &&
+        user.administrator == true &&
+        user.force_sec_auth == false &&
+        user.sec_auth_active == false
+    end
+
+    tests('Update User').succeeds do
+      user = compute.users.get(@user_id)
+      user.administrator = false
+      user.update
+
+      user.id == @user_id &&
+        user.type == 'user' &&
+        user.administrator == false &&
+        user.firstname == 'John' &&
+        user.lastname == 'Doe' &&
+        user.email == 'no-reply@example.com' &&
+        user.force_sec_auth == false
+    end
+
+    tests('Add User to Group').succeeds do
+      user = compute.users.add_group_user(@group_id, @user_id)
+
+      user.id == @user_id &&
+        user.type == 'user'
+    end
+
+    tests('Remove User from Group').succeeds do
+      compute.users.remove_group_user(@group_id, @user_id)
+    end
+  end
+
+  tests('user management failure') do
+    tests('Create Group Failure (Missing Required Parameter)') do
+      begin
+        options = {
+          create_datacenter: true
+        }
+
+        compute.create_group(options)
+      rescue Exception => e
+        returns(true, "exception contains 'Attribute 'name' is required'") {
+          e.message.include? "Attribute 'name' is required"
+        }
+      end
+    end
+
+    tests('Get Group Failure (Nonexistent)') do
+      begin
+        compute.get_group('00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Get share Failure (Nonexistent)') do
+      begin
+        compute.get_share(@group_id, '00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Create User Failure (Missing Required Parameter)') do
+      begin
+        options = {
+          firstname: 'John',
+          lastname: 'Doe'
+        }
+
+        compute.create_user(options)
+      rescue Exception => e
+        returns(true, "exception contains 'Attribute 'email' is required'") {
+          e.message.include? "Attribute 'email' is required"
+        }
+      end
+    end
+
+    tests('Get User Failure (Nonexistent)') do
+      begin
+        compute.get_user('00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+  end
+
+  tests('failure') do
+    tests('Get Location Failure (Nonexistent)') do
+      begin
+        compute.get_location('00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Create Datacenter Failure (Missing Required Parameter)') do
+      options = {
+        name: 'Fog Datacenter'
+      }
+
+      begin
+        compute.create_datacenter(options)
+      rescue Exception => e
+        returns(true, "exception contains 'Attribute 'location' is required'") {
+          e.message.include? "Attribute 'location' is required"
+        }
+      end
+    end
+
+    tests('Get Datacenter Failure (Nonexistent)') do
+      begin
+        compute.get_datacenter('00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, "exception contains 'Resource does not exist'") {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Get LAN Failure (Nonexistent)') do
+      begin
+        compute.get_lan('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, "exception contains 'Resource does not exist'") {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Get Image Failure (Nonexistent)') do
+      begin
+        compute.get_image('00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, "exception contains 'Resource does not exist'") {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Create Volume Failure (Missing Required Parameter)') do
+      options = {
+        name: 'Fog Test'
+      }
+
+      begin
+        compute.create_volume(@datacenter_id, options)
+      rescue Exception => e
+        returns(true, "exception contains 'Attribute 'size' is required'") {
+          e.message.include? "Attribute 'size' is required"
+        }
+      end
+    end
+
+    tests('Create Server Failure (Missing Required Parameter)') do
+      options = {
+        name: 'Fog Test',
+        ram: 1024
+      }
+
+      begin
+        compute.create_server(@datacenter_id, options)
+      rescue Exception => e
+        returns(true, "exception contains 'Attribute 'cores' is required'") {
+          e.message.include? "Attribute 'cores' is required"
+        }
+      end
+    end
+
+    tests('Get Server Failure (Nonexistent)') do
+      begin
+        compute.get_server('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, "exception contains 'Resource does not exist'") {
+          e.message.include? 'Resource does not exist'
+        }
+      end
     end
 
-    tests('should delete a load balancer').succeeds do
+    tests('Get Volume Failure (Nonexistent)') do
+      begin
+        compute.get_volume('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, "exception contains 'Resource does not exist'") {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Get Snapshot Failure (Nonexistent)') do
+      begin
+        compute.get_snapshot('00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, "exception contains 'Resource does not exist'") {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Get Request Failure (Nonexistent)') do
+      begin
+        compute.get_request('00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, "exception contains 'Resource does not exist'") {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Get IP Block Failure (Nonexistent)') do
+      begin
+        compute.get_ip_block('00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Create NIC Failure (Missing Required Parameter)') do
+      begin
+        compute.nics.create(:datacenter_id => @datacenter_id,
+                            :server_id => @server_id,
+                            :name => 'Fog Test')
+      rescue Exception => e
+        returns(true, "exception contains 'lan is required for this operation'") {
+          e.message.include? "lan is required for this operation"
+        }
+      end
+    end
+
+    tests('Get NIC Failure (Nonexistent)') do
+      begin
+        compute.get_nic('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Create Firewall Rule Failure (Missing Required Parameter)') do
+      begin
+        compute.firewall_rules.create(:datacenter_id => @datacenter_id,
+                                      :server_id => @server_id,
+                                      :nic_id => @nic_id,
+                                      :name => 'Fog Test')
+      rescue Exception => e
+        returns(true, "exception contains 'protocol is required for this operation'") {
+          e.message.include? "protocol is required for this operation"
+        }
+      end
+    end
+
+    tests('Get Firewall Rule Failure (Nonexistent)') do
+      begin
+        compute.get_firewall_rule('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000',
+                                  '00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('Create Load Balancer Failure (Missing Required Parameter)') do
+      begin
+        compute.create_load_balancer(@datacenter_id)
+      rescue Exception => e
+        returns(true, "exception contains 'Attribute 'name' is required'") {
+          e.message.include? "Attribute 'name' is required"
+        }
+      end
+    end
+
+    tests('Get Load Balancer Failure (Nonexistent)') do
+      begin
+        compute.get_load_balancer(@datacenter_id, '00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('List Resources Failure (Nonexistent)') do
+      begin
+        compute.resources.get_by_type('unknown')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+
+    tests('List Resources Type Failure (Nonexistent)') do
+      begin
+        compute.resources.get_resource_by_type('datacenter', '00000000-0000-0000-0000-000000000000')
+      rescue Exception => e
+        returns(true, 'exception contains \'Resource does not exist\'') {
+          e.message.include? 'Resource does not exist'
+        }
+      end
+    end
+  end
+
+  tests('user management cleanup') do
+    Excon.defaults[:connection_timeout] = 500
+
+    tests('Remove User').succeeds do
+      user = compute.users.get(@user_id)
+
+      user.delete
+    end
+
+    tests('Remove Share').succeeds do
+      share = compute.shares.get(@group_id, @image_id)
+
+      share.delete
+    end
+
+    tests('Remove Group').succeeds do
+      group = compute.groups.get(@group_id)
+
+      group.delete
+    end
+  end
+
+  tests('cleanup') do
+    Excon.defaults[:connection_timeout] = 500
+
+    tests('Remove Balanced NIC').succeeds do
+      load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
+      result = load_balancer.remove_nic_association(@nic_id)
+
+      sleep(60) if ENV["FOG_MOCK"] != "true"
+
+      result
+    end
+
+    tests('Remove Load Balancer').succeeds do
       load_balancer = compute.load_balancers.get(@datacenter_id, @load_balancer_id)
 
       load_balancer.delete
     end
 
-    tests('should delete an ip block').succeeds do
-      ip_block = compute.ip_blocks.get(@ip_block_id)
+    tests('Remove Firewall Rule').succeeds do
+      firewall_rule = compute.firewall_rules.get(@datacenter_id, @composite_server_id, @nic_id, @firewall_rule_id)
 
-      ip_block.delete
+      firewall_rule.delete
     end
 
-    tests('should delete a server').succeeds do
-      server = compute.servers.get(@datacenter_id, @server_id)
+    tests('Release IP Block').succeeds do
+      ip_block = compute.ip_blocks.get(@ip_block_id)
 
-      server.delete
+      ip_block.delete
     end
 
-    tests('should delete a volume').succeeds do
-      volume = compute.volumes.get(@datacenter_id, @volume_id)
+    tests('Remove NIC').succeeds do
+      sleep(60) if ENV["FOG_MOCK"] != "true"
+      nic = compute.nics.get(@datacenter_id, @composite_server_id, @nic_id)
 
-      volume.delete
+      nic.delete
     end
 
-    if ENV["FOG_MOCK"] == "true"
-      tests('should delete an image').succeeds do
-        image = compute.images.get(@image_id)
+    tests('Remove LAN').succeeds do
+      sleep(60) if ENV["FOG_MOCK"] != "true"
+      lan = compute.lans.get(@datacenter_id, @lan_id)
 
-        image.delete
-      end
+      lan.delete
     end
 
-    tests('should delete a snapshot').succeeds do
+    tests('Remove Snapshot').succeeds do
       snapshot = compute.snapshots.get(@snapshot_id)
 
       snapshot.delete
     end
 
-    tests('should delete a datacenter').succeeds do
+    tests('Remove Volume').succeeds do
+      volume = compute.volumes.get(@datacenter_id, @volume_id)
+
+      volume.delete
+    end
+
+    tests('Remove Server').succeeds do
+      server = compute.servers.get(@datacenter_id, @server_id)
+      composite_server = compute.servers.get(@datacenter_id, @composite_server_id)
+
+      server.delete and composite_server.delete
+    end
+
+    tests('Remove Datacenter').succeeds do
       datacenter = compute.datacenters.get(@datacenter_id)
+      composite_dc = compute.datacenters.get(@composite_dc_id)
 
-      datacenter.delete
+      datacenter.delete and composite_dc.delete
     end
   end
 end