fission 0.3.0 → 0.4.0.beta.1

data/spec/contexts/command.rb

@@ -0,0 +1,12 @@
+shared_context 'command_setup' do
+  before do
+    @string_io = StringIO.new
+    ui_stub = Fission::UI.new(@string_io)
+    Fission::UI.stub!(:new).and_return(ui_stub)
+
+    @all_running_response_mock = mock('all_running_response')
+    @state_response_mock = mock('state_response')
+    @vm_mock = mock('vm_mock')
+  end
+
+end

data/spec/fission/cli_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path('../../spec_helper.rb', __FILE__)
 describe Fission::CLI do
   before do
     @string_io = StringIO.new
-    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
+    Fission::CLI.stub!(:ui).and_return(Fission::UI.new(@string_io))
   end
 
   describe 'self.commands' do
@@ -17,9 +17,7 @@ describe Fission::CLI do
   describe 'execute' do
     describe 'with no arguments' do
       it 'should output the usage info' do
-        lambda {
-          Fission::CLI.execute []
-        }.should raise_error SystemExit
+        lambda { Fission::CLI.execute [] }.should raise_error SystemExit
 
         @string_io.string.should match /Usage/
       end
@@ -28,12 +26,9 @@ describe Fission::CLI do
     describe '-v or --version' do
       ['-v', '--version'].each do |arg|
         it "should output the version with #{arg}" do
-          lambda {
-            Fission::CLI.execute [arg]
-          }.should raise_error SystemExit
+          lambda { Fission::CLI.execute [arg] }.should raise_error SystemExit
 
           @string_io.string.should match /#{Fission::VERSION}/
-
         end
       end
     end
@@ -41,9 +36,7 @@ describe Fission::CLI do
     describe '-h or --help' do
       ['-h', '--help'].each do |arg|
         it "should output the usage info with #{arg}" do
-          lambda {
-            Fission::CLI.execute [arg]
-          }.should raise_error SystemExit
+          lambda { Fission::CLI.execute [arg] }.should raise_error SystemExit
 
           @string_io.string.should match /Usage/
         end

data/spec/fission/command/clone_spec.rb

@@ -1,76 +1,76 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::Clone do
+  include_context 'command_setup'
+
   before do
     @vm_info = ['foo', 'bar']
-    @string_io = StringIO.new
-    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
-  end
+    @source_vm_mock = mock('source_vm')
+    @target_vm_mock = mock('target_vm')
 
-  describe 'execute' do
-    [ [], ['foo'] ].each do |args|
-      it "should output an error and the help when #{args.count} arguments are passed in" do
-        Fission::Command::Clone.should_receive(:help)
+    @clone_response_mock = mock('clone_reponse')
+    @start_response_mock = mock('start_reponse')
 
-        lambda {
-          command = Fission::Command::Clone.new args
-          command.execute
-        }.should raise_error SystemExit
-
-        @string_io.string.should match /Incorrect arguments for clone command/
-      end
-    end
+    @source_vm_mock.stub(:name).and_return('foo')
+    @target_vm_mock.stub(:name).and_return('bar')
 
-    it "should output an error and exit if it can't find the source vm" do
-      Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(false)
-      Fission::VM.should_not_receive(:exists?).with(@vm_info[1])
+    Fission::VM.stub(:new).with('foo').and_return(@source_vm_mock)
+    Fission::VM.stub(:new).with('bar').and_return(@target_vm_mock)
+    Fission::VM.stub(:clone).with(@vm_info.first, @vm_info[1]).
+                             and_return(@clone_response_mock)
+  end
 
-      lambda {
-        command = Fission::Command::Clone.new @vm_info
-        command.execute
-      }.should raise_error SystemExit
+  describe 'execute' do
+   subject { Fission::Command::Clone }
 
-      @string_io.string.should match /Unable to find the source vm #{@vm_info.first}/
+    [ [], ['foo'] ].each do |args|
+      it_should_not_accept_arguments_of args, 'clone'
     end
 
-    it "should output an error and exit if the target vm already exists" do
-      @vm_info.each do |vm|
-        Fission::VM.should_receive(:exists?).with(vm).and_return(true)
-      end
+    it 'should clone the vm' do
+      @clone_response_mock.stub_as_successful
 
-      lambda {
-        command = Fission::Command::Clone.new @vm_info
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::Clone.new @vm_info
+      command.execute
 
-      @string_io.string.should match /The target vm #{@vm_info[1]} already exists/
+      @string_io.string.should match /Clone complete/
     end
 
-    it 'should try to clone the vm if the source vm exists and the target vm does not' do
-      Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(true)
-      Fission::VM.should_receive(:exists?).with(@vm_info[1]).and_return(false)
-      Fission::VM.should_receive(:clone).with(@vm_info.first, @vm_info[1])
+    it 'should output an error and exit if there is an error cloning' do
+      @clone_response_mock.stub_as_unsuccessful
+
       command = Fission::Command::Clone.new @vm_info
-      command.execute
+      lambda { command.execute }.should raise_error SystemExit
 
-      @string_io.string.should match /Clone complete/
+      @string_io.string.should match /There was an error cloning the VM.+it blew up/m
     end
 
     describe 'with --start' do
-      it 'should try to clone the vm and start it' do
-        @vm_mock = mock('vm_mock')
-        Fission::VM.should_receive(:exists?).with(@vm_info.first).and_return(true)
-        Fission::VM.should_receive(:exists?).with(@vm_info[1]).and_return(false)
-        Fission::VM.should_receive(:clone).with(@vm_info.first, @vm_info[1])
+      before do
+        @clone_response_mock.stub_as_successful true
+        @target_vm_mock.should_receive(:start).and_return(@start_response_mock)
+      end
 
-        @vm_mock.should_receive(:start)
-        Fission::VM.should_receive(:new).with(@vm_info[1]).and_return(@vm_mock)
+      it 'should clone the vm and start it' do
+        @start_response_mock.stub_as_successful
 
         command = Fission::Command::Clone.new @vm_info << '--start'
         command.execute
 
         @string_io.string.should match /Clone complete/
         @string_io.string.should match /Starting '#{@vm_info[1]}'/
+        @string_io.string.should match /VM '#{@vm_info[1]}' started/
+      end
+
+      it 'should output an error and exit if there is an error starting the VM after cloning it' do
+        @start_response_mock.stub_as_unsuccessful
+
+        command = Fission::Command::Clone.new @vm_info << '--start'
+        lambda { command.execute }.should raise_error SystemExit
+
+        @string_io.string.should match /Clone complete/
+        @string_io.string.should match /Starting '#{@vm_info[1]}'/
+        @string_io.string.should match /There was an error starting the VM.+it blew up/m
       end
     end
 

data/spec/fission/command/delete_spec.rb

@@ -1,65 +1,74 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::Delete do
+  include_context 'command_setup'
+
   before do
     @target_vm = ['foo']
-    @string_io = StringIO.new
-    Fission.stub!(:ui).and_return(Fission::UI.new(@string_io))
+    Fission::VM.stub(:new).and_return(@vm_mock)
+
+    @delete_response_mock = mock('delete_response')
+    @running_response_mock = mock('running?')
+
+    @vm_mock.stub(:name).and_return(@target_vm.first)
+    @vm_mock.stub(:running?).and_return(@running_response_mock)
+    @running_response_mock.stub_as_successful false
+    Fission::Fusion.stub(:running?).and_return(false)
   end
 
   describe "execute" do
-    it "should output an error and the help when no VM argument is passed in" do
-      Fission::Command::Delete.should_receive(:help)
+    subject { Fission::Command::Delete }
 
-      lambda {
-        command = Fission::Command::Delete.new
-        command.execute
-      }.should raise_error SystemExit
+    it_should_not_accept_arguments_of [], 'delete'
 
-      @string_io.string.should match /Incorrect arguments for delete command/
+    it "should try to delete the vm" do
+      @delete_response_mock.stub_as_successful
+
+      @vm_mock.should_receive(:delete).and_return(@delete_response_mock)
+
+      Fission::Fusion.should_receive(:running?).and_return(false)
+
+      command = Fission::Command::Delete.new @target_vm
+      command.execute
+
+      @string_io.string.should match /Deletion complete/
     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)
+    it "should output an error and exit if unable to determine if it's running" do
+      @running_response_mock.stub_as_unsuccessful
 
-      lambda {
-        command = Fission::Command::Delete.new @target_vm
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::Delete.new @target_vm
+      lambda { command.execute }.should raise_error SystemExit
 
-      @string_io.string.should match /Unable to find target vm #{@target_vm}/
+      @string_io.string.should match /There was an error determining if the VM is running.+it blew up.+/m
     end
 
-    it "should try to delete the vm if it exists" do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      Fission::Fusion.should_receive(:is_running?).and_return(false)
-      Fission::VM.should_receive(:delete).with(@target_vm.first)
+    it 'should output an error and exit if there was an error deleting the VM' do
+      @delete_response_mock.stub_as_unsuccessful
+
+      @vm_mock.should_receive(:delete).and_return(@delete_response_mock)
+
       command = Fission::Command::Delete.new @target_vm
-      command.execute
-      @string_io.string.should match /Deletion complete/
+      lambda { command.execute }.should raise_error SystemExit
+
+      @string_io.string.should match /There was an error deleting the VM.+it blew up/m
     end
 
     it 'should output an error and exit if the VM is running' do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      Fission::VM.should_receive(:all_running).and_return(['foo', 'bar'])
-      lambda {
-        command = Fission::Command::Delete.new @target_vm
-        command.execute
-      }.should raise_error SystemExit
+      @running_response_mock.stub_as_successful true
+
+      command = Fission::Command::Delete.new @target_vm
+      lambda { command.execute }.should raise_error SystemExit
 
       @string_io.string.should match /VM is currently running/
       @string_io.string.should match /Either stop\/suspend the VM or use '--force' and try again/
     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::VM.should_receive(:all_running).and_return(['bar'])
-      Fission::Fusion.should_receive(:is_running?).and_return(true)
+      Fission::Fusion.stub(:running?).and_return(true)
 
-      lambda {
-        command = Fission::Command::Delete.new @target_vm
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::Delete.new @target_vm
+      lambda { command.execute }.should raise_error SystemExit
 
       @string_io.string.should match /Fusion GUI is currently running/
       @string_io.string.should match /Either exit the Fusion GUI or use '--force' and try again/
@@ -68,41 +77,45 @@ describe Fission::Command::Delete do
 
     describe 'with --force' do
       before do
-        Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
+        @vm_mock.should_receive(:delete).and_return(@delete_response_mock)
+        @delete_response_mock.stub_as_successful true
       end
 
       it "should stop the VM if it's running and then delete it" do
         @stop_cmd_mock = mock('stop_cmd')
+
         @stop_cmd_mock.should_receive(:execute)
-        Fission::VM.should_receive(:all_running).and_return(['foo', 'bar'])
-        Fission::Fusion.should_receive(:is_running?).and_return(false)
+        @running_response_mock.stub_as_successful true
+
         Fission::Command::Stop.should_receive(:new).with(@target_vm).
-                                                    and_return(@stop_cmd_mock)
+                               and_return(@stop_cmd_mock)
         command = Fission::Command::Delete.new @target_vm << '--force'
         command.execute
+
         @string_io.string.should match /VM is currently running/
         @string_io.string.should match /Going to stop it/
         @string_io.string.should match /Deletion complete/
       end
 
       it 'should output a warning about fusion metadata issue and then delete the VM' do
-        Fission::VM.should_receive(:all_running).and_return(['bar'])
-        Fission::Fusion.should_receive(:is_running?).and_return(true)
+
+        Fission::Fusion.should_receive(:running?).and_return(true)
         command = Fission::Command::Delete.new @target_vm << '--force'
         command.execute
+
         @string_io.string.should match /Fusion GUI is currently running/
         @string_io.string.should match /metadata for the VM may not be removed completely/
         @string_io.string.should match /Deletion complete/
       end
-
     end
+
   end
 
   describe 'help' do
     it 'should output info for this command' do
       output = Fission::Command::Delete.help
 
-      output.should match /delete target_vm \[--force\]/
+      output.should match /delete vm_name \[--force\]/
       output.should match /--force/
     end
   end

data/spec/fission/command/snapshot_create_spec.rb

@@ -1,88 +1,66 @@
 require File.expand_path('../../../spec_helper.rb', __FILE__)
 
 describe Fission::Command::SnapshotCreate 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_create_response_mock = mock('snap_create_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::SnapshotCreate.should_receive(:help)
+    subject { Fission::Command::SnapshotCreate }
 
-      lambda {
-        command = Fission::Command::SnapshotCreate.new
-        command.execute
-      }.should raise_error SystemExit
-
-      @string_io.string.should match /Incorrect arguments for snapshot create command/
-    end
+    it_should_not_accept_arguments_of [], 'snapshot create'
 
     it "should output an error and the help when no snapshot name is passed in" do
       Fission::Command::SnapshotCreate.should_receive(:help)
 
-      lambda {
-        command = Fission::Command::SnapshotCreate.new @target_vm
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::SnapshotCreate.new @target_vm
+      lambda { command.execute }.should raise_error SystemExit
 
       @string_io.string.should match /Incorrect arguments for snapshot create 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::SnapshotCreate.new @target_vm << 'snap_1'
-        command.execute
-      }.should raise_error SystemExit
+    it 'should create a new snapshot with the provided name' do
+      @snap_create_response_mock.stub_as_successful []
 
-      @string_io.string.should match /Unable to find the VM #{@target_vm.first}/
-    end
+      @vm_mock.should_receive(:create_snapshot).
+               with('snap_1').
+               and_return(@snap_create_response_mock)
 
-    it 'should output an error and exit if the VM is not running' do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      Fission::VM.should_receive(:all_running).and_return([])
-      lambda {
-        command = Fission::Command::SnapshotCreate.new @target_vm << 'snap_1'
-        command.execute
-      }.should raise_error SystemExit
+      command = Fission::Command::SnapshotCreate.new @target_vm << 'snap_1'
+      command.execute
 
-      @string_io.string.should match /VM 'foo' is not running/
-      @string_io.string.should match /A snapshot cannot be created unless the VM is running/
+      @string_io.string.should match /Creating snapshot/
+      @string_io.string.should match /Snapshot 'snap_1' created/
     end
 
-    it "should output an error and exit if there is already a snapshot with the provided name"  do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      Fission::VM.should_receive(:all_running).and_return(['foo'])
-      @vm_mock.should_receive(:snapshots).and_return(['snap_1'])
-      lambda {
-        command = Fission::Command::SnapshotCreate.new @target_vm << 'snap_1'
-        command.execute
-      }.should raise_error SystemExit
+    it 'should output an error and exit if there was an error creating the snapshot' do
+      @snap_create_response_mock.stub_as_unsuccessful
 
-      @string_io.string.should match /VM 'foo' already has a snapshot named 'snap_1'/
-    end
+      @vm_mock.should_receive(:create_snapshot).
+               with('snap_1').
+               and_return(@snap_create_response_mock)
 
-    it 'should create a new snapshot with the provided name' do
-      Fission::VM.should_receive(:exists?).with(@target_vm.first).and_return(true)
-      Fission::VM.should_receive(:all_running).and_return(['foo'])
-      @vm_mock.should_receive(:snapshots).and_return([])
-      @vm_mock.should_receive(:create_snapshot).with('snap_1')
       command = Fission::Command::SnapshotCreate.new @target_vm << 'snap_1'
-      command.execute
+      lambda { command.execute }.should raise_error SystemExit
+
       @string_io.string.should match /Creating snapshot/
+      @string_io.string.should match /There was an error creating the snapshot.+it blew up.+/m
     end
+
   end
 
   describe 'help' do
     it 'should output info for this command' do
       output = Fission::Command::SnapshotCreate.help
 
-      output.should match /snapshot create my_vm snapshot_1/
+      output.should match /snapshot create vm_name snapshot_1/
     end
   end
 end