vagrant 0.4.2 → 0.5.0

data/test/vagrant/busy_test.rb

@@ -1,78 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class BusyTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Busy
-  end
-
-  context "waiting for not busy" do
-    setup do
-      @klass.reset_trap_thread!
-    end
-
-    should "run in a thread" do
-      Thread.expects(:new).once.returns(nil)
-      @klass.wait_for_not_busy
-    end
-
-    should "immediately exit on second call" do
-      tid = "foo"
-      Thread.expects(:new).once.returns(tid)
-      @klass.wait_for_not_busy
-
-      Thread.expects(:kill).once.with(tid)
-      @klass.expects(:abort).once
-      @klass.wait_for_not_busy
-    end
-  end
-
-  context "during an action in a busy block" do
-    should "report as busy" do
-      Vagrant.busy do
-        # Inside the block Vagrant.busy? should be true
-        assert Vagrant.busy?
-      end
-
-      #After the block finishes Vagrant.busy? should be false
-      assert !Vagrant.busy?
-    end
-
-    should "set busy to false upon exception and reraise the error" do
-      assert_raise Exception do
-        Vagrant.busy do
-          assert Vagrant.busy?
-          raise Exception
-        end
-      end
-
-      assert !Vagrant.busy?
-    end
-
-    should "complete the trap thread even if an exception occurs" do
-      trap_thread = mock("trap_thread")
-      trap_thread.expects(:join).once
-      @klass.stubs(:trap_thread).returns(trap_thread)
-
-      assert_raise Exception do
-        Vagrant.busy do
-          raise Exception
-        end
-      end
-    end
-
-    should "report busy to the outside world regardless of thread" do
-      Thread.new do
-        Vagrant.busy do
-          assert Vagrant.busy?
-        end
-      end
-    end
-
-    should "trap INT" do
-      trap_seq = sequence("trap_seq")
-      Signal.expects(:trap).with("INT", anything).once.in_sequence(trap_seq)
-      Signal.expects(:trap).with("INT", "DEFAULT").once.in_sequence(trap_seq)
-      Vagrant.busy do; end
-    end
-  end
-end

data/test/vagrant/command_test.rb

@@ -1,53 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '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

@@ -1,139 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '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

@@ -1,34 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '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

@@ -1,32 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '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

@@ -1,41 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '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/destroy_test.rb

@@ -1,44 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '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

@@ -1,50 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '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