vagrantup 0.1.4 → 0.2.0

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/base_test.rb

@@ -11,6 +11,13 @@ class BaseDownloaderTest < Test::Unit::TestCase
     end
 
     should "implement prepare which does nothing" do
+      assert_nothing_raised do
+        assert @base.respond_to?(:prepare)
+        @base.prepare("source")
+      end
+    end
+
+    should "implement download! which does nothing" do
       assert_nothing_raised do
         assert @base.respond_to?(:download!)
         @base.download!("source", "destination")

data/test/vagrant/downloaders/file_test.rb

@@ -6,26 +6,20 @@ class FileDownloaderTest < Test::Unit::TestCase
     @uri = "foo.box"
   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)
+  context "preparing" do
+    should "raise an exception if the file does not exist" do
+      File.expects(:file?).with(@uri).returns(false)
+      assert_raises(Vagrant::Actions::ActionException) {
+        @downloader.prepare(@uri)
+      }
     end
+  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)
+  context "downloading" do
+    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