fission 0.4.0 → 0.5.0.beta.1

data/spec/fission/vm_spec.rb

@@ -1,9 +1,8 @@
-require File.expand_path('../../spec_helper.rb', __FILE__)
+require 'spec_helper'
 
 describe Fission::VM do
   before do
     @vm = Fission::VM.new('foo')
-    @vm.stub!(:conf_file).and_return(File.join(@vm.path, 'foo.vmx'))
     @conf_file_path = File.join(@vm.path, 'foo.vmx')
     @vmrun_cmd = Fission.config['vmrun_cmd']
     @conf_file_response_mock = mock('conf_file_response')
@@ -15,366 +14,193 @@ describe Fission::VM do
     end
   end
 
-  describe 'start' do
+  describe 'delete' do
     before do
-      @running_response_mock = mock('running?')
-
-      @vm.stub(:exists?).and_return(true)
-      @vm.stub(:running?).and_return(@running_response_mock)
-      @vm.stub(:conf_file).and_return(@conf_file_response_mock)
-      @running_response_mock.stub_as_successful false
-      @conf_file_response_mock.stub_as_successful @conf_file_path
+      @vm_deleter           = mock 'vm deleter'
+      @delete_response_mock = mock 'vm delete response'
+      Fission::Action::VM::Deleter.stub(:new).and_return(@vm_deleter)
+      @vm_deleter.should_receive(:delete).
+                  and_return(@delete_response_mock)
     end
 
-    it "should return an unsuccessful response if the vm doesn't exist" do
-      @vm.stub(:exists?).and_return(false)
-      @vm.start.should be_an_unsuccessful_response 'VM does not exist'
+    it 'should return an unsuccessful response when unable to delete the vm' do
+      @delete_response_mock.stub_as_unsuccessful
+      @vm.delete.should be_an_unsuccessful_response
     end
 
-    it 'should return an unsuccessful response if the vm is already running' do
-      @running_response_mock.stub_as_successful true
-      @vm.start.should be_an_unsuccessful_response 'VM is already running'
+    it 'should return a successful response when deleting' do
+      @delete_response_mock.stub_as_successful
+      @vm.delete.should be_a_successful_response
     end
+  end
 
-    it 'should return an unsuccessful response if unable to determine if running' do
-      @running_response_mock.stub_as_unsuccessful
-      @vm.start.should be_an_unsuccessful_response
+  describe 'start' do
+    before do
+      @vm_starter          = mock 'vm starter'
+      @start_response_mock = mock 'vm start response'
+      Fission::Action::VM::Starter.stub(:new).and_return(@vm_starter)
     end
 
-    it 'should return an unsuccessful response if unable to figure out the conf file' do
-      @conf_file_response_mock.stub_as_unsuccessful
+    it 'should return an unsuccessful response when unable to start the vm' do
+      @vm_starter.should_receive(:start).
+                  and_return(@start_response_mock)
+      @start_response_mock.stub_as_unsuccessful
       @vm.start.should be_an_unsuccessful_response
     end
 
-    describe 'when the fusion gui is not running' do
-      before do
-        Fission::Fusion.stub(:running?).and_return(false)
-      end
-
-      it 'should start the VM and return a successful response' do
-        $?.should_receive(:exitstatus).and_return(0)
-        @vm.should_receive(:`).
-            with("#{@vmrun_cmd} start #{@conf_file_path.gsub(' ', '\ ')} gui 2>&1").
-            and_return("it's all good")
-
-        @vm.start.should be_a_successful_response
-      end
-
-      it 'should successfully start the vm headless' do
-        $?.should_receive(:exitstatus).and_return(0)
-        @vm.should_receive(:`).
-            with("#{@vmrun_cmd} start #{@conf_file_path.gsub(' ', '\ ')} nogui 2>&1").
-            and_return("it's all good")
-
-        @vm.start(:headless => true).should be_a_successful_response
-      end
-
-      it 'should return an unsuccessful response if there was an error starting the VM' do
-        $?.should_receive(:exitstatus).and_return(1)
-        @vm.should_receive(:`).
-            with("#{@vmrun_cmd} start #{@conf_file_path.gsub(' ', '\ ')} gui 2>&1").
-            and_return("it blew up")
-
-        @vm.start.should be_an_unsuccessful_response
-      end
+    it 'should return a successful response when starting headless' do
+      @vm_starter.should_receive(:start).
+                  with(:headless => true).
+                  and_return(@start_response_mock)
+      @start_response_mock.stub_as_successful
+      @vm.start(:headless => true).should be_a_successful_response
     end
 
-    describe 'when the fusion gui is running' do
-      before do
-        Fission::Fusion.stub(:running?).and_return(true)
-      end
-
-      it 'should return an unsuccessful response if starting headless' do
-        response = @vm.start :headless => true
-
-        error_string = 'It looks like the Fusion GUI is currently running.  '
-        error_string << 'A VM cannot be started in headless mode when the Fusion GUI is running.  '
-        error_string << 'Exit the Fusion GUI and try again.'
-
-        response.should be_an_unsuccessful_response error_string
-      end
+    it 'should return a successful response when starting' do
+      @vm_starter.should_receive(:start).
+                  and_return(@start_response_mock)
+      @start_response_mock.stub_as_successful
+      @vm.start.should be_a_successful_response
     end
-
   end
 
   describe 'stop' do
     before do
-      @running_response_mock = mock('running?')
-
-      @vm.stub(:exists?).and_return(true)
-      @vm.stub(:running?).and_return(@running_response_mock)
-      @vm.stub(:conf_file).and_return(@conf_file_response_mock)
-      @running_response_mock.stub_as_successful true
-      @conf_file_response_mock.stub_as_successful @conf_file_path
-    end
-
-    it "should return an unsuccessful response if the vm doesn't exist" do
-      @vm.stub(:exists?).and_return(false)
-      @vm.stop.should be_an_unsuccessful_response 'VM does not exist'
-    end
-
-    it 'should return an unsuccessful response if the vm is not running' do
-      @running_response_mock.stub_as_successful false
-      @vm.stop.should be_an_unsuccessful_response 'VM is not running'
+      @vm_stopper         = mock 'vm stopper'
+      @stop_response_mock = mock 'vm stop response'
+      Fission::Action::VM::Stopper.stub(:new).and_return(@vm_stopper)
     end
 
-    it 'should return an unsuccessful response if unable to determine if running' do
-      @running_response_mock.stub_as_unsuccessful
-      @vm.stop.should be_an_unsuccessful_response
+    it 'should return a successful response when stopping' do
+      @vm_stopper.should_receive(:stop).
+                  and_return(@stop_response_mock)
+      @stop_response_mock.stub_as_successful
+      @vm.stop.should be_a_successful_response
     end
 
-    it 'should return an unsuccessful response if unable to figure out the conf file' do
-      @conf_file_response_mock.stub_as_unsuccessful
+    it 'should return an unsuccessful response when unable to stop the vm' do
+      @vm_stopper.should_receive(:stop).
+                  and_return(@stop_response_mock)
+      @stop_response_mock.stub_as_unsuccessful
       @vm.stop.should be_an_unsuccessful_response
     end
 
-    it 'should return a successful response and stop the vm' do
-      $?.should_receive(:exitstatus).and_return(0)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} stop #{@conf_file_path.gsub ' ', '\ '} 2>&1").
-          and_return("it's all good")
-
-      @vm.stop.should be_a_successful_response
-    end
-
-    it 'should return a suscessful response and hard stop the vm' do
-      $?.should_receive(:exitstatus).and_return(0)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} stop #{@conf_file_path.gsub ' ', '\ '} hard 2>&1").
-          and_return("it's all good")
-
+    it 'should return a successful response when stopping hard' do
+      @vm_stopper.should_receive(:stop).
+                  with(:hard => true).
+                  and_return(@stop_response_mock)
+      @stop_response_mock.stub_as_successful
       @vm.stop(:hard => true).should be_a_successful_response
     end
-
-    it 'it should return an unsuccessful response if unable to stop the vm' do
-      $?.should_receive(:exitstatus).and_return(1)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} stop #{@conf_file_path.gsub ' ', '\ '} 2>&1").
-          and_return("it blew up")
-
-      @vm.stop.should be_an_unsuccessful_response
-    end
   end
 
   describe 'suspend' do
     before do
-      @running_response_mock = mock('running?')
-
-      @vm.stub(:exists?).and_return(true)
-      @vm.stub(:running?).and_return(@running_response_mock)
-      @vm.stub(:conf_file).and_return(@conf_file_response_mock)
-      @running_response_mock.stub_as_successful true
-      @conf_file_response_mock.stub_as_successful @conf_file_path
-    end
-
-    it "should return an unsuccessful response if the vm doesn't exist" do
-      @vm.stub(:exists?).and_return(false)
-      @vm.suspend.should be_an_unsuccessful_response 'VM does not exist'
-    end
-
-    it 'should return an unsuccessful response if the vm is not running' do
-      @running_response_mock.stub_as_successful false
-      @vm.suspend.should be_an_unsuccessful_response 'VM is not running'
+      @vm_suspender          = mock 'vm suspender'
+      @suspend_response_mock = mock 'vm suspend response'
+      Fission::Action::VM::Suspender.stub(:new).and_return(@vm_suspender)
+      @vm_suspender.should_receive(:suspend).
+                    and_return(@suspend_response_mock)
     end
 
-    it 'should return an unsuccessful response if unable to determine if running' do
-      @running_response_mock.stub_as_unsuccessful
-      @vm.suspend.should be_an_unsuccessful_response
-    end
-
-    it 'should return an unsuccessful response if unable to figure out the conf file' do
-      @conf_file_response_mock.stub_as_unsuccessful
-      @vm.suspend.should be_an_unsuccessful_response
-    end
-
-    it 'should return a successful response' do
-      $?.should_receive(:exitstatus).and_return(0)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} suspend #{@conf_file_path.gsub ' ', '\ '} 2>&1").
-          and_return("it's all good")
-
+    it 'should return a successful response when suspending' do
+      @suspend_response_mock.stub_as_successful
       @vm.suspend.should be_a_successful_response
     end
 
-    it 'it should return an unsuccessful response if unable to suspend the vm' do
-      $?.should_receive(:exitstatus).and_return(1)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} suspend #{@conf_file_path.gsub ' ', '\ '} 2>&1").
-          and_return("it blew up")
-
+    it 'should return an unsuccessful response when unable to suspend the vm' do
+      @suspend_response_mock.stub_as_unsuccessful
       @vm.suspend.should be_an_unsuccessful_response
     end
   end
 
   describe 'snapshots' do
     before do
-      @vm.stub(:exists?).and_return(true)
-      @vm.stub(:conf_file).and_return(@conf_file_response_mock)
-      @conf_file_response_mock.stub_as_successful @conf_file_path
+      @snapshot_lister_mock = mock 'snapshot lister'
+      @snapshots_response_mock = mock 'snapshots mock'
+      Fission::Action::Snapshot::Lister.stub(:new).and_return(@snapshot_lister_mock)
+      @snapshot_lister_mock.should_receive(:snapshots).
+                            and_return(@snapshots_response_mock)
     end
 
-    it "should return an unsuccessful repsonse when the vm doesn't exist" do
-      @vm.stub(:exists?).and_return(false)
-      @vm.snapshots.should be_an_unsuccessful_response 'VM does not exist'
+    it "should return an unsuccessful repsonse when unable to list the snapshots" do
+      @snapshots_response_mock.stub_as_unsuccessful
+      @vm.snapshots.should be_an_unsuccessful_response
     end
 
     it 'should return a successful response with the list of snapshots' do
-      $?.should_receive(:exitstatus).and_return(0)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} listSnapshots #{@conf_file_path.gsub ' ', '\ '} 2>&1").
-          and_return("Total snapshots: 3\nsnap foo\nsnap bar\nsnap baz\n")
-
+      @snapshots_response_mock.stub_as_successful ['snap_1', 'snap_2']
       response = @vm.snapshots
       response.should be_a_successful_response
-      response.data.should == ['snap foo', 'snap bar', 'snap baz']
-    end
-
-    it 'should return an unsuccessful response if unable to figure out the conf file' do
-      @conf_file_response_mock.stub_as_unsuccessful
-      @vm.snapshots.should be_an_unsuccessful_response
-    end
-
-    it 'should return an unsuccessful response if there was a problem getting the list of snapshots' do
-      $?.should_receive(:exitstatus).and_return(1)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} listSnapshots #{@conf_file_path.gsub ' ', '\ '} 2>&1").
-          and_return("it blew up")
-
-      @vm.snapshots.should be_an_unsuccessful_response
+      response.data.should == ['snap_1', 'snap_2']
     end
   end
 
   describe 'create_snapshot' do
     before do
-      @snapshots_response_mock = mock('snapshots')
-      @running_response_mock = mock('running?')
-
-      @running_response_mock.stub_as_successful true
-      @conf_file_response_mock.stub_as_successful @conf_file_path
-      @snapshots_response_mock.stub_as_successful []
-
-      @vm.stub(:exists?).and_return(true)
-      @vm.stub(:snapshots).and_return(@snapshots_response_mock)
-      @vm.stub(:running?).and_return(@running_response_mock)
-      @vm.stub(:conf_file).and_return(@conf_file_response_mock)
+      @snapshot_creator_mock         = mock 'snapshot creator'
+      @snapshot_create_response_mock = mock 'snapshot create response'
+      Fission::Action::Snapshot::Creator.stub(:new).and_return(@snapshot_creator_mock)
+      @snapshot_creator_mock.should_receive(:create_snapshot).
+                             with('snap_1').
+                             and_return(@snapshot_create_response_mock)
     end
 
-    it "should return an unsuccessful response if the vm doesn't exist" do
-      @vm.stub(:exists?).and_return(false)
-      @vm.create_snapshot('snap_1').should be_an_unsuccessful_response 'VM does not exist'
-    end
-
-    it 'should return an unsuccessful response if the vm is not running' do
-      @running_response_mock.stub_as_successful false
-
-      response = @vm.create_snapshot 'snap_1'
-      error_message = 'The VM must be running in order to take a snapshot.'
-      response.should be_an_unsuccessful_response error_message
-    end
-
-    it 'should return an unsuccessful response if unable to determine if running' do
-      @running_response_mock.stub_as_unsuccessful
+    it 'should return an unsuccessful response when unable to create the snapshot' do
+      @snapshot_create_response_mock.stub_as_unsuccessful
       @vm.create_snapshot('snap_1').should be_an_unsuccessful_response
     end
 
-    it 'should return an unsuccessful response if unable to figure out the conf file' do
-      @conf_file_response_mock.stub_as_unsuccessful
-      @vm.create_snapshot('snap_1').should be_an_unsuccessful_response
+    it 'should return a successful response when creating the snapshot' do
+      @snapshot_create_response_mock.stub_as_successful
+      @vm.create_snapshot('snap_1').should be_a_successful_response
     end
-    it 'should return a successful response and create a snapshot' do
-      $?.should_receive(:exitstatus).and_return(0)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} snapshot #{@conf_file_path.gsub ' ', '\ '} \"bar\" 2>&1").
-          and_return("")
+  end
 
-      @vm.create_snapshot('bar').should be_a_successful_response
-    end
+  describe 'delete_snapshot' do
+    before do
+      @snapshot_deleter_mock         = mock 'snapshot deleter'
+      @snapshot_delete_response_mock = mock 'snapshot delete response'
 
-    it 'should return an unsuccessful response if the snapshot name is a duplicate' do
-      @snapshots_response_mock.stub_as_successful ['snap_1']
-      response = @vm.create_snapshot 'snap_1'
-      response.should be_an_unsuccessful_response "There is already a snapshot named 'snap_1'."
+      Fission::Action::Snapshot::Deleter.stub(:new).
+                                       and_return(@snapshot_deleter_mock)
+      @snapshot_deleter_mock.should_receive(:delete_snapshot).
+                             with('snap_1').
+                             and_return(@snapshot_delete_response_mock)
     end
 
-    it 'should return an unsuccessful response if there was a problem listing the existing snapshots' do
-      @snapshots_response_mock.stub_as_unsuccessful
-      @vm.create_snapshot('snap_1').should be_an_unsuccessful_response
+    it 'should return an unsuccessful response when unable to delete the snapshot' do
+      @snapshot_delete_response_mock.stub_as_unsuccessful
+      @vm.delete_snapshot('snap_1').should be_an_unsuccessful_response
     end
 
-    it 'should return and unsuccessful response if there was a problem creating the snapshot' do
-      $?.should_receive(:exitstatus).and_return(1)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} snapshot #{@conf_file_path.gsub ' ', '\ '} \"bar\" 2>&1").
-          and_return("it blew up")
-
-      @vm.create_snapshot('bar').should be_an_unsuccessful_response
+    it 'should return a successful response when deleteing the snapshot' do
+      @snapshot_delete_response_mock.stub_as_successful
+      @vm.delete_snapshot('snap_1').should be_a_successful_response
     end
   end
 
   describe 'revert_to_snapshot' do
     before do
-      @snapshots_response_mock = mock('snapshots')
-
-      @conf_file_response_mock.stub_as_successful @conf_file_path
-      @snapshots_response_mock.stub_as_successful ['snap_1']
-
-      @vm.stub(:exists?).and_return(true)
-      @vm.stub(:snapshots).and_return(@snapshots_response_mock)
-      @vm.stub(:conf_file).and_return(@conf_file_response_mock)
-      Fission::Fusion.stub(:running?).and_return(false)
-    end
-
-    it "should return an unsuccessful response if the vm doesn't exist" do
-      @vm.stub(:exists?).and_return(false)
-      @vm.revert_to_snapshot('snap_1').should be_an_unsuccessful_response 'VM does not exist'
-    end
-
-    it 'should return an unsuccessful response if the Fusion GUI is running' do
-      Fission::Fusion.stub(:running?).and_return(true)
-
-      response = @vm.revert_to_snapshot 'snap_1'
+      @snapshot_reverter_mock       = mock 'snapshot reverter'
+      @snapshot_revert_response_mock = 'snapshot revert response'
 
-      error_string = 'It looks like the Fusion GUI is currently running.  '
-      error_string << 'A VM cannot be reverted to a snapshot when the Fusion GUI is running.  '
-      error_string << 'Exit the Fusion GUI and try again.'
-
-      response.should be_an_unsuccessful_response error_string
+      Fission::Action::Snapshot::Reverter.stub(:new).
+                                        and_return(@snapshot_reverter_mock)
+      @snapshot_reverter_mock.should_receive(:revert_to_snapshot).
+                              with('snap_1').
+                              and_return(@snapshot_revert_response_mock)
     end
 
-    it 'should return an unsuccessful response if unable to figure out the conf file' do
-      @conf_file_response_mock.stub_as_unsuccessful
+    it 'should return an unsuccessful response when unable to revert the snapshot' do
+      @snapshot_revert_response_mock.stub_as_unsuccessful
       @vm.revert_to_snapshot('snap_1').should be_an_unsuccessful_response
     end
 
-    it 'should return a successful response and revert to the provided snapshot' do
-      $?.should_receive(:exitstatus).and_return(0)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} revertToSnapshot #{@conf_file_path.gsub ' ', '\ '} \"snap_1\" 2>&1").
-          and_return("")
-
+    it 'should return a successful response when reverting the snapshot' do
+      @snapshot_revert_response_mock.stub_as_successful
       @vm.revert_to_snapshot('snap_1').should be_a_successful_response
     end
-
-    it 'should return an unsuccessful response if the snapshot cannot be found' do
-      @snapshots_response_mock.stub_as_successful []
-      response = @vm.revert_to_snapshot 'snap_1'
-      response.should be_an_unsuccessful_response "Unable to find a snapshot named 'snap_1'."
-    end
-
-    it 'should return an unsuccessful response if unable to list the existing snapshots' do
-      @snapshots_response_mock.stub_as_unsuccessful
-      @vm.revert_to_snapshot('snap_1').should be_an_unsuccessful_response
-    end
-
-    it 'should return and unsuccessful response if unable to revert to the snapshot' do
-      $?.should_receive(:exitstatus).and_return(1)
-      @vm.should_receive(:`).
-          with("#{@vmrun_cmd} revertToSnapshot #{@conf_file_path.gsub ' ', '\ '} \"snap_1\" 2>&1").
-          and_return("it blew up")
-
-      @vm.revert_to_snapshot('snap_1').should be_an_unsuccessful_response
-    end
-
   end
 
   describe 'exists?' do
@@ -394,6 +220,62 @@ describe Fission::VM do
     end
   end
 
+  describe 'hardware_info' do
+    before do
+      @vm_config_data_response_mock = mock 'vm config data response'
+      @vm.stub(:conf_file_data).and_return(@vm_config_data_response_mock)
+      @config_data = { 'numvcpus'         => '2',
+                       'replay.supported' => "TRUE",
+                       'replay.filename'  => '',
+                       'memsize'          => '2048',
+                       'scsi0:0.redo'     => '' }
+    end
+
+    context 'when successful getting the vm config data' do
+      before do
+        @vm_config_data_response_mock.stub_as_successful @config_data
+      end
+
+      context 'when the number of cpus is not specified in the conf file' do
+        before do
+         @config_data.delete 'numvcpus'
+        end
+
+        it 'should return a successful response with a single cpu' do
+          response = @vm.hardware_info
+
+          response.should be_a_successful_response
+          response.data.should have_key 'cpus'
+          response.data['cpus'].should == 1
+        end
+      end
+
+      it 'should return a successful response with the number of cpus' do
+        response = @vm.hardware_info
+
+        response.should be_a_successful_response
+        response.data.should have_key 'cpus'
+        response.data['cpus'].should == 2
+      end
+
+      it 'should return a successful response with the amount of memory' do
+        response = @vm.hardware_info
+
+        response.should be_a_successful_response
+        response.data.should have_key 'memory'
+        response.data['memory'].should == 2048
+      end
+    end
+
+    context 'when unsuccessfully getting the vm config data' do
+      it 'should return an unsuccessful response' do
+        @vm_config_data_response_mock.stub_as_unsuccessful
+        @vm.hardware_info.should be_an_unsuccessful_response
+      end
+    end
+
+  end
+
   describe 'mac_addresses' do
     before do
       @network_info_mock = mock('network_info')
@@ -410,7 +292,7 @@ describe Fission::VM do
       response = @vm.mac_addresses
 
       response.should be_a_successful_response
-      response.data.should == ['00:0c:29:1d:6a:64', '00:0c:29:1d:6a:75']
+      response.data.should =~ ['00:0c:29:1d:6a:64', '00:0c:29:1d:6a:75']
     end
 
     it 'should return a successful response with an empty list if no mac addresses were found' do
@@ -435,150 +317,185 @@ describe Fission::VM do
 
   describe 'network_info' do
     before do
-      @conf_file_response_mock.stub_as_successful @conf_file_path
-
-      @vm.should_receive(:conf_file).and_return(@conf_file_response_mock)
-      @conf_file_io = StringIO.new
       @lease_1_response_mock = mock('lease_1_response')
       @lease_2_response_mock = mock('lease_1_response')
-    end
+      @vm_config_data_response_mock = mock 'vm config data response'
+
+      @vm.stub(:conf_file_data).and_return(@vm_config_data_response_mock)
+      @config_data = { 'ide1:0.deviceType'                   => 'cdrom-image',
+                       'ethernet0.present'                    => 'TRUE',
+                       'ethernet1.address'                    => '00:0c:29:1d:6a:75',
+                       'ethernet0.connectionType'             => 'nat',
+                       'ethernet0.generatedAddress'           => '00:0c:29:1d:6a:64',
+                       'ethernet0.virtualDev'                 => 'e1000',
+                       'ethernet0.wakeOnPcktRcv'              => 'FALSE',
+                       'ethernet0.addressType'                => 'generated',
+                       'ethernet0.linkStatePropagatio.enable' => 'TRUE',
+                       'ethernet0.generatedAddressenable'     => 'TRUE',
+                       'ethernet1.generatedAddressenable'     => 'TRUE' }
+    end
+
+    context 'when successful getting the vm config data' do
+      before do
+        @vm_config_data_response_mock.stub_as_successful @config_data
+      end
 
-    it 'should return a successful response with the list of interfaces, macs, and ips' do
-      @conf_file_response_mock.stub_as_successful @conf_file_path
+      it 'should return a successful response with the list of interfaces, macs, and ips' do
+        @lease_1 = Fission::Lease.new :ip_address  => '127.0.0.1',
+                                      :mac_address => '00:0c:29:1d:6a:64'
+        @lease_1_response_mock.stub_as_successful @lease_1
 
-      @lease_1 = Fission::Lease.new :ip_address  => '127.0.0.1',
-                                    :mac_address => '00:0c:29:1d:6a:64'
-      @lease_1_response_mock.stub_as_successful @lease_1
+        @lease_2 = Fission::Lease.new :ip_address  => '127.0.0.2',
+                                      :mac_address => '00:0c:29:1d:6a:75'
+        @lease_2_response_mock.stub_as_successful @lease_2
 
-      @lease_2 = Fission::Lease.new :ip_address  => '127.0.0.2',
-                                    :mac_address => '00:0c:29:1d:6a:75'
-      @lease_2_response_mock.stub_as_successful @lease_2
+        Fission::Lease.should_receive(:find_by_mac_address).
+                       with('00:0c:29:1d:6a:64').
+                       and_return(@lease_1_response_mock)
+        Fission::Lease.should_receive(:find_by_mac_address).
+                       with('00:0c:29:1d:6a:75').
+                       and_return(@lease_2_response_mock)
 
-      vmx_content = 'ide1:0.deviceType = "cdrom-image"
-ethernet0.present = "TRUE"
-ethernet1.address = "00:0c:29:1d:6a:75"
-ethernet0.connectionType = "nat"
-ethernet0.generatedAddress = "00:0c:29:1d:6a:64"
-ethernet0.virtualDev = "e1000"
-ethernet0.wakeOnPcktRcv = "FALSE"
-ethernet0.addressType = "generated"
-ethernet0.linkStatePropagation.enable = "TRUE"
-ethernet0.generatedAddressenable = "TRUE"
-ethernet1.generatedAddressenable = "TRUE"'
+        response = @vm.network_info
+        response.should be_a_successful_response
+        response.data.should == { 'ethernet0' => { 'mac_address'  => '00:0c:29:1d:6a:64',
+                                                   'ip_address'   => '127.0.0.1' },
+                                  'ethernet1' => { 'mac_address'  => '00:0c:29:1d:6a:75',
+                                                   'ip_address'   => '127.0.0.2' } }
+      end
 
-      @conf_file_io.string = vmx_content
+      it 'should return a successful response with an empty list if there are no macs' do
+        @config_data.delete 'ethernet0.generatedAddress'
+        @config_data.delete 'ethernet1.address'
 
-      File.should_receive(:open).with(@conf_file_path, 'r').
-                                 and_yield(@conf_file_io)
+        response = @vm.network_info
+        response.should be_a_successful_response
+        response.data.should == {}
+      end
 
-      Fission::Lease.should_receive(:find_by_mac_address).
-                     with('00:0c:29:1d:6a:64').
-                     and_return(@lease_1_response_mock)
-      Fission::Lease.should_receive(:find_by_mac_address).
-                     with('00:0c:29:1d:6a:75').
-                     and_return(@lease_2_response_mock)
+      it 'should return a successful response without ip addresses if none were found' do
+        @lease_1_response_mock.stub_as_successful nil
+        @lease_2_response_mock.stub_as_successful nil
 
-      response = @vm.network_info
-      response.should be_a_successful_response
-      response.data.should == { 'ethernet0' => { 'mac_address'  => '00:0c:29:1d:6a:64',
-                                                 'ip_address'   => '127.0.0.1' },
-                                'ethernet1' => { 'mac_address'  => '00:0c:29:1d:6a:75',
-                                                 'ip_address'   => '127.0.0.2' } }
-    end
+        Fission::Lease.should_receive(:find_by_mac_address).
+                       with('00:0c:29:1d:6a:64').
+                       and_return(@lease_1_response_mock)
+        Fission::Lease.should_receive(:find_by_mac_address).
+                       with('00:0c:29:1d:6a:75').
+                       and_return(@lease_2_response_mock)
 
-    it 'should return a successful response with an empty list if there are no macs' do
+        response = @vm.network_info
+        response.should be_a_successful_response
+        response.data.should == { 'ethernet0' => { 'mac_address'  => '00:0c:29:1d:6a:64',
+                                                   'ip_address'   => nil },
+                                  'ethernet1' => { 'mac_address'  => '00:0c:29:1d:6a:75',
+                                                   'ip_address'   => nil } }
+      end
 
-      vmx_content = 'ide1:0.deviceType = "cdrom-image"
-pciBridge7.virtualDev = "pcieRootPort"
-pciBridge7.functions = "8"
-vmci0.present = "TRUE"
-roamingVM.exitBehavior = "go"
-tools.syncTime = "TRUE"'
+      context 'when unsuccessful getting the ip info' do
+        it 'should return an unsuccessful response if there was an error getting the ip information' do
+          @lease_1_response_mock.stub_as_unsuccessful
+          @lease_2_response_mock.stub_as_successful nil
 
-      @conf_file_io.string = vmx_content
+          Fission::Lease.should_receive(:find_by_mac_address).
+                         with('00:0c:29:1d:6a:64').
+                         and_return(@lease_1_response_mock)
+          Fission::Lease.should_receive(:find_by_mac_address).
+                         with('00:0c:29:1d:6a:75').
+                         and_return(@lease_2_response_mock)
 
-      File.should_receive(:open).with(@conf_file_path, 'r').
-                                 and_yield(@conf_file_io)
+          @vm.network_info.should be_an_unsuccessful_response
+        end
+      end
 
-      response = @vm.network_info
-      response.should be_a_successful_response
-      response.data.should == {}
-    end
-
-    it 'should return a successful response without ip addresses if none were found' do
-      @lease_1_response_mock.stub_as_successful nil
-      @lease_2_response_mock.stub_as_successful nil
-
-      vmx_content = 'ide1:0.deviceType = "cdrom-image"
-ethernet0.present = "TRUE"
-ethernet1.address = "00:0c:29:1d:6a:75"
-ethernet0.connectionType = "nat"
-ethernet0.generatedAddress = "00:0c:29:1d:6a:64"
-ethernet0.virtualDev = "e1000"
-ethernet0.wakeOnPcktRcv = "FALSE"
-ethernet0.addressType = "generated"
-ethernet0.linkStatePropagation.enable = "TRUE"
-ethernet0.generatedAddressenable = "TRUE"
-ethernet1.generatedAddressenable = "TRUE"'
-
-      @conf_file_io.string = vmx_content
-
-      File.should_receive(:open).with(@conf_file_path, 'r').
-                                 and_yield(@conf_file_io)
-
-      Fission::Lease.should_receive(:find_by_mac_address).
-                     with('00:0c:29:1d:6a:64').
-                     and_return(@lease_1_response_mock)
-      Fission::Lease.should_receive(:find_by_mac_address).
-                     with('00:0c:29:1d:6a:75').
-                     and_return(@lease_2_response_mock)
-
-      response = @vm.network_info
-      response.should be_a_successful_response
-      response.data.should == { 'ethernet0' => { 'mac_address'  => '00:0c:29:1d:6a:64',
-                                                 'ip_address'   => nil },
-                                'ethernet1' => { 'mac_address'  => '00:0c:29:1d:6a:75',
-                                                 'ip_address'   => nil } }
     end
 
-    it 'should return an unsuccessful response with an error if no conf file was found' do
-      @conf_file_response_mock.stub_as_unsuccessful
+    context 'when unsuccessfully getting the vm config data' do
+      it 'should return an unsuccessful response' do
+        @vm_config_data_response_mock.stub_as_unsuccessful
+        @vm.guestos.should be_an_unsuccessful_response
+      end
+    end
 
-      File.should_not_receive(:open)
+  end
 
-      @vm.network_info.should be_an_unsuccessful_response
+  describe 'guestos' do
+    before do
+      @vm_config_data_response_mock = mock 'vm config data response'
+      @vm.stub(:conf_file_data).and_return(@vm_config_data_response_mock)
+      @config_data = { 'cleanShutdown'   => 'TRUE',
+                       'guestOS'         => 'debian5',
+                       'replay.filename' => '',
+                       'scsi0:0.redo'    => '' }
     end
 
-    it 'should return an unsuccessful response if there was an error getting the ip information' do
-      @lease_1_response_mock.stub_as_unsuccessful
-      @lease_2_response_mock.stub_as_successful nil
+    context 'when successful getting the vm config data' do
+      it 'should return a successful response with a string when a guestos is defined' do
+        @vm_config_data_response_mock.stub_as_successful @config_data
 
-      vmx_content = 'ide1:0.deviceType = "cdrom-image"
-ethernet0.present = "TRUE"
-ethernet1.address = "00:0c:29:1d:6a:75"
-ethernet0.connectionType = "nat"
-ethernet0.generatedAddress = "00:0c:29:1d:6a:64"
-ethernet0.virtualDev = "e1000"
-ethernet0.wakeOnPcktRcv = "FALSE"
-ethernet0.addressType = "generated"
-ethernet0.linkStatePropagation.enable = "TRUE"
-ethernet0.generatedAddressenable = "TRUE"
-ethernet1.generatedAddressenable = "TRUE"'
+        response = @vm.guestos
+        response.should be_a_successful_response
+        response.data.should == 'debian5'
+      end
 
-      @conf_file_io.string = vmx_content
+      it 'should return a successful response with an empty string if guestos is not set' do
+        @config_data.delete 'guestOS'
+        @vm_config_data_response_mock.stub_as_successful @config_data
 
-      File.should_receive(:open).with(@conf_file_path, 'r').
-                                 and_yield(@conf_file_io)
+        response = @vm.guestos
+        response.should be_a_successful_response
+        response.data.should == ''
+      end
+    end
 
-      Fission::Lease.should_receive(:find_by_mac_address).
-                     with('00:0c:29:1d:6a:64').
-                     and_return(@lease_1_response_mock)
-      Fission::Lease.should_receive(:find_by_mac_address).
-                     with('00:0c:29:1d:6a:75').
-                     and_return(@lease_2_response_mock)
+    context 'when unsuccessfully getting the vm config data' do
+      it 'should return an unsuccessful response' do
+        @vm_config_data_response_mock.stub_as_unsuccessful
+        @vm.guestos.should be_an_unsuccessful_response
+      end
+    end
+  end
 
-      @vm.network_info.should be_an_unsuccessful_response
+  describe 'uuids' do
+    before do
+      @vm_config_data_response_mock = mock 'vm config data response'
+      @vm.stub(:conf_file_data).and_return(@vm_config_data_response_mock)
+      @config_data = { 'uuid.location' => '56 4d d8 9c f8 ec 95 73-2e ea a0 f3 7a 1d 6f c8',
+                       'uuid.bios' => '56 4d d8 9c f8 ec 95 73-2e ea a0 f3 7a 1d 6f c8',
+                       'checkpoint.vmState' => '',
+                       'cleanShutdown' => 'TRUE',
+                       'replay.supported' => "TRUE",
+                       'replay.filename' => '',
+                       'scsi0:0.redo' =>'' }
+    end
+
+    context 'when successful getting the vm config data' do
+      it 'should return a successful response with a hash when uuids are defined' do
+        @vm_config_data_response_mock.stub_as_successful @config_data
+
+        response = @vm.uuids
+        response.should be_a_successful_response
+        response.data.should == { 'bios'     => '56 4d d8 9c f8 ec 95 73-2e ea a0 f3 7a 1d 6f c8',
+                                  'location' => '56 4d d8 9c f8 ec 95 73-2e ea a0 f3 7a 1d 6f c8' }
+      end
+
+      it 'should return a successful response with empty hash if no uuids are defined' do
+        ['location', 'bios'].each { |i| @config_data.delete "uuid.#{i}" }
+        @vm_config_data_response_mock.stub_as_successful @config_data
+
+        response = @vm.uuids
+        response.should be_a_successful_response
+        response.data.should == {}
+      end
     end
+
+    context 'when unsuccessfully getting the vm config data' do
+      it 'should return an unsuccessful response' do
+        @vm_config_data_response_mock.stub_as_unsuccessful
+        @vm.uuids.should be_an_unsuccessful_response
+      end
+    end
+
   end
 
   describe 'path' do
@@ -730,6 +647,33 @@ ethernet1.generatedAddressenable = "TRUE"'
 
   end
 
+  describe 'conf_file_data' do
+    before do
+      @vm_config_mock          = mock 'vm config'
+      @vm_config_response_mock = mock 'vm config response'
+
+      Fission::VMConfiguration.should_receive(:new).with(@vm).
+                                                    and_return(@vm_config_mock)
+    end
+
+    it 'should return a successful response with the data' do
+      @vm_config_response_mock.stub_as_successful({ 'numvcpus' => '2' })
+
+      @vm_config_mock.should_receive(:config_data).
+                      and_return(@vm_config_response_mock)
+      config_data = @vm.conf_file_data
+      config_data.should be_a_successful_response
+      config_data.data.should == { 'numvcpus' => '2' }
+    end
+
+    it 'should return an unsuccessful response' do
+      @vm_config_mock.should_receive(:config_data).
+                      and_return(@vm_config_response_mock)
+      @vm_config_response_mock.stub_as_unsuccessful
+      @vm.conf_file_data.should be_an_unsuccessful_response
+    end
+  end
+
   describe 'conf_file' do
     before do
       FakeFS.activate!
@@ -796,390 +740,89 @@ ethernet1.generatedAddressenable = "TRUE"'
 
   describe "self.all" do
     before do
-      @vm_1_mock = mock('vm_1')
-      @vm_2_mock = mock('vm_2')
-    end
-
-    it "should return a successful object with the list of VM objects" do
-      vm_root = Fission.config['vm_dir']
-      Dir.should_receive(:[]).
-          and_return(["#{File.join vm_root, 'foo.vmwarevm' }", "#{File.join vm_root, 'bar.vmwarevm' }"])
-
-      vm_root = Fission.config['vm_dir']
-      File.should_receive(:directory?).with("#{File.join vm_root, 'foo.vmwarevm'}").
-                                       and_return(true)
-      File.should_receive(:directory?).with("#{File.join vm_root, 'bar.vmwarevm'}").
-                                       and_return(true)
-
-      Fission::VM.should_receive(:new).with('foo').and_return(@vm_1_mock)
-      Fission::VM.should_receive(:new).with('bar').and_return(@vm_2_mock)
-
-      response = Fission::VM.all
-      response.should be_a_successful_response
-      response.data.should == [@vm_1_mock, @vm_2_mock]
+      @lister            = mock 'lister'
+      @all_response_mock = mock 'all response'
+      Fission::Action::VM::Lister.stub(:new).and_return(@lister)
+      @lister.should_receive(:all).
+              and_return(@all_response_mock)
     end
 
-    it "should return a successful object and not return an item in the list if it isn't a directory" do
-      vm_root = Fission.config['vm_dir']
-      Dir.should_receive(:[]).
-          and_return((['foo', 'bar', 'baz'].map { |i| File.join vm_root, "#{i}.vmwarevm"}))
-      File.should_receive(:directory?).
-           with("#{File.join vm_root, 'foo.vmwarevm'}").and_return(true)
-      File.should_receive(:directory?).
-           with("#{File.join vm_root, 'bar.vmwarevm'}").and_return(true)
-      File.should_receive(:directory?).
-           with("#{File.join vm_root, 'baz.vmwarevm'}").and_return(false)
-
-      Fission::VM.should_receive(:new).with('foo').and_return(@vm_1_mock)
-      Fission::VM.should_receive(:new).with('bar').and_return(@vm_2_mock)
-
-      response = Fission::VM.all
-      response.should be_a_successful_response
-      response.data.should == [@vm_1_mock, @vm_2_mock]
+    it 'should return an unsuccessful response when unable to delete the vm' do
+      @all_response_mock.stub_as_unsuccessful
+      Fission::VM.all.should be_an_unsuccessful_response
     end
 
-    it "should only query for items with an extension of .vmwarevm" do
-      dir_arg = File.join Fission.config['vm_dir'], '*.vmwarevm'
-      Dir.should_receive(:[]).with(dir_arg).
-                              and_return(['foo.vmwarevm', 'bar.vmwarevm'])
-      Fission::VM.all
+    it 'should return a successful response when deleting' do
+      @all_response_mock.stub_as_successful
+      Fission::VM.all.should be_a_successful_response
     end
   end
 
   describe 'self.all_running' do
     before do
-      @vm_1 = Fission::VM.new 'foo'
-      @vm_2 = Fission::VM.new 'bar'
-      @vm_3 = Fission::VM.new 'baz'
-      @vm_names_and_objs = { 'foo' => @vm_1, 'bar' => @vm_2, 'baz' => @vm_3 }
+      @lister                    = mock 'lister'
+      @all_running_response_mock = mock 'all running response'
+      Fission::Action::VM::Lister.stub(:new).and_return(@lister)
+      @lister.should_receive(:all_running).
+              and_return(@all_running_response_mock)
     end
 
-    it 'should return a successful response with the list of running vms' do
-      list_output = "Total running VMs: 2\n/vm/foo.vmwarevm/foo.vmx\n"
-      list_output << "/vm/bar.vmwarevm/bar.vmx\n/vm/baz.vmwarevm/baz.vmx\n"
-
-      $?.should_receive(:exitstatus).and_return(0)
-      Fission::VM.should_receive(:`).
-                  with("#{@vmrun_cmd} list").
-                  and_return(list_output)
-      [ 'foo', 'bar', 'baz'].each do |vm|
-        File.should_receive(:exists?).with("/vm/#{vm}.vmwarevm/#{vm}.vmx").
-                                      and_return(true)
-
-        Fission::VM.should_receive(:new).with(vm).
-                                         and_return(@vm_names_and_objs[vm])
-      end
-
-      response = Fission::VM.all_running
-      response.should be_a_successful_response
-      response.data.should == [@vm_1, @vm_2, @vm_3]
-    end
-
-    it 'should return a successful response with the VM dir name if it differs from the .vmx file name' do
-      vm_dir_file = { 'foo' => 'foo', 'bar' => 'diff', 'baz' => 'baz'}
-      list_output = "Total running VMs: 3\n"
-      vm_dir_file.each_pair do |dir, file|
-        list_output << "/vm/#{dir}.vmwarevm/#{file}.vmx\n"
-        File.should_receive(:exists?).with("/vm/#{dir}.vmwarevm/#{file}.vmx").
-                                      and_return(true)
-        Fission::VM.should_receive(:new).with(dir).
-                                         and_return(@vm_names_and_objs[dir])
-      end
-
-      $?.should_receive(:exitstatus).and_return(0)
-      Fission::VM.should_receive(:`).
-                  with("#{@vmrun_cmd} list").
-                  and_return(list_output)
-
-      response = Fission::VM.all_running
-      response.should be_a_successful_response
-      response.data.should == [@vm_1, @vm_2, @vm_3]
+    it 'should return an unsuccessful response when unable to delete the vm' do
+      @all_running_response_mock.stub_as_unsuccessful
+      Fission::VM.all_running.should be_an_unsuccessful_response
     end
 
-    it 'should return an unsuccessful response if unable to get the list of running vms' do
-      $?.should_receive(:exitstatus).and_return(1)
-      Fission::VM.should_receive(:`).
-                  with("#{@vmrun_cmd} list").
-                  and_return("it blew up")
-      Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-
-      Fission::VM.all_running.should be_an_unsuccessful_response
+    it 'should return a successful response when deleting' do
+      @all_running_response_mock.stub_as_successful
+      Fission::VM.all_running.should be_a_successful_response
     end
   end
 
   describe "self.clone" do
     before do
-      @source_vm = Fission::VM.new 'foo'
-      @target_vm = Fission::VM.new 'bar'
-      @source_path = @source_vm.path
-      @target_path = @target_vm.path
-
-      @clone_response_mock = mock('clone_response')
-      @vm_files = ['.vmx', '.vmxf', '.vmdk', '-s001.vmdk', '-s002.vmdk', '.vmsd']
-
-      FakeFS.activate!
-
-      FileUtils.mkdir_p @source_path
-
-      @vm_files.each do |file|
-        FileUtils.touch "#{@source_path}/#{@source_vm.name}#{file}"
-      end
-
-      ['.vmx', '.vmxf', '.vmdk'].each do |ext|
-        File.open("#{@source_path}/foo#{ext}", 'w') { |f| f.write 'foo.vmdk'}
-      end
-
-      @source_vm.stub(:exists?).and_return(true)
-      @target_vm.stub(:exists?).and_return(false)
-
-      Fission::VM.stub(:new).with(@source_vm.name).
-                             and_return(@source_vm)
-      Fission::VM.stub(:new).with(@target_vm.name).
-                             and_return(@target_vm)
-
-      vmx_content = 'ide1:0.deviceType = "cdrom-image"
-nvram = "foo.nvram"
-ethernet0.present = "TRUE"
-ethernet1.address = "00:0c:29:1d:6a:75"
-ethernet0.connectionType = "nat"
-ethernet0.generatedAddress = "00:0c:29:1d:6a:64"
-ethernet0.virtualDev = "e1000"
-tools.remindInstall = "TRUE"
-ethernet0.wakeOnPcktRcv = "FALSE"
-ethernet0.addressType = "generated"
-uuid.action = "keep"
-ethernet0.linkStatePropagation.enable = "TRUE"
-ethernet0.generatedAddressenable = "TRUE"
-ethernet1.generatedAddressenable = "TRUE"'
-
-      File.open("#{@source_path}/#{@source_vm.name}.vmx", 'w') do |f|
-        f.write vmx_content
-      end
-
-      ['.vmx', '.vmxf'].each do |ext|
-        File.stub(:binary?).
-             with("#{@target_path}/#{@target_vm.name}#{ext}").
-             and_return(false)
-      end
-
-      File.stub(:binary?).
-           with("#{@target_path}/#{@target_vm.name}.vmdk").
-           and_return(true)
-    end
-
-    after do
-      FakeFS.deactivate!
-      FakeFS::FileSystem.clear
-    end
-
-    it "should return an unsuccessful response if the source vm doesn't exist" do
-      @source_vm.stub(:exists?).and_return(false)
-      response = Fission::VM.clone @source_vm.name, @target_vm.name
-      response.should be_an_unsuccessful_response 'VM does not exist'
-    end
-
-    it "should return an unsuccessful response if the target vm exists" do
-      @target_vm.stub(:exists?).and_return(true)
-      response = Fission::VM.clone @source_vm.name, @target_vm.name
-      response.should be_an_unsuccessful_response 'VM already exists'
-    end
-
-    it 'should copy the vm files to the target' do
-      Fission::VM.clone @source_vm.name, @target_vm.name
-
-      File.directory?(@target_path).should == true
-
-      @vm_files.each do |file|
-        File.file?("#{@target_path}/bar#{file}").should == true
-      end
-    end
-
-    it "should copy the vm files to the target if a file name doesn't match the directory" do
-      FileUtils.touch "#{@source_path}/other_name.nvram"
-
-      Fission::VM.clone @source_vm.name, @target_vm.name
-
-      File.directory?(@target_path).should == true
-
-      @vm_files.each do |file|
-        File.file?("#{@target_path}/#{@target_vm.name}#{file}").should == true
-      end
-
-      File.file?("#{@target_path}/bar.nvram").should == true
+      @vm_1                = mock 'vm 1'
+      @vm_2                = mock 'vm 2'
+      @vm_cloner           = mock 'vm cloner'
+      @clone_response_mock = mock 'vm clone response'
+      Fission::Action::VM::Cloner.should_receive(:new).
+                                with(@vm_1, @vm_2).
+                                and_return(@vm_cloner)
+      Fission::VM.should_receive(:new).with('vm_1').and_return(@vm_1)
+      Fission::VM.should_receive(:new).with('vm_2').and_return(@vm_2)
+      @vm_cloner.should_receive(:clone).
+                 and_return(@clone_response_mock)
     end
 
-    it "should copy the vm files to the target if a sparse disk file name doesn't match the directory" do
-      FileUtils.touch "#{@source_path}/other_name-s003.vmdk"
-
-      Fission::VM.clone @source_vm.name, @target_vm.name
-
-      File.directory?(@target_path).should == true
-
-      @vm_files.each do |file|
-        File.file?("#{@target_path}/#{@target_vm.name}#{file}").should == true
-      end
-
-      File.file?("#{@target_path}/bar-s003.vmdk").should == true
+    it 'should return an unsuccessful response when unable to clone the vm' do
+      @clone_response_mock.stub_as_unsuccessful
+      Fission::VM.clone('vm_1', 'vm_2').should be_an_unsuccessful_response
     end
 
-    it 'should update the target vm config files' do
-      Fission::VM.clone @source_vm.name, @target_vm.name
-
-      ['.vmx', '.vmxf'].each do |ext|
-        File.read("#{@target_path}/bar#{ext}").should_not match /foo/
-        File.read("#{@target_path}/bar#{ext}").should match /bar/
-      end
+    it 'should return a successful response when cloning' do
+      @clone_response_mock.stub_as_successful
+      Fission::VM.clone('vm_1', 'vm_2').should be_a_successful_response
     end
-
-    it 'should disable VMware tools warning in the conf file' do
-      Fission::VM.clone @source_vm.name, @target_vm.name
-
-      pattern = /^tools\.remindInstall = "FALSE"/
-
-      File.read("#{@target_path}/bar.vmx").should match pattern
-    end
-
-    it 'should remove auto generated MAC addresses from the conf file' do
-      Fission::VM.clone @source_vm.name, @target_vm.name
-
-      pattern = /^ethernet\.+generatedAddress.+/
-
-      File.read("#{@target_path}/bar.vmx").should_not match pattern
-    end
-
-    it 'should setup the conf file to generate a new uuid' do
-      Fission::VM.clone @source_vm.name, @target_vm.name
-
-      pattern = /^uuid\.action = "create"/
-
-      File.read("#{@target_path}/bar.vmx").should match pattern
-    end
-
-    it "should not try to update the vmdk file if it's not a sparse disk" do
-      Fission::VM.clone @source_vm.name, @target_vm.name
-
-      File.read("#{@target_path}/bar.vmdk").should match /foo/
-    end
-
-    it 'should return a successful response if clone was successful' do
-      Fission::VM.clone(@source_vm.name, @target_vm.name).should be_a_successful_response
-    end
-
-    describe 'when a sparse disk is found' do
-      it "should update the vmdk" do
-        File.rspec_reset
-        File.stub(:binary?).and_return(false)
-
-        Fission::VM.clone @source_vm.name, @target_vm.name
-
-        File.read("#{@target_path}/bar.vmdk").should match /bar/
-      end
-    end
-
   end
 
   describe 'self.all_with_status' do
     before do
-      @vm_1 = Fission::VM.new 'foo'
-      @vm_2 = Fission::VM.new 'bar'
-      @vm_2.stub(:suspend_file_exists?).and_return('true')
-      @vm_3 = Fission::VM.new 'baz'
-
-      @all_vms_response_mock = mock('all_vms_mock')
-      @all_vms_response_mock.stub_as_successful [@vm_1, @vm_2, @vm_3]
-
-      @all_running_response_mock = mock('all_running_mock')
-      @all_running_response_mock.stub_as_successful [@vm_1]
-
-      Fission::VM.stub(:all).and_return(@all_vms_response_mock)
-      Fission::VM.stub(:all_running).and_return(@all_running_response_mock)
-    end
-
-    it 'should return a sucessful response with the VMs and their status' do
-      response = Fission::VM.all_with_status
-      response.should be_a_successful_response
-      response.data.should == { 'foo' => 'running',
-                                'bar' => 'suspended',
-                                'baz' => 'not running' }
-
+      @lister                   = mock 'lister'
+      @all_status_response_mock = mock 'all status response'
+      Fission::Action::VM::Lister.stub(:new).and_return(@lister)
+      @lister.should_receive(:all_with_status).
+              and_return(@all_status_response_mock)
     end
 
-    it 'should return an unsuccessful response if unable to get all of the VMs' do
-      @all_vms_response_mock.stub_as_unsuccessful
+    it 'should return an unsuccessful response when unable to delete the vm' do
+      @all_status_response_mock.stub_as_unsuccessful
       Fission::VM.all_with_status.should be_an_unsuccessful_response
     end
 
-    it 'should return an unsuccessful repsonse if unable to get the running VMs' do
-      @all_running_response_mock.stub_as_unsuccessful
-      Fission::VM.all_with_status.should be_an_unsuccessful_response
+    it 'should return a successful response when deleting' do
+      @all_status_response_mock.stub_as_successful
+      Fission::VM.all_with_status.should be_a_successful_response
     end
 
   end
 
-  describe 'delete' do
-    before do
-      @running_response_mock = mock('running?')
-      @running_response_mock.stub_as_successful false
-
-      @vm.stub(:exists?).and_return(true)
-      @vm.stub(:running?).and_return(@running_response_mock)
-      @vm.stub(:conf_file).and_return(@conf_file_response_mock)
-
-      @target_vm = 'foo'
-      @vm_files = %w{ .vmx .vmxf .vmdk -s001.vmdk -s002.vmdk .vmsd }
-      FakeFS.activate!
-
-      FileUtils.mkdir_p Fission::VM.new(@target_vm).path
-
-      @vm_files.each do |file|
-        FileUtils.touch File.join(Fission::VM.new(@target_vm).path, "#{@target_vm}#{file}")
-      end
-    end
-
-    after do
-      FakeFS.deactivate!
-    end
-
-    it "should return an unsuccessful response if the vm doesn't exist" do
-      @vm.stub(:exists?).and_return(false)
-
-      response = @vm.delete
-      response.should be_an_unsuccessful_response 'VM does not exist'
-    end
-
-    it 'should return an unsuccessful response if the vm is running' do
-      @running_response_mock.stub_as_successful true
-
-      response = @vm.delete
-      response.should be_an_unsuccessful_response 'The VM must not be running in order to delete it.'
-    end
-
-    it 'should return an unsuccessful response if unable to determine if running' do
-      @running_response_mock.stub_as_unsuccessful
-
-      response = @vm.delete
-      response.should be_an_unsuccessful_response
-    end
-
-    it "should delete the target vm files" do
-      Fission::Metadata.stub!(:delete_vm_info)
-
-      @vm.delete
-
-      @vm_files.each do |file|
-        File.exists?(File.join(Fission::VM.new(@target_vm).path, "#{@target_vm}#{file}")).should == false
-      end
-    end
-
-    it 'should delete the target vm metadata' do
-      Fission::Metadata.should_receive(:delete_vm_info)
-      @vm.delete
-    end
-
-    it 'should return a successful reponsse object' do
-      Fission::Metadata.stub!(:delete_vm_info)
-      @vm.delete.should be_a_successful_response
-    end
-
-  end
 end