vagrant 1.0.7 → 1.5.0

data/test/unit_legacy/vagrant/box_collection_test.rb

@@ -1,45 +0,0 @@
-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_legacy/vagrant/box_test.rb

@@ -1,74 +0,0 @@
-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_legacy/vagrant/cli_test.rb

@@ -1,35 +0,0 @@
-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_legacy/vagrant/command/base_test.rb

@@ -1,23 +0,0 @@
-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_legacy/vagrant/command/group_base_test.rb

@@ -1,15 +0,0 @@
-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_legacy/vagrant/command/helpers_test.rb

@@ -1,88 +0,0 @@
-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_legacy/vagrant/command/init_test.rb

@@ -1,10 +0,0 @@
-require "test_helper"
-
-class CommandInitCommandTest < Test::Unit::TestCase
-  should "create a Vagrantfile in the environment's cwd" do
-    path = vagrant_app
-    env = Vagrant::Environment.new(:cwd => path)
-    silence(:stdout) { env.cli("init") }
-    assert File.exist?(path.join("Vagrantfile"))
-  end
-end

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

@@ -1,27 +0,0 @@
-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_legacy/vagrant/config/base_test.rb

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

data/test/unit_legacy/vagrant/config/error_recorder_test.rb

@@ -1,18 +0,0 @@
-require "test_helper"
-
-class ConfigErrorsTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Config::ErrorRecorder
-    @instance = @klass.new
-  end
-
-  should "not have any errors to start" do
-    assert @instance.errors.empty?
-  end
-
-  should "add errors" do
-    key = "vagrant.test.errors.test_key"
-    @instance.add(key)
-    assert_equal key, @instance.errors.first
-  end
-end

data/test/unit_legacy/vagrant/config/ssh_test.rb

@@ -1,12 +0,0 @@
-require "test_helper"
-
-class ConfigSSHTest < Test::Unit::TestCase
-  setup do
-    @env = vagrant_env
-  end
-
-  should "expand any path when requesting the value" do
-    result = File.expand_path(@env.config.ssh.private_key_path, @env.root_path)
-    assert_equal result, @env.config.ssh.private_key_path
-  end
-end

data/test/unit_legacy/vagrant/config/vagrant_test.rb

@@ -1,35 +0,0 @@
-require "test_helper"
-
-class ConfigVagrantTest < Test::Unit::TestCase
-  setup do
-    @config = Vagrant::Config::VagrantConfig.new
-  end
-
-  context "validation" do
-    setup do
-      @config.dotfile_name = "foo"
-      @config.host = "foo"
-
-      @errors = Vagrant::Config::ErrorRecorder.new
-    end
-
-    should "be valid with given set of values" do
-      @config.validate(@errors)
-      assert @errors.errors.empty?
-    end
-
-    should "be invalid with no dotfile" do
-      @config.dotfile_name = nil
-
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be invalid with no host" do
-      @config.host = nil
-
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-  end
-end