vagrant 0.5.4 → 0.6.0

data/test/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).returns({ :one => 1 })
+      end
+
+      should "raise an exception if a name is specified" do
+        instance = command(["foo"], @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, instance.target_vms
+        }
+      end
+    end
+
+    context "with multivm" do
+      setup do
+        @env.stubs(:vms).returns(:one => 1, :two => 2)
+      end
+
+      should "return all the VMs if no name is specified" do
+        instance = command([], @env)
+        assert_equal @env.vms.values, instance.target_vms
+      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/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 env in the JSON hash" do
+        @base.env = "FOO"
+        hash = @base.instance_variables_hash
+        assert !hash.has_key?(:env)
+      end
+    end
+  end
+end

data/test/vagrant/config/error_recorder_test.rb

@@ -0,0 +1,18 @@
+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/vagrant/config/ssh_test.rb

@@ -0,0 +1,12 @@
+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/vagrant/config/vagrant_test.rb

@@ -0,0 +1,11 @@
+require "test_helper"
+
+class ConfigVagrantTest < Test::Unit::TestCase
+  setup do
+    @config = Vagrant::Config::VagrantConfig.new
+  end
+
+  context "validation" do
+    # TODO
+  end
+end

data/test/vagrant/config/vm_test.rb

@@ -0,0 +1,70 @@
+require "test_helper"
+
+class ConfigVMTest < Test::Unit::TestCase
+  setup do
+    @username = "mitchellh"
+
+    @env = vagrant_env
+    @config = @env.config.vm
+    @env.config.ssh.username = @username
+  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
+  end
+
+  context "customizing" do
+    should "include the stacked proc runner module" do
+      assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
+    end
+
+    should "add the customize proc to the proc stack" do
+      proc = Proc.new {}
+      @config.customize(&proc)
+      assert @config.proc_stack.include?(proc)
+    end
+  end
+
+  context "uid/gid" do
+    should "return the shared folder UID if set" do
+      @config.shared_folder_uid = "foo"
+      assert_equal "foo", @config.shared_folder_uid
+    end
+
+    should "return the SSH username if UID not set" do
+      @config.shared_folder_uid = nil
+      assert_equal @username, @config.shared_folder_uid
+    end
+
+    should "return the shared folder GID if set" do
+      @config.shared_folder_gid = "foo"
+      assert_equal "foo", @config.shared_folder_gid
+    end
+
+    should "return the SSH username if GID not set" do
+      @config.shared_folder_gid = nil
+      assert_equal @username, @config.shared_folder_gid
+    end
+  end
+end

data/test/vagrant/config_test.rb

@@ -1,154 +1,156 @@
 require "test_helper"
 
 class ConfigTest < Test::Unit::TestCase
-  context "the ssh config" do
+  setup do
+    @klass = Vagrant::Config
+  end
+
+  context "with an instance" do
     setup do
-      @env = mock_environment
-      @env.stubs(:root_path).returns("foo")
+      @env = vagrant_env
+      @instance = @klass.new(@env)
+
+      # Don't want validation to occur for these tests
+      @klass::Top.any_instance.stubs(:validate!)
     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
+    should "initially have an empty queue" do
+      assert @instance.queue.empty?
     end
-  end
 
-  context "adding configures" do
-    should "forward the method to the Top class" do
-      key = mock("key")
-      klass = mock("klass")
-      Vagrant::Config::Top.expects(:configures).with(key, klass)
-      Vagrant::Config.configures(key, klass)
+    should "reset the config class on load, then execute" do
+      seq = sequence("sequence")
+      @klass.expects(:reset!).with(@env).in_sequence(seq)
+      @klass.expects(:execute!).in_sequence(seq)
+      @instance.load!
+    end
+
+    should "run the queue in the order given" do
+      @instance.queue << Proc.new { |config| config.vm.box = "foo" }
+      @instance.queue << Proc.new { |config| config.vm.box = "bar" }
+      result = @instance.load!
+
+      assert_equal "bar", result.vm.box
+    end
+
+    should "allow nested arrays" do
+      queue = []
+      queue << Proc.new { |config| config.vm.box = "foo" }
+      queue << Proc.new { |config| config.vm.box = "bar" }
+      @instance.queue << queue
+      result = @instance.load!
+
+      assert_equal "bar", result.vm.box
+    end
+
+    should "load a file if it exists" do
+      filename = "foo"
+      File.expects(:exist?).with(filename).returns(true)
+      @instance.expects(:load).with(filename).once
+
+      @instance.queue << filename
+      @instance.load!
+    end
+
+    should "not load a file if it doesn't exist" do
+      filename = "foo"
+      File.expects(:exist?).with(filename).returns(false)
+      @instance.expects(:load).with(filename).never
+
+      @instance.queue << filename
+      @instance.load!
+    end
+
+    should "raise an exception if there is a syntax error in a file" do
+      @instance.queue << "foo"
+      File.expects(:exist?).with("foo").returns(true)
+      @instance.expects(:load).with("foo").raises(SyntaxError.new)
+
+      assert_raises(Vagrant::Errors::VagrantfileSyntaxError) {
+        @instance.load!
+      }
     end
   end
 
   context "resetting" do
     setup do
-      Vagrant::Config.run { |config| }
-      Vagrant::Config.execute!
+      @klass::Top.any_instance.stubs(:validate!)
+      @klass.run { |config| }
+      @klass.execute!
     end
 
     should "return the same config object typically" do
-      config = Vagrant::Config.config
-      assert config.equal?(Vagrant::Config.config)
+      config = @klass.config
+      assert config.equal?(@klass.config)
     end
 
     should "create a new object if cleared" do
-      config = Vagrant::Config.config
-      Vagrant::Config.reset!
-      assert !config.equal?(Vagrant::Config.config)
+      config = @klass.config
+      @klass.reset!
+      assert !config.equal?(@klass.config)
     end
 
     should "empty the proc stack" do
-      assert !Vagrant::Config.proc_stack.empty?
-      Vagrant::Config.reset!
-      assert Vagrant::Config.proc_stack.empty?
+      assert !@klass.proc_stack.empty?
+      @klass.reset!
+      assert @klass.proc_stack.empty?
     end
 
     should "reload the config object based on the given environment" do
       env = mock("env")
-      Vagrant::Config.expects(:config).with(env).once
-      Vagrant::Config.reset!(env)
+      @klass.expects(:config).with(env).once
+      @klass.reset!(env)
     end
   end
 
   context "initializing" do
     setup do
-      Vagrant::Config.reset!
+      @klass.reset!
+      @klass::Top.any_instance.stubs(:validate!)
     end
 
     should "add the given block to the proc stack" do
       proc = Proc.new {}
-      Vagrant::Config.run(&proc)
-      assert_equal [proc], Vagrant::Config.proc_stack
+      @klass.run(&proc)
+      assert_equal [proc], @klass.proc_stack
     end
 
     should "run the proc stack with the config when execute is called" do
-      Vagrant::Config.expects(:run_procs!).with(Vagrant::Config.config).once
-      Vagrant::Config.execute!
-    end
-
-    should "not be loaded, initially" do
-      assert !Vagrant::Config.config.loaded?
-    end
-
-    should "be loaded after running" do
-      Vagrant::Config.run {}
-      Vagrant::Config.execute!
-      assert Vagrant::Config.config.loaded?
+      seq = sequence('seq')
+      @klass.expects(:run_procs!).with(@klass.config).once.in_sequence(seq)
+      @klass.config.expects(:validate!).once.in_sequence(seq)
+      @klass.execute!
     end
 
     should "return the configuration on execute!" do
-      Vagrant::Config.run {}
-      result = Vagrant::Config.execute!
-      assert result.is_a?(Vagrant::Config::Top)
+      @klass.run {}
+      result = @klass.execute!
+      assert result.is_a?(@klass::Top)
     end
 
     should "use given configuration object if given" do
       fake_env = mock("env")
-      config = Vagrant::Config::Top.new(fake_env)
-      result = Vagrant::Config.execute!(config)
+      config = @klass::Top.new(fake_env)
+      result = @klass.execute!(config)
       assert_equal config.env, result.env
     end
   end
 
-  context "base class" do
-    setup do
-      @base = Vagrant::Config::Base.new
-    end
-
-    should "forward [] access to methods" do
-      @base.expects(:foo).once
-      @base[:foo]
-    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 "convert instance variable hash to json" do
-        @json = mock("json")
-        @iv_hash = mock("iv_hash")
-        @iv_hash.expects(:to_json).once.returns(@json)
-        @base.expects(:instance_variables_hash).returns(@iv_hash)
-        assert_equal @json, @base.to_json
-      end
-
-      should "not include env in the JSON hash" do
-        @base.env = "FOO"
-        hash = @base.instance_variables_hash
-        assert !hash.has_key?(:env)
-      end
-    end
-  end
-
   context "top config class" do
     setup do
       @configures_list = []
-      Vagrant::Config::Top.stubs(:configures_list).returns(@configures_list)
+      @klass::Top.stubs(:configures_list).returns(@configures_list)
     end
 
     context "adding configure keys" do
       setup do
         @key = "top_config_foo"
-        @klass = mock("klass")
+        @config_klass = mock("klass")
       end
 
       should "add key and klass to configures list" do
-        @configures_list.expects(:<<).with([@key, @klass])
-        Vagrant::Config::Top.configures(@key, @klass)
+        @configures_list.expects(:<<).with([@key, @config_klass])
+        @klass::Top.configures(@key, @config_klass)
       end
     end
 
@@ -169,7 +171,7 @@ class ConfigTest < Test::Unit::TestCase
           @configures_list << [key, klass]
         end
 
-        Vagrant::Config::Top.new(env)
+        @klass::Top.new(env)
       end
 
       should "allow reading via methods" do
@@ -178,129 +180,34 @@ class ConfigTest < Test::Unit::TestCase
         instance = mock("instance")
         instance.stubs(:env=)
         klass.expects(:new).returns(instance)
-        Vagrant::Config::Top.configures(key, klass)
+        @klass::Top.configures(key, klass)
 
-        config = Vagrant::Config::Top.new
+        config = @klass::Top.new
         assert_equal instance, config.send(key)
       end
     end
 
-    context "loaded status" do
-      setup do
-        @top= Vagrant::Config::Top.new
-      end
-
-      should "not be loaded by default" do
-        assert !@top.loaded?
+    context "validation" do
+      should "do nothing if no errors are added" do
+        valid_class = Class.new(@klass::Base)
+        @klass::Top.configures(:subconfig, valid_class)
+        instance = @klass::Top.new
+        assert_nothing_raised { instance.validate! }
       end
 
-      should "be loaded after calling loaded!" do
-        @top.loaded!
-        assert @top.loaded?
-      end
-    end
-
-    context "deep cloning" do
-      class DeepCloneConfig < Vagrant::Config::Base
-        attr_accessor :attribute
-      end
-
-      setup do
-        Vagrant::Config::Top.configures :deep, DeepCloneConfig
-        @top = Vagrant::Config::Top.new
-        @top.deep.attribute = [1,2,3]
-      end
-
-      should "deep clone the object" do
-        copy = @top.deep_clone
-        copy.deep.attribute << 4
-        assert_not_equal @top.deep.attribute, copy.deep.attribute
-        assert_equal 3, @top.deep.attribute.length
-        assert_equal 4, copy.deep.attribute.length
-      end
-    end
-  end
-
-  context "vagrant configuration" do
-    setup do
-      @config = Vagrant::Config::VagrantConfig.new
-    end
-
-    should "return nil if home is nil" do
-      File.expects(:expand_path).never
-      assert @config.home.nil?
-    end
-
-    should "expand the path if home is not nil" do
-      @config.home = "foo"
-      File.expects(:expand_path).with("foo").once.returns("result")
-      assert_equal "result", @config.home
-    end
-  end
-
-  context "VM configuration" do
-    setup do
-      @env = mock_environment
-      @config = @env.config.vm
-      @env.config.ssh.username = @username
-    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
-    end
-
-    context "customizing" do
-      should "include the stacked proc runner module" do
-        assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
-      end
-
-      should "add the customize proc to the proc stack" do
-        proc = Proc.new {}
-        @config.customize(&proc)
-        assert_equal [proc], @config.proc_stack
-      end
-    end
-
-    context "uid/gid" do
-      should "return the shared folder UID if set" do
-        @config.shared_folder_uid = "foo"
-        assert_equal "foo", @config.shared_folder_uid
-      end
-
-      should "return the SSH username if UID not set" do
-        @config.shared_folder_uid = nil
-        assert_equal @username, @config.shared_folder_uid
-      end
+      should "raise an exception if there are errors" do
+        invalid_class = Class.new(@klass::Base) do
+          def validate(errors)
+            errors.add("vagrant.test.errors.test_key")
+          end
+        end
 
-      should "return the shared folder GID if set" do
-        @config.shared_folder_gid = "foo"
-        assert_equal "foo", @config.shared_folder_gid
-      end
+        @klass::Top.configures(:subconfig, invalid_class)
+        instance = @klass::Top.new
 
-      should "return the SSH username if GID not set" do
-        @config.shared_folder_gid = nil
-        assert_equal @username, @config.shared_folder_gid
+        assert_raises(Vagrant::Errors::ConfigValidationFailed) {
+          instance.validate!
+        }
       end
     end
   end