vagrantup 0.1.4 → 0.2.0

data/lib/vagrant/stacked_proc_runner.rb

@@ -0,0 +1,33 @@
+module Vagrant
+  # Represents the "stacked proc runner" behavior which is used a
+  # couple places within Vagrant. This allows procs to "stack" on
+  # each other, then all execute in a single action. An example of
+  # its uses can be seen in the {Config} class.
+  module StackedProcRunner
+    # Returns the proc stack. This should always be called as the
+    # accessor of the stack. The instance variable itself should _never_
+    # be used.
+    #
+    # @return [Array<Proc>]
+    def proc_stack
+      @_proc_stack ||= []
+    end
+
+    # Adds (pushes) a proc to the stack. The actual proc added here is
+    # not executed, but merely stored.
+    #
+    # @param [Proc] block
+    def push_proc(&block)
+      proc_stack << block
+    end
+
+    # Executes all the procs on the stack, passing in the given arguments.
+    # The stack is not cleared afterwords. It is up to the user of this
+    # mixin to clear the stack by calling `proc_stack.clear`.
+    def run_procs!(*args)
+      proc_stack.each do |proc|
+        proc.call(*args)
+      end
+    end
+  end
+end

data/lib/vagrant/vm.rb

@@ -19,6 +19,14 @@ module Vagrant
       @vm = vm
     end
 
+    def uuid
+      vm ? vm.uuid : nil
+    end
+
+    def reload!
+      @vm = VirtualBox::VM.find(@vm.uuid)
+    end
+
     def package(out_path, include_files=[])
       add_action(Actions::VM::Export)
       add_action(Actions::VM::Package, out_path, include_files)

data/test/test_helper.rb

@@ -20,11 +20,10 @@ require 'mocha'
 class Test::Unit::TestCase
   # Clears the previous config and sets up the new config
   def mock_config
-    Vagrant::Config.instance_variable_set(:@config_runners, nil)
-    Vagrant::Config.instance_variable_set(:@config, nil)
+    Vagrant::Config.reset!
 
     Vagrant::Config.run do |config|
-      config.vagrant.dotfile_name = ".hobo"
+      config.vagrant.dotfile_name = ".vagrant"
 
       config.ssh.username = "foo"
       config.ssh.password = "bar"
@@ -32,21 +31,28 @@ class Test::Unit::TestCase
       config.ssh.forwarded_port_key = "ssh"
       config.ssh.max_tries = 10
       config.ssh.timeout = 10
+      config.ssh.private_key_path = '~/foo'
 
       config.vm.box = "foo"
       config.vm.box_ovf = "box.ovf"
       config.vm.base_mac = "42"
-      config.vm.project_directory = "/hobo"
+      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.package.name = 'vagrant'
       config.package.extension = '.box'
 
+      # Chef
+      config.chef.chef_server_url = "http://localhost:4000"
+      config.chef.validation_key_path = "validation.pem"
+      config.chef.client_key_path = "/zoo/foo/bar.pem"
       config.chef.cookbooks_path = "cookbooks"
-      config.chef.provisioning_path = "/tmp/hobo-chef"
+      config.chef.provisioning_path = "/tmp/vagrant-chef"
       config.chef.json = {
-        :recipes => ["hobo_main"]
+        :recipes => ["vagrant_main"]
       }
 
       config.vagrant.home = '~/.home'
@@ -72,6 +78,7 @@ class Test::Unit::TestCase
     vm = mock("vboxvm")
     mock_vm = mock("vm")
     action = action_klass.new(mock_vm, *args)
+    stub_default_action_dependecies(action)
 
     mock_vm.stubs(:vm).returns(vm)
     mock_vm.stubs(:vm=)
@@ -82,6 +89,11 @@ class Test::Unit::TestCase
     [mock_vm, vm, action]
   end
 
+  def stub_default_action_dependecies(mock, klass=MockAction)
+    mock.stubs(:precedes).returns([])
+    mock.stubs(:follows).returns([])
+  end
+
   # Sets up the mocks and stubs for a downloader
   def mock_downloader(downloader_klass)
     tempfile = mock("tempfile")
@@ -90,3 +102,7 @@ class Test::Unit::TestCase
     [downloader_klass.new, tempfile]
   end
 end
+
+class MockAction; end
+class MockActionOther; end
+

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

@@ -16,6 +16,10 @@ class DownloadBoxActionTest < Test::Unit::TestCase
       @uri = mock("uri")
       @uri.stubs(:is_a?).returns(false)
       URI.stubs(:parse).returns(@uri)
+
+      @downloader = mock("downloader")
+      Vagrant::Downloaders::File.any_instance.stubs(:prepare)
+      Vagrant::Downloaders::HTTP.any_instance.stubs(:prepare)
     end
 
     should "raise an exception if no URI type is matched" do
@@ -25,6 +29,13 @@ class DownloadBoxActionTest < Test::Unit::TestCase
       }
     end
 
+    should "call #prepare on the downloader" do
+      @downloader.expects(:prepare).with(@runner.uri).once
+      Vagrant::Downloaders::File.expects(:new).returns(@downloader)
+      @uri.stubs(:is_a?).with(URI::Generic).returns(true)
+      @action.prepare
+    end
+
     should "set the downloader to file if URI is generic" do
       @uri.stubs(:is_a?).with(URI::Generic).returns(true)
       @action.prepare

data/test/vagrant/actions/collection_test.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class CollectionTest < Test::Unit::TestCase
+  context "checking uniqueness" do
+    setup do
+      @actions = Vagrant::Actions::Collection.new([1])
+    end
+
+    should "return true if there are duplicate classes in the collection" do
+      @actions << 1
+      assert @actions.duplicates?
+    end
+    
+    should "return false it all the classes are unique" do
+      @actions << 1.0 << "foo"
+      assert !@actions.duplicates?
+    end
+
+    should "raise an exception when there are duplicates" do
+      @actions << 1 
+      assert_raise Vagrant::Actions::DuplicateActionException do
+        @actions.duplicates!
+      end
+    end
+
+    should "not raise an exception when there are no duplicates" do
+      @actions << 1.0 << "foo"
+      assert_nothing_raised do
+        @actions.duplicates!
+      end
+    end
+  end
+
+  context "verifying dependencies" do
+    setup do
+      @mock_action = mock('action')
+      @mock_action.stubs(:class).returns(MockAction)
+
+      @mock_action2 = mock('action2')
+      @mock_action2.stubs(:class).returns(MockActionOther)
+      # see test_helper
+      stub_default_action_dependecies(@mock_action)
+      stub_default_action_dependecies(@mock_action2)
+    end
+    
+    context "that come before an action" do
+      setup do
+        @mock_action.stubs(:follows).returns([MockActionOther])
+      end
+      should "raise an exception if they are not met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action]).dependencies!
+        end
+      end
+    
+      should "not raise an exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action2, @mock_action]).dependencies!
+        end
+      end
+    end
+
+    context "that follow an an action" do
+      setup do
+        @mock_action.stubs(:precedes).returns([MockActionOther])
+      end
+
+      should "raise an exception if they are not met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action]).dependencies!
+        end
+      end
+
+      should "not raise an exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action, @mock_action2]).dependencies!
+        end
+      end
+    end
+
+    context "that are before and after an action" do
+      setup do
+        @mock_action.stubs(:precedes).returns([MockActionOther])
+        @mock_action.stubs(:follows).returns([MockActionOther])
+      end
+
+      should "raise an exception if they are met" do
+        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
+          collection.new([@mock_action2, @mock_action]).dependencies!
+        end
+      end
+
+      should "not raise and exception if they are met" do
+        assert_nothing_raised do
+          collection.new([@mock_action2, @mock_action, @mock_action2]).dependencies!
+        end
+      end
+    end
+  end
+  
+  context "klasses" do
+    should "return a list of the collection element's classes" do
+      @action = mock('action')
+      assert_equal collection.new([@action]).klasses, [@action.class]
+      assert_equal collection.new([@action, 1.0, "foo"]).klasses, [@action.class, Float, String]
+    end
+  end
+
+  def collection; Vagrant::Actions::Collection end
+end

data/test/vagrant/actions/runner_test.rb

@@ -6,6 +6,7 @@ class ActionRunnerTest < Test::Unit::TestCase
     action.stubs(:prepare)
     action.stubs(:execute!)
     action.stubs(:cleanup)
+    stub_default_action_dependecies(action)
     action
   end
 
@@ -135,6 +136,7 @@ class ActionRunnerTest < Test::Unit::TestCase
     should "clear the actions and run a single action if given to execute!" do
       action = mock("action")
       run_action = mock("action_run")
+      stub_default_action_dependecies(run_action)
       run_class = mock("run_class")
       run_class.expects(:new).once.returns(run_action)
       @runner.actions << action
@@ -148,7 +150,6 @@ class ActionRunnerTest < Test::Unit::TestCase
     end
 
     should "clear actions after running execute!" do
-      @runner.actions << mock_fake_action
       @runner.actions << mock_fake_action
       assert !@runner.actions.empty? # sanity
       @runner.execute!
@@ -158,9 +159,10 @@ class ActionRunnerTest < Test::Unit::TestCase
     should "run #prepare on all actions, then #execute!" do
       action_seq = sequence("action_seq")
       actions = []
-      5.times do |i|
+      [MockAction, MockActionOther].each_with_index do |klass, i|
         action = mock("action#{i}")
-
+        action.expects(:class).returns(klass)
+        stub_default_action_dependecies(action, klass)
         @runner.actions << action
         actions << action
       end
@@ -176,10 +178,12 @@ class ActionRunnerTest < Test::Unit::TestCase
 
     context "exceptions" do
       setup do
-        @actions = [mock_fake_action, mock_fake_action]
-        @actions.each do |a|
-          a.stubs(:rescue)
-          @runner.actions << a
+        @actions = [MockAction, MockActionOther].map do |klass|
+          action = mock_fake_action
+          action.expects(:class).returns(klass)
+          action.stubs(:rescue)
+          @runner.actions << action
+          action
         end
 
         @exception = Exception.new

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

@@ -7,6 +7,13 @@ class BootActionTest < Test::Unit::TestCase
     mock_config
   end
 
+  context "preparing" do
+    should "add the root shared folder" do
+      Vagrant.config.vm.expects(:share_folder).with("vagrant-root", Vagrant.config.vm.project_directory, Vagrant::Env.root_path).once
+      @action.prepare
+    end
+  end
+
   context "execution" do
     should "invoke the 'boot' around callback" do
       boot_seq = sequence("boot_seq")
@@ -45,11 +52,4 @@ class BootActionTest < Test::Unit::TestCase
       assert !@action.wait_for_boot(0)
     end
   end
-
-  context "callbacks" do
-    should "setup the root directory shared folder" do
-      expected = ["vagrant-root", Vagrant::Env.root_path, Vagrant.config.vm.project_directory]
-      assert_equal expected, @action.collect_shared_folders
-    end
-  end
 end

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

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class CustomizeActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Customize)
+    mock_config
+  end
+
+  context "executing" do
+    should "run the VM customization procs then save the VM" do
+      Vagrant.config.vm.expects(:run_procs!).with(@vm)
+      @vm.expects(:save).with(true).once
+      @action.execute!
+    end
+  end
+end

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

@@ -2,23 +2,36 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 
 class DestroyActionTest < Test::Unit::TestCase
   setup do
-    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Destroy)
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Destroy)
     mock_config
   end
 
   context "executing" do
-    setup do
-      @vm.stubs(:destroy)
+    should "invoke an around callback around the destroy" do
+      @runner.expects(:invoke_around_callback).with(:destroy).once
+      @action.execute!
     end
 
-    should "invoke an around callback around the destroy" do
-      @mock_vm.expects(:invoke_around_callback).with(:destroy).once
+    should "destroy VM and clear persist" do
+      @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.execute!
     end
+  end
 
+  context "destroying the VM" do
     should "destroy VM and attached images" do
       @vm.expects(:destroy).with(:destroy_image => true).once
-      @action.execute!
+      @action.destroy_vm
+    end
+  end
+
+  context "depersisting" do
+    should "call depersist_vm on Env" do
+      Vagrant::Env.expects(:depersist_vm).with(@runner).once
+      @action.depersist
     end
   end
 end

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

@@ -6,6 +6,58 @@ class ForwardPortsActionTest < Test::Unit::TestCase
     mock_config
   end
 
+  context "checking for colliding ports" do
+    setup do
+      @forwarded_port = mock("forwarded_port")
+      @forwarded_port.stubs(:hostport)
+      @forwarded_ports = [@forwarded_port]
+
+      @vm = mock("vm")
+      @vm.stubs(:forwarded_ports).returns(@forwarded_ports)
+      @vm.stubs(:running?).returns(true)
+      @vm.stubs(:uuid).returns("foo")
+      @mock_vm.stubs(:uuid).returns("bar")
+      vms = [@vm]
+      VirtualBox::VM.stubs(:all).returns(vms)
+
+      mock_config do |config|
+        config.vm.forwarded_ports.clear
+        config.vm.forward_port("ssh", 22, 2222)
+      end
+    end
+
+    should "ignore vms which aren't running" do
+      @vm.expects(:running?).returns(false)
+      @vm.expects(:forwarded_ports).never
+      @action.prepare
+    end
+
+    should "ignore vms which are equivalent to ours" do
+      @mock_vm.expects(:uuid).returns(@vm.uuid)
+      @vm.expects(:forwarded_ports).never
+      @action.prepare
+    end
+
+    should "not raise any errors if no forwarded ports collide" do
+      @forwarded_port.expects(:hostport).returns(80)
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an ActionException if a port collides" do
+      @forwarded_port.expects(:hostport).returns(2222)
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "convert ports to strings prior to checking" do
+      @forwarded_port.expects(:hostport).returns("2222")
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+  end
+
   context "execution" do
     should "clear all previous ports and forward new ports" do
       exec_seq = sequence("exec_seq")