vagrantup 0.5.4 → 0.6.0

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

@@ -3,7 +3,7 @@ require "test_helper"
 class HaltVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::Halt
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @vm.stubs(:name).returns("foo")
@@ -26,6 +26,7 @@ class HaltVMActionTest < Test::Unit::TestCase
 
   context "calling" do
     setup do
+      @vm.stubs(:created?).returns(true)
       @internal_vm.stubs(:running?).returns(true)
 
       @vm.system.stubs(:halt)
@@ -33,6 +34,15 @@ class HaltVMActionTest < Test::Unit::TestCase
       @internal_vm.stubs(:state).returns(:powered_off)
     end
 
+    should "do nothing if VM is not created" do
+      @internal_vm.stubs(:created?).returns(false)
+      @vm.system.expects(:halt).never
+      @internal_vm.expects(:stop).never
+      @app.expects(:call).once
+
+      @instance.call(@env)
+    end
+
     should "do nothing if VM not running" do
       @internal_vm.stubs(:running?).returns(false)
       @vm.system.expects(:halt).never

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

@@ -2,49 +2,65 @@ require "test_helper"
 
 class ImportVMActionTest < Test::Unit::TestCase
   setup do
+    clean_paths
+    vagrant_box("foo")
+
     @klass = Vagrant::Action::VM::Import
-    @app, @env = mock_action_data
-    @instance = @klass.new(@app, @env)
+    @app, @env = action_env(vagrant_env(vagrantfile(<<-vf)))
+      config.vm.box = "foo"
+    vf
 
-    ovf_file = "foo"
-    @box = mock("box")
-    @box.stubs(:ovf_file).returns(ovf_file)
-    @env.env.stubs(:box).returns(@box)
+    @instance = @klass.new(@app, @env)
 
-    @env.env.vm = Vagrant::VM.new
+    @env.env.vm = Vagrant::VM.new(:env => @env.env, :name => "foobar")
 
     VirtualBox::VM.stubs(:import)
+
+    @vm = mock("vm")
+    @vm.stubs(:uuid).returns("foobar")
   end
 
   should "call import on VirtualBox with proper base" do
-    VirtualBox::VM.expects(:import).once.with(@env.env.box.ovf_file).returns("foo")
+    VirtualBox::VM.expects(:import).once.with(@env.env.box.ovf_file.to_s).returns(@vm)
     @instance.call(@env)
   end
 
   should "call next in chain on success and set VM" do
-    vm = mock("vm")
-    VirtualBox::VM.stubs(:import).returns(vm)
+    VirtualBox::VM.stubs(:import).returns(@vm)
     @app.expects(:call).with(@env).once
     @instance.call(@env)
 
-    assert_equal vm, @env["vm"].vm
+    assert_equal @vm, @env["vm"].vm
   end
 
   should "mark environment erroneous and not continue chain on failure" do
     @app.expects(:call).never
-    @instance.call(@env)
-
-    assert @env.error?
+    assert_raises(Vagrant::Errors::VMImportFailure) {
+      @instance.call(@env)
+    }
   end
 
-  should "run the destroy action if interrupted" do
-    VirtualBox::VM.stubs(:import).returns(mock("vm"))
-    @app.expects(:call).once.with() do |env|
-      assert_equal @env, env
-      @env.error!(:interrupt)
+  context "recovery" do
+    setup do
+      @env.env.vm.stubs(:created?).returns(true)
     end
-    @env.env.actions.expects(:run).with(:destroy).once
 
-    @instance.call(@env)
+    should "not run the destroy action on recover if error is a VagrantError" do
+      @env["vagrant.error"] = Vagrant::Errors::VMImportFailure.new
+      @env.env.actions.expects(:run).never
+      @instance.recover(@env)
+    end
+
+    should "not run the destroy action on recover if VM is not created" do
+      @env.env.vm.stubs(:created?).returns(false)
+      @env.env.actions.expects(:run).never
+      @instance.recover(@env)
+    end
+
+    should "run the destroy action on recover" do
+      @env.env.vm.stubs(:created?).returns(true)
+      @env.env.actions.expects(:run).with(:destroy).once
+      @instance.recover(@env)
+    end
   end
 end

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

@@ -3,7 +3,7 @@ require "test_helper"
 class MatchMACAddressVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::MatchMACAddress
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @env["vm"] = @vm

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

@@ -3,7 +3,7 @@ require "test_helper"
 class NetworkVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::Network
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @vm.stubs(:name).returns("foo")
@@ -18,7 +18,7 @@ class NetworkVMActionTest < Test::Unit::TestCase
   context "initializing" do
     should "verify no bridge collisions for each network enabled" do
       @env.env.config.vm.network("foo")
-      @klass.any_instance.expects(:verify_no_bridge_collision).once.with() do |options|
+      @klass.any_instance.expects(:verify_no_bridge_collision).returns(true).once.with() do |options|
         assert_equal "foo", options[:ip]
         true
       end
@@ -139,8 +139,9 @@ class NetworkVMActionTest < Test::Unit::TestCase
         mock_interface(:name => @options[:name],
                        :interface_type => :bridged)
 
-        @instance.network_name(@options)
-        assert @env.error?
+        assert_raises(Vagrant::Errors::NetworkNotFound) {
+          @instance.network_name(@options)
+        }
       end
 
       should "return the network which matches the name if given" do
@@ -154,9 +155,9 @@ class NetworkVMActionTest < Test::Unit::TestCase
         @options[:name] = "foo"
 
         @interfaces.expects(:create).never
-        @instance.network_name(@options)
-        assert @env.error?
-        assert_equal :network_not_found, @env.error.first
+        assert_raises(Vagrant::Errors::NetworkNotFound) {
+          @instance.network_name(@options)
+        }
       end
 
       should "create a network for the IP and netmask" do

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

@@ -2,9 +2,11 @@ require "test_helper"
 
 class NFSHelpersVMActionTest < Test::Unit::TestCase
   setup do
-    @klass = Class.new
-    @klass.send(:include, Vagrant::Action::VM::NFSHelpers)
-    @app, @env = mock_action_data
+    @klass = Class.new do
+      include Vagrant::Action::VM::NFSHelpers
+    end
+
+    @app, @env = action_env
 
     @instance = @klass.new
   end
@@ -18,6 +20,7 @@ class NFSHelpersVMActionTest < Test::Unit::TestCase
   end
 
   should "not do anything if host is nil" do
+    @env.env.stubs(:host).returns(nil)
     assert_nothing_raised { @instance.clear_nfs_exports(@env) }
   end
 end

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

@@ -3,7 +3,7 @@ require "test_helper"
 class NFSVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::NFS
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @vm.stubs(:system).returns(mock("system"))
@@ -65,32 +65,12 @@ class NFSVMActionTest < Test::Unit::TestCase
         @instance.expects(:mount_folders).never
         @instance.call(@env)
       end
+    end
 
-      should "halt chain if environment error occured" do
-        @env.error!(:foo)
-
-        seq = sequence('seq')
-        @instance.expects(:extract_folders).in_sequence(seq)
-        @instance.expects(:prepare_folders).in_sequence(seq)
-        @instance.expects(:clear_nfs_exports).in_sequence(seq)
-        @instance.expects(:export_folders).in_sequence(seq)
-        @app.expects(:call).never
-        @instance.call(@env)
-      end
-
-      should "not mount folders if an error occured" do
-        seq = sequence("seq")
-        @app.expects(:call).in_sequence(seq).with() do
-          # Use this mark the env as error
-          @env.error!(:foo)
-
-          true
-        end
-
-        @instance.expects(:clear_nfs_exports).with(@env).in_sequence(seq)
-
-        @instance.expects(:mount_folders).never
-        @instance.call(@env)
+    context "recovery" do
+      should "clear NFS exports" do
+        @instance.expects(:clear_nfs_exports).with(@env).once
+        @instance.recover(@env)
       end
     end
 
@@ -129,11 +109,12 @@ class NFSVMActionTest < Test::Unit::TestCase
       end
 
       should "return nil if the perm is not set" do
+        @env.env.config.nfs.map_uid = nil
         assert_nil @instance.prepare_permission(:uid, {:gid => 7})
       end
 
       should "return nil if the perm explicitly says nil" do
-        assert_nil @instance.prepare_permission(:uid, {:uid => nil})
+        assert_nil @instance.prepare_permission(:uid, {:map_uid => nil})
       end
 
       should "return the set value if it is set" do
@@ -164,13 +145,6 @@ class NFSVMActionTest < Test::Unit::TestCase
         @env["host"].expects(:nfs_export).with(@instance.guest_ip, @instance.folders)
         @instance.export_folders
       end
-
-      should "error the environment if exception is raised" do
-        @env["host"].expects(:nfs_export).raises(Vagrant::Action::ActionException.new(:foo))
-        @instance.export_folders
-        assert @env.error?
-        assert_equal :foo, @env.error.first
-      end
     end
 
     context "mounting folders" do
@@ -240,29 +214,30 @@ class NFSVMActionTest < Test::Unit::TestCase
 
       should "error environment if host is nil" do
         @env.env.stubs(:host).returns(nil)
-        @instance.verify_settings
-        assert @env.error?
-        assert_equal :nfs_host_required, @env.error.first
+        assert_raises(Vagrant::Errors::NFSHostRequired) {
+          @instance.verify_settings
+        }
       end
 
       should "error environment if host does not support NFS" do
         @env.env.host.stubs(:nfs?).returns(false)
-        @instance.verify_settings
-        assert @env.error?
-        assert_equal :nfs_not_supported, @env.error.first
+        assert_raises(Vagrant::Errors::NFSNotSupported) {
+          @instance.verify_settings
+        }
       end
 
       should "error environment if host only networking is not enabled" do
         @env.env.config.vm.network_options.clear
-        @instance.verify_settings
-        assert @env.error?
-        assert_equal :nfs_no_host_network, @env.error.first
+        assert_raises(Vagrant::Errors::NFSNoHostNetwork) {
+          @instance.verify_settings
+        }
       end
 
       should "be fine if everything passes" do
         @env.env.host.stubs(:nfs?).returns(true)
-        @instance.verify_settings
-        assert !@env.error?
+        assert_nothing_raised {
+          @instance.verify_settings
+        }
       end
     end
   end

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

@@ -3,7 +3,7 @@ require "test_helper"
 class PackageVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::Package
-    @app, @env = mock_action_data
+    @app, @env = action_env
     @env["export.temp_dir"] = "foo"
 
     @instance = @klass.new(@app, @env)

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

@@ -3,7 +3,7 @@ require "test_helper"
 class PackageVagrantfileVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::PackageVagrantfile
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @env["vm"] = @vm

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

@@ -3,7 +3,7 @@ require "test_helper"
 class ProvisionVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::Provision
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @vm.stubs(:name).returns("foo")
@@ -65,9 +65,10 @@ class ProvisionVMActionTest < Test::Unit::TestCase
 
         should "error environment if the class is not a subclass of the provisioner base" do
           @prov.expects(:is_a?).with(Vagrant::Provisioners::Base).returns(false)
-          @instance.load_provisioner
-          assert @env.error?
-          assert_equal :provisioner_invalid_class, @env.error.first
+
+          assert_raises(Vagrant::Errors::ProvisionInvalidClass) {
+            @instance.load_provisioner
+          }
         end
       end
 
@@ -81,11 +82,12 @@ class ProvisionVMActionTest < Test::Unit::TestCase
           assert_equal instance, @instance.load_provisioner
         end
 
-        should "raise an ActionException if its an unknown symbol" do
+        should "raise an error if its an unknown symbol" do
           @env["config"].vm.provisioner = :this_will_never_exist
-          @instance.load_provisioner
-          assert @env.error?
-          assert_equal :provisioner_unknown_type, @env.error.first
+
+          assert_raises(Vagrant::Errors::ProvisionUnknownType) {
+            @instance.load_provisioner
+          }
         end
 
         should "set :chef_solo to the ChefSolo provisioner" do
@@ -120,15 +122,6 @@ class ProvisionVMActionTest < Test::Unit::TestCase
 
         @instance.call(@env)
       end
-
-      should "not provision if erroneous environment" do
-        @env.error!(:foo)
-
-        @prov.expects(:provision!).never
-        @app.expects(:call).with(@env).once
-
-        @instance.call(@env)
-      end
     end
   end
 end

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

@@ -3,7 +3,7 @@ require "test_helper"
 class ResumeVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::Resume
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @env["vm"] = @vm

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

@@ -3,7 +3,7 @@ require "test_helper"
 class ShareFoldersVMActionTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Action::VM::ShareFolders
-    @app, @env = mock_action_data
+    @app, @env = action_env
 
     @vm = mock("vm")
     @vm.stubs(:name).returns("foo")
@@ -14,22 +14,18 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
     @internal_vm = mock("internal")
     @vm.stubs(:vm).returns(@internal_vm)
 
+    # No validation for this test since its a nightmare due to all the
+    # nonexistent shared folders.
+    Vagrant::Config::Top.any_instance.stubs(:validate!)
+
     @instance = @klass.new(@app, @env)
   end
 
-  def stub_shared_folders
-    env = mock_environment do |config|
+  def stub_shared_folders(contents)
+    env = vagrant_env(vagrantfile(<<-vf))
       config.vm.shared_folders.clear
-
-      if block_given?
-        yield config
-      else
-        folders = [%w{foo fooguest foohost}, %w{bar barguest barhost}]
-        folders.each do |data|
-          config.vm.share_folder(*data)
-        end
-      end
-    end
+      #{contents}
+    vf
 
     @env.stubs(:env).returns(env)
     env.config.vm.shared_folders
@@ -41,40 +37,22 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
       @instance.expects(:create_metadata).once.in_sequence(before_seq)
       @app.expects(:call).with(@env).in_sequence(before_seq)
       @instance.expects(:mount_shared_folders).once.in_sequence(before_seq)
-      @instance.expects(:setup_unison).once.in_sequence(before_seq)
-
-      @instance.call(@env)
-    end
-
-    should "run only the metadata actions if erroneous environment" do
-      @env.error!(:foo)
-
-      before_seq = sequence("before")
-      @instance.expects(:create_metadata).once.in_sequence(before_seq)
-      @app.expects(:call).with(@env).in_sequence(before_seq)
-      @instance.expects(:mount_shared_folders).never
-      @instance.expects(:setup_unison).never
 
       @instance.call(@env)
     end
   end
 
   context "collecting shared folders" do
-    setup do
-      File.stubs(:expand_path).returns("baz")
-    end
-
     should "return a hash of the shared folders" do
       data = {
         "foo" => %W[bar baz],
         "bar" => %W[foo baz]
       }
 
-      stub_shared_folders do |config|
-        data.each do |name, value|
-          config.vm.share_folder(name, *value)
-        end
-      end
+      stub_shared_folders(<<-sf)
+        config.vm.share_folder("foo", "bar", "baz")
+        config.vm.share_folder("bar", "foo", "baz")
+      sf
 
       result = @instance.shared_folders
       assert_equal data.length, result.length
@@ -86,34 +64,20 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
     end
 
     should "ignore disabled shared folders" do
-      stub_shared_folders do |config|
+      stub_shared_folders(<<-sf)
         config.vm.share_folder("v-foo", "/foo", "/foo")
         config.vm.share_folder("v-root", "/vagrant", ".", :disabled => true)
         config.vm.share_folder("v-bar", "/bar", "/bar")
-      end
+      sf
 
       assert_equal 2, @instance.shared_folders.length
       assert_equal %W[v-bar v-foo], @instance.shared_folders.keys.sort
     end
 
-    should "append sync suffix if sync enabled to a folder" do
-      name = "foo"
-      guest = "bar"
-      host = "baz"
-
-      stub_shared_folders do |config|
-        config.vm.share_folder(name, guest, host, :sync => true)
-      end
-
-      result = @instance.shared_folders
-      assert_equal "#{guest}#{@env.env.config.unison.folder_suffix}", result[name][:guestpath]
-      assert_equal guest, result[name][:original][:guestpath]
-    end
-
     should "not destroy original hash" do
-      @folders = stub_shared_folders do |config|
+      @folders = stub_shared_folders(<<-sf)
         config.vm.share_folder("foo", "bar", "baz", :sync => true)
-      end
+      sf
 
       folder = @folders["foo"].dup
 
@@ -122,25 +86,12 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
     end
   end
 
-  context "unison shared folders" do
-    setup do
-      @folders = stub_shared_folders do |config|
-        config.vm.share_folder("foo", "bar", "baz", :sync => true)
-        config.vm.share_folder("bar", "foo", "baz")
-      end
-    end
-
-    should "only return the folders marked for syncing" do
-      result = @instance.unison_folders
-      assert_equal 1, result.length
-      assert result.has_key?("foo")
-      assert !result.has_key?("bar")
-    end
-  end
-
   context "setting up shared folder metadata" do
     setup do
-      stub_shared_folders
+      stub_shared_folders(<<-sf)
+        config.vm.share_folder("foo", "fooguest", "foohost")
+        config.vm.share_folder("bar", "barguest", "barhost")
+      sf
     end
 
     should "add all shared folders to the VM" do
@@ -162,7 +113,10 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
 
   context "mounting the shared folders" do
     setup do
-      @folders = stub_shared_folders
+      @folders = stub_shared_folders(<<-sf)
+        config.vm.share_folder("foo", "fooguest", "foohost")
+        config.vm.share_folder("bar", "barguest", "barhost")
+      sf
       @ssh = mock("ssh")
       @vm.ssh.stubs(:execute).yields(@ssh)
       @vm.system.stubs(:mount_shared_folder)
@@ -177,39 +131,4 @@ class ShareFoldersVMActionTest < Test::Unit::TestCase
       @instance.mount_shared_folders
     end
   end
-
-  context "setting up unison" do
-    setup do
-      @ssh = mock("ssh")
-      @vm.ssh.stubs(:execute).yields(@ssh)
-
-      @folders = stub_shared_folders do |config|
-        config.vm.share_folder("foo", "bar", "baz", :sync => true)
-        config.vm.share_folder("bar", "foo", "baz")
-      end
-    end
-
-    should "do nothing if unison folders is empty" do
-      @instance.stubs(:unison_folders).returns({})
-      @vm.ssh.expects(:execute).never
-      @instance.setup_unison
-    end
-
-    should "prepare unison then create for each folder" do
-      seq = sequence("unison seq")
-      @vm.system.expects(:prepare_unison).with(@ssh).once.in_sequence(seq)
-      @instance.unison_folders.each do |name, data|
-        if data[:sync]
-          @vm.system.expects(:create_unison).with do |ssh, opts|
-            assert_equal @ssh, ssh
-            assert_equal data, opts
-
-            true
-          end
-        end
-      end
-
-      @instance.setup_unison
-    end
-  end
 end