vagrant 0.3.4 → 0.4.0

data/test/vagrant/commands/provision_test.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsProvisionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Provision
+    @env = mock_environment
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "provision all if no name is given" do
+      @instance.expects(:all_or_single).with([], :provision).once
+      @instance.execute
+    end
+  end
+
+  context "provisioning a single VM" do
+    setup do
+      @foo_vm = mock("vm")
+      @foo_vm.stubs(:env).returns(@env)
+
+      @vm_for_real = mock("vm for real")
+      @foo_vm.stubs(:vm).returns(@vm_for_real)
+      vms = { :foo => @foo_vm }
+      @env.stubs(:vms).returns(vms)
+    end
+
+    should "error and exit if the VM doesn't exist" do
+      @env.stubs(:vms).returns({})
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => 'foo').once
+      @instance.execute(["foo"])
+    end
+
+    should "reload if it's running" do
+      @vm_for_real.stubs(:running?).returns(true)
+      @foo_vm.expects(:provision).once
+      @instance.execute(["foo"])
+    end
+
+    should "do log to info if it's not running" do
+      logger = mock("logger")
+      logger.expects(:info)
+      @env.stubs(:logger).returns(logger)
+      @vm_for_real.stubs(:running?).returns(false)
+      @foo_vm.expects(:provision).never
+      @instance.execute(["foo"])
+    end
+  end
+
+end

data/test/vagrant/commands/reload_test.rb

@@ -4,25 +4,41 @@ class CommandsReloadTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::Reload
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
-
     @instance = @klass.new(@env)
   end
 
   context "executing" do
-    should "require a persisted VM" do
-      @env.expects(:require_persisted_vm).once
+    should "call all or single for the method" do
+      @instance.expects(:all_or_single).with([], :reload)
       @instance.execute
     end
+  end
 
-    should "call the `reload` action on the VM" do
-      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Reload).once
-      @instance.execute
+  context "reloading a single VM" do
+    setup do
+      @foo_vm = mock("vm")
+      @foo_vm.stubs(:env).returns(@env)
+      vms = { :foo => @foo_vm }
+      @env.stubs(:vms).returns(vms)
+    end
+
+    should "error and exit if the VM doesn't exist" do
+      @env.stubs(:vms).returns({})
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.reload_single(:foo)
+    end
+
+    should "reload if its created" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:reload).once
+      @instance.execute(["foo"])
+    end
+
+    should "do nothing if its not created" do
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:reload).never
+      @instance.reload_single(:foo)
     end
   end
 end

data/test/vagrant/commands/resume_test.rb

@@ -4,30 +4,41 @@ class CommandsResumeTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::Resume
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
-
     @instance = @klass.new(@env)
   end
 
   context "executing" do
+    should "call all or single for the method" do
+      @instance.expects(:all_or_single).with([], :resume)
+      @instance.execute
+    end
+  end
+
+  context "resuming a single VM" do
     setup do
-      @persisted_vm.stubs(:resume)
-      @persisted_vm.stubs(:saved?).returns(true)
+      @foo_vm = mock("vm")
+      @foo_vm.stubs(:env).returns(@env)
+      vms = { :foo => @foo_vm }
+      @env.stubs(:vms).returns(vms)
     end
 
-    should "require a persisted VM" do
-      @env.expects(:require_persisted_vm).once
-      @instance.execute
+    should "error and exit if the VM doesn't exist" do
+      @env.stubs(:vms).returns({})
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.resume_single(:foo)
     end
 
-    should "save the state of the VM" do
-      @persisted_vm.expects(:resume).once
-      @instance.execute
+    should "resume if its created" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:resume).once
+      @instance.execute(["foo"])
+    end
+
+    should "do nothing if its not created" do
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:resume).never
+      @instance.resume_single(:foo)
     end
   end
 end

data/test/vagrant/commands/ssh_config_test.rb

@@ -4,36 +4,59 @@ class CommandsSSHConfigTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::SSHConfig
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
-
+    @env.stubs(:require_root_path)
     @instance = @klass.new(@env)
   end
 
   context "executing" do
+    setup do
+      @instance.stubs(:show_single)
+    end
+
+    should "require root path" do
+      @env.expects(:require_root_path).once
+      @instance.execute
+    end
+
+    should "call show_single with given argument" do
+      @instance.expects(:show_single).with("foo").once
+      @instance.execute(["foo"])
+    end
+  end
+
+  context "showing a single entry" do
     setup do
       @ssh = mock("ssh")
       @ssh.stubs(:port).returns(2197)
-      @env.stubs(:ssh).returns(@ssh)
-      @env.stubs(:require_root_path)
 
-      @instance.stubs(:puts)
+      @bar = mock("vm")
+      @bar.stubs(:env).returns(mock_environment)
+      @bar.stubs(:ssh).returns(@ssh)
+
+      @vms = {:bar => @bar}
+      @env.stubs(:multivm?).returns(true)
+      @env.stubs(:vms).returns(@vms)
 
       @data = {
         :host_key => "vagrant",
-        :ssh_user => @env.config.ssh.username,
-        :ssh_port => @env.ssh.port,
-        :private_key_path => @env.config.ssh.private_key_path
+        :ssh_user => @bar.env.config.ssh.username,
+        :ssh_port => @bar.ssh.port,
+        :private_key_path => @bar.env.config.ssh.private_key_path
       }
+
+      @instance.stubs(:puts)
     end
 
-    should "require root path" do
-      @env.expects(:require_root_path).once
-      @instance.execute
+    should "error if name is nil and multivm" do
+      @env.stubs(:multivm?).returns(true)
+      @instance.expects(:error_and_exit).with(:ssh_config_multivm).once
+      @instance.show_single(nil)
+    end
+
+    should "error if the VM is not found" do
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => "foo").once
+      @instance.show_single("foo")
     end
 
     should "output rendered template" do
@@ -41,14 +64,14 @@ class CommandsSSHConfigTest < Test::Unit::TestCase
       Vagrant::Util::TemplateRenderer.expects(:render).with("ssh_config", @data).returns(result)
 
       @instance.expects(:puts).with(result).once
-      @instance.execute
+      @instance.show_single(:bar)
     end
 
     should "render with the given host name if given" do
       host = "foo"
       @data[:host_key] = host
       Vagrant::Util::TemplateRenderer.expects(:render).with("ssh_config", @data)
-      @instance.execute(["--host", host])
+      @instance.execute(["bar", "--host", host])
     end
   end
 end

data/test/vagrant/commands/ssh_test.rb

@@ -4,29 +4,68 @@ class CommandsSSHTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::SSH
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
-
     @instance = @klass.new(@env)
   end
 
   context "executing" do
-    setup do
-      @env.ssh.stubs(:connect)
+    should "connect to the given argument" do
+      @instance.expects(:ssh_connect).with("foo").once
+      @instance.execute(["foo"])
     end
 
-    should "require a persisted VM" do
-      @env.expects(:require_persisted_vm).once
+    should "connect with nil name if none is given" do
+      @instance.expects(:ssh_connect).with(nil).once
       @instance.execute
     end
+  end
 
-    should "connect to SSH" do
-      @env.ssh.expects(:connect).once
-      @instance.execute
+  context "ssh connecting" do
+    setup do
+      @vm = mock("vm")
+      @vm.stubs(:created?).returns(true)
+
+      @vms = {:bar => @vm}
+      @env.stubs(:vms).returns(@vms)
+      @env.stubs(:multivm?).returns(false)
+    end
+
+    should "error and exit if no VM is specified and multivm and no primary VM" do
+      @env.stubs(:multivm?).returns(true)
+      @env.stubs(:primary_vm).returns(nil)
+      @instance.expects(:error_and_exit).with(:ssh_multivm).once
+      @instance.ssh_connect(nil)
+    end
+
+    should "use the primary VM if it exists and no name is specified" do
+      vm = mock("vm")
+      ssh = mock("ssh")
+      vm.stubs(:created?).returns(true)
+      vm.stubs(:ssh).returns(ssh)
+
+      @env.stubs(:multivm?).returns(true)
+      @env.stubs(:primary_vm).returns(vm)
+      ssh.expects(:connect).once
+      @instance.ssh_connect(nil)
+    end
+
+    should "error and exit if VM is nil" do
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.ssh_connect(:foo)
+    end
+
+    should "error and exit if VM isn't created" do
+      @vm.stubs(:created?).returns(false)
+      @instance.expects(:error_and_exit).with(:environment_not_created).once
+      @instance.ssh_connect(:bar)
+    end
+
+    should "ssh connect" do
+      ssh = mock("ssh")
+      @vm.stubs(:ssh).returns(ssh)
+      ssh.expects(:connect)
+
+      @instance.ssh_connect(:bar)
     end
   end
 end

data/test/vagrant/commands/status_test.rb

@@ -15,6 +15,26 @@ class CommandsStatusTest < Test::Unit::TestCase
   end
 
   context "executing" do
-    # TODO
+    should "show local status by default" do
+      @instance.expects(:show_local_status).once
+      @instance.expects(:show_global_status).never
+      @instance.execute
+    end
+
+    should "show global status if flagged" do
+      @instance.expects(:show_local_status).never
+      @instance.expects(:show_global_status).once
+      @instance.execute(["--global"])
+    end
+
+    should "show help if too many args are given" do
+      @instance.expects(:show_help).once
+      @instance.execute(["1","2","3"])
+    end
+
+    should "pass the VM name to local status if given" do
+      @instance.expects(:show_local_status).with("foo").once
+      @instance.execute(["foo"])
+    end
   end
 end

data/test/vagrant/commands/suspend_test.rb

@@ -4,30 +4,41 @@ class CommandsSuspendTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::Suspend
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
-
     @instance = @klass.new(@env)
   end
 
   context "executing" do
+    should "call all or single for the method" do
+      @instance.expects(:all_or_single).with([], :suspend)
+      @instance.execute
+    end
+  end
+
+  context "suspending a single VM" do
     setup do
-      @persisted_vm.stubs(:suspend)
-      @persisted_vm.stubs(:saved?).returns(false)
+      @foo_vm = mock("vm")
+      @foo_vm.stubs(:env).returns(@env)
+      vms = { :foo => @foo_vm }
+      @env.stubs(:vms).returns(vms)
     end
 
-    should "require a persisted VM" do
-      @env.expects(:require_persisted_vm).once
-      @instance.execute
+    should "error and exit if the VM doesn't exist" do
+      @env.stubs(:vms).returns({})
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.suspend_single(:foo)
     end
 
-    should "suspend the VM" do
-      @persisted_vm.expects(:suspend).once
-      @instance.execute
+    should "suspend if its created" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:suspend).once
+      @instance.execute(["foo"])
+    end
+
+    should "do nothing if its not created" do
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:suspend).never
+      @instance.suspend_single(:foo)
     end
   end
 end

data/test/vagrant/commands/up_test.rb

@@ -6,36 +6,42 @@ class CommandsUpTest < Test::Unit::TestCase
 
     @env = mock_environment
     @instance = @klass.new(@env)
-
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
   end
 
   context "executing" do
+    should "call all or single for the method" do
+      @instance.expects(:all_or_single).with([], :up)
+      @instance.execute
+    end
+  end
+
+  context "upping a single VM" do
     setup do
-      @new_vm = mock("vm")
-      @new_vm.stubs(:execute!)
+      @vm = mock("vm")
+      @vm.stubs(:env).returns(@env)
 
-      @env.stubs(:vm).returns(nil)
-      @env.stubs(:require_box)
-      @env.stubs(:create_vm).returns(@new_vm)
+      @vms = {:foo => @vm}
+      @env.stubs(:vms).returns(@vms)
     end
 
-    should "require a box" do
-      @env.expects(:require_box).once
-      @instance.execute
+    should "error and exit if the VM doesn't exist" do
+      @env.stubs(:vms).returns({})
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.up_single(:foo)
     end
 
-    should "call the up action on VM if it doesn't exist" do
-      @new_vm.expects(:execute!).with(Vagrant::Actions::VM::Up).once
-      @instance.execute
+    should "start created VMs" do
+      @vm.stubs(:created?).returns(true)
+      @vm.expects(:start).once
+      @instance.up_single(:foo)
     end
 
-    should "call start on the persisted vm if it exists" do
-      @env.stubs(:vm).returns(@persisted_vm)
-      @persisted_vm.expects(:start).once
-      @env.expects(:create_vm).never
-      @instance.execute
+    should "up non-created VMs" do
+      @vm.stubs(:created?).returns(false)
+      @vm.env.expects(:require_box).once
+      @vm.expects(:up).once
+      @vm.expects(:start).never
+      @instance.up_single(:foo)
     end
   end
 end