vagrant 0.8.10 → 0.9.0

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

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

@@ -1,56 +1,71 @@
-require "test_helper"
+require File.expand_path("../../../base", __FILE__)
 
-class ConfigVMTest < Test::Unit::TestCase
-  setup do
-    @username = "mitchellh"
+describe Vagrant::Config::VMConfig do
+  include_context "unit"
 
-    @env = vagrant_env
-    @config = @env.config.vm
-    @env.config.ssh.username = @username
+  it "merges by appending forwarded ports" do
+    a = described_class.new
+    a.forward_port 80, 8080
+
+    b = described_class.new
+    b.forward_port 100, 1000
+
+    c = a.merge(b)
+    c.forwarded_ports.length.should == 2
+    c.forwarded_ports[0][:guestport].should == 80
+    c.forwarded_ports[0][:hostport].should == 8080
+    c.forwarded_ports[1][:guestport].should == 100
+    c.forwarded_ports[1][:hostport].should == 1000
   end
 
-  context "defining VMs" do
-    should "store the proc by name but not run it" do
-      foo = mock("proc")
-      foo.expects(:call).never
-
-      proc = Proc.new { foo.call }
-      @config.define(:name, &proc)
-      assert @config.defined_vms[:name].proc_stack.include?(proc)
-    end
-
-    should "store the options" do
-      @config.define(:name, :set => true)
-      assert @config.defined_vms[:name].options[:set]
-    end
-
-    should "not have multi-VMs by default" do
-      assert !@config.has_multi_vms?
-    end
-
-    should "have multi-VMs once one is specified" do
-      @config.define(:foo) {}
-      assert @config.has_multi_vms?
-    end
-
-    should "retain vm definition order" do
-      @config.define(:a) {}
-      @config.define(:b) {}
-      @config.define(:c) {}
-
-      assert_equal [:a, :b, :c], @config.defined_vm_keys
-    end
+  it "merges by merging shared folders" do
+    a = described_class.new
+    a.share_folder "a", "/guest", "/host"
+    a.share_folder "b", "/guest", "/host"
+
+    b = described_class.new
+    b.share_folder "c", "/guest", "/host"
+
+    c = a.merge(b)
+    c.shared_folders.has_key?("a").should be
+    c.shared_folders.has_key?("b").should be
+    c.shared_folders.has_key?("c").should be
   end
 
-  context "customizing" do
-    should "include the stacked proc runner module" do
-      assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
-    end
+  it "merges by appending networks" do
+    a = described_class.new
+    a.network :hostonly, "33.33.33.10"
+
+    b = described_class.new
+    b.network :hostonly, "33.33.33.11"
+
+    c = a.merge(b)
+    c.networks.length.should == 2
+    c.networks[0].should == [:hostonly, ["33.33.33.10"]]
+    c.networks[1].should == [:hostonly, ["33.33.33.11"]]
+  end
+
+  it "merges by appending provisioners" do
+    a = described_class.new
+    a.provision :foo
+
+    b = described_class.new
+    b.provision :bar
+
+    c = a.merge(b)
+    c.provisioners.length.should == 2
+    c.provisioners[0].shortcut.should == :foo
+    c.provisioners[1].shortcut.should == :bar
+  end
+
+  it "merges by appending customizations" do
+    a = described_class.new
+    a.customize "a"
+
+    b = described_class.new
+    b.customize "b"
 
-    should "add the customize proc to the proc stack" do
-      proc = Proc.new {}
-      @config.customize(&proc)
-      assert @config.proc_stack.include?(proc)
-    end
+    c = a.merge(b)
+    c.customizations.should == ["a", "b"]
   end
 end