fog-profitbricks 0.0.5 → 2.0.1

data/tests/profitbricks/requests/compute/request_tests.rb

@@ -0,0 +1,52 @@
+Shindo.tests('Fog::Compute[:profitbricks] | request request', ['profitbricks', 'compute']) do
+
+  @requests_schema = {
+    'id'    => String,
+    'type'  => String,
+    'href'  => String,
+    'items' => Array
+  }
+
+  @request_schema = {
+    'id'          => String,
+    'type'        => String,
+    'href'        => String,
+    'metadata'    => Hash,
+    'properties'  => Hash
+  }
+
+  service = Fog::Compute[:profitbricks]
+
+  tests('success') do
+
+    Excon.defaults[:connection_timeout] = 500
+
+    tests('#get_all_requests').data_matches_schema(@requests_schema) do
+      data = service.get_all_requests
+
+      @request_id = data.body['items'][0]['id']
+
+      data.body
+    end
+
+    tests('#get_request').data_matches_schema(@request_schema) do
+      data = service.get_request(@request_id)
+      data.body
+    end
+
+    tests('#get_request_status').data_matches_schema(@request_schema) do
+      data = service.get_request(@request_id)
+      data.body
+    end
+  end
+
+  tests('failure') do
+    tests('#get_location').raises(ArgumentError) do
+      service.get_request
+    end
+
+    tests('#get_location_status').raises(ArgumentError) do
+      service.get_request_status
+    end
+  end
+end

data/tests/profitbricks/requests/compute/server_tests.rb

@@ -1,46 +1,18 @@
 Shindo.tests('Fog::Compute[:profitbricks] | server request', ['profitbricks', 'compute']) do
 
-  @data_center_format = {
-    'requestId'         => String,
-    'dataCenterId'      => String,
-    'dataCenterName'    => String,
-    'dataCenterVersion' => Integer,
-    'provisioningState' => 'AVAILABLE',
-    'location'          => String
+  @resource_schema = {
+      'id'                  => String,
+      'type'                => String,
+      'href'                => String,
+      'metadata'            => Hash,
+      'properties'          => Hash
   }
 
-  @server_format = {
-    'serverId'             => String,
-    'serverName'           => 'FogServer',
-    'cores'                => Integer,
-    'ram'                  => Integer,
-    'internetAccess'       => String,
-    'connectedStorages'    => Fog::Nullable::Array,
-    'nics'                 => Fog::Nullable::Array,
-    'provisioningState'    => 'AVAILABLE',
-    'virtualMachineState'  => 'RUNNING',
-    'creationTime'         => Time,
-    'lastModificationTime' => Time,
-    'osType'               => String,
-    'availabilityZone'     => 'AUTO' || 'ZONE_1' || 'ZONE_2',
-  }
-
-  @storage_format = {
-    'dataCenterId'         => String,
-    'dataCenterVersion'    => Integer,
-    'storageId'            => String,
-    'size'                 => Integer,
-    'storageName'          => String,
-    'mountImage'           => Hash,
-    'provisioningState'    => 'AVAILABLE',
-    'creationTime'         => Time,
-    'lastModificationTime' => Time
-  }
-
-  @minimal_format = {
-    'requestId'         => String,
-    'dataCenterId'      => String,
-    'dataCenterVersion' => Integer
+  @minimal_schema_with_items = {
+      'id'    => String,
+      'type'  => String,
+      'href'  => String,
+      'items' => Array
   }
 
   service = Fog::Compute[:profitbricks]
@@ -49,201 +21,452 @@ Shindo.tests('Fog::Compute[:profitbricks] | server request', ['profitbricks', 'c
 
     Excon.defaults[:connection_timeout] = 500
 
-    tests('#create_data_center').formats(@minimal_format.merge('location' => String)) do
-      # puts '#create_data_center'
-      data = service.create_data_center('FogDataCenter', 'us/las')
-      @data_center_id = data.body['createDataCenterResponse']['dataCenterId']
-      service.datacenters.get(@data_center_id).wait_for { ready? }
-      data.body['createDataCenterResponse']
-    end
-
-    tests('#get_data_center').formats(@data_center_format) do
-      # puts '#get_data_center'
-      data = service.get_data_center(@data_center_id)
-      data.body['getDataCenterResponse']
-    end
-
-    tests('#get_all_data_centers').formats({
-      'dataCenterId' => String,
-      'dataCenterName' => String,
-      'dataCenterVersion' => Integer
-    }) do
-      # puts '#get_all_data_centers'
-      data = service.get_all_data_centers
-      data.body['getAllDataCentersResponse'].find { |dc|
-        dc['dataCenterId'] == @data_center_id
-      }
+    tests('#create_datacenter').data_matches_schema(@resource_schema) do
+      options = {}
+      options[:name]        = 'FogDataCenter'
+      options[:location]    = 'us/las'
+      options[:description] = 'Part of server tests suite'
+
+      createDatacenterResponse = service.create_datacenter(options)
+      @datacenter_id = createDatacenterResponse.body['id']
+
+      if ENV["FOG_MOCK"] != "true"
+        service.datacenters.get(@datacenter_id).wait_for { ready? }
+      end
+
+      createDatacenterResponse.body
+    end
+
+    tests('#get_datacenter').data_matches_schema(@resource_schema) do
+      getDatacenterResponse = service.get_datacenter(@datacenter_id)
+      getDatacenterResponse.body
     end
 
-    tests('#update_data_center').formats(@minimal_format) do
-      # puts '#update_data_center'
-      data = service.update_data_center(
-        @data_center_id, { 'dataCenterName' => 'FogDataCenterRename' }
+    tests('#get_all_datacenters').data_matches_schema(@minimal_schema_with_items) do
+      getAllDatacentersResponse = service.get_all_datacenters
+      getAllDatacentersResponse.body
+    end
+
+    tests('#update_datacenter').data_matches_schema(@resource_schema) do
+      options = {}
+      options[:name] = 'FogDataCenterRename'
+      options[:description] = 'FogDataCenterDescriptionUpdated'
+
+      updateDatacenterResponse = service.update_datacenter(
+        @datacenter_id, options
       )
-      data.body['updateDataCenterResponse']
+
+      if ENV["FOG_MOCK"] != "true"
+        service.datacenters.get(@datacenter_id).wait_for { ready? }
+      end
+
+      updateDatacenterResponse.body
     end
 
-    tests('#get_all_images') do
-      # puts '#get_all_images'
-      data = service.get_all_images.body['getAllImagesResponse'].find { |image|
-        image['location'] == 'us/las' &&
-        image['imageType'] == 'HDD' &&
-        image['osType'] == 'LINUX'
+    tests('#get_all_images').data_matches_schema(@minimal_schema_with_items) do
+      getAllImagesResponse = service.get_all_images
+      data = service.get_all_images.body['items'].find { |image|
+        image['properties']['location'] == 'us/las' &&
+        image['properties']['imageType'] == 'CDROM' &&
+        image['properties']['licenceType'] == 'LINUX'
       }
-      @image_id = data['imageId']
+      @image_id = data['id']
+      getAllImagesResponse.body
     end
 
-    tests('#create_storage') do
-      # puts '#create_storage'
-      data = service.create_storage(
-        @data_center_id, 5, {
-          'storageName' => 'FogVolume',
-          'mountImageId' => @image_id
-        }
-      )
-      @storage_id = data.body['createStorageResponse']['storageId']
-      service.volumes.get(@storage_id).wait_for { ready? }
-      data.body['createStorageResponse']
+    tests('#get_image').data_matches_schema(@resource_schema) do
+      getImageResponse = service.get_image(@image_id)
+      getImageResponse.body
     end
 
-    tests('#get_storage').formats(@storage_format) do
-      # puts '#get_storage'
-      data = service.get_storage(@storage_id).body['getStorageResponse']
+    if ENV["FOG_MOCK"] == "true"
+      tests('#update_image').data_matches_schema(@resource_schema) do
+        options = {}
+        options[:name]                = 'FogImageRename'
+        options[:description]         = 'FogImageDescriptionUpdated'
+
+        updateImageResponse = service.update_image(
+            @image_id, options
+        )
+
+        updateImageResponse.body
+      end
     end
 
-    tests('#get_all_storages').formats(@storage_format) do
-      # puts '#get_all_storages'
-      data = service.get_all_storages
-      data.body['getAllStoragesResponse'].find {
-        |storage| storage['storageId'] == @storage_id
+    tests('#get_all_volumes').data_matches_schema(@minimal_schema_with_items) do
+      if dc = service.get_all_datacenters.body["items"].find {
+          |datacenter| datacenter["id"] == @datacenter_id
       }
+      else
+        raise Fog::Errors::NotFound.new("The requested resource could not be found")
+      end
+
+      getAllVolumesResponse = service.get_all_volumes(dc['id'])
+      getAllVolumesResponse.body
     end
 
-    tests('#update_storage').formats(@minimal_format) do
-      # puts '#update_storage'
-      service.update_storage(@storage_id, { 'size' => 6 }).body['updateStorageResponse']
+    tests('#create_volume').data_matches_schema(@resource_schema) do
+      options = {}
+      options[:name]        = 'FogRestTestVolume'
+      options[:size]        = 5
+      options[:licenceType] = 'LINUX'
+      options[:type]        = 'HDD'
+
+      createVolumeResponse = service.create_volume(@datacenter_id, options)
+      @volume_id = createVolumeResponse.body['id']
+
+      if ENV["FOG_MOCK"] != "true"
+        loop do
+          sleep(5)
+          vlm = service.volumes.get(@datacenter_id, @volume_id)
+          break unless !vlm.ready?
+        end
+      end
+
+      # Calling wait_for causes ArgumentError
+      # vlm.wait_for { ready? }
+
+      createVolumeResponse.body
     end
 
-    tests('#create_server').formats(@minimal_format.merge('serverId' => String)) do
-      # puts '#create_server'
-      data = service.create_server(@data_center_id, 1, 512, { 
-        'serverName' => 'FogServer',
-        'bootFromStorageId' => @storage_id
-      })
-      @server_id = data.body['createServerResponse']['serverId']
-      service.servers.get(@server_id).wait_for { ready? }
-      data.body['createServerResponse']
+    tests('#get_volume').data_matches_schema(@resource_schema) do
+      getVolumeResponse = service.get_volume(@datacenter_id, @volume_id)
+      getVolumeResponse.body
     end
 
-    tests('#get_all_servers').formats(@server_format.merge(
-      'dataCenterId' => String, 'dataCenterVersion' => Integer
-    )) do
-      # puts '#get_all_servers'
-      data = service.get_all_servers
-      data.body['getAllServersResponse'].find {
-        |server| server['serverId'] == @server_id
-      }
+    tests('#create_volume_snapshot').data_matches_schema(@resource_schema) do
+      options = {}
+      options[:name]        = 'FogRestTestSnapshot'
+      options[:description] = 'Testing fog create snapshot'
+
+      createVolumeSnapshotResponse = service.create_volume_snapshot(@datacenter_id, @volume_id, options)
+      @snapshot_id = createVolumeSnapshotResponse.body['id']
+
+      if ENV["FOG_MOCK"] != "true"
+        sleep(5)
+        snapshot = service.snapshots.get(@snapshot_id)
+        snapshot.wait_for { ready? }
+      end
+
+      createVolumeSnapshotResponse.body
+    end
+
+    tests('#update_volume').data_matches_schema(@resource_schema) do
+      options = {}
+      options[:name] = 'FogRestTestVolumeRenamed'
+      options[:size] = 6
+
+      updateVolumeResponse = service.update_volume(@datacenter_id, @volume_id, options)
+
+      if ENV["FOG_MOCK"] != "true"
+        loop do
+          sleep(1)
+          vlm = service.volumes.get(@datacenter_id, @volume_id)
+          break unless !vlm.ready?
+        end
+      end
+
+      # Calling wait_for causes ArgumentError
+      # vlm.wait_for { ready? }
+
+      updateVolumeResponse.body
+    end
+
+    tests('#update_snapshot').data_matches_schema(@resource_schema) do
+      options = {}
+      options[:name]        = 'FogRestTestSnapshotRename'
+      options[:description] = 'Testing fog create snapshot - updated description'
+      options[:ramHotPlug]  = true
+
+      updateSnapshotResponse = service.update_snapshot(@snapshot_id, options)
+
+      if ENV["FOG_MOCK"] != "true"
+        snapshot = service.snapshots.get(@snapshot_id)
+        snapshot.wait_for { ready? }
+      end
+      updateSnapshotResponse.body
+    end
+
+    tests('#get_snapshot').data_matches_schema(@resource_schema) do
+      getSnapshotResponse = service.get_snapshot(@snapshot_id)
+      getSnapshotResponse.body
+    end
+
+    tests('#restore_volume_snapshot').succeeds do
+      options = {}
+      options[:snapshot_id] = @snapshot_id
+
+      restoreVolumeSnapshotResponse = service.restore_volume_snapshot(@datacenter_id, @volume_id, options)
+      restoreVolumeSnapshotResponse.status == 202
+    end
+
+    tests('#get_all_snapshots').data_matches_schema(@minimal_schema_with_items) do
+      getAllSnapshotsResponse = service.get_all_snapshots
+      getAllSnapshotsResponse.body
+    end
+
+    tests('#create_server').data_matches_schema(@resource_schema) do
+      properties = {}
+      properties[:name]             = 'FogTestServer_2'
+      properties[:cores]            = 1
+      properties[:ram]              = 1024
+      properties[:availabilityZone] = 'ZONE_1'
+      properties[:cpuFamily]        = 'INTEL_XEON'
+
+      entities = {}
+      entities[:volumes] = {}
+      entities[:volumes]['items'] = [
+        {
+          'id' => @volume_id
+        }
+      ]
+
+      createServerResponse = service.create_server(@datacenter_id, properties, entities)
+      @server_id = createServerResponse.body['id']
+
+      if ENV["FOG_MOCK"] != "true"
+        loop do
+          sleep(480)
+          server = service.servers.get(@datacenter_id, @server_id)
+          break unless !server.ready?
+        end
+      end
+
+      # Calling wait_for causes ArgumentError
+      # server.wait_for { ready? }
+
+      createServerResponse.body
     end
 
-    tests('#get_server').formats(@server_format.merge(@minimal_format)) do
-      # puts '#get_server'
-      data = service.get_server(@server_id)
-      data.body['getServerResponse']
+    tests('#get_server').data_matches_schema(@resource_schema) do
+      getServerResponse = service.get_server(@datacenter_id, @server_id)
+      getServerResponse.body
     end
 
-    tests('#update_server').formats(@minimal_format) do
-      # puts '#update_server'
-      data = service.update_server(@server_id, { 'serverName' => 'FogServerRename' })
-      service.servers.get(@server_id).wait_for { ready? }
-      data.body['updateServerResponse']
+    tests('#list_attached_volumes').data_matches_schema(@minimal_schema_with_items) do
+      listAttachedVolumesResponse = service.list_attached_volumes(@datacenter_id, @server_id)
+      listAttachedVolumesResponse.body
     end
 
-    tests('#connect_storage_to_server').formats(@minimal_format) do
-      # puts '#connect_storage_to_server'
-      service.connect_storage_to_server(@storage_id, @server_id).body['connectStorageToServerResponse']
+    tests('#attach_volume').data_matches_schema(@resource_schema) do
+      attachVolumeResponse = service.attach_volume(@datacenter_id, @server_id, @volume_id)
+
+      if ENV["FOG_MOCK"] != "true"
+        loop do
+          vlm = service.volumes.get(@datacenter_id, @volume_id)
+          sleep(1)
+          break unless !vlm.ready?
+        end
+      end
+
+      # Calling wait_for causes ArgumentError
+      # vlm.wait_for { ready? }
+
+      attachVolumeResponse.body
+    end
+
+    tests('#get_attached_volume').data_matches_schema(@resource_schema) do
+      getAttachedVolumeResponse = service.get_attached_volume(@datacenter_id, @server_id, @volume_id)
+      getAttachedVolumeResponse.body
+    end
+
+    tests('#detach_volume').succeeds do
+      detachVolumeResponse = service.detach_volume(@datacenter_id, @server_id, @volume_id)
+      detachVolumeResponse.status == 202
+    end
+
+    tests('#attach_cdrom').data_matches_schema(@resource_schema) do
+      attachCdromResponse = service.attach_cdrom(@datacenter_id, @server_id, @image_id)
+
+      if ENV["FOG_MOCK"] != "true"
+        cd = service.images.get(@image_id)
+        cd.wait_for { ready? }
+      end
+
+      @cdrom_id = attachCdromResponse.body['id']
+
+      attachCdromResponse.body
+    end
+
+    tests('#get_attached_cdrom').data_matches_schema(@resource_schema) do
+      if ENV["FOG_MOCK"] != "true"
+        sleep(240)
+      end
+      getAttachedVolumeResponse = service.get_attached_cdrom(@datacenter_id, @server_id, @cdrom_id)
+      getAttachedVolumeResponse.body
+    end
+
+    tests('#list_attached_cdroms').data_matches_schema(@minimal_schema_with_items) do
+      listAttachedCdromsResponse = service.list_attached_cdroms(@datacenter_id, @server_id)
+
+      listAttachedCdromsResponse.body
+    end
+
+    tests('#detach_cdrom').succeeds do
+      detachVolumeResponse = service.detach_cdrom(@datacenter_id, @server_id, @cdrom_id)
+      detachVolumeResponse.status == 202
+    end
+
+    tests('#update_server').data_matches_schema(@resource_schema) do
+      updateServerResponse = service.update_server(@datacenter_id, @server_id, { 'name' => 'FogServerRename' })
+
+      if ENV["FOG_MOCK"] != "true"
+        loop do
+          server = service.servers.get(@datacenter_id, @server_id)
+          sleep(1)
+          break unless !server.ready?
+        end
+      end
+
+      # Calling wait_for causes ArgumentError
+      # server.wait_for { ready? }
+
+      updateServerResponse.body
+    end
+
+    tests('#get_all_servers').data_matches_schema(@minimal_schema_with_items) do
+      getAllServersResponse = service.get_all_servers(@datacenter_id)
+
+      getAllServersResponse.body
     end
 
     tests('#stop_server').succeeds do
-      # puts '#stop_server'
-      service.stop_server(@server_id)
-      service.servers.get(@server_id).wait_for { state == "INACTIVE" }
+      stopServerResponse = service.stop_server(@datacenter_id, @server_id)
+
+      if ENV["FOG_MOCK"] != "true"
+        loop do
+          server = service.servers.get(@datacenter_id, @server_id)
+          sleep(1)
+          break unless !server.shutoff?
+        end
+      end
+
+      # Calling wait_for causes ArgumentError
+      # server.wait_for { shutoff? }
+
+      stopServerResponse.status == 202
     end
 
     tests('#start_server').succeeds do
-      # puts '#start_server'
-      service.start_server(@server_id)
-      service.servers.get(@server_id).wait_for { state == "AVAILABLE" }
+      startServerResponse = service.start_server(@datacenter_id, @server_id)
+
+      if ENV["FOG_MOCK"] != "true"
+        loop do
+          server = service.servers.get(@datacenter_id, @server_id)
+          sleep(1)
+          break unless !server.running?
+        end
+      end
+
+      # Calling wait_for causes ArgumentError
+      # server.wait_for { running? }
+
+      startServerResponse.status == 202
     end
 
-    tests('#reset_server').succeeds do
-      # puts '#reset_server'
-      service.reset_server(@server_id)
-      service.servers.get(@server_id).wait_for { state == "AVAILABLE" }
+    tests('#reboot_server').succeeds do
+      rebootServerResponse = service.reboot_server(@datacenter_id, @server_id)
+
+      if ENV["FOG_MOCK"] != "true"
+        loop do
+          server = service.servers.get(@datacenter_id, @server_id)
+          sleep(1)
+          break unless !server.running?
+        end
+      end
+
+      rebootServerResponse.status == 202
     end
 
-    tests('#disconnect_storage_from_server').formats(@minimal_format) do
-      # puts '#disconnect_storage_from_server'
-      service.disconnect_storage_from_server(@storage_id, @server_id).body['disconnectStorageFromServerResponse']
+    tests('#delete_server').succeeds do
+      deleteServerResponse = service.delete_server(@datacenter_id, @server_id)
+      deleteServerResponse.status == 202
     end
 
-    tests('#delete_storage').formats(@minimal_format) do
-      # puts '#delete_storage'
-      data = service.delete_storage(@storage_id)
-      data.body['deleteStorageResponse']
+    tests('#delete_snapshot').succeeds do
+      deleteSnapshotResponse = service.delete_snapshot(@snapshot_id)
+      deleteSnapshotResponse.status == 202
     end
 
-    tests('#delete_server').formats(@minimal_format) do
-      # puts '#delete_server'
-      data = service.delete_server(@server_id)
-      data.body['deleteServerResponse']
+    tests('#delete_volume').succeeds do
+      deleteVolumeResponse = service.delete_volume(@datacenter_id, @volume_id)
+      deleteVolumeResponse.status == 202
     end
 
-    tests('#clear_data_center').formats(@minimal_format) do
-      data = service.clear_data_center(@data_center_id)
-      data.body['clearDataCenterResponse']
+    if ENV["FOG_MOCK"] == "true"
+      tests('#delete_image').succeeds do
+        deleteImageResponse = service.delete_image(@image_id)
+        deleteImageResponse.status == 202
+      end
     end
 
-    tests('#delete_data_center').formats({'requestId' => String}) do
-      # puts '#delete_data_center'
-      service.delete_data_center(@data_center_id).body['deleteDataCenterResponse']
+    tests('#delete_datacenter').succeeds do
+      deleteDatacenterResponse = service.delete_datacenter(@datacenter_id)
+      deleteDatacenterResponse.status == 202
     end
   end
 
   tests('failure') do
 
-    tests('#get_data_center').raises(Fog::Errors::NotFound) do
-      # puts '#get_data_center'
-      service.get_data_center('00000000-0000-0000-0000-000000000000')
+    tests('#get_datacenter').raises(Fog::Errors::NotFound) do
+      service.get_datacenter('00000000-0000-0000-0000-000000000000')
+    end
+
+    tests('#update_datacenter').raises(Fog::Errors::NotFound) do
+      service.update_datacenter('00000000-0000-0000-0000-000000000000',
+                    { 'name' => 'FogTestDCRename' })
+    end
+
+    tests('#delete_datacenter').raises(Fog::Errors::NotFound) do
+      service.delete_datacenter('00000000-0000-0000-0000-000000000000')
     end
 
-    tests('#update_data_center').raises(Fog::Errors::NotFound) do
-      # puts '#update_data_center'
-      service.update_data_center('00000000-0000-0000-0000-000000000000',
-                    { 'dataCenterName' => 'FogTestDCRename' })
+    tests('#get_image').raises(Fog::Errors::NotFound) do
+      service.get_image('00000000-0000-0000-0000-000000000000')
     end
 
-    tests('#delete_data_center').raises(Fog::Errors::NotFound) do
-      # puts '#delete_data_center'
-      service.delete_data_center('00000000-0000-0000-0000-000000000000')
+    tests('#update_image').raises(Fog::Errors::NotFound) do
+      service.update_image('00000000-0000-0000-0000-000000000000', {})
     end
-     tests('#create_storage').raises(ArgumentError) do
-      # puts '#create_storage'
-      service.create_storage
+
+    tests('#create_volume').raises(ArgumentError) do
+      service.create_volume
+    end
+
+    tests('#create_volume_snapshot').raises(ArgumentError) do
+      service.create_volume_snapshot
+    end
+
+    tests('#create_volume_snapshot').raises(Fog::Errors::NotFound) do
+      service.create_volume_snapshot('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000', {})
+    end
+
+    tests('#get_snapshot').raises(Fog::Errors::NotFound) do
+      service.get_snapshot('00000000-0000-0000-0000-000000000000')
+    end
+
+    tests('#get_snapshot').raises(ArgumentError) do
+      service.get_snapshot
+    end
+
+    tests('#restore_volume_snapshot').raises(ArgumentError) do
+      service.restore_volume_snapshot
+    end
+
+    tests('#restore_volume_snapshot').raises(Fog::Errors::NotFound) do
+      service.restore_volume_snapshot('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000', {})
     end
 
-    tests('#get_storage').raises(Fog::Errors::NotFound) do
-      # puts '#get_storage'
-      service.get_storage('00000000-0000-0000-0000-000000000000')
+    tests('#get_volume').raises(Fog::Errors::NotFound) do
+      service.get_volume('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000')
     end
 
-    tests('#update_storage').raises(Fog::Errors::NotFound) do
-      # puts '#update_storage'
-      service.update_storage('00000000-0000-0000-0000-000000000000')
+    tests('#update_volume').raises(Fog::Errors::NotFound) do
+      service.update_volume('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000')
     end
 
-    tests('#delete_storage').raises(Fog::Errors::NotFound) do
-      # puts '#delete_storage'
-      service.delete_storage('00000000-0000-0000-0000-000000000000')
+    tests('#delete_volume').raises(Fog::Errors::NotFound) do
+      service.delete_volume('00000000-0000-0000-0000-000000000000', '00000000-0000-0000-0000-000000000000')
     end
   end
 end