fission 0.4.0 → 0.5.0.beta.1

data/spec/fission/action/vm/deleter_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Fission::Action::VM::Deleter do
+
+  describe 'delete' do
+    before do
+      @vm                      = Fission::VM.new 'foo'
+      @vmrun_cmd               = Fission.config['vmrun_cmd']
+      @conf_file_path          = File.join @vm.path, 'foo.vmx'
+      @conf_file_response_mock = mock 'conf_file_response'
+      @running_response_mock   = mock 'running?'
+      @vm_files                = %w{ .vmx .vmxf .vmdk -s001.vmdk -s002.vmdk .vmsd }
+
+      @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
+      @deleter = Fission::Action::VM::Deleter.new @vm
+
+      FakeFS.activate!
+
+      FileUtils.mkdir_p @vm.path
+
+      @vm_files.each do |file|
+        FileUtils.touch File.join(@vm.path, "#{@vm.name}#{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 = @deleter.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 = @deleter.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 = @deleter.delete
+      response.should be_an_unsuccessful_response
+    end
+
+    it "should delete the target vm files" do
+      Fission::Metadata.stub!(:delete_vm_info)
+
+      @deleter.delete
+
+      @vm_files.each do |file|
+        file_path = File.join @vm.path, "#{@vm.name}#{file}"
+        File.exists?(file_path).should == false
+      end
+
+      File.directory?(@vm.path).should == false
+    end
+
+    it 'should delete the target vm metadata' do
+      Fission::Metadata.should_receive(:delete_vm_info).with(@vm.path)
+      @deleter.delete
+    end
+
+    it 'should return a successful reponse object' do
+      Fission::Metadata.stub!(:delete_vm_info)
+      @deleter.delete.should be_a_successful_response
+    end
+
+  end
+end

data/spec/fission/action/vm/lister_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe Fission::Action::VM::Lister do
+  before do
+    @vm_1   = Fission::VM.new 'foo'
+    @vm_2   = Fission::VM.new 'bar'
+    @vm_3   = Fission::VM.new 'baz'
+    @lister = Fission::Action::VM::Lister.new
+  end
+
+  describe 'all' do
+    before do
+      @vm_1_mock = mock('vm_1')
+      @vm_2_mock = mock('vm_2')
+      @vm_root   = Fission.config['vm_dir']
+      @vm_dirs   = ['foo.vmwarevm', 'bar.vmwarevm'].map do |d|
+        File.join(@vm_root, d)
+      end
+    end
+
+    it "should return a successful response with the list of VM objects" do
+      Dir.should_receive(:[]).and_return(@vm_dirs)
+      @vm_dirs.each do |dir|
+        File.should_receive(:directory?).with(dir).and_return(true)
+      end
+
+      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 = @lister.all
+      response.should be_a_successful_response
+      response.data.should == [@vm_1_mock, @vm_2_mock]
+    end
+
+    it "should not return an item in the list if it isn't a directory" do
+      @vm_dirs << File.join(@vm_root, 'baz.vmwarevm')
+      Dir.should_receive(:[]).and_return(@vm_dirs)
+      @vm_dirs.each do |dir|
+        if dir =~ /baz/
+          File.should_receive(:directory?).with(dir).and_return(false)
+        else
+          File.should_receive(:directory?).with(dir).and_return(true)
+        end
+      end
+
+      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 = @lister.all
+      response.should be_a_successful_response
+      response.data.should == [@vm_1_mock, @vm_2_mock]
+    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([])
+      @lister.all
+    end
+  end
+
+  describe 'all running' do
+    before do
+      @vmrun_cmd         = Fission.config['vmrun_cmd']
+      @vm_names_and_objs = { 'foo' => @vm_1, 'bar' => @vm_2, 'baz' => @vm_3 }
+      @executor          = mock 'executor'
+      @process_status    = mock 'process status'
+    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"
+      Fission::Action::ShellExecutor.should_receive(:new).
+                                     with("#{@vmrun_cmd} list").
+                                     and_return(@executor)
+      @process_status.should_receive(:exitstatus).and_return(0)
+      @executor.should_receive(:execute).
+                and_return({'process_status' => @process_status,
+                            'output'  => 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 = @lister.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
+
+      Fission::Action::ShellExecutor.should_receive(:new).
+                                     with("#{@vmrun_cmd} list").
+                                     and_return(@executor)
+      @process_status.should_receive(:exitstatus).and_return(0)
+      @executor.should_receive(:execute).
+                and_return({'process_status' => @process_status,
+                            'output'  => list_output})
+
+      response = @lister.all_running
+      response.should be_a_successful_response
+      response.data.should =~ [@vm_1, @vm_2, @vm_3]
+    end
+
+    it 'should return an unsuccessful response if unable to get the list of running vms' do
+      Fission::Action::ShellExecutor.should_receive(:new).
+                                     with("#{@vmrun_cmd} list").
+                                     and_return(@executor)
+      @process_status.should_receive(:exitstatus).and_return(1)
+      @executor.should_receive(:execute).
+                and_return({'process_status' => @process_status,
+                            'output'  => 'it blew up'})
+      @lister.all_running.should be_an_unsuccessful_response
+    end
+
+  end
+
+  describe 'all_with_status' do
+    before do
+      @all_running_response_mock = mock('all_running_mock')
+      @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.stub_as_successful [@vm_1]
+
+      @vm_2.stub(:suspend_file_exists?).and_return('true')
+      @lister.stub(:all).and_return(@all_vms_response_mock)
+      @lister.stub(:all_running).and_return(@all_running_response_mock)
+    end
+
+    it 'should return a sucessful response with the VMs and their status' do
+      response = @lister.all_with_status
+      response.should be_a_successful_response
+      response.data.should == { 'foo' => 'running',
+                                'bar' => 'suspended',
+                                'baz' => 'not running' }
+
+    end
+
+    it 'should return an unsuccessful response if unable to get all of the VMs' do
+      @all_vms_response_mock.stub_as_unsuccessful
+      @lister.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
+      @lister.all_with_status.should be_an_unsuccessful_response
+    end
+
+  end
+
+end

data/spec/fission/action/vm/starter_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Fission::Action::VM::Starter do
+
+  describe 'start' do
+    before do
+      @vm                      = Fission::VM.new 'foo'
+      @vmrun_cmd               = Fission.config['vmrun_cmd']
+      @conf_file_path          = File.join @vm.path, 'foo.vmx'
+      @conf_file_response_mock = mock 'conf_file_response'
+      @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
+      @starter = Fission::Action::VM::Starter.new @vm
+    end
+
+    it "should return an unsuccessful response if the vm doesn't exist" do
+      @vm.stub(:exists?).and_return(false)
+      @starter.start.should be_an_unsuccessful_response 'VM does not exist'
+    end
+
+    it 'should return an unsuccessful response if the vm is already running' do
+      @running_response_mock.stub_as_successful true
+      @starter.start.should be_an_unsuccessful_response 'VM is already running'
+    end
+
+    it 'should return an unsuccessful response if unable to determine if running' do
+      @running_response_mock.stub_as_unsuccessful
+      @starter.start.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
+      @starter.start.should be_an_unsuccessful_response
+    end
+
+    context 'when the fusion gui is not running' do
+      before do
+        @executor_mock = mock 'executor'
+        @response      = stub
+        @executor_mock.should_receive(:execute).and_return(@executor_mock)
+        Fission::Fusion.stub(:running?).and_return(false)
+        Fission::Response.should_receive(:from_shell_executor).
+                          with(@executor_mock).
+                          and_return(@response)
+      end
+
+      it 'should return a response when starting the vm' do
+        cmd = "#{@vmrun_cmd} start '#{@conf_file_path}' gui 2>&1"
+        Fission::Action::ShellExecutor.should_receive(:new).
+                                       with(cmd).
+                                       and_return(@executor_mock)
+        @starter.start.should == @response
+      end
+
+      it 'should return a response when starting the vm headless' do
+        cmd = "#{@vmrun_cmd} start '#{@conf_file_path}' nogui 2>&1"
+        Fission::Action::ShellExecutor.should_receive(:new).
+                                       with(cmd).
+                                       and_return(@executor_mock)
+        @starter.start(:headless => true).should == @response
+      end
+
+    end
+
+    context '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 = @starter.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
+    end
+
+  end
+
+end

data/spec/fission/action/vm/stopper_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Fission::Action::VM::Stopper do
+
+  describe 'stop' do
+    before do
+      @vm                      = Fission::VM.new 'foo'
+      @vmrun_cmd               = Fission.config['vmrun_cmd']
+      @conf_file_path          = File.join @vm.path, 'foo.vmx'
+      @conf_file_response_mock = mock 'conf_file_response'
+      @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
+      @stopper = Fission::Action::VM::Stopper.new @vm
+    end
+
+    it "should return an unsuccessful response if the vm doesn't exist" do
+      @vm.stub(:exists?).and_return(false)
+      @stopper.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
+      @stopper.stop.should be_an_unsuccessful_response 'VM is not running'
+    end
+
+    it 'should return an unsuccessful response if unable to determine if running' do
+      @running_response_mock.stub_as_unsuccessful
+      @stopper.stop.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
+      @stopper.stop.should be_an_unsuccessful_response
+    end
+
+    context 'when stopping the vm' do
+      before do
+        @executor_mock = mock 'executor'
+        @response      = stub
+        @executor_mock.should_receive(:execute).and_return(@executor_mock)
+        Fission::Fusion.stub(:running?).and_return(false)
+        Fission::Response.should_receive(:from_shell_executor).
+                          with(@executor_mock).
+                          and_return(@response)
+      end
+
+      it 'should return a response' do
+        cmd = "#{@vmrun_cmd} stop '#{@conf_file_path}' 2>&1"
+        Fission::Action::ShellExecutor.should_receive(:new).
+                                       with(cmd).
+                                       and_return(@executor_mock)
+        @stopper.stop.should  == @response
+      end
+
+      it 'should return a response for a hard stop' do
+        cmd = "#{@vmrun_cmd} stop '#{@conf_file_path}' hard 2>&1"
+        Fission::Action::ShellExecutor.should_receive(:new).
+                                       with(cmd).
+                                       and_return(@executor_mock)
+        @stopper.stop(:hard => true).should == @response
+      end
+    end
+
+  end
+
+end

data/spec/fission/action/vm/suspender_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Fission::Action::VM::Suspender do
+
+  describe 'suspend' do
+    before do
+      @vm                      = Fission::VM.new 'foo'
+      @vmrun_cmd               = Fission.config['vmrun_cmd']
+      @conf_file_path          = File.join @vm.path, 'foo.vmx'
+      @conf_file_response_mock = mock 'conf_file_response'
+      @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
+      @suspender = Fission::Action::VM::Suspender.new @vm
+    end
+
+    it "should return an unsuccessful response if the vm doesn't exist" do
+      @vm.stub(:exists?).and_return(false)
+      @suspender.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
+      @suspender.suspend.should be_an_unsuccessful_response 'VM is not running'
+    end
+
+    it 'should return an unsuccessful response if unable to determine if running' do
+      @running_response_mock.stub_as_unsuccessful
+      @suspender.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
+      @suspender.suspend.should be_an_unsuccessful_response
+    end
+
+    it 'should return a response' do
+      executor_mock = mock 'executor'
+      response      = stub
+      cmd           = "#{@vmrun_cmd} suspend "
+      cmd           << "'#{@conf_file_path}' 2>&1"
+
+      executor_mock.should_receive(:execute).and_return(executor_mock)
+      Fission::Action::ShellExecutor.should_receive(:new).
+                                     with(cmd).
+                                     and_return(executor_mock)
+      Fission::Response.should_receive(:from_shell_executor).
+                        with(executor_mock).
+                        and_return(response)
+      @suspender.suspend.should == response
+    end
+
+  end
+
+end