vagrant 0.5.2 → 0.5.3

data/test/vagrant/box_test.rb

@@ -0,0 +1,166 @@
+require "test_helper"
+
+class BoxTest < Test::Unit::TestCase
+  context "class methods" do
+    setup do
+      @env = mock_environment
+    end
+
+    context "listing all boxes" do
+      setup do
+        Dir.stubs(:open)
+        File.stubs(:directory?).returns(true)
+
+        @boxes_path = "foo"
+        @env.stubs(:boxes_path).returns(@boxes_path)
+      end
+
+      should "open the boxes directory" do
+        Dir.expects(:open).with(@env.boxes_path)
+        Vagrant::Box.all(@env)
+      end
+
+      should "return an array" do
+        result = Vagrant::Box.all(@env)
+        assert result.is_a?(Array)
+      end
+
+      should "not return the '.' and '..' directories" do
+        dir = [".", "..", "..", ".", ".."]
+        Dir.expects(:open).yields(dir)
+        result = Vagrant::Box.all(@env)
+        assert result.empty?
+      end
+
+      should "return the other directories" do
+        dir = [".", "foo", "bar", "baz"]
+        Dir.expects(:open).yields(dir)
+        result = Vagrant::Box.all(@env)
+        assert_equal ["foo", "bar", "baz"], result
+      end
+
+      should "ignore the files" do
+        dir = ["foo", "bar"]
+        files = [true, false]
+        Dir.expects(:open).yields(dir)
+        dir_sequence = sequence("directory")
+        dir.each_with_index do |dir, index|
+          File.expects(:directory?).with(File.join(@boxes_path, dir)).returns(files[index]).in_sequence(dir_sequence)
+        end
+
+        result = Vagrant::Box.all(@env)
+        assert_equal ["foo"], result
+      end
+    end
+
+    context "finding" do
+      setup do
+        @dir = "foo"
+        @name = "bar"
+        Vagrant::Box.stubs(:directory).with(@env, @name).returns(@dir)
+      end
+
+      should "return nil if the box doesn't exist" do
+        File.expects(:directory?).with(@dir).once.returns(false)
+        assert_nil Vagrant::Box.find(@env, @name)
+      end
+
+      should "return a box object with the proper name set" do
+        File.expects(:directory?).with(@dir).once.returns(true)
+        result = Vagrant::Box.find(@env, @name)
+        assert result
+        assert_equal @name, result.name
+      end
+
+      should "return a box object with the proper env set" do
+        File.expects(:directory?).with(@dir).once.returns(true)
+        result = Vagrant::Box.find(@env, @name)
+        assert result
+        assert_equal @env, result.env
+      end
+    end
+
+    context "adding" do
+      setup do
+        @name = "foo"
+        @uri = "bar"
+      end
+
+      should "create a new instance, set the variables, and add it" do
+        box = mock("box")
+        box.expects(:name=).with(@name)
+        box.expects(:uri=).with(@uri)
+        box.expects(:env=).with(@env)
+        box.expects(:add).once
+        Vagrant::Box.expects(:new).returns(box)
+        Vagrant::Box.add(@env, @name, @uri)
+      end
+    end
+
+    context "box directory" do
+      setup do
+        @name = "foo"
+        @box_dir = File.join(@env.boxes_path, @name)
+      end
+
+      should "return the boxes_path joined with the name" do
+        assert_equal @box_dir, Vagrant::Box.directory(@env, @name)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @box = Vagrant::Box.new
+      @box.env = mock_environment
+    end
+
+    should "execute the Add action when add is called" do
+      @box.env.actions.expects(:run).with(:box_add, { "box" => @box })
+      @box.add
+    end
+
+    context "box directory" do
+      setup do
+        @box.name = "foo"
+      end
+
+      should "return the boxes_path joined with the name" do
+        result = mock("object")
+        Vagrant::Box.expects(:directory).with(@box.env, @box.name).returns(result)
+        assert result.equal?(@box.directory)
+      end
+    end
+
+    context "destroying" do
+      should "execute the destroy action" do
+        @box.env.actions.expects(:run).with(:box_remove, { "box" => @box })
+        @box.destroy
+      end
+    end
+
+    context "repackaging" do
+      should "execute the repackage action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box })
+        @box.repackage
+      end
+
+      should "forward given options into the action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "foo" => "bar" })
+        @box.repackage("foo" => "bar")
+      end
+    end
+
+    context "ovf file" do
+      setup do
+        @box.stubs(:directory).returns("foo")
+
+        @box.env.config.vm.box_ovf = "foo.ovf"
+      end
+
+      should "be the directory joined with the config ovf file" do
+        assert_equal File.join(@box.directory, @box.env.config.vm.box_ovf), @box.ovf_file
+      end
+    end
+  end
+end

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