fission 0.2.0 → 0.3.0.beta.1

data/spec/fission/command/status_spec.rb

@@ -1,13 +1,13 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::Status do
-  before :each do
+  before do
     @string_io = StringIO.new
     Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
   end
 
   describe 'execute' do
-    before :each do
+    before do
       Fission::VM.stub!(:all).and_return(['foo', 'bar', 'baz'])
       Fission::VM.stub!(:all_running).and_return(['foo', 'baz'])
     end

data/spec/fission/command/stop_spec.rb

@@ -1,11 +1,8 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::Stop do
-  before :all do
+  before do
     @vm_info = ['foo']
-  end
-
-  before :each do
     @string_io = StringIO.new
     Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
   end

data/spec/fission/command/suspend_spec.rb

@@ -1,11 +1,8 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::Suspend do
-  before :all do
+  before do
     @vm_info = ['foo']
-  end
-
-  before :each do
     @string_io = StringIO.new
     Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
   end
@@ -56,7 +53,31 @@ describe Fission::Command::Suspend do
       command = Fission::Command::Suspend.new @vm_info
       command.execute
 
-      @string_io.string.should match /suspending '#{@vm_info.first}'/
+      @string_io.string.should match /Suspending '#{@vm_info.first}'/
+    end
+
+    describe 'with --all' do
+      it 'should suspend all running VMs' do
+        @vm_mock_1 = mock('vm_mock_1')
+        @vm_mock_2 = mock('vm_mock_2')
+
+        vm_items = {'vm_1' => @vm_mock_1,
+                    'vm_2' => @vm_mock_2
+        }
+
+        Fission::VM.should_receive(:all_running).and_return(vm_items.keys)
+
+        vm_items.each_pair do |name, mock|
+          Fission::VM.should_receive(:new).with(name).and_return(mock)
+          mock.should_receive(:suspend)
+        end
+
+        command = Fission::Command::Suspend.new ['--all']
+        command.execute
+
+        @string_io.string.should match /Suspending 'vm_1'/
+        @string_io.string.should match /Suspending 'vm_2'/
+      end
     end
 
   end
@@ -65,7 +86,7 @@ describe Fission::Command::Suspend do
     it 'should output info for this command' do
       output = Fission::Command::Suspend.help
 
-      output.should match /suspend vm/
+      output.should match /suspend \[vm \| --all\]/
     end
   end
 end

data/spec/fission/command_spec.rb

@@ -1,7 +1,6 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Fission::Command do
-
   describe 'new' do
     it 'should set options variable as an open struct' do
       @command = Fission::Command.new

data/spec/fission/config_spec.rb

@@ -16,6 +16,16 @@ describe Fission::Config do
       end
     end
 
+    it 'should use the fusion default for plist_file' do
+      @config = Fission::Config.new
+      @config.attributes['plist_file'].should == File.expand_path('~/Library/Preferences/com.vmware.fusion.plist')
+    end
+
+    it 'should use the fusion default for the gui bin' do
+      @config = Fission::Config.new
+      @config.attributes['gui_bin'].should == File.expand_path('/Applications/VMware Fusion.app/Contents/MacOS/vmware')
+    end
+
     it "should use the user specified dir in ~/.fissionrc" do
       FakeFS do
         File.open('~/.fissionrc', 'w') { |f| f.puts YAML.dump({ 'vm_dir' => '/var/tmp/foo' })}

data/spec/fission/fusion_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Fission::Fusion do
+  describe 'self.is_running?' do
+    before do
+      @cmd = "ps -ef | grep -v grep | "
+      @cmd << "grep -c #{Fission.config.attributes['gui_bin'].gsub(' ', '\ ')} 2>&1"
+    end
+
+    it 'should return true if the fusion app is running' do
+      Fission::Fusion.should_receive(:`).with(@cmd).
+                                         and_return("1\n")
+      Fission::Fusion.is_running?.should == true
+    end
+
+    it 'should return false if the fusion app is not running' do
+      Fission::Fusion.should_receive(:`).with(@cmd).
+                                         and_return("0\n")
+      Fission::Fusion.is_running?.should == false
+    end
+  end
+end

data/spec/fission/metadata_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Fission::Metadata do
+  before do
+    @plist_mock = mock('plist_mock')
+    @plist_file_path = Fission.config.attributes['plist_file']
+    @metadata = Fission::Metadata.new
+  end
+
+  describe 'load' do
+    it 'should load the existing data' do
+      plist = {'vm_list' => ['1', '2', '3']}
+      CFPropertyList::List.should_receive(:new).
+                           with(:file => @plist_file_path).
+                           and_return(@plist_mock)
+      @plist_mock.stub!(:value).and_return(plist)
+      CFPropertyList.should_receive(:native_types).with(plist).
+                                                   and_return([1, 2, 3])
+      @metadata.load
+      @metadata.content.should == [1, 2, 3]
+    end
+  end
+
+  describe 'delete_vm_restart_document' do
+    before do
+      @data = { 'PLRestartDocumentPaths' => ['/vm/foo.vmwarevm', '/vm/bar.vmwarevm']}
+      @metadata.content = @data
+    end
+
+    it 'should remove the vm item from the list if the vm path is in the list' do
+      @metadata.delete_vm_restart_document(Fission::VM.path('foo'))
+      @metadata.content.should == { 'PLRestartDocumentPaths' => ['/vm/bar.vmwarevm']}
+    end
+
+    it 'should not doing anything if the vm is not in the list' do
+      @metadata.delete_vm_restart_document(Fission::VM.path('baz'))
+      @metadata.content.should == @data
+    end
+
+    it 'should not do anything if the restart document list does not exist' do
+      other_data = { 'OtherConfigItem' => ['foo', 'bar']}
+      @metadata.content = other_data
+      @metadata.delete_vm_restart_document(Fission::VM.path('foo'))
+      @metadata.content.should == other_data
+    end
+  end
+
+  describe 'delete_vm_favorite_entry' do
+    before do
+      @data = { 'VMFavoritesListDefaults2' => [{'path' => '/vm/foo.vmwarevm'}] }
+      @metadata.content = @data
+    end
+
+    it 'should remove the vm item from the list' do
+      @metadata.delete_vm_favorite_entry(Fission::VM.path('foo'))
+      @metadata.content.should == { 'VMFavoritesListDefaults2' => [] }
+    end
+
+    it 'should not do anything if the vm is not in the list' do
+      @metadata.delete_vm_favorite_entry(Fission::VM.path('bar'))
+      @metadata.content.should == @data
+    end
+  end
+
+  describe 'self.delete_vm_info' do
+    before do
+      @md_mock = mock('metadata_mock')
+      @md_mock.should_receive(:load)
+      @md_mock.should_receive(:save)
+      Fission::Metadata.stub!(:new).and_return(@md_mock)
+    end
+
+    it 'should remove the vm from the restart document list' do
+      @md_mock.should_receive(:delete_vm_restart_document).with('/vm/foo.vmwarevm')
+      @md_mock.stub!(:delete_vm_favorite_entry)
+      Fission::Metadata.delete_vm_info(Fission::VM.path('foo'))
+    end
+
+    it 'should remove the vm from the favorite list' do
+      @md_mock.should_receive(:delete_vm_favorite_entry).with('/vm/foo.vmwarevm')
+      @md_mock.stub!(:delete_vm_restart_document)
+      Fission::Metadata.delete_vm_info(Fission::VM.path('foo'))
+    end
+  end
+
+  describe 'save' do
+    it 'should save the data' do
+      CFPropertyList::List.should_receive(:new).and_return(@plist_mock)
+      CFPropertyList.should_receive(:guess).with([1, 2, 3]).
+                                           and_return(['1', '2', '3'])
+
+      @plist_mock.should_receive(:value=).with(['1', '2', '3'])
+      @plist_mock.should_receive(:save).
+                  with(@plist_file_path, CFPropertyList::List::FORMAT_BINARY)
+
+      @metadata.content = [1, 2, 3]
+      @metadata.save
+    end
+  end
+end

data/spec/fission/ui_spec.rb

@@ -1,13 +1,14 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Fission::UI do
+  before do
+    @string_io = StringIO.new
+  end
+
   describe 'output' do
     it 'should show the desired text' do
-      output = capturing_output do
-        Fission::UI.new.output "foo bar\nbaz blah"
-      end
-
-      output.should == "foo bar\nbaz blah\n"
+      Fission::UI.new(@string_io).output "foo bar\nbaz blah"
+      @string_io.string.should == "foo bar\nbaz blah\n"
     end
   end
 
@@ -22,13 +23,8 @@ describe Fission::UI do
   describe 'output_and_exit' do
     it 'should show the desired text and exit with the desired exit code' do
       Fission::UI.any_instance.should_receive(:exit).and_return(1)
-
-      output = capturing_output do
-        Fission::UI.new.output_and_exit "foo bar\nbaz blah", 1
-      end
-
-      output.should == "foo bar\nbaz blah\n"
+      Fission::UI.new(@string_io).output_and_exit "foo bar\nbaz blah", 1
+      @string_io.string.should == "foo bar\nbaz blah\n"
     end
-
   end
 end

data/spec/fission/vm_spec.rb

@@ -1,8 +1,12 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Fission::VM do
-  before :each do
+  before do
     @string_io = StringIO.new
+    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
+    @vm = Fission::VM.new('foo')
+    @vm.stub!(:conf_file).and_return(File.join(Fission::VM.path('foo'), 'foo.vmx'))
+    @vmrun_cmd = Fission.config.attributes['vmrun_cmd']
   end
 
   describe 'new' do
@@ -14,36 +18,41 @@ describe Fission::VM do
   describe 'start' do
     it 'should output that it was successful' do
       $?.should_receive(:exitstatus).and_return(0)
-      Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-      @vm = Fission::VM.new('foo')
       @vm.should_receive(:`).
-          with("#{Fission.config.attributes['vmrun_cmd']} start #{@vm.conf_file.gsub(' ', '\ ')} gui 2>&1").
+          with("#{@vmrun_cmd} start #{@vm.conf_file.gsub(' ', '\ ')} gui 2>&1").
           and_return("it's all good")
       @vm.start
 
       @string_io.string.should match /VM started/
     end
 
-    it 'it should output that it was unsuccessful' do
+    it 'should start the vm headless' do
+      $?.should_receive(:exitstatus).and_return(0)
+      @vm.should_receive(:`).
+          with("#{@vmrun_cmd} start #{@vm.conf_file.gsub(' ', '\ ')} nogui 2>&1").
+          and_return("it's all good")
+      @vm.start(:headless => true)
+
+      @string_io.string.should match /VM started/
+    end
+
+    it 'should output that it was unsuccessful' do
       $?.should_receive(:exitstatus).and_return(1)
-      Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-      @vm = Fission::VM.new('foo')
       @vm.should_receive(:`).
-          with("#{Fission.config.attributes['vmrun_cmd']} start #{@vm.conf_file.gsub(' ', '\ ')} gui 2>&1").
+          with("#{@vmrun_cmd} start #{@vm.conf_file.gsub(' ', '\ ')} gui 2>&1").
           and_return("it blew up")
       @vm.start
 
       @string_io.string.should match /There was a problem starting the VM.+it blew up.+/m
     end
+
   end
 
   describe 'stop' do
     it 'should output that it was successful' do
       $?.should_receive(:exitstatus).and_return(0)
-      Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-      @vm = Fission::VM.new('foo')
       @vm.should_receive(:`).
-          with("#{Fission.config.attributes['vmrun_cmd']} stop #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
+          with("#{@vmrun_cmd} stop #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
           and_return("it's all good")
       @vm.stop
 
@@ -52,10 +61,8 @@ describe Fission::VM do
 
     it 'it should output that it was unsuccessful' do
       $?.should_receive(:exitstatus).and_return(1)
-      Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-      @vm = Fission::VM.new('foo')
       @vm.should_receive(:`).
-          with("#{Fission.config.attributes['vmrun_cmd']} stop #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
+          with("#{@vmrun_cmd} stop #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
           and_return("it blew up")
       @vm.stop
 
@@ -66,10 +73,8 @@ describe Fission::VM do
   describe 'suspend' do
     it 'should output that it was successful' do
       $?.should_receive(:exitstatus).and_return(0)
-      Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-      @vm = Fission::VM.new('foo')
       @vm.should_receive(:`).
-          with("#{Fission.config.attributes['vmrun_cmd']} suspend #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
+          with("#{@vmrun_cmd} suspend #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
           and_return("it's all good")
       @vm.suspend
 
@@ -78,10 +83,8 @@ describe Fission::VM do
 
     it 'it should output that it was unsuccessful' do
       $?.should_receive(:exitstatus).and_return(1)
-      Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-      @vm = Fission::VM.new('foo')
       @vm.should_receive(:`).
-          with("#{Fission.config.attributes['vmrun_cmd']} suspend #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
+          with("#{@vmrun_cmd} suspend #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
           and_return("it blew up")
       @vm.suspend
 
@@ -89,55 +92,203 @@ describe Fission::VM do
     end
   end
 
+  describe 'snapshots' do
+    it 'should return the list of snapshots' do
+      $?.should_receive(:exitstatus).and_return(0)
+      @vm.should_receive(:`).
+          with("#{@vmrun_cmd} listSnapshots #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
+          and_return("Total snapshots: 3\nsnap foo\nsnap bar\nsnap baz\n")
+      @vm.snapshots.should == ['snap foo', 'snap bar', 'snap baz']
+    end
+
+    it 'should print an error and exit if there was a problem getting the list of snapshots' do
+      $?.should_receive(:exitstatus).and_return(1)
+      @vm.should_receive(:`).
+          with("#{@vmrun_cmd} listSnapshots #{@vm.conf_file.gsub ' ', '\ '} 2>&1").
+          and_return("it blew up\n")
+      lambda { @vm.snapshots }.should raise_error SystemExit
+      @string_io.string.should match /error getting the list of snapshots/
+      @string_io.string.should match /error was.+it blew up/m
+    end
+  end
+
+  describe 'create_snapshot' do
+    it 'should create a snapshot' do
+      $?.should_receive(:exitstatus).and_return(0)
+      @vm.should_receive(:`).
+          with("#{@vmrun_cmd} snapshot #{@vm.conf_file.gsub ' ', '\ '} \"bar\" 2>&1").
+          and_return("")
+      @vm.create_snapshot('bar')
+      @string_io.string.should match /Snapshot 'bar' created/
+    end
+
+    it 'should print an error and exit if there was a problem creating the snapshot' do
+      $?.should_receive(:exitstatus).and_return(1)
+      @vm.should_receive(:`).
+          with("#{@vmrun_cmd} snapshot #{@vm.conf_file.gsub ' ', '\ '} \"bar\" 2>&1").
+          and_return("it blew up")
+      lambda { @vm.create_snapshot('bar') }.should raise_error SystemExit
+      @string_io.string.should match /error creating the snapshot/
+      @string_io.string.should match /error was.+it blew up/m
+    end
+  end
+
+  describe 'revert_to_snapshot' do
+    it 'should revert to the provided snapshot' do
+      $?.should_receive(:exitstatus).and_return(0)
+      @vm.should_receive(:`).
+          with("#{@vmrun_cmd} revertToSnapshot #{@vm.conf_file.gsub ' ', '\ '} \"bar\" 2>&1").
+          and_return("")
+      @vm.revert_to_snapshot('bar')
+      @string_io.string.should match /Reverted to snapshot 'bar'/
+    end
+
+    it "should print an error and exit if the snapshot doesn't exist" do
+      $?.should_receive(:exitstatus).and_return(1)
+      @vm.should_receive(:`).
+          with("#{@vmrun_cmd} revertToSnapshot #{@vm.conf_file.gsub ' ', '\ '} \"bar\" 2>&1").
+          and_return("it blew up")
+      lambda { @vm.revert_to_snapshot('bar') }.should raise_error SystemExit
+      @string_io.string.should match /error reverting to the snapshot/
+      @string_io.string.should match /error was.+it blew up/m
+    end
+  end
+
   describe 'conf_file' do
+    before do
+      FakeFS.activate!
+      @vm_root_dir = Fission::VM.path('foo')
+      FileUtils.mkdir_p(@vm_root_dir)
+    end
+
+    after do
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+    end
+
     it 'should return the path to the conf file' do
-      Fission::VM.new('foo').conf_file.should == File.join(Fission.config.attributes['vm_dir'], 'foo.vmwarevm', 'foo.vmx')
+      file_path = File.join(@vm_root_dir, 'foo.vmx')
+      FileUtils.touch(file_path)
+      Fission::VM.new('foo').conf_file.should == file_path
+    end
+
+    it 'should output an error and exit if no vmx file was found' do
+      lambda {
+        FileUtils.mkdir_p(@vm_root_dir)
+        Fission::VM.new('foo').conf_file
+      }.should raise_error SystemExit
+
+      @string_io.string.should match /Unable to find a config file for VM 'foo' \(in '#{File.join(@vm_root_dir, '\*\.vmx')}'\)/m
+    end
+
+    describe 'when the VM name and conf file name do not match' do
+      it 'should return the path to the conf file' do
+        file_path = File.join(@vm_root_dir, 'bar.vmx')
+        FileUtils.touch(file_path)
+        Fission::VM.new('foo').conf_file.should == file_path
+      end
     end
+
+    describe 'if multiple vmx files are found' do
+      before do
+        FileUtils.mkdir_p(@vm_root_dir)
+      end
+
+      it 'should use the conf file which matches the VM name if it exists' do
+        ['foo.vmx', 'bar.vmx'].each do |file|
+          FileUtils.touch(File.join(@vm_root_dir, file))
+        end
+        Fission::VM.new('foo').conf_file.should == File.join(@vm_root_dir, 'foo.vmx')
+      end
+
+      it 'should output an error and exit' do
+        lambda {
+          ['bar.vmx', 'baz.vmx'].each do |file|
+            FileUtils.touch(File.join(@vm_root_dir, file))
+          end
+          Fission::VM.new('foo').conf_file
+        }.should raise_error SystemExit
+
+        @string_io.string.should match /Multiple config files found for VM 'foo' \('bar\.vmx', 'baz\.vmx' in '#{@vm_root_dir}'/m
+      end
+    end
+
   end
 
   describe "self.all" do
     it "should return the list of VMs" do
       vm_root = Fission.config.attributes['vm_dir']
-      Dir.should_receive(:[]).and_return(["#{File.join vm_root, 'foo.vmwarevm' }", "#{File.join vm_root, 'bar.vmwarevm' }"])
+      Dir.should_receive(:[]).
+          and_return(["#{File.join vm_root, 'foo.vmwarevm' }", "#{File.join vm_root, 'bar.vmwarevm' }"])
 
       vm_root = Fission.config.attributes['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)
+      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.all.should == ['foo', 'bar']
     end
 
     it "should not return an item in the list if it isn't a directory" do
       vm_root = Fission.config.attributes['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)
+      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.all.should == ['foo', 'bar']
     end
 
     it "should only query for items with an extension of .vmwarevm" do
       dir_arg = File.join Fission.config.attributes['vm_dir'], '*.vmwarevm'
-      Dir.should_receive(:[]).with(dir_arg).and_return(['foo.vmwarevm', 'bar.vmwarevm'])
+      Dir.should_receive(:[]).with(dir_arg).
+                              and_return(['foo.vmwarevm', 'bar.vmwarevm'])
       Fission::VM.all
     end
   end
 
   describe 'self.all_running' do
     it 'should list the running vms' do
-      list_output = "Total running VMs: 2\n/vm/foo.vmwarevm/foo.vmx\n/vm/bar.vmwarevm/bar.vmx\n/vm/baz.vmwarevm/baz.vmx\n"
+      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("#{Fission.config.attributes['vmrun_cmd']} list").and_return(list_output)
+      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)
+        File.should_receive(:exists?).with("/vm/#{vm}.vmwarevm/#{vm}.vmx").
+                                      and_return(true)
       end
 
       Fission::VM.all_running.should == ['foo', 'bar', 'baz']
     end
 
+    it 'should output 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)
+      end
+
+      $?.should_receive(:exitstatus).and_return(0)
+      Fission::VM.should_receive(:`).
+                  with("#{@vmrun_cmd} list").
+                  and_return(list_output)
+
+      Fission::VM.all_running.should == ['foo', 'bar', 'baz']
+    end
+
     it 'should output an error and exit if unable to get the list of running vms' do
       $?.should_receive(:exitstatus).and_return(1)
-      Fission::VM.should_receive(:`).with("#{Fission.config.attributes['vmrun_cmd']} list").and_return("it blew up")
+      Fission::VM.should_receive(:`).
+                  with("#{@vmrun_cmd} list").
+                  and_return("it blew up")
       Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
 
       lambda {
@@ -172,8 +323,7 @@ describe Fission::VM do
   end
 
   describe "self.clone" do
-    before :each do
-      Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
+    before do
       @source_vm = 'foo'
       @target_vm = 'bar'
       @vm_files = ['.vmx', '.vmxf', '.vmdk', '-s001.vmdk', '-s002.vmdk', '.vmsd']
@@ -191,16 +341,35 @@ describe Fission::VM do
       end
 
       ['.vmx', '.vmxf'].each do |ext|
-        File.should_receive(:binary?).with(File.join(Fission::VM.path('bar'), "bar#{ext}")).and_return(false)
+        File.should_receive(:binary?).
+             with(File.join(Fission::VM.path('bar'), "bar#{ext}")).
+             and_return(false)
       end
     end
 
-    after :each do
+    after do
       FakeFS.deactivate!
+      FakeFS::FileSystem.clear
     end
 
     it 'should copy the vm files to the target' do
-      File.should_receive(:binary?).with(File.join(Fission::VM.path('bar'), "bar.vmdk")).and_return(true)
+      File.should_receive(:binary?).
+           with(File.join(Fission::VM.path('bar'), "bar.vmdk")).
+           and_return(true)
+      Fission::VM.clone @source_vm, @target_vm
+
+      File.directory?(Fission::VM.path('bar')).should == true
+
+      @vm_files.each do |file|
+        File.file?(File.join(Fission::VM.path('bar'), "#{@target_vm}#{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 File.join(Fission::VM.path('foo'), 'other_name.nvram')
+      File.should_receive(:binary?).
+           with(File.join(Fission::VM.path('bar'), "bar.vmdk")).
+           and_return(true)
       Fission::VM.clone @source_vm, @target_vm
 
       File.directory?(Fission::VM.path('bar')).should == true
@@ -208,10 +377,31 @@ describe Fission::VM do
       @vm_files.each do |file|
         File.file?(File.join(Fission::VM.path('bar'), "#{@target_vm}#{file}")).should == true
       end
+
+      File.file?(File.join(Fission::VM.path('bar'), "bar.nvram")).should == true
+    end
+
+
+    it "should copy the vm files to the target if a sparse disk file name doesn't match the directory" do
+      FileUtils.touch File.join(Fission::VM.path('foo'), 'other_name-s003.vmdk')
+      File.should_receive(:binary?).
+           with(File.join(Fission::VM.path('bar'), "bar.vmdk")).
+           and_return(true)
+      Fission::VM.clone @source_vm, @target_vm
+
+      File.directory?(Fission::VM.path('bar')).should == true
+
+      @vm_files.each do |file|
+        File.file?(File.join(Fission::VM.path('bar'), "#{@target_vm}#{file}")).should == true
+      end
+
+      File.file?(File.join(Fission::VM.path('bar'), "bar-s003.vmdk")).should == true
     end
 
     it 'should update the target vm config files' do
-      File.should_receive(:binary?).with(File.join(Fission::VM.path('bar'), "bar.vmdk")).and_return(true)
+      File.should_receive(:binary?).
+           with(File.join(Fission::VM.path('bar'), "bar.vmdk")).
+           and_return(true)
       Fission::VM.clone @source_vm, @target_vm
 
       ['.vmx', '.vmxf'].each do |ext|
@@ -221,27 +411,61 @@ describe Fission::VM do
     end
 
     it "should not try to update the vmdk file if it's not a sparse disk" do
-      File.should_receive(:binary?).with(File.join(Fission::VM.path('bar'), "bar.vmdk")).and_return(true)
+      File.should_receive(:binary?).
+           with(File.join(Fission::VM.path('bar'), "bar.vmdk")).and_return(true)
       Fission::VM.clone @source_vm, @target_vm
 
       File.read(File.join(Fission::VM.path('bar'), 'bar.vmdk')).should match /foo/
     end
 
     it "should update the vmdk when a sparse disk is found" do
-      File.should_receive(:binary?).with(File.join(Fission::VM.path('bar'), "bar.vmdk")).and_return(false)
+      File.should_receive(:binary?).
+           with(File.join(Fission::VM.path('bar'), "bar.vmdk")).and_return(false)
       Fission::VM.clone @source_vm, @target_vm
 
       File.read(File.join(Fission::VM.path('bar'), 'bar.vmdk')).should match /bar/
     end
 
     it 'should output that the clone was successful' do
-      File.should_receive(:binary?).with(File.join(Fission::VM.path('bar'), "bar.vmdk")).and_return(true)
+      File.should_receive(:binary?).
+           with(File.join(Fission::VM.path('bar'), "bar.vmdk")).and_return(true)
       Fission::VM.clone @source_vm, @target_vm
 
       @string_io.string.should match /Cloning #{@source_vm} to #{@target_vm}/
-        @string_io.string.should match /Configuring #{@target_vm}/
+      @string_io.string.should match /Configuring #{@target_vm}/
     end
-
   end
 
+  describe "self.delete" do
+    before do
+      @target_vm = 'foo'
+      @vm_files = %w{ .vmx .vmxf .vmdk -s001.vmdk -s002.vmdk .vmsd }
+      FakeFS.activate!
+
+      FileUtils.mkdir_p Fission::VM.path(@target_vm)
+
+      @vm_files.each do |file|
+        FileUtils.touch File.join(Fission::VM.path(@target_vm), "#{@target_vm}#{file}")
+      end
+    end
+
+    after do
+      FakeFS.deactivate!
+    end
+
+    it "should delete the target vm files" do
+      Fission::Metadata.stub!(:delete_vm_info)
+      Fission::VM.delete @target_vm
+      @vm_files.each do |file|
+        File.exists?(File.join(Fission::VM.path(@target_vm), "#{@target_vm}#{file}")).should == false
+      end
+      @string_io.string.should match /Deleting vm #{@target_vm}/
+    end
+
+    it 'should delete the target vm metadata' do
+      Fission::Metadata.should_receive(:delete_vm_info)
+      Fission::VM.delete @target_vm
+    end
+
+  end
 end