vagrantup 0.3.4 → 0.4.0

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

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

@@ -10,6 +10,8 @@ class ImportActionTest < Test::Unit::TestCase
     @runner.env.stubs(:box).returns(@box)
 
     VirtualBox::VM.stubs(:import)
+
+    @import.stubs(:complete_progress)
   end
 
   should "run in a busy block" do

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

@@ -0,0 +1,237 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class NetworkTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Network)
+    @runner.stubs(:system).returns(linux_system(@vm))
+  end
+
+  context "before destroy" do
+    setup do
+      @network_adapters = []
+      @vm.stubs(:network_adapters).returns(@network_adapters)
+    end
+
+    def stub_interface(length=5)
+      interface = mock("interface")
+      adapter = mock("adapter")
+      adapter.stubs(:host_interface_object).returns(interface)
+      interface.stubs(:attached_vms).returns(Array.new(length))
+
+      @network_adapters << adapter
+      interface
+    end
+
+    should "destroy only the unused network interfaces" do
+      stub_interface(5)
+      stub_interface(7)
+      results = [stub_interface(1), stub_interface(1)]
+
+      results.each do |result|
+        result.expects(:destroy).once
+      end
+
+      @action.before_destroy
+    end
+  end
+
+  context "before boot" do
+    setup do
+      @action.stubs(:enable_network?).returns(false)
+    end
+
+    should "do nothing if network should not be enabled" do
+      @action.expects(:assign_network).never
+      @action.before_boot
+    end
+
+    should "assign the network if host only networking is enabled" do
+      @action.stubs(:enable_network?).returns(true)
+      @action.expects(:assign_network).once
+      @action.before_boot
+    end
+  end
+
+  context "after boot" do
+    setup do
+      @runner.env.config.vm.network("foo")
+      @action.stubs(:enable_network?).returns(true)
+    end
+
+    should "prepare the host only network, then enable them" do
+      run_seq = sequence("run")
+      @runner.system.expects(:prepare_host_only_network).once.in_sequence(run_seq)
+      @runner.system.expects(:enable_host_only_network).once.in_sequence(run_seq)
+      @action.after_boot
+    end
+
+    should "do nothing if network is not enabled" do
+      @action.stubs(:enable_network?).returns(false)
+      @runner.system.expects(:prepare_host_only_network).never
+      @action.after_boot
+    end
+  end
+
+  context "checking if network is enabled" do
+    should "return true if the network options are set" do
+      @runner.env.config.vm.network("foo")
+      assert @action.enable_network?
+    end
+
+    should "return false if the network was not set" do
+      assert !@action.enable_network?
+    end
+  end
+
+  context "assigning the network" do
+    setup do
+      @network_name = "foo"
+      @action.stubs(:network_name).returns(@network_name)
+
+      @network_adapters = []
+      @vm.stubs(:network_adapters).returns(@network_adapters)
+
+      @options = {
+        :ip => "foo",
+        :adapter => 7
+      }
+
+      @runner.env.config.vm.network(@options[:ip], @options)
+    end
+
+    should "setup the specified network adapter" do
+      adapter = mock("adapter")
+      @network_adapters[@options[:adapter]] = adapter
+
+      adapter.expects(:enabled=).with(true).once
+      adapter.expects(:attachment_type=).with(:host_only).once
+      adapter.expects(:host_interface=).with(@network_name).once
+      adapter.expects(:save).once
+
+      @action.assign_network
+    end
+  end
+
+  context "network name" do
+    setup do
+      @interfaces = []
+      VirtualBox::Global.global.host.stubs(:network_interfaces).returns(@interfaces)
+
+      @action.stubs(:matching_network?).returns(false)
+
+      @options = { :ip => :foo, :netmask => :bar, :name => nil }
+    end
+
+    should "return the network which matches" do
+      result = mock("result")
+      interface = mock("interface")
+      interface.stubs(:name).returns(result)
+      @interfaces << interface
+
+      @action.expects(:matching_network?).with(interface, @options).returns(true)
+      assert_equal result, @action.network_name(@options)
+    end
+
+    should "return the network which matches the name if given" do
+      @options[:name] = "foo"
+
+      interface = mock("interface")
+      interface.stubs(:name).returns(@options[:name])
+      @interfaces << interface
+
+      assert_equal @options[:name], @action.network_name(@options)
+    end
+
+    should "error and exit if the given network name is not found" do
+      @options[:name] = "foo"
+
+      @interfaces.expects(:create).never
+
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.network_name(@options)
+      }
+    end
+
+    should "create a network for the IP and netmask" do
+      result = mock("result")
+      interface = mock("interface")
+      network_ip = :foo
+      @interfaces.expects(:create).returns(interface)
+      @action.expects(:network_ip).with(@options[:ip], @options[:netmask]).once.returns(network_ip)
+      interface.expects(:enable_static).with(network_ip, @options[:netmask])
+      interface.expects(:name).returns(result)
+
+      assert_equal result, @action.network_name(@options)
+    end
+  end
+
+  context "checking for a matching network" do
+    setup do
+      @interface = mock("interface")
+      @interface.stubs(:network_mask).returns("foo")
+      @interface.stubs(:ip_address).returns("192.168.0.1")
+
+      @options = {
+        :netmask => "foo",
+        :ip => "baz"
+      }
+    end
+
+    should "return false if the netmasks don't match" do
+      @options[:netmask] = "bar"
+      assert @interface.network_mask != @options[:netmask] # sanity
+      assert !@action.matching_network?(@interface, @options)
+    end
+
+    should "return true if the netmasks yield the same IP" do
+      tests = [["255.255.255.0", "192.168.0.1", "192.168.0.45"],
+               ["255.255.0.0", "192.168.45.1", "192.168.28.7"]]
+
+      tests.each do |netmask, interface_ip, guest_ip|
+        @options[:netmask] = netmask
+        @options[:ip] = guest_ip
+        @interface.stubs(:network_mask).returns(netmask)
+        @interface.stubs(:ip_address).returns(interface_ip)
+
+        assert @action.matching_network?(@interface, @options)
+      end
+    end
+  end
+
+  context "applying the netmask" do
+    should "return the proper result" do
+      tests = {
+        ["192.168.0.1","255.255.255.0"] => [192,168,0,0],
+        ["192.168.45.10","255.255.255.0"] => [192,168,45,0]
+      }
+
+      tests.each do |k,v|
+        assert_equal v, @action.apply_netmask(*k)
+      end
+    end
+  end
+
+  context "splitting an IP" do
+    should "return the proper result" do
+      tests = {
+        "192.168.0.1" => [192,168,0,1]
+      }
+
+      tests.each do |k,v|
+        assert_equal v, @action.split_ip(k)
+      end
+    end
+  end
+
+  context "network IP" do
+    should "return the proper result" do
+      tests = {
+        ["192.168.0.45", "255.255.255.0"] => "192.168.0.1"
+      }
+
+      tests.each do |args, result|
+        assert_equal result, @action.network_ip(*args)
+      end
+    end
+  end
+end

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

@@ -2,12 +2,15 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 
 class PackageActionTest < Test::Unit::TestCase
   setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package, "bing", [])
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package)
   end
 
   context "initialization" do
-    def get_action(*args)
-      runner, vm, action = mock_action(Vagrant::Actions::VM::Package, *args)
+    def get_action(output, include_files)
+      runner, vm, action = mock_action(Vagrant::Actions::VM::Package, {
+                                         :output => output,
+                                         :include => include_files
+                                       })
       return action
     end
 
@@ -35,6 +38,31 @@ class PackageActionTest < Test::Unit::TestCase
     end
   end
 
+  context "out path" do
+    should "be the specified output file if given" do
+      result = mock("result")
+      @action.options[:output] = result
+      assert_equal result, @action.out_path
+    end
+
+    should "default to 'package'" do
+      @action.options[:output] = nil
+      assert_equal "package", @action.out_path
+    end
+  end
+
+  context "include files" do
+    should "specified array if given" do
+      @action.options[:include] = [1,2,3]
+      assert_equal @action.options[:include], @action.include_files
+    end
+
+    should "be an empty array by default" do
+      @action.options[:include] = nil
+      assert_equal [], @action.include_files
+    end
+  end
+
   context "tar path" do
     should "be the temporary directory with the name and extension attached" do
       pwd = "foo"
@@ -138,7 +166,7 @@ class PackageActionTest < Test::Unit::TestCase
     end
 
     should "open the tar file with the tar path properly" do
-      File.expects(:open).with(@tar_path, File::CREAT | File::WRONLY, 0644).once
+      File.expects(:open).with(@tar_path, Vagrant::Util::Platform.tar_file_options).once
       @action.compress
     end
 
@@ -185,7 +213,9 @@ class PackageActionTest < Test::Unit::TestCase
     context "checking include files" do
       setup do
         @include_files = ['fooiest', 'booiest']
-        @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package, "bing", @include_files)
+        @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package, {
+                                              :include => @include_files
+                                            })
         @runner.stubs(:find_action).returns("foo")
       end
 

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

@@ -44,13 +44,13 @@ class ProvisionActionTest < Test::Unit::TestCase
         @instance.stubs(:prepare)
         @klass = mock("klass")
         @klass.stubs(:is_a?).with(Class).returns(true)
-        @klass.stubs(:new).with(@runner.env).returns(@instance)
+        @klass.stubs(:new).with(@runner).returns(@instance)
 
         @runner.env.config.vm.provisioner = @klass
       end
 
       should "set the provisioner to an instantiation of the class" do
-        @klass.expects(:new).with(@runner.env).once.returns(@instance)
+        @klass.expects(:new).with(@runner).once.returns(@instance)
         assert_nothing_raised { @action.prepare }
         assert_equal @instance, @action.provisioner
       end
@@ -74,7 +74,7 @@ class ProvisionActionTest < Test::Unit::TestCase
 
         instance = mock("instance")
         instance.expects(:prepare).once
-        provisioner.expects(:new).with(@runner.env).returns(instance)
+        provisioner.expects(:new).with(@runner).returns(instance)
         assert_nothing_raised { @action.prepare }
         assert_equal instance, @action.provisioner
       end

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

@@ -7,7 +7,7 @@ class ReloadActionTest < Test::Unit::TestCase
 
   context "sub-actions" do
     setup do
-      @default_order = [Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
+      @default_order = [Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Network, Vagrant::Actions::VM::Boot]
       @vm.stubs(:running?).returns(false)
     end
 

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

@@ -3,6 +3,7 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 class SharedFoldersActionTest < Test::Unit::TestCase
   setup do
     @runner, @vm, @action = mock_action(Vagrant::Actions::VM::SharedFolders)
+    @runner.stubs(:system).returns(linux_system(@vm))
   end
 
   def stub_shared_folders
@@ -26,19 +27,14 @@ class SharedFoldersActionTest < Test::Unit::TestCase
     end
 
     should "convert the vagrant config values into an array" do
-      env = mock_environment do |config|
-        config.vm.shared_folders.clear
-        config.vm.share_folder("foo", "bar", "baz")
-      end
-
-      @runner.expects(:env).returns(env)
+      mock_env_shared_folders
 
       result = [["foo", "baz", "bar"]]
       assert_equal result, @action.shared_folders
     end
 
     should "expand the path of the host folder" do
-      File.expects(:expand_path).with("baz").once.returns("expanded_baz")
+      File.expects(:expand_path).with("baz", @runner.env.root_path).once.returns("expanded_baz")
 
       env = mock_environment do |config|
         config.vm.shared_folders.clear
@@ -50,6 +46,23 @@ class SharedFoldersActionTest < Test::Unit::TestCase
       result = [["foo", "expanded_baz", "bar"]]
       assert_equal result, @action.shared_folders
     end
+
+    context "with sync" do
+      should "append the sync value to the other config values" do
+        mock_env_shared_folders(:sync => true)
+
+        assert_equal [["foo", "baz", "bar-sync", "bar"]], @action.shared_folders
+      end
+    end
+
+    def mock_env_shared_folders(opts={})
+      env = mock_environment do |config|
+        config.vm.shared_folders.clear
+        config.vm.share_folder("foo", "bar", "baz", opts)
+      end
+
+      @runner.expects(:env).returns(env)
+    end
   end
 
   context "clearing shared folders" do
@@ -68,6 +81,12 @@ class SharedFoldersActionTest < Test::Unit::TestCase
       @runner.expects(:reload!).once.in_sequence(destroy_seq)
       @action.clear_shared_folders
     end
+
+    should "do nothing if no shared folders existed" do
+      @shared_folders.clear
+      @runner.expects(:reload!).never
+      @action.clear_shared_folders
+    end
   end
 
   context "setting up shared folder metadata" do
@@ -90,86 +109,34 @@ class SharedFoldersActionTest < Test::Unit::TestCase
   context "mounting the shared folders" do
     setup do
       @folders = stub_shared_folders
+      @ssh = mock("ssh")
+      @runner.ssh.stubs(:execute).yields(@ssh)
+      @runner.system.stubs(:mount_shared_folder)
     end
 
     should "mount all shared folders to the VM" do
       mount_seq = sequence("mount_seq")
-      ssh = mock("ssh")
       @folders.each do |name, hostpath, guestpath|
-        ssh.expects(:exec!).with("sudo mkdir -p #{guestpath}").in_sequence(mount_seq)
-        @action.expects(:mount_folder).with(ssh, name, guestpath).in_sequence(mount_seq)
-        ssh.expects(:exec!).with("sudo chown #{@runner.env.config.ssh.username} #{guestpath}").in_sequence(mount_seq)
+        @runner.system.expects(:mount_shared_folder).with(@ssh, name, guestpath).in_sequence(mount_seq)
       end
-      @runner.env.ssh.expects(:execute).yields(ssh)
 
       @action.after_boot
     end
-  end
 
-  context "mounting the main folder" do
-    setup do
-      @ssh = mock("ssh")
-      @name = "foo"
-      @guestpath = "bar"
-      @sleeptime = 0
-      @limit = 10
-
-      @success_return = false
-    end
-
-    def mount_folder
-      @action.mount_folder(@ssh, @name, @guestpath, @sleeptime)
-    end
-
-    should "execute the proper mount command" do
-      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{@runner.env.config.ssh.username},gid=#{@runner.env.config.ssh.username} #{@name} #{@guestpath}").returns(@success_return)
-      mount_folder
-    end
-
-    should "test type of text and text string to detect error" do
-      data = mock("data")
-      data.expects(:[]=).with(:result, !@success_return)
-
-      @ssh.expects(:exec!).yields(data, :stderr, "No such device").returns(@success_return)
-      mount_folder
-    end
-
-    should "test type of text and test string to detect success" do
-      data = mock("data")
-      data.expects(:[]=).with(:result, @success_return)
-
-      @ssh.expects(:exec!).yields(data, :stdout, "Nothing such device").returns(@success_return)
-      mount_folder
-    end
-
-    should "raise an ActionException if the command fails constantly" do
-      @ssh.expects(:exec!).times(@limit).returns(!@success_return)
-
-      assert_raises(Vagrant::Actions::ActionException) {
-        mount_folder
-      }
-    end
-
-    should "not raise any exception if the command succeeded" do
-      @ssh.expects(:exec!).once.returns(@success_return)
-
-      assert_nothing_raised {
-        mount_folder
-      }
-    end
-
-    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
+    should "execute the necessary rysnc commands for each sync folder" do
+      @folders.map { |f| f << 'sync' }
+      @folders.each do |name, hostpath, guestpath, syncd|
+        @runner.system.expects(:create_sync).with(@ssh, :syncpath => syncd, :guestpath => guestpath)
       end
+      @runner.ssh.expects(:execute).yields(@ssh)
 
-      @runner.expects(:env).twice.returns(env)
+      @action.after_boot
+    end
+  end
 
-      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{uid},gid=#{gid} #{@name} #{@guestpath}").returns(@success_return)
-      mount_folder
+  context "with syncd folders" do
+    # TODO prevented by odd configuration swapping when stubbing ssh.execute
+    should "prepare the system for sync if necessary" do
     end
   end
 end