fixed-vagrant 0.7.4.dev

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,35 @@
+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

data/test/vagrant/config/vm/provisioner_test.rb

@@ -0,0 +1,92 @@
+require "test_helper"
+
+class ConfigVMProvisionerTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Config::VMConfig::Provisioner
+    @top = Vagrant::Config::Top.new(nil)
+  end
+
+  context "initializing" do
+    should "expose the top instance that the provisioner belongs to" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal @top, instance.top
+    end
+
+    should "expose the shortcut used" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal :chef_solo, instance.shortcut
+    end
+
+    should "expose the provisioner class if its a valid shortcut" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal Vagrant::Provisioners::ChefSolo, instance.provisioner
+    end
+
+    should "expose the provisioner class if its a valid class" do
+      instance = @klass.new(@top, Vagrant::Provisioners::ChefSolo)
+      assert_equal Vagrant::Provisioners::ChefSolo, instance.provisioner
+    end
+
+    should "have a nil provisioner class if invalid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      assert_nil instance.provisioner
+    end
+
+    should "have a nil config instance if invalid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      assert_nil instance.config
+    end
+
+    should "set the top of the config object to the given top" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal @top, instance.config.top
+    end
+
+    should "configure the provisioner if valid" do
+      instance = @klass.new(@top, :chef_solo) do |chef|
+        chef.cookbooks_path = "foo"
+      end
+
+      assert_equal "foo", instance.config.cookbooks_path
+    end
+
+    should "configure the provisioner with a hash if valid" do
+      instance = @klass.new(@top, :chef_solo, :cookbooks_path => "foo")
+      assert_equal "foo", instance.config.cookbooks_path
+    end
+  end
+
+  context "validation" do
+    setup do
+      @errors = Vagrant::Config::ErrorRecorder.new
+    end
+
+    should "be invalid if provisioner is valid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if provisioner doesn't inherit from provisioners base" do
+      klass = Class.new
+      instance = @klass.new(@top, klass)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be valid with a valid provisioner" do
+      instance = @klass.new(@top, :chef_solo) do |chef|
+        chef.add_recipe "foo"
+      end
+
+      instance.validate(@errors)
+      assert @errors.errors.empty?
+    end
+
+    should "be invalid if a provisioner's config is invalid" do
+      instance = @klass.new(@top, :chef_solo)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+  end
+end

data/test/vagrant/config/vm_test.rb

@@ -0,0 +1,86 @@
+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
+
+    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
+  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
+
+  context "deprecated config" do
+    should "raise an error for provisioner=" do
+      assert_raises(Vagrant::Errors::VagrantError) {
+        @config.provisioner = :chef_solo
+      }
+    end
+  end
+end

data/test/vagrant/config_test.rb

@@ -0,0 +1,162 @@
+require "test_helper"
+
+class ConfigTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Config
+  end
+
+  context "with the class" do
+    should "allow access to the last proc" do
+      foo = mock("object")
+      foo.expects(:call).once
+
+      @klass.run { |config| foo.call }
+      value = @klass.last_proc.first
+      assert value.is_a?(Proc)
+      value.call(nil)
+
+      assert @klass.last_proc.nil?
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @instance = @klass.new
+    end
+
+    should "load the config files in the given order" do
+      names = %w{alpha beta gamma}
+
+      @instance.load_order = [:alpha, :beta]
+
+      names.each do |name|
+        vagrantfile(vagrant_box(name), "config.vm.box = '#{name}'")
+        @instance.set(name.to_sym, vagrant_box(name).join("Vagrantfile"))
+      end
+
+      config = @instance.load(nil)
+      assert_equal "beta", config.vm.box
+    end
+
+    should "load the config as procs" do
+      @instance.set(:proc, Proc.new { |config| config.vm.box = "proc" })
+      @instance.load_order = [:proc]
+      config = @instance.load(nil)
+
+      assert_equal "proc", config.vm.box
+    end
+
+    should "load an array of procs" do
+      @instance.set(:proc, [Proc.new { |config| config.vm.box = "proc" },
+                            Proc.new { |config| config.vm.box = "proc2" }])
+      @instance.load_order = [:proc]
+      config = @instance.load(nil)
+
+      assert_equal "proc2", config.vm.box
+    end
+
+    should "not care if a file doesn't exist" do
+      @instance.load_order = [:foo]
+      assert_nothing_raised { @instance.set(:foo, "i/dont/exist") }
+      assert_nothing_raised { @instance.load(nil) }
+    end
+
+    should "not reload a file" do
+      foo_path = vagrant_box("foo").join("Vagrantfile")
+
+      vagrantfile(vagrant_box("foo"))
+      @instance.set(:foo, foo_path)
+
+      # Nothing should be raised in this case because the file isn't reloaded
+      vagrantfile(vagrant_box("foo"), "^%&8318")
+      assert_nothing_raised { @instance.set(:foo, foo_path) }
+    end
+
+    should "raise an exception if there is a syntax error in a file" do
+      vagrantfile(vagrant_box("foo"), "^%&8318")
+
+      assert_raises(Vagrant::Errors::VagrantfileSyntaxError) {
+        @instance.set(:foo, vagrant_box("foo").join("Vagrantfile"))
+      }
+    end
+  end
+
+  context "top config class" do
+    setup do
+      @configures_list = {}
+      @klass::Top.stubs(:configures_list).returns(@configures_list)
+    end
+
+    context "adding configure keys" do
+      setup do
+        @key = "top_config_foo"
+        @config_klass = mock("klass")
+      end
+
+      should "add key and klass to configures list" do
+        @klass::Top.configures(@key, @config_klass)
+        assert_equal @config_klass, @configures_list[@key]
+      end
+    end
+
+    context "configuration keys on instance" do
+      setup do
+        @configures_list.clear
+      end
+
+      should "initialize each configurer and set it to its key" do
+        env = mock('env')
+
+        5.times do |i|
+          key = "key#{i}"
+          klass = mock("klass#{i}")
+          instance = mock("instance#{i}")
+          instance.expects(:top=).with() do |top|
+            assert top.is_a?(@klass::Top)
+            true
+          end
+          klass.expects(:new).returns(instance)
+          @configures_list[key] = klass
+        end
+
+        @klass::Top.new(env)
+      end
+
+      should "allow reading via methods" do
+        key = "my_foo_bar_key"
+        klass = mock("klass")
+        instance = mock("instance")
+        instance.stubs(:top=)
+        klass.expects(:new).returns(instance)
+        @klass::Top.configures(key, klass)
+
+        config = @klass::Top.new
+        assert_equal instance, config.send(key)
+      end
+    end
+
+    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 "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
+
+        @klass::Top.configures(:subconfig, invalid_class)
+        instance = @klass::Top.new
+
+        assert_raises(Vagrant::Errors::ConfigValidationFailed) {
+          instance.validate!
+        }
+      end
+    end
+  end
+end

data/test/vagrant/data_store_test.rb

@@ -0,0 +1,77 @@
+require "fileutils"
+require "test_helper"
+
+class DataStoreTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::DataStore
+    @initial_data = { "foo" => "bar" }
+    @db_file = File.join(tmp_path, "data_store_test")
+    File.open(@db_file, "w") { |f| f.write(@initial_data.to_json) }
+
+    @instance = @klass.new(@db_file)
+  end
+
+  teardown do
+    File.delete(@db_file) if File.exist?(@db_file)
+  end
+
+  should "raise an exception if the db file is a directory" do
+    file = tmp_path.join("data_store_folder_test")
+    FileUtils.mkdir_p(file)
+    assert_raises (Vagrant::Errors::DotfileIsDirectory) {
+      @klass.new(file)
+    }
+  end
+
+  should "be a hash with indifferent access" do
+    assert @instance.is_a?(Vagrant::Util::HashWithIndifferentAccess)
+  end
+
+  should "just be an empty hash if file doesn't exist" do
+    assert @klass.new("NEvERNENVENRNE").empty?
+  end
+
+  should "read the data" do
+    assert_equal @initial_data["foo"], @instance[:foo]
+  end
+
+  should "read the data by stringifying keys" do
+    @instance[:bar] = { "baz" => "yay" }
+    @instance.commit
+    @instance = @klass.new(@db_file)
+    assert_equal "yay", @instance[:bar]["baz"]
+  end
+
+  should "write the data, but not save it right away" do
+    @instance[:foo] = "changed"
+    assert_equal "changed", @instance[:foo]
+    assert_equal @initial_data["foo"], @klass.new(@db_file)["foo"]
+  end
+
+  should "write the data if commit is called" do
+    @instance[:foo] = "changed"
+    @instance.commit
+
+    assert_equal "changed", @klass.new(@db_file)[:foo]
+  end
+
+  should "delete the data store file if the hash is empty" do
+    @instance[:foo] = :bar
+    @instance.commit
+    assert File.exist?(@db_file)
+
+    @instance.clear
+    assert @instance.empty?
+    @instance.commit
+    assert !File.exist?(@db_file)
+  end
+
+  should "clean nil and empties if commit is called" do
+    @instance[:foo] = { :bar => nil }
+    @instance[:bar] = {}
+    @instance.commit
+
+    assert !@instance.has_key?(:foo)
+    assert !@instance.has_key?(:bar)
+  end
+end