vagrantup 0.2.0 → 0.3.0

data/test/vagrant/commands/destroy_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsDestroyTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Destroy
+
+    @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
+      @persisted_vm.stubs(:destroy)
+    end
+
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "destroy the persisted VM and the VM image" do
+      @persisted_vm.expects(:destroy).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/down_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsDownTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Down
+
+    @env = mock_environment
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "just error and exit" do
+      @instance.expects(:error_and_exit).with(:command_deprecation_down)
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/halt_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsHaltTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Halt
+
+    @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
+      @instance.execute
+    end
+
+    should "call the `halt` action on the VM" do
+      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Halt).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/init_test.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsInitTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Init
+
+    @env = mock_environment
+    @instance = @klass.new(@env)
+  end
+
+  context "execute" do
+    should "create the vagrantfile with the first arg" do
+      args = [:foo]
+      @instance.expects(:create_vagrantfile).with(args.first)
+      @instance.execute(args)
+    end
+  end
+
+  context "creating the vagrantfile" do
+    setup do
+      @file = mock("file")
+      @file.stubs(:write)
+      File.stubs(:open).yields(@file)
+      @rootfile_path = File.join(Dir.pwd, Vagrant::Environment::ROOTFILE_NAME)
+
+      Vagrant::Util::TemplateRenderer.stubs(:render)
+    end
+
+    should "error and exit if a rootfile already exists" do
+      File.expects(:exist?).with(@rootfile_path).returns(true)
+      @instance.expects(:error_and_exit).with(:rootfile_already_exists).once
+      @instance.create_vagrantfile
+    end
+
+    should "write to the rootfile path using the template renderer" do
+      result = "foo"
+      Vagrant::Util::TemplateRenderer.expects(:render).returns(result).once
+      @file.expects(:write).with(result).once
+      File.expects(:open).with(@rootfile_path, 'w+').yields(@file)
+
+      @instance.create_vagrantfile
+    end
+
+    should "use the given base box if given" do
+      box = "zooo"
+      Vagrant::Util::TemplateRenderer.expects(:render).with(Vagrant::Environment::ROOTFILE_NAME, :default_box => box)
+      @instance.create_vagrantfile(box)
+    end
+
+    should "use the default `base` if no box is given" do
+      Vagrant::Util::TemplateRenderer.expects(:render).with(Vagrant::Environment::ROOTFILE_NAME, :default_box => "base")
+      @instance.create_vagrantfile
+    end
+  end
+end

data/test/vagrant/commands/package_test.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsPackageTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Package
+
+    @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
+      @persisted_vm.stubs(:package)
+      @persisted_vm.stubs(:powered_off?).returns(true)
+    end
+
+    context "with no base specified" do
+      should "require a persisted vm" do
+        @env.expects(:require_persisted_vm).once
+        @instance.execute
+      end
+    end
+
+    context "with base specified" do
+      setup do
+        @vm = mock("vm")
+
+        Vagrant::VM.stubs(:find).with(@name).returns(@vm)
+        @vm.stubs(:env=).with(@env)
+        @env.stubs(:vm=)
+
+        @name = "bar"
+      end
+
+      should "find the given base and set it on the env" do
+        Vagrant::VM.expects(:find).with(@name).returns(@vm)
+        @vm.expects(:env=).with(@env)
+        @env.expects(:vm=).with(@vm)
+
+        @instance.execute(["foo", "--base", @name])
+      end
+
+      should "error if the VM is not found" do
+        Vagrant::VM.expects(:find).with(@name).returns(nil)
+        @instance.expects(:error_and_exit).with(:vm_base_not_found, :name => @name).once
+
+        @instance.execute(["foo", "--base", @name])
+      end
+    end
+
+    context "shared (with and without base specified)" do
+      should "error and exit if the VM is not powered off" do
+        @persisted_vm.stubs(:powered_off?).returns(false)
+        @instance.expects(:error_and_exit).with(:vm_power_off_to_package).once
+        @persisted_vm.expects(:package).never
+        @instance.execute
+      end
+
+      should "call package on the persisted VM" do
+        @persisted_vm.expects(:package).once
+        @instance.execute
+      end
+
+      should "pass the out path and include_files to the package method" do
+        out_path = mock("out_path")
+        include_files = "foo"
+        @persisted_vm.expects(:package).with(out_path, [include_files]).once
+        @instance.execute([out_path, "--include", include_files])
+      end
+
+      should "default to an empty array when not include_files are specified" do
+        out_path = mock("out_path")
+        @persisted_vm.expects(:package).with(out_path, []).once
+        @instance.execute([out_path])
+      end
+    end
+  end
+end

data/test/vagrant/commands/reload_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+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
+      @instance.execute
+    end
+
+    should "call the `reload` action on the VM" do
+      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Reload).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/resume_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+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
+    setup do
+      @persisted_vm.stubs(:resume)
+      @persisted_vm.stubs(:saved?).returns(true)
+    end
+
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "save the state of the VM" do
+      @persisted_vm.expects(:resume).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/ssh_config_test.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+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)
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    setup do
+      @ssh = mock("ssh")
+      @ssh.stubs(:port).returns(2197)
+      @env.stubs(:ssh).returns(@ssh)
+      @env.stubs(:require_root_path)
+
+      @instance.stubs(:puts)
+
+      @data = {
+        :host_key => "vagrant",
+        :ssh_user => @env.config.ssh.username,
+        :ssh_port => @env.ssh.port,
+        :private_key_path => @env.config.ssh.private_key_path
+      }
+    end
+
+    should "require root path" do
+      @env.expects(:require_root_path).once
+      @instance.execute
+    end
+
+    should "output rendered template" do
+      result = mock("result")
+      Vagrant::Util::TemplateRenderer.expects(:render).with("ssh_config", @data).returns(result)
+
+      @instance.expects(:puts).with(result).once
+      @instance.execute
+    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])
+    end
+  end
+end

data/test/vagrant/commands/ssh_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+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)
+    end
+
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "connect to SSH" do
+      @env.ssh.expects(:connect).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/status_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsStatusTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Status
+
+    @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
+    # TODO
+  end
+end

data/test/vagrant/commands/suspend_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+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
+    setup do
+      @persisted_vm.stubs(:suspend)
+      @persisted_vm.stubs(:saved?).returns(false)
+    end
+
+    should "require a persisted VM" do
+      @env.expects(:require_persisted_vm).once
+      @instance.execute
+    end
+
+    should "suspend the VM" do
+      @persisted_vm.expects(:suspend).once
+      @instance.execute
+    end
+  end
+end

data/test/vagrant/commands/up_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CommandsUpTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Up
+
+    @env = mock_environment
+    @instance = @klass.new(@env)
+
+    @persisted_vm = mock("persisted_vm")
+    @persisted_vm.stubs(:execute!)
+  end
+
+  context "executing" do
+    setup do
+      @new_vm = mock("vm")
+      @new_vm.stubs(:execute!)
+
+      @env.stubs(:vm).returns(nil)
+      @env.stubs(:require_box)
+      @env.stubs(:create_vm).returns(@new_vm)
+    end
+
+    should "require a box" do
+      @env.expects(:require_box).once
+      @instance.execute
+    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
+    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
+    end
+  end
+end