vagrant 0.7.8 → 0.8.1

data/test/vagrant/action/vm/clear_forwarded_ports_test.rb

@@ -8,53 +8,18 @@ class ClearForwardedPortsVMActionTest < Test::Unit::TestCase
     @vm = mock("vm")
     @vm.stubs(:name).returns("foo")
     @env["vm"] = @vm
+    @env["vm.modify"] = mock("proc")
 
     @instance = @klass.new(@app, @env)
   end
 
   context "calling" do
-    should "call the proper methods and continue chain" do
-      seq = sequence('seq')
-      @instance.expects(:clear).in_sequence(seq)
-      @app.expects(:call).with(@env).in_sequence(seq)
-      @instance.call(@env)
-    end
-  end
-
-  context "clearing forwarded ports" do
-    setup do
-      @instance.stubs(:used_ports).returns([:a])
-      @instance.stubs(:clear_ports)
-    end
-
-    should "call destroy on all forwarded ports" do
-      @instance.expects(:clear_ports).once
-      @vm.expects(:reload!)
-      @instance.clear
-    end
-
-    should "do nothing if there are no forwarded ports" do
-      @instance.stubs(:used_ports).returns([])
-      @vm.expects(:reload!).never
-      @instance.clear
-    end
-  end
-
-  context "clearing ports" do
     def mock_fp
       fp = mock("fp")
       fp.expects(:destroy).once
       fp
     end
 
-    setup do
-      VirtualBox.stubs(:version).returns("3.2.8")
-      @adapters = []
-      @internal_vm = mock("internal_vm")
-      @internal_vm.stubs(:network_adapters).returns(@adapters)
-      @vm.stubs(:vm).returns(@internal_vm)
-    end
-
     def mock_adapter
       na = mock("adapter")
       engine = mock("engine")
@@ -63,10 +28,25 @@ class ClearForwardedPortsVMActionTest < Test::Unit::TestCase
       na
     end
 
-    should "destroy each forwarded port" do
+    setup do
+      VirtualBox.stubs(:version).returns("3.2.8")
+      @adapters = []
+      @internal_vm = mock("internal_vm")
+      @internal_vm.stubs(:network_adapters).returns(@adapters)
+      @vm.stubs(:vm).returns(@internal_vm)
+    end
+
+    should "call the proper methods and continue chain" do
       @adapters << mock_adapter
       @adapters << mock_adapter
-      @instance.clear_ports
+
+      @env["vm.modify"].expects(:call).with() do |proc|
+        proc.call(@internal_vm)
+        true
+      end
+
+      @app.expects(:call).with(@env)
+      @instance.call(@env)
     end
   end
 end

data/test/vagrant/action/vm/clear_shared_folders_test.rb

@@ -7,6 +7,7 @@ class ClearSharedFoldersVMActionTest < Test::Unit::TestCase
 
     @vm = mock("vm")
     @env["vm"] = @vm
+    @env["vm.modify"] = mock("proc")
 
     @internal_vm = mock("internal")
     @vm.stubs(:vm).returns(@internal_vm)
@@ -15,15 +16,6 @@ class ClearSharedFoldersVMActionTest < Test::Unit::TestCase
   end
 
   context "calling" do
-    should "call the proper methods in sequence" do
-      seq = sequence("seq")
-      @instance.expects(:clear_shared_folders).once.in_sequence(seq)
-      @app.expects(:call).with(@env).once
-      @instance.call(@env)
-    end
-  end
-
-  context "clearing shared folders" do
     setup do
       @shared_folder = mock("shared_folder")
       @shared_folders = [@shared_folder]
@@ -36,14 +28,13 @@ class ClearSharedFoldersVMActionTest < Test::Unit::TestCase
         sf.expects(:destroy).once.in_sequence(destroy_seq)
       end
 
-      @vm.expects(:reload!).once.in_sequence(destroy_seq)
-      @instance.clear_shared_folders
-    end
+      @env["vm.modify"].expects(:call).with() do |proc|
+        proc.call(@internal_vm)
+        true
+      end
 
-    should "do nothing if no shared folders existed" do
-      @shared_folders.clear
-      @vm.expects(:reload!).never
-      @instance.clear_shared_folders
+      @app.expects(:call).with(@env).once
+      @instance.call(@env)
     end
   end
 end

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

@@ -8,22 +8,29 @@ class CustomizeVMActionTest < Test::Unit::TestCase
 
     @vm = mock("vm")
     @env["vm"] = @vm
+    @env["vm.modify"] = mock("proc")
 
     @internal_vm = mock("internal")
     @vm.stubs(:vm).returns(@internal_vm)
   end
 
   should "not run anything if no customize blocks exist" do
-    @env.env.config.vm.proc_stack.clear
-    @internal_vm.expects(:save).never
+    @env["config"].vm.proc_stack.clear
+    @env["vm.modify"].expects(:call).never
     @app.expects(:call).with(@env).once
     @instance.call(@env)
   end
 
   should "run the VM customization procs then save the VM" do
-    @env.env.config.vm.customize { |vm| }
-    @env.env.config.vm.expects(:run_procs!).with(@internal_vm)
-    @internal_vm.expects(:save).once
+    ran = false
+    @env["config"].vm.customize { |vm| }
+    @env["config"].vm.expects(:run_procs!).with(@internal_vm)
+
+    @env["vm.modify"].expects(:call).with() do |proc|
+      proc.call(@internal_vm)
+      true
+    end
+
     @app.expects(:call).with(@env).once
     @instance.call(@env)
   end

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

@@ -8,6 +8,7 @@ class ForwardPortsVMActionTest < Test::Unit::TestCase
     @vm = mock("vm")
     @vm.stubs(:name).returns("foo")
     @env["vm"] = @vm
+    @env["vm.modify"] = mock("proc")
   end
 
   context "initializing" do
@@ -123,6 +124,12 @@ class ForwardPortsVMActionTest < Test::Unit::TestCase
     context "calling" do
       should "clear all previous ports and forward new ports" do
         exec_seq = sequence("exec_seq")
+
+        @env["vm.modify"].expects(:call).with() do |proc|
+          proc.call(@internal_vm)
+          true
+        end
+
         @instance.expects(:forward_ports).once.in_sequence(exec_seq)
         @app.expects(:call).once.with(@env).in_sequence(exec_seq)
         @instance.call(@env)
@@ -143,9 +150,8 @@ class ForwardPortsVMActionTest < Test::Unit::TestCase
         network_adapter.expects(:attachment_type).returns(:nat)
 
         @instance.expects(:forward_port).once
-        @internal_vm.expects(:save).once
-        @vm.expects(:reload!).once
-        @instance.forward_ports
+
+        @instance.forward_ports(@internal_vm)
       end
 
       should "not port forward for non NAT interfaces" do
@@ -154,9 +160,8 @@ class ForwardPortsVMActionTest < Test::Unit::TestCase
 
         @internal_vm.expects(:network_adapters).returns([network_adapter])
         network_adapter.expects(:attachment_type).returns(:host_only)
-        @internal_vm.expects(:save).once
-        @vm.expects(:reload!).once
-        @instance.forward_ports
+
+        @instance.forward_ports(@internal_vm)
       end
     end
 
@@ -188,7 +193,7 @@ class ForwardPortsVMActionTest < Test::Unit::TestCase
         adapters[opts[:adapter]] = adapter
         @internal_vm.stubs(:network_adapters).returns(adapters)
 
-        @instance.forward_port(name, opts)
+        @instance.forward_port(@internal_vm, name, opts)
       end
     end
   end

data/test/vagrant/action/vm/match_mac_address_test.rb

@@ -20,9 +20,13 @@ class MatchMACAddressVMActionTest < Test::Unit::TestCase
 
     update_seq = sequence("update_seq")
     @internal_vm.expects(:network_adapters).returns([nic]).once.in_sequence(update_seq)
-    @internal_vm.expects(:save).once.in_sequence(update_seq)
     @app.expects(:call).with(@env).once.in_sequence(update_seq)
 
+    @env["vm.modify"].expects(:call).with() do |proc|
+      proc.call(@internal_vm)
+      true
+    end
+
     @instance.call(@env)
   end
 

data/test/vagrant/action/vm/modify_test.rb

@@ -0,0 +1,38 @@
+require "test_helper"
+
+class ModifyVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Modify
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:ssh).returns(mock("ssh"))
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "initialization" do
+    should "have the vm.modify function setup in the environment" do
+      assert @env.has_key?("vm.modify")
+    end
+  end
+
+  context "calling" do
+    should "run the procs with the VM as an argument and save the VM" do
+      seq = sequence("procseq")
+
+      proc = Proc.new { |vm| }
+      @env["vm.modify"].call(proc)
+
+      proc.expects(:call).with(@internal_vm).once.in_sequence(seq)
+      @internal_vm.expects(:save).once.in_sequence(seq)
+      @vm.expects(:reload!).once.in_sequence(seq)
+
+      @instance.call(@env)
+    end
+  end
+end

data/test/vagrant/action/vm/provision_test.rb

@@ -15,29 +15,6 @@ class ProvisionVMActionTest < Test::Unit::TestCase
     @vm.stubs(:vm).returns(@internal_vm)
   end
 
-  context "initializing" do
-    setup do
-      @klass.any_instance.stubs(:load_provisioners)
-    end
-
-    should "load provisioner if provisioning enabled" do
-      @env["config"].vm.provision :chef_solo
-      @klass.any_instance.expects(:load_provisioners).once
-      @klass.new(@app, @env)
-    end
-
-    should "not load provisioner if disabled" do
-      @klass.any_instance.expects(:load_provisioners).never
-      @klass.new(@app, @env)
-    end
-
-    should "not load provisioner if disabled through env hash" do
-      @env["provision.enabled"] = false
-      @klass.any_instance.expects(:load_provisioners).never
-      @klass.new(@app, @env)
-    end
-  end
-
   context "with an instance" do
     setup do
       # Set provisioner to nil so the provisioner isn't loaded on init
@@ -46,16 +23,12 @@ class ProvisionVMActionTest < Test::Unit::TestCase
     end
 
     context "loading a provisioner" do
-      setup do
-        Vagrant::Provisioners::ChefSolo.any_instance.expects(:prepare).at_least(0)
-      end
-
       should "instantiate and prepare each provisioner" do
         @env["config"].vm.provision :chef_solo
         @env["config"].vm.provision :chef_solo
-        @instance.load_provisioners
+        provisioners = @instance.enabled_provisioners
 
-        assert_equal 2, @instance.provisioners.length
+        assert_equal 2, provisioners.length
       end
 
       should "set the config for each provisioner" do
@@ -63,23 +36,25 @@ class ProvisionVMActionTest < Test::Unit::TestCase
           chef.cookbooks_path = "foo"
         end
 
-        @instance.load_provisioners
+        provisioners = @instance.enabled_provisioners
 
-        assert_equal "foo", @instance.provisioners.first.config.cookbooks_path
+        assert_equal "foo", provisioners.first.config.cookbooks_path
       end
     end
 
     context "calling" do
-      setup do
-        Vagrant::Provisioners::ChefSolo.any_instance.stubs(:prepare)
-        @env["config"].vm.provision :chef_solo
-        @instance.load_provisioners
-      end
-
       should "provision and continue chain" do
+        provisioners = [mock("one"), mock("two")]
         seq = sequence("seq")
+        @instance.stubs(:enabled_provisioners).returns(provisioners)
+
+        provisioners.each do |prov|
+          prov.expects(:prepare).in_sequence(seq)
+        end
+
         @app.expects(:call).with(@env).in_sequence(seq)
-        @instance.provisioners.each do |prov|
+
+        provisioners.each do |prov|
           prov.expects(:provision!).in_sequence(seq)
         end
 

data/test/vagrant/action/vm/provisioner_cleanup_test.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+
+class ProvisionerCleanupVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ProvisionerCleanup
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+  end
+
+  context "with an instance" do
+    setup do
+      # Set provisioner to nil so the provisioner isn't loaded on init
+      @env["config"].vm.provisioners.clear
+      @instance = @klass.new(@app, @env)
+    end
+
+    context "loading a provisioner" do
+      should "instantiate and prepare each provisioner" do
+        @env["config"].vm.provision :chef_solo
+        @env["config"].vm.provision :chef_solo
+        provisioners = @instance.enabled_provisioners
+
+        assert_equal 2, provisioners.length
+      end
+
+      should "set the config for each provisioner" do
+        @env["config"].vm.provision :chef_solo do |chef|
+          chef.cookbooks_path = "foo"
+        end
+
+        provisioners = @instance.enabled_provisioners
+
+        assert_equal "foo", provisioners.first.config.cookbooks_path
+      end
+    end
+
+    context "calling" do
+      should "provision and continue chain" do
+        provisioners = [mock("one"), mock("two")]
+        seq = sequence("seq")
+        @instance.stubs(:enabled_provisioners).returns(provisioners)
+        provisioners.each do |prov|
+          prov.expects(:cleanup).in_sequence(seq)
+        end
+        @app.expects(:call).with(@env).in_sequence(seq)
+
+        @instance.call(@env)
+      end
+    end
+  end
+end

data/test/vagrant/action/vm/share_folders_test.rb

@@ -10,6 +10,7 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
     @vm.stubs(:ssh).returns(mock("ssh"))
     @vm.stubs(:system).returns(mock("system"))
     @env["vm"] = @vm
+    @env["vm.modify"] = mock("proc")
 
     @internal_vm = mock("internal")
     @vm.stubs(:vm).returns(@internal_vm)
@@ -105,7 +106,11 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
       end
 
       @internal_vm.stubs(:shared_folders).returns(shared_folders)
-      @internal_vm.expects(:save).once
+
+      @env["vm.modify"].expects(:call).with() do |proc|
+        proc.call(@internal_vm)
+        true
+      end
 
       @instance.create_metadata
     end
@@ -114,8 +119,8 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
   context "mounting the shared folders" do
     setup do
       @folders = stub_shared_folders(<<-sf)
-        config.vm.share_folder("foo", "fooguest", "foohost")
-        config.vm.share_folder("bar", "barguest", "barhost")
+        config.vm.share_folder("foo", "fooguest", "foohost", :owner => "yo", :group => "fo")
+        config.vm.share_folder("bar", "barguest", "barhost", :owner => "foo", :group => "bar")
         config.vm.share_folder("foo_no_mount", nil, "foohost2")
       sf
       @ssh = mock("ssh")
@@ -127,9 +132,9 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
       mount_seq = sequence("mount_seq")
       @folders.each do |name, data|
         if data[:guestpath]
-          @vm.system.expects(:mount_shared_folder).with(@ssh, name, data[:guestpath]).in_sequence(mount_seq)
+          @vm.system.expects(:mount_shared_folder).with(@ssh, name, data[:guestpath], data[:owner], data[:group]).in_sequence(mount_seq)
         else
-          @vm.system.expects(:mount_shared_folder).with(@ssh, name, anything).never
+          @vm.system.expects(:mount_shared_folder).with(@ssh, name, anything, anything, anything).never
         end
       end