fixed-vagrant 0.7.4.dev

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

@@ -0,0 +1,70 @@
+require "test_helper"
+
+class ForwardPortsHelpersVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Class.new do
+      include Vagrant::Action::VM::ForwardPortsHelpers
+      def initialize(env); @env = env; end
+    end
+
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:name).returns("foo")
+    @env["vm"] = @vm
+
+    @instance = @klass.new(@env)
+  end
+
+  context "getting list of used ports" do
+    setup do
+      @vms = []
+      VirtualBox::VM.stubs(:all).returns(@vms)
+      VirtualBox.stubs(:version).returns("3.1.0")
+      @vm.stubs(:uuid).returns(:bar)
+    end
+
+    def mock_vm(options={})
+      options = {
+        :running? => true,
+        :uuid => :foo
+      }.merge(options)
+
+      vm = mock("vm")
+      options.each do |k,v|
+        vm.stubs(k).returns(v)
+      end
+
+      vm
+    end
+
+    def mock_fp(hostport)
+      fp = mock("fp")
+      fp.stubs(:hostport).returns(hostport.to_s)
+      fp
+    end
+
+    should "ignore VMs which aren't running" do
+      @vms << mock_vm(:running? => false)
+      @vms[0].expects(:forwarded_ports).never
+      @instance.used_ports
+    end
+
+    should "ignore VMs of the same uuid" do
+      @vms << mock_vm(:uuid => @vm.uuid)
+      @vms[0].expects(:forwarded_ports).never
+      @instance.used_ports
+    end
+
+    should "return the forwarded ports for VB 3.2.x" do
+      VirtualBox.stubs(:version).returns("3.2.4")
+      fps = [mock_fp(2222), mock_fp(80)]
+      na = mock("na")
+      ne = mock("ne")
+      na.stubs(:nat_driver).returns(ne)
+      ne.stubs(:forwarded_ports).returns(fps)
+      @vms << mock_vm(:network_adapters => [na])
+      assert_equal [2222, 80], @instance.used_ports
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+require "test_helper"
+
+class ForwardPortsVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ForwardPorts
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:name).returns("foo")
+    @env["vm"] = @vm
+  end
+
+  context "initializing" do
+    should "call proper methods" do
+      @klass.any_instance.expects(:threshold_check)
+      @klass.any_instance.expects(:external_collision_check)
+      @klass.new(@app, @env)
+    end
+  end
+
+  context "checking for threshold" do
+    setup do
+      @klass.any_instance.stubs(:external_collision_check)
+    end
+
+    should "error if has a port below threshold" do
+      @env.env.config.vm.forwarded_ports.clear
+      @env.env.config.vm.forward_port("foo", 22, 222)
+
+      assert_raises(Vagrant::Errors::ForwardPortBelowThreshold) {
+        @klass.new(@app, @env)
+      }
+    end
+
+    should "not error if ports are fine" do
+      @env.env.config.vm.forwarded_ports.clear
+      @env.env.config.vm.forward_port("foo", 22, 2222)
+
+      assert_nothing_raised {
+        @klass.new(@app, @env)
+      }
+    end
+  end
+
+  context "checking for colliding external ports" do
+    setup do
+      @env.env.config.vm.forwarded_ports.clear
+      @env.env.config.vm.forward_port("ssh", 22, 2222)
+
+      @used_ports = []
+      @klass.any_instance.stubs(:used_ports).returns(@used_ports)
+      @klass.any_instance.stubs(:handle_collision)
+    end
+
+    should "not raise any errors if no forwarded ports collide" do
+      @used_ports << 80
+      assert_nothing_raised { @klass.new(@app, @env) }
+    end
+
+    should "handle collision if it happens" do
+      @used_ports << 2222
+      @klass.any_instance.expects(:handle_collision).with("ssh", anything, anything).once
+      assert_nothing_raised { @klass.new(@app, @env) }
+    end
+  end
+
+  context "with instance" do
+    setup do
+      @klass.any_instance.stubs(:threshold_check)
+      @klass.any_instance.stubs(:external_collision_check)
+      @instance = @klass.new(@app, @env)
+    end
+
+    context "handling collisions" do
+      setup do
+        @name = :foo
+        @options = {
+          :hostport => 0,
+          :auto => true
+        }
+        @used_ports = [1,2,3]
+
+        @env.env.config.vm.auto_port_range = (1..5)
+      end
+
+      should "error if auto forwarding is disabled" do
+        @options[:auto] = false
+
+        assert_raises(Vagrant::Errors::ForwardPortCollision) {
+          @instance.handle_collision(@name, @options, @used_ports)
+        }
+      end
+
+      should "set the host port to the first available port" do
+        assert_equal 0, @options[:hostport]
+        @instance.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)
+        @instance.handle_collision(@name, @options, @used_ports)
+        assert @used_ports.include?(4)
+      end
+
+      should "not use a host port which is being forwarded later" do
+        @env.env.config.vm.forward_port("http", 80, 4)
+
+        assert_equal 0, @options[:hostport]
+        @instance.handle_collision(@name, @options, @used_ports)
+        assert_equal 5, @options[:hostport]
+      end
+
+      should "raise an exception if there are no auto ports available" do
+        @env.env.config.vm.auto_port_range = (1..3)
+
+        assert_raises(Vagrant::Errors::ForwardPortAutolistEmpty) {
+          @instance.handle_collision(@name, @options, @used_ports)
+        }
+      end
+    end
+
+    context "calling" do
+      should "clear all previous ports and forward new ports" do
+        exec_seq = sequence("exec_seq")
+        @instance.expects(:forward_ports).once.in_sequence(exec_seq)
+        @app.expects(:call).once.with(@env).in_sequence(exec_seq)
+        @instance.call(@env)
+      end
+    end
+
+    context "forwarding ports" do
+      setup do
+        @internal_vm = mock("internal_vm")
+        @vm.stubs(:vm).returns(@internal_vm)
+      end
+
+      should "create a port forwarding for the VM" do
+        forwarded_ports = mock("forwarded_ports")
+        network_adapter = mock("network_adapter")
+
+        @internal_vm.stubs(:network_adapters).returns([network_adapter])
+        network_adapter.expects(:attachment_type).returns(:nat)
+
+        @instance.expects(:forward_port).once
+        @internal_vm.expects(:save).once
+        @vm.expects(:reload!).once
+        @instance.forward_ports
+      end
+
+      should "not port forward for non NAT interfaces" do
+        forwarded_ports = mock("forwarded_ports")
+        network_adapter = mock("network_adapter")
+
+        @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
+      end
+    end
+
+    context "forwarding ports implementation" do
+      setup do
+        VirtualBox.stubs(:version).returns("3.2.8")
+
+        @internal_vm = mock("internal_vm")
+        @vm.stubs(:vm).returns(@internal_vm)
+      end
+
+      should "forward ports" do
+        name, opts = @env.env.config.vm.forwarded_ports.first
+
+        adapters = []
+        adapter = mock("adapter")
+        engine = mock("engine")
+        fps = mock("forwarded ports")
+        adapter.stubs(:nat_driver).returns(engine)
+        engine.stubs(:forwarded_ports).returns(fps)
+        fps.expects(:<<).with do |port|
+          assert_equal name, port.name
+          assert_equal opts[:hostport], port.hostport
+          assert_equal opts[:guestport], port.guestport
+          true
+        end
+
+        adapters[opts[:adapter]] = adapter
+        @internal_vm.stubs(:network_adapters).returns(adapters)
+
+        @instance.forward_port(name, opts)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require "test_helper"
+
+class HaltVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Halt
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:name).returns("foo")
+    @vm.stubs(:ssh).returns(mock("ssh"))
+    @vm.stubs(:system).returns(mock("system"))
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "initializing" do
+    should "merge in the given options" do
+      @klass.new(@app, @env, :foo => :bar)
+      assert_equal :bar, @env[:foo]
+    end
+  end
+
+  context "calling" do
+    setup do
+      @vm.stubs(:created?).returns(true)
+      @internal_vm.stubs(:running?).returns(true)
+
+      @vm.system.stubs(:halt)
+      @internal_vm.stubs(:stop)
+      @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
+      @internal_vm.expects(:stop).never
+      @app.expects(:call).once
+
+      @instance.call(@env)
+    end
+
+    should "halt with the system and NOT force VM to stop if powered off" do
+      @internal_vm.expects(:state).with(true).returns(:powered_off)
+      @vm.system.expects(:halt).once
+      @internal_vm.expects(:stop).never
+      @app.expects(:call).once
+
+      @instance.call(@env)
+    end
+
+    should "halt with the system and force VM to stop if NOT powered off" do
+      @internal_vm.expects(:state).with(true).returns(:running)
+      @vm.system.expects(:halt).once
+      @internal_vm.expects(:stop).once
+      @app.expects(:call).once
+
+      @instance.call(@env)
+    end
+
+    should "not call halt on the system if forcing" do
+      @env[:force] = true
+      @vm.system.expects(:halt).never
+      @instance.call(@env)
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "test_helper"
+
+class HostNameVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::HostName
+    @app, @env = action_env
+    @instance = @klass.new(@app, @env)
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+  end
+
+  should "not run anything if no host name is set" do
+    @env["config"].vm.host_name = nil
+    @env["vm"].expects(:system).never
+    @app.expects(:call).with(@env).once
+
+    @instance.call(@env)
+  end
+
+  should "change host name if set" do
+    @env["config"].vm.host_name = "foo"
+
+    system = mock("system")
+    @vm.stubs(:system).returns(system)
+
+    seq = sequence("host_seq")
+    @app.expects(:call).with(@env).in_sequence(seq)
+    system.expects(:change_host_name).with(@env["config"].vm.host_name).in_sequence(seq)
+
+    @instance.call(@env)
+  end
+end

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

@@ -0,0 +1,66 @@
+require "test_helper"
+
+class ImportVMActionTest < Test::Unit::TestCase
+  setup do
+    clean_paths
+    vagrant_box("foo")
+
+    @klass = Vagrant::Action::VM::Import
+    @app, @env = action_env(vagrant_env(vagrantfile(<<-vf)))
+      config.vm.box = "foo"
+    vf
+
+    @instance = @klass.new(@app, @env)
+
+    @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.to_s).returns(@vm)
+    @instance.call(@env)
+  end
+
+  should "call next in chain on success and set VM" do
+    VirtualBox::VM.stubs(:import).returns(@vm)
+    @app.expects(:call).with(@env).once
+    @instance.call(@env)
+
+    assert_equal @vm, @env["vm"].vm
+  end
+
+  should "mark environment erroneous and not continue chain on failure" do
+    @app.expects(:call).never
+    assert_raises(Vagrant::Errors::VMImportFailure) {
+      @instance.call(@env)
+    }
+  end
+
+  context "recovery" do
+    setup do
+      @env.env.vm.stubs(:created?).returns(true)
+    end
+
+    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