vagrant 0.5.2 → 0.5.3

data/test/vagrant/commands/box/repackage_test.rb

@@ -0,0 +1,52 @@
+require "test_helper"
+
+class CommandsBoxRepackageTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Box::Repackage
+
+    @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
+      @name = "foo"
+    end
+
+    should "show help if not enough arguments" do
+      Vagrant::Box.expects(:find).never
+      @instance.expects(:show_help).once
+      @instance.execute(["--include", "x,y,z"])
+    end
+
+    should "error and exit if the box doesn't exist" do
+      Vagrant::Box.expects(:find).returns(nil)
+      @instance.expects(:error_and_exit).with(:box_repackage_doesnt_exist).once
+      @instance.execute([@name])
+    end
+
+    should "call repackage on the box if it exists" do
+      @box = mock("box")
+      Vagrant::Box.expects(:find).with(@env, @name).returns(@box)
+      @box.expects(:repackage).once
+      @instance.execute([@name])
+    end
+
+    should "pass given options into repackage" do
+      @box = mock("box")
+      Vagrant::Box.expects(:find).with(@env, @name).returns(@box)
+      @box.expects(:repackage).once.with() do |opts|
+        assert opts.is_a?(Hash)
+        assert_equal "filename.box", opts["package.output"]
+        true
+      end
+      @instance.execute([@name, "--output", "filename.box"])
+    end
+  end
+end

data/test/vagrant/commands/destroy_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class CommandsDestroyTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Destroy
+
+    @env = mock_environment
+
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "call all or single for the method" do
+      @instance.expects(:all_or_single).with([], :destroy)
+      @instance.execute
+    end
+  end
+
+  context "destroying 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.destroy_single(:foo)
+    end
+
+    should "destroy if its created" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:destroy).once
+      @instance.destroy_single(:foo)
+    end
+
+    should "do nothing if its not created" do
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:destroy).never
+      @instance.destroy_single(:foo)
+    end
+  end
+end

data/test/vagrant/commands/halt_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+
+class CommandsHaltTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Halt
+
+    @env = mock_environment
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "call all or single for the method" do
+      @instance.expects(:all_or_single).with([], :halt)
+      @instance.execute
+    end
+  end
+
+  context "halting 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.halt_single(:foo)
+    end
+
+    should "halt if its created" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:halt).with(:force => false).once
+      @instance.execute(["foo"])
+    end
+
+    should "halt and force if specified" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:halt).with(:force => true).once
+      @instance.execute(["foo", "--force"])
+    end
+
+    should "do nothing if its not created" do
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:halt).never
+      @instance.halt_single(:foo)
+    end
+  end
+end

data/test/vagrant/commands/init_test.rb

@@ -0,0 +1,71 @@
+require "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 a vagrant file without any args" do
+      args = []
+      @instance.expects(:create_vagrantfile).with(:default_box => nil, :default_box_url => nil)
+      @instance.execute(args)
+    end
+    context "when any arg is provided" do
+      should "create the vagrant file using the first arg as default_box and the second as default_box_url" do
+        args = []
+        args[0] = "foo"
+        args[1] = "foo.box"
+
+        @instance.expects(:create_vagrantfile).with(:default_box => "foo", :default_box_url => "foo.box")
+        @instance.execute(args)
+      end
+    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 :default_box => box
+    end
+
+    should "use the box_url if given" do
+      box_url = "fubar.box"
+      Vagrant::Util::TemplateRenderer.expects(:render).with(Vagrant::Environment::ROOTFILE_NAME, :default_box => "base", :default_box_url => "fubar.box")
+      @instance.create_vagrantfile :default_box_url => box_url
+    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,97 @@
+require "test_helper"
+
+class CommandsPackageTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Package
+
+    @env = mock_environment
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "package base if a base is given" do
+      @instance.expects(:package_base).once
+      @instance.execute(["--base","foo"])
+    end
+
+    should "package single if no name is given" do
+      @instance.expects(:package_single).with(nil).once
+      @instance.execute
+    end
+
+    should "package single if a name is given" do
+      @instance.expects(:package_single).with("foo").once
+      @instance.execute(["foo"])
+    end
+  end
+
+  context "packaging base" do
+    should "error and exit if no VM is found" do
+      Vagrant::VM.expects(:find).with("foo", @instance.env).returns(nil)
+      @instance.expects(:error_and_exit).with(:vm_base_not_found, :name => "foo").once
+      @instance.execute(["--base", "foo"])
+    end
+
+    should "package the VM like any other VM" do
+      vm = mock("vm")
+      Vagrant::VM.expects(:find).with("foo", @instance.env).returns(vm)
+      @instance.expects(:package_vm).with(vm).once
+      @instance.execute(["--base", "foo"])
+    end
+  end
+
+  context "packaging a single VM" 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 name is given in a multi-vm env" do
+      @env.stubs(:multivm?).returns(true)
+      @instance.expects(:error_and_exit).with(:package_multivm).once
+      @instance.package_single(nil)
+    end
+
+    should "error and exit if the VM doesn't exist" do
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.package_single(:foo)
+    end
+
+    should "error and exit if the VM is not created" do
+      @vm.stubs(:created?).returns(false)
+      @instance.expects(:error_and_exit).with(:environment_not_created).once
+      @instance.package_single(:bar)
+    end
+
+    should "use the first VM is no name is given in a single VM environment" do
+      @instance.expects(:package_vm).with(@vm).once
+      @instance.package_single(nil)
+    end
+
+    should "package the VM" do
+      @instance.expects(:package_vm).with(@vm).once
+      @instance.package_single(:bar)
+    end
+  end
+
+  context "packaging a VM" do
+    setup do
+      @vm = mock("vm")
+
+      @options = {}
+      @instance.stubs(:options).returns(@options)
+    end
+
+    should "package the VM with the proper arguments" do
+      @options[:output] = "foo.box"
+      @options[:include] = :bar
+
+      @vm.expects(:package).with(@options).once
+      @instance.package_vm(@vm)
+    end
+  end
+end

data/test/vagrant/commands/provision_test.rb

@@ -0,0 +1,60 @@
+require "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)
+      @foo_vm.stubs(:created?).returns(true)
+
+      @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
+
+    should "do log to info if it's not created" do
+      logger = mock("logger")
+      logger.expects(:info)
+      @env.stubs(:logger).returns(logger)
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:provision).never
+      @instance.execute(["foo"])
+    end
+  end
+
+end

data/test/vagrant/commands/reload_test.rb

@@ -0,0 +1,47 @@
+require "test_helper"
+
+class CommandsReloadTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Reload
+
+    @env = mock_environment
+    @env.stubs(:require_root_path)
+    @instance = @klass.new(@env)
+  end
+
+  context "executing" do
+    should "call all or single for the method" do
+      seq = sequence("seq")
+      @env.expects(:require_root_path).in_sequence(seq)
+      @instance.expects(:all_or_single).with([], :reload).in_sequence(seq)
+      @instance.execute
+    end
+  end
+
+  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

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class CommandsResumeTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Resume
+
+    @env = mock_environment
+    @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
+      @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.resume_single(:foo)
+    end
+
+    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