vagrant 0.1.4 → 0.2.0.pre

data/test/vagrant/config_test.rb

@@ -1,6 +1,23 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class ConfigTest < Test::Unit::TestCase
+  context "the ssh config" do
+    should "expand any path when requesting the value" do
+      Vagrant::Env.stubs(:root_path).returns('foo')
+      File.stubs(:expand_path).with(Vagrant.config.ssh[:private_key_path], 'foo').returns('success')
+      assert Vagrant.config.ssh.private_key_path, 'success'
+    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)
+    end
+  end
+
   context "resetting" do
     setup do
       Vagrant::Config.run { |config| }
@@ -18,10 +35,10 @@ class ConfigTest < Test::Unit::TestCase
       assert !config.equal?(Vagrant::Config.config)
     end
 
-    should "empty the runners" do
-      assert !Vagrant::Config.config_runners.empty?
+    should "empty the proc stack" do
+      assert !Vagrant::Config.proc_stack.empty?
       Vagrant::Config.reset!
-      assert Vagrant::Config.config_runners.empty?
+      assert Vagrant::Config.proc_stack.empty?
     end
   end
 
@@ -37,30 +54,18 @@ class ConfigTest < Test::Unit::TestCase
   end
 
   context "initializing" do
-    teardown do
-      Vagrant::Config.instance_variable_set(:@config_runners, nil)
-      Vagrant::Config.instance_variable_set(:@config, nil)
-    end
-
-    should "not run the blocks right away" do
-      obj = mock("obj")
-      obj.expects(:foo).never
-      Vagrant::Config.run { |config| obj.foo }
-      Vagrant::Config.run { |config| obj.foo }
-      Vagrant::Config.run { |config| obj.foo }
+    setup do
+      Vagrant::Config.reset!
     end
 
-    should "run the blocks when execute! is ran" do
-      obj = mock("obj")
-      obj.expects(:foo).times(2)
-      Vagrant::Config.run { |config| obj.foo }
-      Vagrant::Config.run { |config| obj.foo }
-      Vagrant::Config.execute!
+    should "add the given block to the proc stack" do
+      proc = Proc.new {}
+      Vagrant::Config.run(&proc)
+      assert_equal [proc], Vagrant::Config.proc_stack
     end
 
-    should "run the blocks with the same config object" do
-      Vagrant::Config.run { |config| assert config }
-      Vagrant::Config.run { |config| assert config }
+    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
 
@@ -109,15 +114,126 @@ class ConfigTest < Test::Unit::TestCase
     end
   end
 
-  context "chef config" do
+  context "top config class" do
     setup do
-      @config = Vagrant::Config::ChefConfig.new
-      @config.json = "HEY"
+      @configures_list = []
+      Vagrant::Config::Top.stubs(:configures_list).returns(@configures_list)
     end
 
-    should "not include the 'json' key in the config dump" do
-      result = JSON.parse(@config.to_json)
-      assert !result.has_key?("json")
+    context "adding configure keys" do
+      setup do
+        @key = "top_config_foo"
+        @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)
+      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
+        5.times do |i|
+          key = "key#{i}"
+          klass = mock("klass#{i}")
+          instance = mock("instance#{i}")
+          klass.expects(:new).returns(instance)
+          @configures_list << [key, klass]
+        end
+
+        Vagrant::Config::Top.new
+      end
+
+      should "allow reading via methods" do
+        key = "my_foo_bar_key"
+        klass = mock("klass")
+        instance = mock("instance")
+        klass.expects(:new).returns(instance)
+        Vagrant::Config::Top.configures(key, klass)
+
+        config = Vagrant::Config::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?
+      end
+
+      should "be loaded after calling loaded!" do
+        @top.loaded!
+        assert @top.loaded?
+      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
+      @config = Vagrant::Config::VMConfig.new
+      @username = "bob"
+
+      mock_config do |config|
+        config.ssh.username = @username
+      end
+    end
+
+    should "include the stacked proc runner module" do
+      assert @config.class.included_modules.include?(Vagrant::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
+
+    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
 end

data/test/vagrant/downloaders/file_test.rb

@@ -7,25 +7,10 @@ class FileDownloaderTest < Test::Unit::TestCase
   end
 
   context "downloading" do
-    setup do
-      @file = mock("file")
-      @file.stubs(:read)
-      @file.stubs(:eof?).returns(false)
-      @downloader.stubs(:open).yields(@file)
-    end
-
-    should "open with the given uri" do
-      @downloader.expects(:open).with(@uri).once
-      @downloader.download!(@uri, @tempfile)
-    end
-
-    should "buffer the read from the file and write to the tempfile" do
-      data = mock("data")
-      write_seq = sequence("write_seq")
-      @file.stubs(:eof?).returns(false).in_sequence(write_seq)
-      @file.expects(:read).returns(data).in_sequence(write_seq)
-      @tempfile.expects(:write).with(data).in_sequence(write_seq)
-      @file.stubs(:eof?).returns(true).in_sequence(write_seq)
+    should "cp the file" do
+      path = '/path'
+      @tempfile.expects(:path).returns(path)
+      FileUtils.expects(:cp).with(@uri, path)
       @downloader.download!(@uri, @tempfile)
     end
   end

data/test/vagrant/env_test.rb

@@ -15,6 +15,24 @@ class EnvTest < Test::Unit::TestCase
     Vagrant::Box.stubs(:find).returns("foo")
   end
 
+  context "checking virtualbox version" do
+    setup do
+      VirtualBox::Command.stubs(:version)
+    end
+
+    should "error and exit if VirtualBox is not installed or detected" do
+      Vagrant::Env.expects(:error_and_exit).once
+      VirtualBox::Command.expects(:version).returns(nil)
+      Vagrant::Env.check_virtualbox!
+    end
+
+    should "error and exit if VirtualBox is lower than version 3.1" do
+      Vagrant::Env.expects(:error_and_exit).once
+      VirtualBox::Command.expects(:version).returns("3.0.12r1041")
+      Vagrant::Env.check_virtualbox!
+    end
+  end
+
   context "requiring a VM" do
     setup do
       Vagrant::Env.stubs(:require_root_path)
@@ -89,6 +107,20 @@ class EnvTest < Test::Unit::TestCase
       Vagrant::Env.load_config!
     end
 
+    should "load from the home directory" do
+      File.expects(:exist?).with(File.join(Vagrant::Env.home_path, Vagrant::Env::ROOTFILE_NAME)).once
+      Vagrant::Env.load_config!
+    end
+
+    should "not load from the home directory if the home config is nil" do
+      mock_config do |config|
+        config.vagrant.home = nil
+      end
+
+      File.expects(:exist?).with(File.join(Vagrant::Env.home_path, Vagrant::Env::ROOTFILE_NAME)).never
+      Vagrant::Env.load_config!
+    end
+
     should "not load from the root path if nil" do
       Vagrant::Env.stubs(:root_path).returns(nil)
       File.expects(:exist?).with(File.join(@root_path, Vagrant::Env::ROOTFILE_NAME)).never
@@ -129,29 +161,69 @@ class EnvTest < Test::Unit::TestCase
   end
 
   context "initial load" do
-    test "load! should load the config and set the persisted_uid" do
-      Vagrant::Env.expects(:load_config!).once
-      Vagrant::Env.expects(:load_vm!).once
-      Vagrant::Env.expects(:load_root_path!).once
-      Vagrant::Env.expects(:load_home_directory!).once
-      Vagrant::Env.expects(:load_box!).once
+    should "load! should load the config and set the persisted_uid" do
+      call_seq = sequence("call_sequence")
+      Vagrant::Env.expects(:load_root_path!).once.in_sequence(call_seq)
+      Vagrant::Env.expects(:load_config!).once.in_sequence(call_seq)
+      Vagrant::Env.expects(:load_home_directory!).once.in_sequence(call_seq)
+      Vagrant::Env.expects(:load_box!).once.in_sequence(call_seq)
+      Vagrant::Env.expects(:load_config!).once.in_sequence(call_seq)
+      Vagrant::Env.expects(:check_virtualbox!).once.in_sequence(call_seq)
+      Vagrant::Env.expects(:load_vm!).once.in_sequence(call_seq)
       Vagrant::Env.load!
     end
   end
 
   context "persisting the VM into a file" do
     setup do
-      mock_config
-    end
+      @vm = mock("vm")
+      @vm.stubs(:uuid).returns("foo")
 
-    test "should save it to the dotfile path" do
-      vm = mock("vm")
-      vm.stubs(:uuid).returns("foo")
+      File.stubs(:open)
+      Vagrant::ActiveList.stubs(:add)
+    end
 
+    should "should save it to the dotfile path" do
       filemock = mock("filemock")
-      filemock.expects(:write).with(vm.uuid)
+      filemock.expects(:write).with(@vm.uuid)
       File.expects(:open).with(Vagrant::Env.dotfile_path, 'w+').once.yields(filemock)
-      Vagrant::Env.persist_vm(vm)
+      Vagrant::Env.persist_vm(@vm)
+    end
+
+    should "add the VM to the activelist" do
+      Vagrant::ActiveList.expects(:add).with(@vm)
+      Vagrant::Env.persist_vm(@vm)
+    end
+  end
+
+  context "depersisting the VM" do
+    setup do
+      File.stubs(:exist?).returns(false)
+      File.stubs(:delete)
+
+      Vagrant::ActiveList.stubs(:remove)
+
+      @dotfile_path = "foo"
+      Vagrant::Env.stubs(:dotfile_path).returns(@dotfile_path)
+
+      @vm = mock("vm")
+    end
+
+    should "remove the dotfile if it exists" do
+      File.expects(:exist?).with(Vagrant::Env.dotfile_path).returns(true)
+      File.expects(:delete).with(Vagrant::Env.dotfile_path).once
+      Vagrant::Env.depersist_vm(@vm)
+    end
+
+    should "not remove the dotfile if it doesn't exist" do
+      File.expects(:exist?).returns(false)
+      File.expects(:delete).never
+      Vagrant::Env.depersist_vm(@vm)
+    end
+
+    should "remove from the active list" do
+      Vagrant::ActiveList.expects(:remove).with(@vm)
+      Vagrant::Env.depersist_vm(@vm)
     end
   end
 
@@ -191,7 +263,7 @@ class EnvTest < Test::Unit::TestCase
   context "loading the root path" do
     should "default the path to the pwd if nil" do
       @path = mock("path")
-      @path.stubs(:to_s).returns("/")
+      @path.stubs(:root?).returns(true)
       Pathname.expects(:new).with(Dir.pwd).returns(@path)
       Vagrant::Env.load_root_path!(nil)
     end
@@ -199,7 +271,9 @@ class EnvTest < Test::Unit::TestCase
     should "not default the path to pwd if its not nil" do
       @path = mock("path")
       @path.stubs(:to_s).returns("/")
-      Pathname.expects(:new).never
+      File.expects(:expand_path).with(@path).returns("/")
+      Pathname.expects(:new).with("/").returns(@path)
+      @path.stubs(:root?).returns(true)
       Vagrant::Env.load_root_path!(@path)
     end
 
@@ -224,8 +298,13 @@ class EnvTest < Test::Unit::TestCase
     end
 
     should "return false if not found on windows-style root" do
-      path = Pathname.new("C:.")
-      assert !Vagrant::Env.load_root_path!(path)
+      # TODO: Is there _any_ way to test this on unix machines? The
+      # expand path doesn't work [properly for the test] on unix machines.
+      if RUBY_PLATFORM.downcase.include?("mswin")
+        # Note the escaped back slash
+        path = Pathname.new("C:\\")
+        assert !Vagrant::Env.load_root_path!(path)
+      end
     end
 
     should "should set the path for the rootfile" do
@@ -283,12 +362,6 @@ class EnvTest < Test::Unit::TestCase
       Vagrant::Env.load_box!
       assert @box.equal?(Vagrant::Env.box)
     end
-
-    should "load the config if a box is loaded" do
-      Vagrant::Env.expects(:load_config!).once
-      Vagrant::Box.expects(:find).returns(@box)
-      Vagrant::Env.load_box!
-    end
   end
 
   context "requiring boxes" do

data/test/vagrant/provisioners/base_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class BaseProvisionerTest < Test::Unit::TestCase
+  should "include the util class so subclasses have access to it" do
+    assert Vagrant::Provisioners::Base.include?(Vagrant::Util)
+  end
+
+  context "base instance" do
+    setup do
+      @base = Vagrant::Provisioners::Base.new
+    end
+
+    should "implement provision! which does nothing" do
+      assert_nothing_raised do
+        assert @base.respond_to?(:provision!)
+        @base.provision!
+      end
+    end
+
+    should "implement prepare which does nothing" do
+      assert_nothing_raised do
+        assert @base.respond_to?(:prepare)
+        @base.prepare
+      end
+    end
+  end
+end

data/test/vagrant/provisioners/chef_server_test.rb

@@ -0,0 +1,175 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ChefServerProvisionerTest < Test::Unit::TestCase
+  setup do
+    @action = Vagrant::Provisioners::ChefServer.new
+
+    Vagrant::SSH.stubs(:execute)
+    Vagrant::SSH.stubs(:upload!)
+
+    mock_config
+  end
+
+  context "provisioning" do
+    should "run the proper sequence of methods in order" do
+      prov_seq = sequence("prov_seq")
+      @action.expects(:chown_provisioning_folder).once.in_sequence(prov_seq)
+      @action.expects(:create_client_key_folder).once.in_sequence(prov_seq)
+      @action.expects(:upload_validation_key).once.in_sequence(prov_seq)
+      @action.expects(:setup_json).once.in_sequence(prov_seq)
+      @action.expects(:setup_config).once.in_sequence(prov_seq)
+      @action.expects(:run_chef_client).once.in_sequence(prov_seq)
+      @action.provision!
+    end
+  end
+
+  context "preparing" do
+    setup do
+      File.stubs(:file?).returns(true)
+    end
+
+    should "not raise an exception if validation_key_path is set" do
+      mock_config do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an exception if validation_key_path is nil" do
+      mock_config do |config|
+        config.chef.validation_key_path = nil
+      end
+
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "not raise an exception if validation_key_path does exist" do
+      mock_config do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      File.expects(:file?).with(Vagrant.config.chef.validation_key_path).returns(true)
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an exception if validation_key_path doesn't exist" do
+      mock_config do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      File.expects(:file?).with(Vagrant.config.chef.validation_key_path).returns(false)
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "not raise an exception if chef_server_url is set" do
+      mock_config do |config|
+        config.chef.chef_server_url = "7"
+      end
+
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an exception if chef_server_url is nil" do
+      mock_config do |config|
+        config.chef.chef_server_url = nil
+      end
+
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+  end
+
+  context "creating the client key folder" do
+    setup do
+      @raw_path = "/foo/bar/baz.pem"
+      mock_config do |config|
+        config.chef.client_key_path = @raw_path
+      end
+
+      @path = Pathname.new(@raw_path)
+    end
+
+    should "create the folder using the dirname of the path" do
+      ssh = mock("ssh")
+      ssh.expects(:exec!).with("sudo mkdir -p #{@path.dirname}").once
+      Vagrant::SSH.expects(:execute).yields(ssh)
+      @action.create_client_key_folder
+    end
+  end
+
+  context "uploading the validation key" do
+    should "upload the validation key to the provisioning path" do
+      @action.expects(:validation_key_path).once.returns("foo")
+      @action.expects(:guest_validation_key_path).once.returns("bar")
+      Vagrant::SSH.expects(:upload!).with("foo", "bar").once
+      @action.upload_validation_key
+    end
+  end
+
+  context "the validation key path" do
+    should "expand the configured key path" do
+      result = mock("result")
+      File.expects(:expand_path).with(Vagrant.config.chef.validation_key_path, Vagrant::Env.root_path).once.returns(result)
+      assert_equal result, @action.validation_key_path
+    end
+  end
+
+  context "the guest validation key path" do
+    should "be the provisioning path joined with validation.pem" do
+      result = mock("result")
+      File.expects(:join).with(Vagrant.config.chef.provisioning_path, "validation.pem").once.returns(result)
+      assert_equal result, @action.guest_validation_key_path
+    end
+  end
+
+  context "generating and uploading chef client configuration file" do
+    setup do
+      @action.stubs(:guest_validation_key_path).returns("foo")
+    end
+
+    should "upload properly generate the configuration file using configuration data" do
+      expected_config = <<-config
+log_level          :info
+log_location       STDOUT
+ssl_verify_mode    :verify_none
+chef_server_url    "#{Vagrant.config.chef.chef_server_url}"
+
+validation_client_name "#{Vagrant.config.chef.validation_client_name}"
+validation_key         "#{@action.guest_validation_key_path}"
+client_key             "#{Vagrant.config.chef.client_key_path}"
+
+file_store_path    "/srv/chef/file_store"
+file_cache_path    "/srv/chef/cache"
+
+pid_file           "/var/run/chef/chef-client.pid"
+
+Mixlib::Log::Formatter.show_time = true
+config
+
+      StringIO.expects(:new).with(expected_config).once
+      @action.setup_config
+    end
+
+    should "upload this file as client.rb to the provisioning folder" do
+      StringIO.expects(:new).returns("foo")
+      File.expects(:join).with(Vagrant.config.chef.provisioning_path, "client.rb").once.returns("bar")
+      Vagrant::SSH.expects(:upload!).with("foo", "bar").once
+      @action.setup_config
+    end
+  end
+
+  context "running chef client" do
+    should "cd into the provisioning directory and run chef client" do
+      ssh = mock("ssh")
+      ssh.expects(:exec!).with("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json").once
+      Vagrant::SSH.expects(:execute).yields(ssh)
+      @action.run_chef_client
+    end
+  end
+end