rvagrant 0.8.7.dev

data/test/unit/vagrant/action_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class ActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action
+  end
+
+  context "with a class" do
+    teardown do
+      @klass.actions.delete(:foo)
+    end
+
+    should "be able to register an action" do
+      @klass.register(:foo, :bar)
+      assert @klass.actions.has_key?(:foo)
+      assert_equal :bar, @klass.actions[:foo]
+    end
+
+    should "be able to retrieve an action using []" do
+      @klass.register(:foo, :bar)
+      assert_equal :bar, @klass[:foo]
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @instance = @klass.new(vagrant_env)
+    end
+
+    should "raise an exception if a nil action is given" do
+      assert_raises(ArgumentError) { @instance.run(nil) }
+      assert_raises(ArgumentError) { @instance.run(:dontexist) }
+    end
+
+    should "run the callable item with the proper context" do
+      callable = mock("callable")
+      callable.expects(:call).with() do |env|
+        assert env.kind_of?(Vagrant::Action::Environment)
+        assert_equal @instance.env, env.env
+        true
+      end
+
+      @instance.run(callable)
+    end
+
+    should "run the callable with the passed in options if given" do
+      options = {
+        :key => :value,
+        :another => %W[1 2 3]
+      }
+
+      callable = mock("callable")
+      callable.expects(:call).with() do |env|
+        assert env.kind_of?(Vagrant::Action::Environment)
+        assert_equal @instance.env, env.env
+
+        options.each do |k,v|
+          assert_equal v, env[k]
+        end
+
+        true
+      end
+
+      @instance.run(callable, options)
+    end
+
+    should "run the registered callable if a symbol is given" do
+      callable = mock("callable")
+      callable.expects(:call).once
+
+      @klass.register(:call, callable)
+      @instance.run(:call)
+      @klass.actions.delete(:call)
+    end
+
+    should "run the given class if a class is given" do
+      callable = Class.new do
+        def initialize(app, env); end
+      end
+
+      callable.any_instance.expects(:call).with() do |env|
+        assert_equal :foo, env[:bar]
+        true
+      end
+
+      @instance.run(callable, :bar => :foo)
+    end
+  end
+end

data/test/unit/vagrant/box_collection_test.rb

@@ -0,0 +1,45 @@
+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 result.length >= 2
+    assert names.include?("foo")
+    assert names.include?("bar")
+  end
+
+  should "reload the box list" do
+    instance = @klass.new(vagrant_env)
+    amount = instance.length
+
+    vagrant_box("foo")
+
+    instance.reload!
+    assert_equal (amount + 1), instance.length
+  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/unit/vagrant/box_test.rb

@@ -0,0 +1,74 @@
+require "test_helper"
+
+class BoxTest < Test::Unit::TestCase
+  context "class methods" do
+    setup do
+      @env = vagrant_env
+    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(:uri=).with(@uri)
+        box.expects(:add).once
+        Vagrant::Box.expects(:new).with(@env, @name).returns(box)
+        Vagrant::Box.add(@env, @name, @uri)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @box = Vagrant::Box.new(vagrant_env, "foo")
+    end
+
+    should "raise an exception if a box exists with the name we're attempting to add" do
+      vagrant_box(@box.name)
+
+      assert_raises(Vagrant::Errors::BoxAlreadyExists) {
+        @box.add
+      }
+    end
+
+    should "execute the Add action when add is called" do
+      @box.env.actions.expects(:run).with(:box_add, { "box" => @box, "validate" => false })
+      @box.add
+    end
+
+    context "box directory" do
+      should "return the boxes_path joined with the name" do
+        assert_equal @box.env.boxes_path.join(@box.name), @box.directory
+      end
+    end
+
+    context "destroying" do
+      should "execute the destroy action" do
+        @box.env.actions.expects(:run).with(:box_remove, { "box" => @box, "validate" => false })
+        @box.destroy
+      end
+    end
+
+    context "repackaging" do
+      should "execute the repackage action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "validate" => false })
+        @box.repackage
+      end
+
+      should "forward given options into the action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "foo" => "bar", "validate" => false })
+        @box.repackage("foo" => "bar")
+      end
+    end
+
+    context "ovf file" do
+      should "be the directory joined with the config ovf file" do
+        assert_equal @box.directory.join(@box.env.config.vm.box_ovf), @box.ovf_file
+      end
+    end
+  end
+end

data/test/unit/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/unit/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/unit/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

data/test/unit/vagrant/command/helpers_test.rb

@@ -0,0 +1,88 @@
+require "test_helper"
+
+class CommandHelpersTest < Test::Unit::TestCase
+  setup do
+    @module = Vagrant::Command::Helpers
+    @command = Class.new(Vagrant::Command::Base) do
+      argument :name, :optional => true, :type => :string
+    end
+  end
+
+  def command(args, env)
+    @command.new(args, {}, { :env => env })
+  end
+
+  context "initializing environment" do
+    should "raise an exception if no environment is given" do
+      assert_raises(Vagrant::Errors::CLIMissingEnvironment) { command([], nil) }
+    end
+  end
+
+  context "vms from args" do
+    setup do
+      @env = vagrant_env
+    end
+
+    should "raise an exception if no root path" do
+      @env.stubs(:root_path).returns(nil)
+
+      assert_raises(Vagrant::Errors::NoEnvironmentError) {
+        command([], @env).target_vms
+      }
+    end
+
+    should "only calculate the result once" do
+      instance = command([], @env)
+      result = instance.target_vms
+      assert instance.target_vms.equal?(result)
+    end
+
+    context "without multivm" do
+      setup do
+        @env.stubs(:vms_ordered => [1, 2], :vms => {:one => 1, :two => 2})
+      end
+
+      should "raise an exception if a name is specified" do
+        instance = command(["foo"], vagrant_env)
+        assert_raises(Vagrant::Errors::MultiVMEnvironmentRequired) {
+          instance.target_vms
+        }
+      end
+
+      should "return the VM if no name is specified" do
+        instance = command([], @env)
+        assert_nothing_raised {
+          assert_equal @env.vms.values.sort, instance.target_vms.sort
+        }
+      end
+    end
+
+    context "with multivm" do
+      setup do
+        @env.stubs(:vms_ordered => [1, 2], :vms => {:one => 1, :two => 2})
+      end
+
+      should "return all the VMs if no name is specified" do
+        instance = command([], @env)
+        assert_equal @env.vms.values.sort, instance.target_vms.sort
+      end
+
+      should "return only the specified VM if a name is given" do
+        instance = command(["one"], @env)
+        assert_equal @env.vms[:one], instance.target_vms.first
+      end
+
+      should "return only the specified VM if name is given in the arg" do
+        instance = command([], @env)
+        assert_equal @env.vms[:two], instance.target_vms("two").first
+      end
+
+      should "raise an exception if an invalid name is given" do
+        instance = command(["foo"], @env)
+        assert_raises(Vagrant::Errors::VMNotFoundError) {
+          instance.target_vms
+        }
+      end
+    end
+  end
+end

data/test/unit/vagrant/command/package_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+class CommandPackageCommandTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Command::PackageCommand
+    @env = vagrant_env
+  end
+
+  def command(args, opts, env)
+    @klass.new(args, opts, { :env => env })
+  end
+
+  context "initialization" do
+    should "require an environment" do
+      assert_raises(Vagrant::Errors::CLIMissingEnvironment) { command([], {}, nil) }
+      assert_nothing_raised { command([], {}, @env) }
+    end
+  end
+
+  should "raise an exception if VM for supplied base option is not found" do
+    Vagrant::VM.stubs(:find).returns(Vagrant::VM.new(nil))
+
+    assert_raises(Vagrant::Errors::BaseVMNotFound) {
+      command([], { :base => "foo" }, @env).execute
+    }
+  end
+end

data/test/unit/vagrant/config/base_test.rb

@@ -0,0 +1,52 @@
+require "test_helper"
+
+class ConfigBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Config::Base
+  end
+
+  context "class methods" do
+    should "enable configuration with proper accessor" do
+      klass = Class.new(@klass)
+      acc = :foo
+      Vagrant::Config::Top.expects(:configures).with(acc, klass)
+      klass.configures(acc)
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @base = @klass.new
+    end
+
+    should "return a hash of instance variables" do
+      data = { "foo" => "bar", "bar" => "baz" }
+
+      data.each do |iv, value|
+        @base.instance_variable_set("@#{iv}".to_sym, value)
+      end
+
+      result = @base.instance_variables_hash
+      assert_equal data.length, result.length
+
+      data.each do |iv, value|
+        assert_equal value, result[iv]
+      end
+    end
+
+    context "converting to JSON" do
+      should "include magic `json_class`" do
+        @iv_hash = { "foo" => "bar" }
+        @base.expects(:instance_variables_hash).returns(@iv_hash)
+        @json = { 'json_class' => @base.class.name }.merge(@iv_hash).to_json
+        assert_equal @json, @base.to_json
+      end
+
+      should "not include top in the JSON hash" do
+        @base.top = "FOO"
+        hash = @base.instance_variables_hash
+        assert !hash.has_key?(:top)
+      end
+    end
+  end
+end