vagrantup 0.5.2 → 0.5.3

data/test/vagrant/command_test.rb

@@ -0,0 +1,53 @@
+require "test_helper"
+
+class CommandTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Command
+  end
+
+  context "initializing" do
+    setup do
+      @env = mock("environment")
+    end
+
+    should "set the env attribute" do
+      @instance = @klass.new(@env)
+      assert_equal @env, @instance.env
+    end
+  end
+
+  context "class methods" do
+    context "executing" do
+      should "load the environment then send the command on commands" do
+        env = mock("env")
+        commands = mock("commands")
+        env.stubs(:commands).returns(commands)
+        Vagrant::Environment.expects(:load!).returns(env)
+        commands.expects(:subcommand).with(1,2,3).once
+
+        @klass.execute(1,2,3)
+      end
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @env = mock_environment
+      @instance = @klass.new(@env)
+    end
+
+    context "subcommands" do
+      setup do
+        @raw_name = :bar
+        @name = :foo
+        @instance.stubs(:camelize).with(@raw_name).returns(@name)
+      end
+
+      should "send the env, name, and args to the base class" do
+        args = [1,2,3]
+        Vagrant::Commands::Base.expects(:dispatch).with(@env, @name, *args)
+        @instance.subcommand(@name, *args)
+      end
+    end
+  end
+end

data/test/vagrant/commands/base_test.rb

@@ -0,0 +1,139 @@
+require "test_helper"
+
+class CommandsBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Base
+  end
+
+  context "initializing" do
+    should "setup the env attribute" do
+      env = mock("env")
+      instance = @klass.new(env)
+      assert_equal env, instance.env
+    end
+  end
+
+  context "class methods" do
+    setup do
+      @env = mock_environment
+      @klass.subcommands.clear
+    end
+
+    context "registering commands" do
+      should "register commands" do
+        klass = mock("klass")
+        @klass.subcommand("init", klass)
+        assert_equal klass, @klass.subcommands["init"]
+      end
+    end
+
+    context "dispatching to subcommands" do
+      setup do
+        @command_klass = mock("klass")
+        @name = "init"
+        @klass.subcommand(@name, @command_klass)
+
+        @args = [1,2,3]
+      end
+
+      should "call dispatch on child if subcommand is found" do
+        @command_klass.expects(:dispatch).with(@env, *@args)
+        @klass.dispatch(@env, @name, *@args)
+      end
+
+      should "instantiate and execute when no subcommand is found" do
+        instance = mock("instance")
+        @klass.expects(:new).with(@env).returns(instance)
+        instance.expects(:execute).with(@args)
+        @klass.dispatch(@env, *@args)
+      end
+    end
+
+    context "descriptions" do
+      should "be able to set description" do
+        description = "The lazy fox yada yada"
+        @klass.description(description)
+        assert_equal description, @klass.description
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @env = mock_environment
+      @instance = @klass.new(@env)
+    end
+
+    context "executing" do
+      should "show version if flag is set" do
+        @instance.expects(:puts_version).once
+        @instance.expects(:show_help).never
+        @instance.execute(["--version"])
+      end
+
+      should "just print the help by default" do
+        @instance.expects(:puts_version).never
+        @instance.expects(:show_help).once
+        @instance.execute([])
+      end
+    end
+
+    context "all or single methods" do
+      should "call the single method if a name is given" do
+        name = "bar"
+        @instance.expects(:foo_single).with(name).once
+        @instance.all_or_single(["bar"], :foo)
+      end
+
+      should "call the single method for each VM if no name is given" do
+        vms = { :foo => nil, :bar => nil }
+        vms.keys.each do |name|
+          @instance.expects(:foo_single).with(name).once
+        end
+
+        @env.stubs(:vms).returns(vms)
+        @instance.all_or_single([], :foo)
+      end
+    end
+
+    context "getting the option parser" do
+      should "create it with the options spec if it hasn't been created yet" do
+        opts = mock("opts")
+        opts.stubs(:on)
+
+        result = mock("result")
+        OptionParser.expects(:new).yields(opts).returns(result)
+        @instance.expects(:options_spec).with(opts)
+
+        assert_equal result, @instance.option_parser(true)
+      end
+
+      should "not create it once its been created" do
+        result = mock("result")
+        OptionParser.expects(:new).once.returns(result)
+
+        assert_equal result, @instance.option_parser(true)
+        assert_equal result, @instance.option_parser
+        assert_equal result, @instance.option_parser
+      end
+    end
+
+    context "parsing options" do
+      setup do
+        @args = []
+
+        @options = mock("options")
+        @option_parser = mock("option_parser")
+
+        @instance.stubs(:option_parser).returns(@option_parser)
+        @instance.stubs(:options).returns(@options)
+      end
+
+      should "parse the options with the args" do
+        result = mock("result")
+        @option_parser.expects(:parse!).with(@args).once.returns(result)
+        assert_equal result, @instance.parse_options(@args)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "test_helper"
+
+class CommandsBoxAddTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Box::Add
+
+    @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"
+      @path = "bar"
+    end
+
+    should "execute the add action with the name and path" do
+      Vagrant::Box.expects(:add).with(@env, @name, @path).once
+      @instance.execute([@name, @path])
+    end
+
+    should "show help if not enough arguments" do
+      Vagrant::Box.expects(:add).never
+      @instance.expects(:show_help).once
+      @instance.execute([])
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "test_helper"
+
+class CommandsBoxListTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Box::List
+
+    @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
+      @boxes = ["foo", "bar"]
+
+      Vagrant::Box.stubs(:all).returns(@boxes)
+      @instance.stubs(:wrap_output)
+    end
+
+    should "call all on box and sort the results" do
+      @all = mock("all")
+      @all.expects(:sort).returns(@boxes)
+      Vagrant::Box.expects(:all).with(@env).returns(@all)
+      @instance.execute
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require "test_helper"
+
+class CommandsBoxRemoveTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Commands::Box::Remove
+
+    @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([])
+    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_remove_doesnt_exist).once
+      @instance.execute([@name])
+    end
+
+    should "call destroy on the box if it exists" do
+      @box = mock("box")
+      Vagrant::Box.expects(:find).with(@env, @name).returns(@box)
+      @box.expects(:destroy).once
+      @instance.execute([@name])
+    end
+  end
+end

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