vagrantup 0.2.0 → 0.3.0

data/test/vagrant/box_test.rb

@@ -2,36 +2,40 @@ require File.join(File.dirname(__FILE__), '..', '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"
-        Vagrant::Env.stubs(:boxes_path).returns(@boxes_path)
+        @env.stubs(:boxes_path).returns(@boxes_path)
       end
 
       should "open the boxes directory" do
-        Dir.expects(:open).with(Vagrant::Env.boxes_path)
-        Vagrant::Box.all
+        Dir.expects(:open).with(@env.boxes_path)
+        Vagrant::Box.all(@env)
       end
 
       should "return an array" do
-        result = Vagrant::Box.all
+        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
+        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
+        result = Vagrant::Box.all(@env)
         assert_equal ["foo", "bar", "baz"], result
       end
 
@@ -44,7 +48,7 @@ class BoxTest < Test::Unit::TestCase
           File.expects(:directory?).with(File.join(@boxes_path, dir)).returns(files[index]).in_sequence(dir_sequence)
         end
 
-        result = Vagrant::Box.all
+        result = Vagrant::Box.all(@env)
         assert_equal ["foo"], result
       end
     end
@@ -53,20 +57,27 @@ class BoxTest < Test::Unit::TestCase
       setup do
         @dir = "foo"
         @name = "bar"
-        Vagrant::Box.stubs(:directory).with(@name).returns(@dir)
+        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(@name)
+        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(@name)
+        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
@@ -79,20 +90,21 @@ class BoxTest < Test::Unit::TestCase
         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(@name, @uri)
+        Vagrant::Box.add(@env, @name, @uri)
       end
     end
 
     context "box directory" do
       setup do
         @name = "foo"
-        @box_dir = File.join(Vagrant::Env.boxes_path, @name)
+        @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(@name)
+        assert_equal @box_dir, Vagrant::Box.directory(@env, @name)
       end
     end
   end
@@ -114,7 +126,7 @@ class BoxTest < Test::Unit::TestCase
 
       should "return the boxes_path joined with the name" do
         result = mock("object")
-        Vagrant::Box.expects(:directory).with(@box.name).returns(result)
+        Vagrant::Box.expects(:directory).with(@box.env, @box.name).returns(result)
         assert result.equal?(@box.directory)
       end
     end

data/test/vagrant/busy_test.rb

@@ -1,19 +1,28 @@
 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
-      Vagrant::Busy.reset_trap_thread!
+      @klass.reset_trap_thread!
     end
 
     should "run in a thread" do
       Thread.expects(:new).once.returns(nil)
-      Vagrant::Busy.wait_for_not_busy
+      @klass.wait_for_not_busy
     end
 
-    should "not start a thread multiple times" do
-      Thread.expects(:new).once.returns("foo")
-      Vagrant::Busy.wait_for_not_busy
+    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
 
@@ -42,7 +51,7 @@ class BusyTest < Test::Unit::TestCase
     should "complete the trap thread even if an exception occurs" do
       trap_thread = mock("trap_thread")
       trap_thread.expects(:join).once
-      Vagrant::Busy.stubs(:trap_thread).returns(trap_thread)
+      @klass.stubs(:trap_thread).returns(trap_thread)
 
       assert_raise Exception do
         Vagrant.busy do

data/test/vagrant/command_test.rb

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,118 @@
+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(:puts_help).never
+        @instance.execute(["--version"])
+      end
+
+      should "just print the help by default" do
+        @instance.expects(:puts_version).never
+        @klass.expects(:puts_help)
+        @instance.execute([])
+      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")
+        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
+        @option_parser.expects(:parse!).with(@args).once
+        assert_equal @options, @instance.parse_options(@args)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,41 @@
+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