vagrant 0.5.4 → 0.6.0

data/test/vagrant/action/vm/suspend_test.rb

@@ -3,7 +3,7 @@ require "test_helper"
 class SuspendVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::Suspend
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @env["vm"] = @vm

data/test/vagrant/action/warden_test.rb

@@ -0,0 +1,105 @@
+require "test_helper"
+
+class ActionWardenTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::Warden
+    @instance = @klass.new([], {})
+  end
+
+  context "initializing" do
+    should "finalize the middleware" do
+      middleware = [1,2,3]
+      middleware.each do |m|
+        @klass.any_instance.expects(:finalize_action).with(m, {}).returns(m)
+      end
+      @warden = @klass.new(middleware, new_env)
+      assert_equal @warden.actions, [1,2,3]
+    end
+  end
+
+  context "setting up middleware" do
+    should "make non-classes lambdas" do
+      env = new_env
+      env.expects(:foo).once
+
+      func = lambda { |x| x.foo }
+      @instance.finalize_action(func, env).call(env)
+    end
+
+    should "raise exception if given invalid middleware" do
+      assert_raises(RuntimeError) {
+        @instance.finalize_action(7, nil)
+      }
+    end
+  end
+
+  context "calling" do
+    should "return if there are no actions to execute" do
+      @instance.actions.expects(:pop).never
+      assert !@instance.call(new_env)
+    end
+
+    should "move the last action to the front of the stack" do
+      @instance.actions << lambda { |env| }
+      assert @instance.stack.empty?
+      @instance.call(new_env)
+      assert !@instance.stack.empty?
+      assert @instance.actions.empty?
+    end
+
+    should "call the next action" do
+      action = mock('action')
+      action.expects(:call).with({})
+      @instance.actions << action
+      @instance.call(new_env)
+    end
+
+    should "begin recovery sequence when the called action raises an exception" do
+      class Foo
+        def initialize(*args); end
+        def call(env)
+          raise "An exception"
+        end
+      end
+
+      @instance.actions << Foo.new
+      @instance.expects(:begin_rescue).with() do |env|
+        assert env["vagrant.error"].is_a?(RuntimeError)
+        true
+      end
+      assert_raises(RuntimeError) { @instance.call(new_env) }
+    end
+
+    should "raise interrupt if the environment is interupted" do
+      env = new_env
+      env.expects(:interrupted?).returns(true)
+      @instance.actions << lambda { |env| }
+
+      assert_raises(Vagrant::Errors::VagrantInterrupt) {
+        @instance.call(env)
+      }
+    end
+  end
+
+  context "recover" do
+    should "call recover on all items in the stack" do
+      seq = sequence("sequence")
+      @instance.stack = [rescueable_mock("action"), rescueable_mock("another")]
+      @instance.stack.each do |action|
+        action.expects(:recover).with(new_env).in_sequence(seq)
+      end
+
+      @instance.begin_rescue(new_env)
+    end
+  end
+
+  def new_env
+    Vagrant::Action::Environment.new(nil)
+  end
+
+  def rescueable_mock(name)
+    mock_action = mock(name)
+    mock_action.stubs(:respond_to?).with(:recover).returns(true)
+    mock_action
+  end
+end

data/test/vagrant/action_test.rb

@@ -7,7 +7,7 @@ class ActionTest < Test::Unit::TestCase
 
   context "with a class" do
     teardown do
-      @klass.actions.clear
+      @klass.actions.delete(:foo)
     end
 
     should "be able to register an action" do
@@ -24,16 +24,12 @@ class ActionTest < Test::Unit::TestCase
 
   context "with an instance" do
     setup do
-      @instance = @klass.new(mock_environment)
-    end
-
-    teardown do
-      @klass.actions.clear
+      @instance = @klass.new(vagrant_env)
     end
 
     should "raise an exception if a nil action is given" do
-      assert_raises(Vagrant::Exceptions::UncallableAction) { @instance.run(nil) }
-      assert_raises(Vagrant::Exceptions::UncallableAction) { @instance.run(:dontexist) }
+      assert_raises(ArgumentError) { @instance.run(nil) }
+      assert_raises(ArgumentError) { @instance.run(:dontexist) }
     end
 
     should "run the callable item with the proper context" do
@@ -74,6 +70,7 @@ class ActionTest < Test::Unit::TestCase
 
       @klass.register(:call, callable)
       @instance.run(:call)
+      @klass.actions.delete(:call)
     end
 
     should "run the given class if a class is given" do
@@ -88,24 +85,5 @@ class ActionTest < Test::Unit::TestCase
 
       @instance.run(callable, :bar => :foo)
     end
-
-    should "exit if environment was marked as interrupted" do
-      callable = lambda do |env|
-        env.error!(:interrupt)
-      end
-
-      @instance.stubs(:error_and_exit)
-      @instance.expects(:exit).once
-      @instance.run(callable)
-    end
-
-    should "error and exit if erroneous environment results" do
-      callable = lambda do |env|
-        env.error!(:key, :foo => :bar)
-      end
-
-      @instance.expects(:error_and_exit).with(:key, :foo => :bar)
-      @instance.run(callable)
-    end
   end
 end

data/test/vagrant/box_collection_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class BoxCollectionTest < Test::Unit::TestCase
+  setup do
+    clean_paths
+
+    @klass = Vagrant::BoxCollection
+  end
+
+  should "load all the boxes from the box path" do
+    vagrant_box("foo")
+    vagrant_box("bar")
+
+    result = @klass.new(vagrant_env)
+    names = result.collect { |b| b.name }.sort
+    assert_equal 2, result.length
+    assert_equal ["bar", "foo"], names
+  end
+
+  should "reload the box list" do
+    instance = @klass.new(vagrant_env)
+    assert instance.empty?
+
+    vagrant_box("foo")
+
+    instance.reload!
+    assert !instance.empty?
+  end
+
+  should "find a specific box" do
+    vagrant_box("foo")
+    vagrant_box("bar")
+
+    instance = @klass.new(vagrant_env)
+    result = instance.find("foo")
+    assert result
+    assert_equal "foo", result.name
+  end
+
+  should "return nil if it couldn't find a specific box" do
+    instance = @klass.new(vagrant_env)
+    assert_nil instance.find("thisshouldnotexist")
+  end
+end

data/test/vagrant/box_test.rb

@@ -3,81 +3,7 @@ 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
+      @env = vagrant_env
     end
 
     context "adding" do
@@ -88,31 +14,17 @@ class BoxTest < Test::Unit::TestCase
 
       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.expects(:new).with(@env, @name).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
+      @box = Vagrant::Box.new(vagrant_env, "foo")
     end
 
     should "execute the Add action when add is called" do
@@ -121,14 +33,8 @@ class BoxTest < Test::Unit::TestCase
     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)
+        assert_equal @box.env.boxes_path.join(@box.name), @box.directory
       end
     end
 
@@ -152,14 +58,8 @@ class BoxTest < Test::Unit::TestCase
     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
+        assert_equal @box.directory.join(@box.env.config.vm.box_ovf), @box.ovf_file
       end
     end
   end

data/test/vagrant/cli_test.rb

@@ -0,0 +1,35 @@
+require "test_helper"
+
+class CLITest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::CLI
+  end
+
+  context "registering" do
+    should "register a base command as a single invokable" do
+      base = Class.new(Vagrant::Command::Base)
+      name = "__test_registering_single_subcommand"
+      @klass.register(base, name, name, "A description")
+      assert @klass.tasks[name]
+    end
+
+    should "register a group base as a subcommand" do
+      base = Class.new(Vagrant::Command::GroupBase)
+      name = "_test_registering_single_group"
+      @klass.register(base, name, name, "A description")
+      assert @klass.subcommands.include?(name)
+    end
+
+    should "alias methods if the alias option is given" do
+      base = Class.new(Vagrant::Command::Base) do
+        def execute
+          raise "WORKED"
+        end
+      end
+
+      name = "__test_registering_with_alias"
+      @klass.register(base, name, name, "A description", :alias => "--ALIAS")
+      assert_raises(RuntimeError) { @klass.start(["--ALIAS"], :env => vagrant_env) }
+    end
+  end
+end

data/test/vagrant/command/base_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class CommandBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Command::Base
+    @env = vagrant_env
+  end
+
+  context "initialization" do
+    should "require an environment" do
+      assert_raises(Vagrant::Errors::CLIMissingEnvironment) { @klass.new([], {}, {}) }
+      assert_nothing_raised { @klass.new([], {}, { :env => @env }) }
+    end
+  end
+
+  context "extracting a name from a usage string" do
+    should "extract properly" do
+      assert_equal "init", @klass.extract_name_from_usage("init")
+      assert_equal "init", @klass.extract_name_from_usage("init [foo] [bar]")
+      assert_equal "ssh-config", @klass.extract_name_from_usage("ssh-config")
+    end
+  end
+end

data/test/vagrant/command/group_base_test.rb

@@ -0,0 +1,15 @@
+require "test_helper"
+
+class CommandGroupBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Command::GroupBase
+    @env = vagrant_env
+  end
+
+  context "initialization" do
+    should "require an environment" do
+      assert_raises(Vagrant::Errors::CLIMissingEnvironment) { @klass.new([], {}, {}) }
+      assert_nothing_raised { @klass.new([], {}, { :env => @env }) }
+    end
+  end
+end