vagrant 0.5.4 → 0.6.0

data/test/vagrant/systems/linux_test.rb

@@ -4,7 +4,7 @@ class LinuxSystemTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Systems::Linux
     @ssh = mock("ssh")
-    @mock_env = mock_environment
+    @mock_env = vagrant_env
     @vm = mock("vm")
     @vm.stubs(:env).returns(@mock_env)
     @instance = @klass.new(@vm)
@@ -43,71 +43,6 @@ class LinuxSystemTest < Test::Unit::TestCase
     end
   end
 
-  context "preparing unison" do
-    setup do
-      @ssh.stubs(:exec!)
-      @ssh.stubs(:upload!)
-      @vm.stubs(:ssh).returns(@ssh)
-    end
-
-    should "upload the script" do
-      @vm.ssh.expects(:upload!).with do |script, path|
-        assert_equal @mock_env.config.unison.script, path
-        true
-      end
-
-      @instance.prepare_unison(@ssh)
-    end
-
-    should "make the script executable" do
-      @ssh.expects(:exec!).with("sudo chmod +x #{@mock_env.config.unison.script}").once
-      @instance.prepare_unison(@ssh)
-    end
-
-    should "remove old crontab entry file" do
-      @ssh.expects(:exec!).with("sudo rm #{@mock_env.config.unison.crontab_entry_file}", :error_check => false).once
-      @instance.prepare_unison(@ssh)
-    end
-  end
-
-  context "creating unison entry" do
-    setup do
-      @ssh.stubs(:exec!)
-      @options = {
-        :guestpath => "foo",
-        :original => { :guestpath => "bar!" }
-      }
-    end
-
-    should "render the crontab entry with proper variables" do
-      variables = {
-        :from => @options[:guestpath],
-        :to => @options[:original][:guestpath],
-        :options => @mock_env.config.unison.options,
-        :script => @mock_env.config.unison.script,
-        :log_file => @mock_env.config.unison.log_file % "bar-"
-      }
-      Vagrant::Util::TemplateRenderer.expects(:render).with('/unison/crontab_entry',
-                                                            variables).once
-      @instance.create_unison(@ssh, @options)
-    end
-
-    should "remove the .unison directory" do
-      @ssh.expects(:exec!).with("sudo rm -rf ~/.unison")
-      @instance.create_unison(@ssh, @options)
-    end
-
-    should "remove the original guestpath" do
-      @ssh.expects(:exec!).with("sudo rm -rf #{@options[:original][:guestpath]}")
-      @instance.create_unison(@ssh, @options)
-    end
-
-    should "enable the crontab file" do
-      @ssh.expects(:exec!).with("crontab #{@mock_env.config.unison.crontab_entry_file}")
-      @instance.create_unison(@ssh, @options)
-    end
-  end
-
   #-------------------------------------------------------------------
   # "Private" methods tests
   #-------------------------------------------------------------------
@@ -149,7 +84,7 @@ class LinuxSystemTest < Test::Unit::TestCase
     should "raise an ActionException if the command fails constantly" do
       @ssh.expects(:exec!).times(@limit).returns(!@success_return)
 
-      assert_raises(Vagrant::Action::ActionException) {
+      assert_raises(Vagrant::Systems::Linux::LinuxError) {
         mount_folder
       }
     end
@@ -165,10 +100,10 @@ class LinuxSystemTest < Test::Unit::TestCase
     should "add uid AND gid to mount" do
       uid = "foo"
       gid = "bar"
-      env = mock_environment do |config|
-        config.vm.shared_folder_uid = uid
-        config.vm.shared_folder_gid = gid
-      end
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.shared_folder_uid = "#{uid}"
+        config.vm.shared_folder_gid = "#{gid}"
+      vf
 
       @vm.stubs(:env).returns(env)
 

data/test/vagrant/ui_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+class ShellUITest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::UI::Shell
+    @shell = mock("shell")
+    @instance = @klass.new(vagrant_env, @shell)
+  end
+
+  context "prefixing with resource" do
+    should "prefix message with environment resource" do
+      @shell.expects(:say).with() do |message, color|
+        assert message =~ /\[#{@instance.env.resource}\]/
+        true
+      end
+
+      @instance.info("vagrant.errors.test_key")
+    end
+
+    should "not prefix the message if given false" do
+      @shell.expects(:say).with() do |message, color|
+        assert message !~ /\[#{@instance.env.resource}\]/
+        true
+      end
+
+      @instance.info("vagrant.errors.test_key", :prefix => false)
+    end
+  end
+end

data/test/vagrant/util/hash_with_indifferent_access_test.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+
+class HashWithIndifferentAccessUtilTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Util::HashWithIndifferentAccess
+    @instance = @klass.new
+  end
+
+  should "be a hash" do
+    assert @instance.is_a?(Hash)
+  end
+
+  should "allow indifferent access when setting with a string" do
+    @instance["foo"] = "bar"
+    assert_equal "bar", @instance[:foo]
+  end
+
+  should "allow indifferent access when setting with a symbol" do
+    @instance[:foo] = "bar"
+    assert_equal "bar", @instance["foo"]
+  end
+
+  should "allow indifferent key lookup" do
+    @instance["foo"] = "bar"
+    assert @instance.key?(:foo)
+    assert @instance.has_key?(:foo)
+    assert @instance.include?(:foo)
+    assert @instance.member?(:foo)
+  end
+
+  should "forward up block to Hash if given to initializer" do
+    instance = @klass.new do |h,k|
+      h[k] = "foo"
+    end
+
+    assert_equal "foo", instance[:foo]
+    assert_equal "foo", instance["foo"]
+  end
+end

data/test/vagrant/util/resource_logger_test.rb

@@ -12,34 +12,29 @@ class ResourceLoggerUtilTest < Test::Unit::TestCase
       @result = mock("result")
     end
 
-    should "return a nil plain logger if no environment is given" do
-      Vagrant::Util::PlainLogger.expects(:new).with(nil).returns(@result)
-      assert_equal @result, @klass.singleton_logger
-    end
-
-    should "return a nil plain logger if the config is not loaded" do
-      env = mock_environment
-      env.config.stubs(:loaded?).returns(false)
+    should "return a nil plain logger if the environment is not loaded" do
+      env = vagrant_env
+      env.stubs(:loaded?).returns(false)
 
       Vagrant::Util::PlainLogger.expects(:new).with(nil).returns(@result)
       assert_equal @result, @klass.singleton_logger(env)
     end
 
-    should "return a logger with the specified output if environment is ready" do
-      output = mock("output")
-      env = mock_environment
-      env.config.vagrant.log_output = output
+    should "return a logger with the output file set if environment is ready" do
+      env = vagrant_env
+
+      Vagrant::Util::PlainLogger.expects(:new).returns(@result).with() do |path|
+        assert path.to_s =~ /logs/
+        true
+      end
 
-      Vagrant::Util::PlainLogger.expects(:new).with(output).returns(@result)
       assert_equal @result, @klass.singleton_logger(env)
     end
 
     should "only load the logger once" do
-      output = mock("output")
-      env = mock_environment
-      env.config.vagrant.log_output = output
+      env = vagrant_env
 
-      Vagrant::Util::PlainLogger.expects(:new).with(output).returns(@result)
+      Vagrant::Util::PlainLogger.expects(:new).with(anything).returns(@result)
       assert_equal @result, @klass.singleton_logger(env)
       assert_equal @result, @klass.singleton_logger(env)
       assert_equal @result, @klass.singleton_logger(env)
@@ -48,7 +43,7 @@ class ResourceLoggerUtilTest < Test::Unit::TestCase
 
   context "initialization" do
     should "setup the logger and attributes" do
-      env = mock_environment
+      env = vagrant_env
       resource = mock("resource")
       result = mock("result")
 
@@ -63,7 +58,7 @@ class ResourceLoggerUtilTest < Test::Unit::TestCase
   context "with an instance" do
     setup do
       @resource = "foo"
-      @env = mock_environment
+      @env = vagrant_env
       @logger = mock("logger")
 
       @klass.stubs(:singleton_logger).returns(@logger)
@@ -71,11 +66,6 @@ class ResourceLoggerUtilTest < Test::Unit::TestCase
     end
 
     context "logging methods" do
-      setup do
-        @instance.stubs(:flush_progress)
-        @instance.stubs(:cl_reset).returns("")
-      end
-
       [:debug, :info, :error, :fatal].each do |method|
         should "log with the proper format on #{method}" do
           message = "bar"
@@ -84,62 +74,5 @@ class ResourceLoggerUtilTest < Test::Unit::TestCase
         end
       end
     end
-
-    context "reporting progress" do
-      setup do
-        @instance.stubs(:flush_progress)
-      end
-
-      should "flush progress" do
-        @instance.expects(:flush_progress).once
-        @instance.report_progress(72, 100)
-      end
-
-      should "add the reporter to the progress reporters" do
-        @instance.report_progress(72, 100)
-        assert @klass.progress_reporters.has_key?(@instance.resource)
-      end
-    end
-
-    context "clearing progress" do
-      setup do
-        @instance.stubs(:flush_progress)
-
-        @klass.progress_reporters.clear
-        @instance.report_progress(72, 100)
-      end
-
-      should "remove the key from the reporters" do
-        assert @klass.progress_reporters.has_key?(@instance.resource)
-        @instance.clear_progress
-        assert !@klass.progress_reporters.has_key?(@instance.resource)
-      end
-    end
-
-    context "command line reset" do
-      setup do
-        Mario::Platform.logger(nil)
-      end
-
-      context "on windows" do
-        setup do
-          Mario::Platform.forced = Mario::Platform::Windows7
-        end
-
-        should "just return \\r for the clear screen" do
-          assert_equal  "\r", @instance.cl_reset
-        end
-      end
-
-      context "on other platforms" do
-        setup do
-          Mario::Platform.forced = Mario::Platform::Linux
-        end
-
-        should "return the full clear screen" do
-          assert_equal "\r\e[0K", @instance.cl_reset
-        end
-      end
-    end
   end
 end

data/test/vagrant/util/retryable_test.rb

@@ -0,0 +1,38 @@
+require "test_helper"
+
+class RetryableUtilTest < Test::Unit::TestCase
+  setup do
+    @klass = Class.new do
+      extend Vagrant::Util::Retryable
+    end
+  end
+
+  should "retry specified number of times if exception is raised" do
+    proc = mock("proc")
+    proc.expects(:call).twice
+
+    assert_raises(RuntimeError) {
+      @klass.retryable(:tries => 2, :on => RuntimeError) do
+        proc.call
+        raise "An error"
+      end
+    }
+  end
+
+  should "only retry on specified exception" do
+    proc = mock("proc")
+    proc.expects(:call).once
+
+    assert_raises(StandardError) {
+      @klass.retryable(:tries => 5, :on => RuntimeError) do
+        proc.call
+        raise StandardError.new
+      end
+    }
+  end
+
+  should "return the value of the block" do
+    result = @klass.retryable { 7 }
+    assert_equal 7, result
+  end
+end

data/test/vagrant/util/template_renderer_test.rb

@@ -73,14 +73,14 @@ class TemplateRendererUtilTest < Test::Unit::TestCase
     end
 
     should "be the ERB file in the templates directory" do
-      result = File.join(PROJECT_ROOT, "templates", "#{@template}.erb")
-      assert_equal result, @r.full_template_path
+      result = Vagrant.source_root.join("templates", "#{@template}.erb")
+      assert_equal result.to_s, @r.full_template_path
     end
 
     should "remove duplicate path separators" do
       @r.template = "foo///bar"
-      result = File.join(PROJECT_ROOT, "templates", "foo", "bar.erb")
-      assert_equal result, @r.full_template_path
+      result = Vagrant.source_root.join("templates", "foo", "bar.erb")
+      assert_equal result.to_s, @r.full_template_path
     end
   end
 

data/test/vagrant/vm_test.rb

@@ -2,12 +2,7 @@ require "test_helper"
 
 class VMTest < Test::Unit::TestCase
   setup do
-    @mock_vm = mock("vm")
-
-    @persisted_vm = mock("persisted_vm")
-
-    @env = mock_environment
-    @env.stubs(:vm).returns(@persisted_vm)
+    @env = vagrant_env
 
     Net::SSH.stubs(:start)
   end
@@ -22,7 +17,7 @@ class VMTest < Test::Unit::TestCase
 
     should "return a Vagrant::VM object for that VM if found" do
       VirtualBox::VM.expects(:find).with("foo").returns("bar")
-      result = Vagrant::VM.find("foo", mock_environment)
+      result = Vagrant::VM.find("foo", @env)
       assert result.is_a?(Vagrant::VM)
       assert_equal "bar", result.vm
     end
@@ -31,7 +26,8 @@ class VMTest < Test::Unit::TestCase
   context "vagrant VM instance" do
     setup do
       @vm_name = "foo"
-      @vm = Vagrant::VM.new(:env => @env, :vm => @mock_vm, :vm_name => @vm_name)
+      @mock_vm = mock("vm")
+      @vm = Vagrant::VM.new(:env => @env, :vm => @mock_vm, :name => @vm_name)
       @mock_vm.stubs(:uuid).returns("foo")
     end
 
@@ -47,6 +43,35 @@ class VMTest < Test::Unit::TestCase
       end
     end
 
+    context "setting the VM" do
+      setup do
+        @raw_vm = mock("vm")
+        @raw_vm.stubs(:uuid).returns("foobar")
+      end
+
+      should "set the VM" do
+        @vm.vm = @raw_vm
+        assert_equal @raw_vm, @vm.vm
+      end
+
+      should "add the VM to the active list" do
+        assert @env.local_data.empty?
+        @vm.vm = @raw_vm
+        assert_equal @raw_vm.uuid, @env.local_data[:active][@vm.name.to_s]
+      end
+
+      should "remove the VM from the active list if nil is given" do
+        @env.local_data[:active] = { @vm.name.to_s => "foo" }
+
+        assert @env.local_data[:active].has_key?(@vm.name.to_s) # sanity
+        @vm.vm = nil
+
+        # This becomes empty because vm= will commit the local data which
+        # actually prunes out the empty values.
+        assert @env.local_data.empty?
+      end
+    end
+
     context "accessing the SSH object" do
       setup do
         # Reset this to nil to force the reload
@@ -56,25 +81,21 @@ class VMTest < Test::Unit::TestCase
         Vagrant::SSH.stubs(:new).returns(@ssh)
       end
 
-      should "load it the first time" do
+      should "load it the first time, and only load it once" do
         Vagrant::SSH.expects(:new).with(@vm.env).once.returns(@ssh)
         @vm.ssh
         @vm.ssh
         @vm.ssh
       end
-
-      should "use the same value once its loaded" do
-        result = @vm.ssh
-        assert_equal result, @vm.ssh
-      end
     end
 
     context "loading associated system" do
       should "error and exit if system is not specified" do
         @vm.env.config.vm.system = nil
 
-        @vm.expects(:error_and_exit).with(:system_unspecified).once
-        @vm.load_system!
+        assert_raises(Vagrant::Errors::VMSystemError) {
+          @vm.load_system!
+        }
       end
 
       context "with a class" do
@@ -85,16 +106,15 @@ class VMTest < Test::Unit::TestCase
         should "initialize class if given" do
           @vm.env.config.vm.system = Vagrant::Systems::Linux
 
-          @vm.expects(:error_and_exit).never
-          @vm.load_system!
-
+          assert_nothing_raised { @vm.load_system!}
           assert @vm.system.is_a?(Vagrant::Systems::Linux)
         end
 
-        should "error and exit if class has invalid parent" do
+        should "raise error if class has invalid parent" do
           @vm.env.config.vm.system = FakeSystemClass
-          @vm.expects(:error_and_exit).with(:system_invalid_class, :system => @vm.env.config.vm.system.to_s).once
-          @vm.load_system!
+          assert_raises(Vagrant::Errors::VMSystemError) {
+            @vm.load_system!
+          }
         end
       end
 
@@ -106,9 +126,8 @@ class VMTest < Test::Unit::TestCase
 
           valid.each do |symbol, klass|
             @vm.env.config.vm.system = symbol
-            @vm.expects(:error_and_exit).never
-            @vm.load_system!
 
+            assert_nothing_raised { @vm.load_system! }
             assert @vm.system.is_a?(klass)
             assert_equal @vm, @vm.system.vm
           end
@@ -116,8 +135,10 @@ class VMTest < Test::Unit::TestCase
 
         should "error and exit with invalid symbol" do
           @vm.env.config.vm.system = :shall_never_exist
-          @vm.expects(:error_and_exit).with(:system_unknown_type, :system => @vm.env.config.vm.system.to_s).once
-          @vm.load_system!
+
+          assert_raises(Vagrant::Errors::VMSystemError) {
+            @vm.load_system!
+          }
         end
       end
     end