fission 0.3.0 → 0.4.0.beta.1

data/spec/fission/command/snapshot_list_spec.rb

@@ -1,40 +1,29 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::SnapshotList do
+  include_context 'command_setup'
+
   before do
     @target_vm = ['foo']
-    @vm_mock = mock('vm_mock')
     Fission::VM.stub!(:new).and_return(@vm_mock)
-    @string_io = StringIO.new
-    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-  end
 
-  describe 'execute' do
-    it "should output an error and the help when no VM argument is passed in" do
-      Fission::Command::SnapshotList.should_receive(:help)
+    @snap_list_response_mock = mock('snap_list_response')
 
-      lambda {
-        command = Fission::Command::SnapshotList.new
-        command.execute
-      }.should raise_error SystemExit
+    @vm_mock.stub(:name).and_return(@target_vm.first)
+  end
 
-      @string_io.string.should match /Incorrect arguments for snapshot list command/
+  describe 'execute' do
+    before do
+      @vm_mock.stub(:snapshots).and_return(@snap_list_response_mock)
     end
 
-    it "should output an error and exit if it can't find the target vm" do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(false)
-
-      lambda {
-        command = Fission::Command::SnapshotList.new @target_vm
-        command.execute
-      }.should raise_error SystemExit
+    subject { Fission::Command::SnapshotList }
 
-      @string_io.string.should match /Unable to find the VM #{@target_vm.first}/
-    end
+    it_should_not_accept_arguments_of [], 'snapshot list'
 
     it 'should output the list of snapshots if any exist' do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      @vm_mock.should_receive(:snapshots).and_return(['snap 1', 'snap 2', 'snap 3'])
+      @snap_list_response_mock.stub_as_successful ['snap 1', 'snap 2', 'snap 3']
+
       command = Fission::Command::SnapshotList.new @target_vm
       command.execute
 
@@ -42,20 +31,30 @@ describe Fission::Command::SnapshotList do
     end
 
     it 'should output that it could not find any snapshots if none exist' do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      @vm_mock.should_receive(:snapshots).and_return([])
+      @snap_list_response_mock.stub_as_successful []
+
       command = Fission::Command::SnapshotList.new @target_vm
       command.execute
 
       @string_io.string.should match /No snapshots found for VM '#{@target_vm.first}'/
     end
+
+    it 'should output an error and exit if there was an error getting the list of snapshots' do
+      @snap_list_response_mock.stub_as_unsuccessful
+
+      command = Fission::Command::SnapshotList.new @target_vm
+      lambda { command.execute }.should raise_error SystemExit
+
+      @string_io.string.should match /There was an error listing the snapshots.+it blew up.+/m
+    end
+
   end
 
   describe 'help' do
     it 'should output info for this command' do
       output = Fission::Command::SnapshotList.help
 
-      output.should match /snapshot list/
+      output.should match /snapshot list vm_name/
     end
   end
 end

data/spec/fission/command/snapshot_revert_spec.rb

@@ -1,90 +1,64 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::SnapshotRevert do
+  include_context 'command_setup'
+
   before do
     @target_vm = ['foo']
-    @vm_mock = mock('vm_mock')
     Fission::VM.stub!(:new).and_return(@vm_mock)
-    @string_io = StringIO.new
-    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
+
+    @snap_revert_response_mock = mock('snap_revert_response')
+
+    @vm_mock.stub(:name).and_return(@target_vm.first)
   end
 
   describe 'execute' do
-    it "should output an error and the help when no vm name is passed in" do
-      Fission::Command::SnapshotRevert.should_receive(:help)
-
-      lambda {
-        command = Fission::Command::SnapshotRevert.new
-        command.execute
-      }.should raise_error SystemExit
+    subject { Fission::Command::SnapshotRevert }
 
-      @string_io.string.should match /Incorrect arguments for snapshot revert command/
-    end
+    it_should_not_accept_arguments_of [], 'snapshot revert'
 
     it "should output an error and the help when no snapshot name is passed in" do
       Fission::Command::SnapshotRevert.should_receive(:help)
 
-      lambda {
-        command = Fission::Command::SnapshotRevert.new @target_vm
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::SnapshotRevert.new @target_vm
+      lambda { command.execute }.should raise_error SystemExit
 
       @string_io.string.should match /Incorrect arguments for snapshot revert command/
     end
 
-    it "should output an error and exit if it can't find the target vm" do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(false)
-
-      lambda {
-        command = Fission::Command::SnapshotRevert.new @target_vm << 'snap_1'
-        command.execute
-      }.should raise_error SystemExit
-
-      @string_io.string.should match /Unable to find the VM #{@target_vm.first}/
-    end
+    it 'should revert to the snapshot with the provided name' do
+      @snap_revert_response_mock.stub_as_successful
 
-    it "should output an error and exit if it can't find the snapshot" do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      Fission::Fusion.should_receive(:is_running?).and_return(false)
-      @vm_mock.should_receive(:snapshots).and_return([])
+      @vm_mock.should_receive(:revert_to_snapshot).with('snap_1').
+               and_return(@snap_revert_response_mock)
 
-      lambda {
-        command = Fission::Command::SnapshotRevert.new @target_vm << 'snap_1'
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::SnapshotRevert.new @target_vm << 'snap_1'
+      command.execute
 
-      @string_io.string.should match /Unable to find the snapshot 'snap_1'/
+      @string_io.string.should match /Reverting to snapshot 'snap_1'/
+      @string_io.string.should match /Reverted to snapshot 'snap_1'/
     end
 
-    it 'should output an error and exit if the fusion app is running' do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      Fission::Fusion.should_receive(:is_running?).and_return(true)
-
-      lambda {
-        command = Fission::Command::SnapshotRevert.new @target_vm << 'snap_1'
-        command.execute
-      }.should raise_error SystemExit
+    it 'should output an error and exit if there was an error reverting to the snapshot' do
+      @snap_revert_response_mock.stub_as_unsuccessful
 
-      @string_io.string.should match /Fusion GUI is currently running/
-      @string_io.string.should match /Please exit the Fusion GUI and try again/
-    end
+      @vm_mock.should_receive(:revert_to_snapshot).with('snap_1').
+               and_return(@snap_revert_response_mock)
 
-    it 'should revert to the snapshot with the provided name' do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      Fission::Fusion.should_receive(:is_running?).and_return(false)
-      @vm_mock.should_receive(:snapshots).and_return(['snap_1', 'snap_2'])
-      @vm_mock.should_receive(:revert_to_snapshot).with('snap_1')
       command = Fission::Command::SnapshotRevert.new @target_vm << 'snap_1'
-      command.execute
+      lambda { command.execute }.should raise_error SystemExit
+
       @string_io.string.should match /Reverting to snapshot 'snap_1'/
+      @string_io.string.should match /There was an error reverting to the snapshot.+it blew up.+/m
     end
+
   end
 
   describe 'help' do
     it 'should output info for this command' do
       output = Fission::Command::SnapshotRevert.help
 
-      output.should match /snapshot revert my_vm snapshot_1/
+      output.should match /snapshot revert vm_name snapshot_1/
     end
   end
 end

data/spec/fission/command/start_spec.rb

@@ -1,99 +1,55 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::Start do
-  before do
-    @vm_info = ['foo']
-    @string_io = StringIO.new
-    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-    @vm_mock = mock('vm_mock')
-  end
-
-  describe 'execute' do
-    it "should output an error and the help when no VM argument is passed in" do
-      Fission::Command::Start.should_receive(:help)
-
-      lambda {
-        command = Fission::Command::Start.new
-        command.execute
-      }.should raise_error SystemExit
-
-      @string_io.string.should match /Incorrect arguments for start command/
-    end
+  include_context 'command_setup'
 
-    it "should output an error and exit if it can't find the vm" do
-      Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(false)
-
-      lambda {
-        command = Fission::Command::Start.new @vm_info
-        command.execute
-      }.should raise_error SystemExit
+  before do
+    @target_vm = ['foo']
+    Fission::VM.stub(:new).and_return(@vm_mock)
 
-      @string_io.string.should match /Unable to find the VM #{@vm_info.first}/
-    end
+    @start_response_mock = mock('start_response')
 
+    @vm_mock.stub(:name).and_return(@target_vm.first)
+  end
 
-    it "should output and exit if the vm is already running" do
-      Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(true)
-      Fission::VM.should_receive(:all_running).and_return(@vm_info)
+  describe 'execute' do
+    subject { Fission::Command::Start }
 
-      lambda {
-        command = Fission::Command::Start.new @vm_info
-        command.execute
-      }.should raise_error SystemExit
+    it_should_not_accept_arguments_of [], 'start'
 
-      @string_io.string.should match /VM '#{@vm_info.first}' is already running/
-    end
+    it 'should output an error and exit if there was an error starting the vm' do
+      @start_response_mock.stub_as_unsuccessful
 
-    it 'should try to start the vm if it is not running' do
-      Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(true)
-      Fission::VM.should_receive(:all_running).and_return([])
-      Fission::VM.should_receive(:new).with(@vm_info.first).and_return(@vm_mock)
-      @vm_mock.should_receive(:start)
+      @vm_mock.should_receive(:start).and_return(@start_response_mock)
 
-      command = Fission::Command::Start.new @vm_info
-      command.execute
+      command = Fission::Command::Start.new @target_vm
+      lambda { command.execute }.should raise_error SystemExit
 
-      @string_io.string.should match /Starting '#{@vm_info.first}'/
+      @string_io.string.should match /Starting '#{@target_vm.first}'/
+      @string_io.string.should match /There was a problem starting the VM.+it blew up.+/m
     end
 
     describe 'with --headless' do
       it 'should start the vm headless' do
-        Fission::Fusion.should_receive(:is_running?).and_return(false)
-        Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(true)
-        Fission::VM.should_receive(:all_running).and_return([])
-        Fission::VM.should_receive(:new).with(@vm_info.first).and_return(@vm_mock)
-        @vm_mock.should_receive(:start).with(:headless => true)
+        @start_response_mock.stub_as_successful
 
-        command = Fission::Command::Start.new @vm_info << '--headless'
-        command.execute
+        @vm_mock.should_receive(:start).and_return(@start_response_mock)
 
-        @string_io.string.should match /Starting '#{@vm_info.first}'/
-      end
+        command = Fission::Command::Start.new @target_vm << '--headless'
+        command.execute
 
-      it 'should output an error and exit if the fusion app is running' do
-        Fission::Fusion.should_receive(:is_running?).and_return(true)
-        Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(true)
-        Fission::VM.should_receive(:all_running).and_return([])
-        Fission::VM.should_receive(:new).with(@vm_info.first).and_return(@vm_mock)
-        @vm_mock.should_not_receive(:start)
-
-        lambda {
-          command = Fission::Command::Start.new @vm_info << '--headless'
-          command.execute
-        }.should raise_error SystemExit
-
-        @string_io.string.should match /Fusion GUI is currently running/
-        @string_io.string.should match /A VM cannot be started in headless mode when the Fusion GUI is running/
-        @string_io.string.should match /Exit the Fusion GUI and try again/
+        @string_io.string.should match /Starting '#{@target_vm.first}'/
+          @string_io.string.should match /VM '#{@target_vm.first}' started/
       end
     end
+
   end
 
   describe 'help' do
     it 'should output info for this command' do
       output = Fission::Command::Start.help
 
-      output.should match /start vm \[options\]/
+      output.should match /start vm_name \[options\]/
       output.should match /--headless/
     end
   end

data/spec/fission/command/status_spec.rb

@@ -1,30 +1,65 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::Status do
+  include_context 'command_setup'
+
   before do
-    @string_io = StringIO.new
-    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
+    @all_response_mock = mock('response')
+    @vm_1 = Fission::VM.new 'foo'
+    @vm_2 = Fission::VM.new 'bar'
+    @vm_3 = Fission::VM.new 'baz'
+    @vm_4 = Fission::VM.new 'blah'
   end
 
   describe 'execute' do
     before do
-      Fission::VM.stub!(:all).and_return(['foo', 'bar', 'baz'])
-      Fission::VM.stub!(:all_running).and_return(['foo', 'baz'])
+      @all_response_mock.stub_as_successful [@vm_1, @vm_2, @vm_3, @vm_4]
+
+      Fission::VM.should_receive(:all).and_return(@all_response_mock)
+      Fission::VM.stub(:all_running).and_return(@all_running_response_mock)
     end
 
-    it 'should output the VMs which are running' do
-      command = Fission::Command::Status.new
-      command.execute
+    describe 'when successful' do
+      before do
+        @all_running_response_mock.stub_as_successful [@vm_1, @vm_3]
+      end
+
+      it 'should output the VMs which are running' do
+        command = Fission::Command::Status.new
+        command.execute
+
+        @string_io.string.should match /foo.+\[running\]/
+        @string_io.string.should match /baz.+\[running\]/
+      end
+
+      it 'should output the VMs which are not running' do
+        command = Fission::Command::Status.new
+        command.execute
+
+        @string_io.string.should match /bar.+\[not running\]/
+      end
+
+      it 'should output the VMs which are suspended' do
+        @vm_4.stub(:suspend_file_exists?).and_return(true)
+        command = Fission::Command::Status.new
+        command.execute
+
+        @string_io.string.should match /blah.+\[suspended\]/
+      end
 
-      @string_io.string.should match /foo.+[running]/
-      @string_io.string.should match /baz.+[running]/
     end
 
-    it 'should output the VMs which are not running' do
-      command = Fission::Command::Status.new
-      command.execute
+    describe 'when unsuccessful' do
+      before do
+        @all_running_response_mock.stub_as_unsuccessful
+      end
+
+      it 'should output an error and exit if there was an error getting the list of running VMs' do
+        command = Fission::Command::Status.new
+        lambda { command.execute }.should raise_error SystemExit
 
-      @string_io.string.should match /bar.+[not running]/
+        @string_io.string.should match /There was an error getting the list of running VMs.+it blew up/m
+      end
     end
   end
 

data/spec/fission/command/stop_spec.rb

@@ -1,68 +1,51 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::Stop do
+  include_context 'command_setup'
+
   before do
-    @vm_info = ['foo']
-    @string_io = StringIO.new
-    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
+    @target_vm = ['foo']
+    Fission::VM.stub(:new).and_return(@vm_mock)
+
+    @stop_response_mock = mock('stop_response')
+
+    @vm_mock.stub(:name).and_return(@target_vm.first)
   end
 
   describe 'execute' do
-    it "should output an error and the help when no VM argument is passed in" do
-      Fission::Command::Stop.should_receive(:help)
+    subject { Fission::Command::Stop }
 
-      lambda {
-        command = Fission::Command::Stop.new
-        command.execute
-      }.should raise_error SystemExit
+    it_should_not_accept_arguments_of [], 'stop'
 
-      @string_io.string.should match /Incorrect arguments for stop command/
-    end
-
-    it "should output an error and exit if it can't find the vm" do
-      Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(false)
+    it 'should stop the vm' do
+      @stop_response_mock.should_receive(:successful?).and_return(true)
+      @vm_mock.should_receive(:stop).and_return(@stop_response_mock)
 
-      lambda {
-        command = Fission::Command::Stop.new @vm_info
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::Stop.new @target_vm
+      command.execute
 
-      @string_io.string.should match /Unable to find the VM #{@vm_info.first}/
+      @string_io.string.should match /Stopping '#{@target_vm.first}'/
+      @string_io.string.should match /VM '#{@target_vm.first}' stopped/
     end
 
+    it 'should output an error and exit if there was an error stopping the vm' do
+      @stop_response_mock.stub_as_unsuccessful
 
-    it "should output and exit if the vm is not running" do
-      Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(true)
-      Fission::VM.should_receive(:all_running).and_return([])
+      @vm_mock.should_receive(:stop).and_return(@stop_response_mock)
 
-      lambda {
-        command = Fission::Command::Stop.new @vm_info
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::Stop.new @target_vm
+      lambda { command.execute }.should raise_error SystemExit
 
-      @string_io.string.should match /VM '#{@vm_info.first}' is not running/
+      @string_io.string.should match /Stopping '#{@target_vm.first}'/
+        @string_io.string.should match /There was an error stopping the VM.+it blew up.+/m
     end
-
-    it 'should try to stop the vm if it is not running' do
-      @vm_mock = mock('vm_mock')
-      Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(true)
-      Fission::VM.should_receive(:all_running).and_return(@vm_info)
-      Fission::VM.should_receive(:new).with(@vm_info.first).and_return(@vm_mock)
-      @vm_mock.should_receive(:stop)
-
-      command = Fission::Command::Stop.new @vm_info
-      command.execute
-
-      @string_io.string.should match /Stopping '#{@vm_info.first}'/
-    end
-
   end
 
   describe 'help' do
     it 'should output info for this command' do
       output = Fission::Command::Stop.help
 
-      output.should match /stop vm/
+      output.should match /stop vm_name/
     end
   end
 end