vagrant 0.3.4 → 0.4.0

data/templates/sync.erb

@@ -0,0 +1,14 @@
+#!/bin/sh
+TIMESTART=`date +%s`
+while [ 1 ]
+do
+  echo 'Syncing...'
+  unison $1 $2 $3 $4
+  TIME=$((`date +%s`-$TIMESTART))
+  echo $TIME
+  if [ $TIME -ge 50 ]
+  then
+    break
+  fi
+  sleep 1
+done

data/test/test_helper.rb

@@ -24,10 +24,11 @@ class Test::Unit::TestCase
 
     Vagrant::Config.run do |config|
       config.vagrant.dotfile_name = ".vagrant"
+      config.vagrant.log_output = nil
 
       config.ssh.username = "foo"
-      config.ssh.password = "bar"
       config.ssh.host = "baz"
+      config.ssh.port = 22
       config.ssh.forwarded_port_key = "ssh"
       config.ssh.max_tries = 10
       config.ssh.timeout = 10
@@ -36,11 +37,14 @@ class Test::Unit::TestCase
       config.vm.box = "foo"
       config.vm.box_ovf = "box.ovf"
       config.vm.base_mac = "42"
-      config.vm.project_directory = "/vagrant"
       config.vm.disk_image_format = 'VMDK'
       config.vm.forward_port("ssh", 22, 2222)
       config.vm.shared_folder_uid = nil
       config.vm.shared_folder_gid = nil
+      config.vm.system = :linux
+      config.vm.sync_script = "/foo"
+      config.vm.sync_crontab_entry_file = "/tmp/foo"
+      config.vm.share_folder("v-root", "/vagrant", ".")
 
       config.package.name = 'vagrant'
       config.package.extension = '.box'
@@ -69,9 +73,26 @@ class Test::Unit::TestCase
     config = Vagrant::Config.execute!
 
     environment.instance_variable_set(:@config, config)
+
+    # Setup the logger. We create it then reset it so that subsequent
+    # calls will recreate it for us.
+    environment.load_logger!
+    environment.logger.class.reset_singleton_logger!
+    environment.logger.stubs(:flush_progress)
+    environment.logger.stubs(:cl_reset).returns("")
+
     environment
   end
 
+  # Sets up the mocks for a VM
+  def mock_vm(env=nil)
+    env ||= mock_environment
+    vm = Vagrant::VM.new
+    vm.stubs(:env).returns(env)
+    vm.stubs(:ssh).returns(Vagrant::SSH.new(vm.env))
+    vm
+  end
+
   # Sets up the mocks and instantiates an action for testing
   def mock_action(action_klass, *args)
     vm = mock("vboxvm")
@@ -79,16 +100,38 @@ class Test::Unit::TestCase
     action = action_klass.new(mock_vm, *args)
     stub_default_action_dependecies(action)
 
+    mock_vm.stubs(:name).returns("foo")
     mock_vm.stubs(:vm).returns(vm)
     mock_vm.stubs(:vm=)
     mock_vm.stubs(:invoke_callback)
     mock_vm.stubs(:invoke_around_callback).yields
     mock_vm.stubs(:actions).returns([action])
     mock_vm.stubs(:env).returns(mock_environment)
+    mock_vm.env.stubs(:logger).returns(quiet_logger("mock"))
+
+    mock_ssh = Vagrant::SSH.new(mock_vm.env)
+    mock_ssh.stubs(:execute)
+
+    mock_vm.stubs(:ssh).returns(mock_ssh)
+
+    vm.stubs(:env).returns(mock_vm.env)
 
     [mock_vm, vm, action]
   end
 
+  # Returns a resource logger which is safe for tests
+  def quiet_logger(resource, env=nil)
+    logger = Vagrant::ResourceLogger.new(resource, env)
+    logger.stubs(:flush_progress)
+    logger.stubs(:cl_reset).returns("")
+    logger
+  end
+
+  # Returns a linux system
+  def linux_system(vm)
+    Vagrant::Systems::Linux.new(vm)
+  end
+
   def stub_default_action_dependecies(mock)
     mock.stubs(:precedes).returns([])
     mock.stubs(:follows).returns([])
@@ -99,7 +142,7 @@ class Test::Unit::TestCase
     tempfile = mock("tempfile")
     tempfile.stubs(:write)
 
-    [downloader_klass.new, tempfile]
+    [downloader_klass.new(mock_environment), tempfile]
   end
 end
 

data/test/vagrant/actions/box/download_test.rb

@@ -93,7 +93,6 @@ class DownloadBoxActionTest < Test::Unit::TestCase
       @action.with_tempfile
     end
 
-
     should "yield the tempfile object" do
       @tempfile = mock("tempfile")
       File.expects(:open).yields(@tempfile)
@@ -104,22 +103,6 @@ class DownloadBoxActionTest < Test::Unit::TestCase
     end
   end
 
-  context "file options" do
-    should "include add binary bit to options on windows platform" do
-      # This constant is not defined on non-windows platforms, so define it here
-      File::BINARY = 4096 unless defined?(File::BINARY)
-
-      Mario::Platform.expects(:windows?).returns(true)
-      assert_equal @action.file_options, File::CREAT|File::EXCL|File::WRONLY|File::BINARY
-    end
-
-    should "not include binary bit on other platforms" do
-      Mario::Platform.expects(:windows?).returns(false)
-      assert_equal @action.file_options, File::CREAT|File::EXCL|File::WRONLY
-    end
-  end
-
-
   context "cleaning up" do
     setup do
       @temp_path = "foo"

data/test/vagrant/actions/vm/boot_test.rb

@@ -6,13 +6,6 @@ class BootActionTest < Test::Unit::TestCase
     @runner.stubs(:invoke_callback)
   end
 
-  context "preparing" do
-    should "add the root shared folder" do
-      @runner.env.config.vm.expects(:share_folder).with("v-root", @runner.env.config.vm.project_directory, @runner.env.root_path).once
-      @action.prepare
-    end
-  end
-
   context "execution" do
     should "invoke the 'boot' around callback" do
       boot_seq = sequence("boot_seq")
@@ -43,13 +36,13 @@ class BootActionTest < Test::Unit::TestCase
   context "waiting for boot" do
     should "repeatedly ping the SSH port and return false with no response" do
       seq = sequence('pings')
-      @runner.env.ssh.expects(:up?).times(@runner.env.config.ssh.max_tries.to_i - 1).returns(false).in_sequence(seq)
-      @runner.env.ssh.expects(:up?).once.returns(true).in_sequence(seq)
+      @runner.ssh.expects(:up?).times(@runner.env.config.ssh.max_tries.to_i - 1).returns(false).in_sequence(seq)
+      @runner.ssh.expects(:up?).once.returns(true).in_sequence(seq)
       assert @action.wait_for_boot(0)
     end
 
     should "ping the max number of times then just return" do
-      @runner.env.ssh.expects(:up?).times(Vagrant.config.ssh.max_tries.to_i).returns(false)
+      @runner.ssh.expects(:up?).times(@runner.env.config.ssh.max_tries.to_i).returns(false)
       assert !@action.wait_for_boot(0)
     end
   end

data/test/vagrant/actions/vm/customize_test.rb

@@ -7,9 +7,15 @@ class CustomizeActionTest < Test::Unit::TestCase
 
   context "executing" do
     should "run the VM customization procs then save the VM" do
+      @runner.env.config.vm.customize { |vm| }
       @runner.env.config.vm.expects(:run_procs!).with(@vm)
       @vm.expects(:save).once
       @action.execute!
     end
+
+    should "not run anything if no customize blocks exist" do
+      @vm.expects(:save).never
+      @action.execute!
+    end
   end
 end

data/test/vagrant/actions/vm/destroy_test.rb

@@ -15,7 +15,7 @@ class DestroyActionTest < Test::Unit::TestCase
       @runner.stubs(:invoke_around_callback).yields
       clear_seq = sequence("clear")
       @action.expects(:destroy_vm).in_sequence(clear_seq)
-      @action.expects(:depersist).in_sequence(clear_seq)
+      @action.expects(:update_dotfile).in_sequence(clear_seq)
       @action.execute!
     end
   end
@@ -23,14 +23,15 @@ class DestroyActionTest < Test::Unit::TestCase
   context "destroying the VM" do
     should "destroy VM and attached images" do
       @vm.expects(:destroy).with(:destroy_medium => :delete).once
+      @runner.expects(:vm=).with(nil).once
       @action.destroy_vm
     end
   end
 
-  context "depersisting" do
-    should "call depersist_vm on Env" do
-      @runner.env.expects(:depersist_vm).once
-      @action.depersist
+  context "updating the dotfile" do
+    should "update the environment dotfile" do
+      @runner.env.expects(:update_dotfile).once
+      @action.update_dotfile
     end
   end
 end

data/test/vagrant/actions/vm/down_test.rb

@@ -13,33 +13,27 @@ class DownActionTest < Test::Unit::TestCase
     def setup_action_expectations(order)
       default_seq = sequence("default_seq")
       order.each do |action|
-        @runner.expects(:add_action).with(action).once.in_sequence(default_seq)
+        action = [action] unless action.is_a?(Array)
+        @runner.expects(:add_action).with(action.shift, *action).once.in_sequence(default_seq)
       end
     end
 
     should "add the destroy action alone if VM is not running" do
-      setup_action_expectations([Vagrant::Actions::VM::Destroy])
+      setup_action_expectations([Vagrant::Actions::VM::Network, Vagrant::Actions::VM::Destroy])
       @action.prepare
     end
 
     should "add the halt action if the VM is running" do
       @vm.expects(:running?).returns(true)
-      setup_action_expectations([Vagrant::Actions::VM::Halt, Vagrant::Actions::VM::Destroy])
+      setup_action_expectations([[Vagrant::Actions::VM::Halt, {:force => true}], Vagrant::Actions::VM::Network, Vagrant::Actions::VM::Destroy])
       @action.prepare
     end
   end
 
   context "after halting" do
-    should "sleep if boot mode is GUI" do
-      @runner.env.config.vm.boot_mode = "gui"
+    should "sleep" do
       Kernel.expects(:sleep).once
       @action.after_halt
     end
-
-    should "not sleep if boot mode is anything else" do
-      @runner.env.config.vm.boot_mode = "vrdp"
-      Kernel.expects(:sleep).never
-      @action.after_halt
-    end
   end
 end

data/test/vagrant/actions/vm/export_test.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 class ExportActionTest < Test::Unit::TestCase
   setup do
     @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Export)
+    @action.stubs(:complete_progress)
   end
 
   context "executing" do

data/test/vagrant/actions/vm/forward_ports_test.rb

@@ -2,10 +2,18 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 
 class ForwardPortsActionTest < Test::Unit::TestCase
   setup do
-    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::ForwardPorts)
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::ForwardPorts)
   end
 
-  context "checking for colliding ports" do
+  context "preparing" do
+    should "call proper sequence" do
+      prep_seq = sequence("prepare")
+      @action.expects(:external_collision_check).in_sequence(prep_seq)
+      @action.prepare
+    end
+  end
+
+  context "checking for colliding external ports" do
     setup do
       @forwarded_port = mock("forwarded_port")
       @forwarded_port.stubs(:hostport)
@@ -15,7 +23,7 @@ class ForwardPortsActionTest < Test::Unit::TestCase
       @vm.stubs(:forwarded_ports).returns(@forwarded_ports)
       @vm.stubs(:running?).returns(true)
       @vm.stubs(:uuid).returns("foo")
-      @mock_vm.stubs(:uuid).returns("bar")
+      @runner.stubs(:uuid).returns("bar")
       vms = [@vm]
       VirtualBox::VM.stubs(:all).returns(vms)
 
@@ -24,37 +32,80 @@ class ForwardPortsActionTest < Test::Unit::TestCase
         config.vm.forward_port("ssh", 22, 2222)
       end
 
-      @mock_vm.stubs(:env).returns(@env)
+      @runner.stubs(:env).returns(@env)
+
+      # So no exceptions are raised
+      @action.stubs(:handle_collision)
     end
 
     should "ignore vms which aren't running" do
       @vm.expects(:running?).returns(false)
       @vm.expects(:forwarded_ports).never
-      @action.prepare
+      @action.external_collision_check
     end
 
     should "ignore vms which are equivalent to ours" do
-      @mock_vm.expects(:uuid).returns(@vm.uuid)
+      @runner.expects(:uuid).returns(@vm.uuid)
       @vm.expects(:forwarded_ports).never
-      @action.prepare
+      @action.external_collision_check
     end
 
     should "not raise any errors if no forwarded ports collide" do
       @forwarded_port.expects(:hostport).returns(80)
-      assert_nothing_raised { @action.prepare }
+      assert_nothing_raised { @action.external_collision_check }
     end
 
-    should "raise an ActionException if a port collides" do
+    should "handle the collision if it happens" do
       @forwarded_port.expects(:hostport).returns(2222)
+      @action.expects(:handle_collision).with("ssh", anything, anything).once
+      @action.external_collision_check
+    end
+  end
+
+  context "handling collisions" do
+    setup do
+      @name = :foo
+      @options = {
+        :hostport => 0,
+        :auto => true
+      }
+      @used_ports = [1,2,3]
+
+      @runner.env.config.vm.auto_port_range = (1..5)
+    end
+
+    should "raise an exception if auto forwarding is disabled" do
+      @options[:auto] = false
+
       assert_raises(Vagrant::Actions::ActionException) {
-        @action.prepare
+        @action.handle_collision(@name, @options, @used_ports)
       }
     end
 
-    should "convert ports to strings prior to checking" do
-      @forwarded_port.expects(:hostport).returns("2222")
+    should "set the host port to the first available port" do
+      assert_equal 0, @options[:hostport]
+      @action.handle_collision(@name, @options, @used_ports)
+      assert_equal 4, @options[:hostport]
+    end
+
+    should "add the newly used port to the list of used ports" do
+      assert !@used_ports.include?(4)
+      @action.handle_collision(@name, @options, @used_ports)
+      assert @used_ports.include?(4)
+    end
+
+    should "not use a host port which is being forwarded later" do
+      @runner.env.config.vm.forward_port("http", 80, 4)
+
+      assert_equal 0, @options[:hostport]
+      @action.handle_collision(@name, @options, @used_ports)
+      assert_equal 5, @options[:hostport]
+    end
+
+    should "raise an exception if there are no auto ports available" do
+      @runner.env.config.vm.auto_port_range = (1..3)
       assert_raises(Vagrant::Actions::ActionException) {
-        @action.prepare
+        @action.handle_collision(@name, @options, @used_ports)
       }
     end
   end
@@ -71,18 +122,37 @@ class ForwardPortsActionTest < Test::Unit::TestCase
   context "forwarding ports" do
     should "create a port forwarding for the VM" do
       forwarded_ports = mock("forwarded_ports")
+      network_adapter = mock("network_adapter")
 
-      @mock_vm.env.config.vm.forwarded_ports.each do |name, opts|
+      @vm.expects(:network_adapters).returns([network_adapter])
+      network_adapter.expects(:attachment_type).returns(:nat)
+
+      @runner.env.config.vm.forwarded_ports.each do |name, opts|
         forwarded_ports.expects(:<<).with do |port|
           assert_equal name, port.name
           assert_equal opts[:hostport], port.hostport
           assert_equal opts[:guestport], port.guestport
+          assert_equal opts[:adapter], port.instance
           true
         end
       end
 
       @vm.expects(:forwarded_ports).returns(forwarded_ports)
       @vm.expects(:save).once
+      @runner.expects(:reload!).once
+      @action.forward_ports
+    end
+  end
+
+  context "Not forwarding ports" do
+    should "No port forwarding for non NAT interfaces" do
+      forwarded_ports = mock("forwarded_ports")
+      network_adapter = mock("network_adapter")
+
+      @vm.expects(:network_adapters).returns([network_adapter])
+      network_adapter.expects(:attachment_type).returns(:host_only)
+      @vm.expects(:save).once
+      @runner.expects(:reload!).once
       @action.forward_ports
     end
   end
@@ -96,7 +166,14 @@ class ForwardPortsActionTest < Test::Unit::TestCase
         forwarded_ports << port
       end
 
-      @vm.expects(:forwarded_ports).returns(forwarded_ports)
+      @vm.stubs(:forwarded_ports).returns(forwarded_ports)
+      @runner.expects(:reload!)
+      @action.clear
+    end
+
+    should "do nothing if there are no forwarded ports" do
+      @vm.stubs(:forwarded_ports).returns([])
+      @runner.expects(:reload!).never
       @action.clear
     end
   end

data/test/vagrant/actions/vm/halt_test.rb

@@ -3,25 +3,57 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 class HaltActionTest < Test::Unit::TestCase
   setup do
     @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Halt)
+    @runner.stubs(:system).returns(linux_system(@vm))
+  end
+
+  context "force?" do
+    should "not force by default" do
+      @action.options[:force] = nil
+      assert !@action.force?
+    end
+
+    should "force if specified" do
+      @action.options[:force] = true
+      assert @action.force?
+    end
   end
 
   context "executing" do
     setup do
       @vm.stubs(:running?).returns(true)
+
+      @runner.system.stubs(:halt)
+      @vm.stubs(:stop)
+      @vm.stubs(:state).returns(:powered_off)
     end
 
     should "invoke the 'halt' around callback" do
-      halt_seq = sequence("halt_seq")
-      @runner.expects(:invoke_around_callback).with(:halt).once.in_sequence(halt_seq).yields
-      @vm.expects(:stop).in_sequence(halt_seq)
+      @runner.expects(:invoke_around_callback).with(:halt).once
       @action.execute!
     end
 
-    should "force the VM to stop" do
+    should "halt with the system and NOT force VM to stop if powered off" do
+      @vm.expects(:state).with(true).returns(:powered_off)
+
+      @runner.system.expects(:halt).once
+      @vm.expects(:stop).never
+      @action.execute!
+    end
+
+    should "halt with the system and force VM to stop if NOT powered off" do
+      @vm.expects(:state).with(true).returns(:running)
+
+      @runner.system.expects(:halt).once
       @vm.expects(:stop).once
       @action.execute!
     end
 
+    should "not call halt on the system if forcing" do
+      @action.stubs(:force).returns(true)
+      @runner.system.expects(:halt).never
+      @action.execute!
+    end
+
     should "raise an ActionException if VM is not running" do
       @vm.stubs(:running?).returns(false)
       @vm.expects(:stop).never