vagrantup 0.8.10 → 0.9.0

data/test/unit/vagrant/box_collection_test.rb

@@ -1,45 +1,56 @@
-require "test_helper"
+require File.expand_path("../../base", __FILE__)
 
-class BoxCollectionTest < Test::Unit::TestCase
-  setup do
-    clean_paths
+describe Vagrant::BoxCollection do
+  include_context "unit"
 
-    @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
+  let(:environment) { isolated_environment }
+  let(:action_runner) { double("action runner") }
+  let(:instance)    { described_class.new(environment.boxes_dir, action_runner) }
 
-    vagrant_box("foo")
+  it "should list all available boxes" do
+    # No boxes yet.
+    instance.length.should == 0
 
+    # Add some boxes to the environment and try again
+    environment.box("foo")
+    environment.box("bar")
     instance.reload!
-    assert_equal (amount + 1), instance.length
+    instance.length.should == 2
   end
 
-  should "find a specific box" do
-    vagrant_box("foo")
-    vagrant_box("bar")
+  describe "finding" do
+    it "should return nil if it can't find the box" do
+      instance.find("foo").should be_nil
+    end
+
+    it "should return a box instance for any boxes it does find" do
+      environment.box("foo")
+      result = instance.find("foo")
+      result.should be_kind_of(Vagrant::Box)
+      result.name.should == "foo"
+    end
+  end
 
-    instance = @klass.new(vagrant_env)
-    result = instance.find("foo")
-    assert result
-    assert_equal "foo", result.name
+  it "should throw an error if the box already exists when adding" do
+    environment.box("foo")
+    expect { instance.add("foo", "bar") }.to raise_error(Vagrant::Errors::BoxAlreadyExists)
   end
 
-  should "return nil if it couldn't find a specific box" do
-    instance = @klass.new(vagrant_env)
-    assert_nil instance.find("thisshouldnotexist")
+  it "should add the box" do
+    name = "foo"
+    url  = "bar"
+
+    # Test the invocation of the action runner with the proper name
+    # and parameters. We leave the testing of the actual stack to
+    # acceptance tests, and individual pieces to unit tests of each
+    # step.
+    options = {
+      :box_name => name,
+      :box_url => url,
+      :box_directory => instance.directory.join(name)
+    }
+    action_runner.should_receive(:run).with(:box_add, options)
+
+    instance.add(name, url)
   end
 end

data/test/unit/vagrant/box_test.rb

@@ -1,74 +1,34 @@
-require "test_helper"
+require File.expand_path("../../base", __FILE__)
 
-class BoxTest < Test::Unit::TestCase
-  context "class methods" do
-    setup do
-      @env = vagrant_env
-    end
+describe Vagrant::Box do
+  let(:name)          { "foo" }
+  let(:directory)     { "bar" }
+  let(:action_runner) { double("action_runner") }
+  let(:instance)      { described_class.new(name, directory, action_runner) }
 
-    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
+  it "provides the name" do
+    instance.name.should == name
   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
+  it "can destroy itself" do
+    # Simply test the messages to the action runner
+    options = {
+      :box_name => name,
+      :box_directory => directory
+    }
+    action_runner.should_receive(:run).with(:box_remove, options)
 
-    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
+    instance.destroy
+  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
+  it "can repackage itself" do
+    # Simply test the messages to the action runner
+    options = {
+      :box_name => name,
+      :box_directory => directory
+    }
+    action_runner.should_receive(:run).with(:box_repackage, options)
 
-    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
+    instance.repackage
   end
 end

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

@@ -1,23 +1,150 @@
-require "test_helper"
+require File.expand_path("../../../base", __FILE__)
+require 'optparse'
 
-class CommandBaseTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Command::Base
-    @env = vagrant_env
+describe Vagrant::Command::Base do
+  describe "parsing options" do
+    let(:klass) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :parse_options
+      end
+    end
+
+    it "returns the remaining arguments" do
+      options = {}
+      opts = OptionParser.new do |opts|
+        opts.on("-f") do |f|
+          options[:f] = f
+        end
+      end
+
+      result = klass.new(["-f", "foo"], nil).parse_options(opts)
+
+      # Check the results
+      options[:f].should be
+      result.should == ["foo"]
+    end
+
+    it "creates an option parser if none is given" do
+      result = klass.new(["foo"], nil).parse_options(nil)
+      result.should == ["foo"]
+    end
+
+    ["-h", "--help"].each do |help_string|
+      it "returns nil and prints the help if '#{help_string}' is given" do
+        instance = klass.new([help_string], nil)
+        instance.should_receive(:puts)
+        instance.parse_options(OptionParser.new).should be_nil
+      end
+    end
+
+    it "raises an error if invalid options are given" do
+      instance = klass.new(["-f"], nil)
+      expect { instance.parse_options(OptionParser.new) }.
+        to raise_error(Vagrant::Errors::CLIInvalidOptions)
+    end
   end
 
-  context "initialization" do
-    should "require an environment" do
-      assert_raises(Vagrant::Errors::CLIMissingEnvironment) { @klass.new([], {}, {}) }
-      assert_nothing_raised { @klass.new([], {}, { :env => @env }) }
+  describe "target VMs" do
+    let(:klass) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :with_target_vms
+      end
+    end
+
+    let(:environment) do
+      env = double("environment")
+      env.stub(:root_path => "foo")
+      env
+    end
+
+    let(:instance)    { klass.new([], environment) }
+
+    it "should raise an exception if a root_path is not available" do
+      environment.stub(:root_path => nil)
+
+      expect { instance.with_target_vms }.
+        to raise_error(Vagrant::Errors::NoEnvironmentError)
+    end
+
+    it "should raise an exception if a name is given in a non-multivm environment" do
+      environment.stub(:multivm?).and_return(false)
+
+      expect { instance.with_target_vms("foo") }.
+        to raise_error(Vagrant::Errors::MultiVMEnvironmentRequired)
+    end
+
+    it "should yield every VM in order is no name is given" do
+      foo_vm = double("foo")
+      foo_vm.stub(:name).and_return("foo")
+
+      bar_vm = double("bar")
+      bar_vm.stub(:name).and_return("bar")
+
+      environment.stub(:multivm? => true,
+                       :vms => { "foo" => foo_vm, "bar" => bar_vm },
+                       :vms_ordered => [foo_vm, bar_vm])
+
+      vms = []
+      instance.with_target_vms do |vm|
+        vms << vm
+      end
+
+      vms.should == [foo_vm, bar_vm]
+    end
+
+    it "raises an exception if the named VM doesn't exist" do
+      environment.stub(:multivm? => true, :vms => {})
+
+      expect { instance.with_target_vms("foo") }.
+        to raise_error(Vagrant::Errors::VMNotFoundError)
+    end
+
+    it "yields the given VM if a name is given" do
+      foo_vm = double("foo")
+      foo_vm.stub(:name).and_return(:foo)
+
+      environment.stub(:multivm? => true,
+                       :vms => { :foo => foo_vm, :bar => nil })
+
+      vms = []
+      instance.with_target_vms("foo") { |vm| vms << vm }
+      vms.should == [foo_vm]
     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")
+  describe "splitting the main and subcommand args" do
+    let(:instance) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :split_main_and_subcommand
+      end.new(nil, nil)
+    end
+
+    it "should work when given all 3 parts" do
+      result = instance.split_main_and_subcommand(["-v", "status", "-h", "-v"])
+      result.should == [["-v"], "status", ["-h", "-v"]]
+    end
+
+    it "should work when given only a subcommand and args" do
+      result = instance.split_main_and_subcommand(["status", "-h"])
+      result.should == [[], "status", ["-h"]]
+    end
+
+    it "should work when given only main flags" do
+      result = instance.split_main_and_subcommand(["-v", "-h"])
+      result.should == [["-v", "-h"], nil, []]
+    end
+
+    it "should work when given only a subcommand" do
+      result = instance.split_main_and_subcommand(["status"])
+      result.should == [[], "status", []]
+    end
+
+    it "works when there are other non-flag args after the subcommand" do
+      result = instance.split_main_and_subcommand(["-v", "box", "add", "-h"])
+      result.should == [["-v"], "box", ["add", "-h"]]
     end
   end
 end

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

@@ -1,52 +1,25 @@
-require "test_helper"
+require File.expand_path("../../../base", __FILE__)
 
-class ConfigBaseTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Config::Base
-  end
+describe Vagrant::Config::Base do
+  include_context "unit"
 
-  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)
+  let(:foo_class) do
+    Class.new(described_class) do
+      attr_accessor :one
+      attr_accessor :two
     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
+  it "should merge by default by simply copying each instance variable" do
+    one = foo_class.new
+    one.one = 2
+    one.two = 1
 
-      result = @base.instance_variables_hash
-      assert_equal data.length, result.length
+    two = foo_class.new
+    two.two = 5
 
-      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
+    result = one.merge(two)
+    result.one.should == 2
+    result.two.should == 5
   end
 end

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

@@ -0,0 +1,79 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Config::Loader do
+  include_context "unit"
+
+  let(:instance) { described_class.new }
+
+  it "should ignore non-existent load order keys" do
+    instance.load_order = [:foo]
+    instance.load
+  end
+
+  it "should load and return the configuration" do
+    proc = Proc.new do |config|
+      config.vagrant.dotfile_name = "foo"
+    end
+
+    instance.load_order = [:proc]
+    instance.set(:proc, proc)
+    config = instance.load
+
+    config.vagrant.dotfile_name.should == "foo"
+  end
+
+  it "should only run the same proc once" do
+    count = 0
+    proc = Proc.new do |config|
+      config.vagrant.dotfile_name = "foo"
+      count += 1
+    end
+
+    instance.load_order = [:proc]
+    instance.set(:proc, proc)
+
+    5.times do
+      result = instance.load
+
+      # Verify the config result
+      result.vagrant.dotfile_name.should == "foo"
+
+      # Verify the count is only one
+      count.should == 1
+    end
+  end
+
+  it "should only load configuration files once" do
+    $_config_data = 0
+
+    # We test both setting a file multiple times as well as multiple
+    # loads, since both should not cache the data.
+    file = temporary_file("$_config_data += 1")
+    instance.load_order = [:file]
+    5.times { instance.set(:file, file) }
+    5.times { instance.load }
+
+    $_config_data.should == 1
+  end
+
+  it "should not clear the cache if setting to the same value multiple times" do
+    $_config_data = 0
+
+    file = temporary_file("$_config_data += 1")
+
+    instance.load_order = [:proc]
+    instance.set(:proc, file)
+    5.times { instance.load }
+
+    instance.set(:proc, file)
+    5.times { instance.load }
+
+    $_config_data.should == 1
+  end
+
+  it "should raise proper error if there is a syntax error in a Vagrantfile" do
+    instance.load_order = [:file]
+    expect { instance.set(:file, temporary_file("Vagrant:^Config")) }.
+      to raise_exception(Vagrant::Errors::VagrantfileSyntaxError)
+  end
+end

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

@@ -0,0 +1,69 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/registry"
+
+describe Vagrant::Config::Top do
+  include_context "unit"
+
+  let(:registry) { Vagrant::Registry.new }
+  let(:instance) { described_class.new(registry) }
+
+  it "should load in the proper config class" do
+    registry.register(:foo, Object)
+
+    instance.foo.should be_kind_of(Object)
+  end
+
+  it "should load the proper config class only once" do
+    registry.register(:foo, Object)
+
+    obj = instance.foo
+    instance.foo.should eql(obj)
+  end
+
+  it "still raises a method missing error if invalid key" do
+    expect { instance.foo }.to raise_error(NoMethodError)
+  end
+
+  describe "merging" do
+    let(:foo_class) do
+      Class.new do
+        attr_accessor :one
+        attr_accessor :two
+
+        def merge(other)
+          result = self.class.new
+          result.one = other.one || one
+          result.two = other.two || two
+          result
+        end
+      end
+    end
+
+    it "merges each key by calling `merge` on the class" do
+      registry.register(:foo, foo_class)
+
+      instance.foo.one = 1
+      instance.foo.two = 2
+
+      another = described_class.new(registry)
+      another.foo.one = 2
+
+      result = instance.merge(another)
+      result.foo.one.should == 2
+      result.foo.two.should == 2
+    end
+
+    it "merges keys that aren't in the source instance" do
+      reg = Vagrant::Registry.new
+      reg.register(:foo, foo_class)
+
+      another = described_class.new(reg)
+      another.foo.one = 2
+
+      result = instance.merge(another)
+      result.foo.one.should == 2
+      result.foo.two.should be_nil
+    end
+  end
+end