vagrant 0.5.2 → 0.5.3

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
+      def initialize(env); @env = env; end
+    end
+
+    @klass.send(:include, Vagrant::Action::VM::ForwardPortsHelpers)
+    @app, @env = mock_action_data
+
+    @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 %W[2222 80], @instance.used_ports
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+require "test_helper"
+
+class ForwardPortsVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::ForwardPorts
+    @app, @env = mock_action_data
+
+    @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)
+      @klass.new(@app, @env)
+      assert @env.error?
+      assert_equal :vm_port_below_threshold, @env.error.first
+    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)
+      @klass.new(@app, @env)
+      assert !@env.error?
+    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"
+      @klass.new(@app, @env)
+      assert !@env.error?
+    end
+
+    should "handle collision if it happens" do
+      @used_ports << "2222"
+      @klass.any_instance.expects(:handle_collision).with("ssh", anything, anything).once
+      @klass.new(@app, @env)
+      assert !@env.error?
+    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
+        @instance.handle_collision(@name, @options, @used_ports)
+        assert @env.error?
+        assert_equal :vm_port_collision, @env.error.first
+      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)
+        @instance.handle_collision(@name, @options, @used_ports)
+        assert @env.error?
+        assert_equal :vm_port_auto_empty, @env.error.first
+      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,69 @@
+require "test_helper"
+
+class HaltVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Halt
+    @app, @env = mock_action_data
+
+    @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
+      @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 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/import_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+
+class ImportVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Import
+    @app, @env = mock_action_data
+    @instance = @klass.new(@app, @env)
+
+    ovf_file = "foo"
+    @box = mock("box")
+    @box.stubs(:ovf_file).returns(ovf_file)
+    @env.env.stubs(:box).returns(@box)
+
+    @env.env.vm = Vagrant::VM.new
+
+    VirtualBox::VM.stubs(:import)
+  end
+
+  should "call import on VirtualBox with proper base" do
+    VirtualBox::VM.expects(:import).once.with(@env.env.box.ovf_file).returns("foo")
+    @instance.call(@env)
+  end
+
+  should "call next in chain on success and set VM" do
+    vm = mock("vm")
+    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
+    @instance.call(@env)
+
+    assert @env.error?
+  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)
+    end
+    @env.env.actions.expects(:run).with(:destroy).once
+
+    @instance.call(@env)
+  end
+end

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

@@ -0,0 +1,28 @@
+require "test_helper"
+
+class MatchMACAddressVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::MatchMACAddress
+    @app, @env = mock_action_data
+
+    @vm = mock("vm")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  should "match the mac addresses" do
+    nic = mock("nic")
+    nic.expects(:mac_address=).once
+
+    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)
+
+    @instance.call(@env)
+  end
+end

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

@@ -0,0 +1,246 @@
+require "test_helper"
+
+class NetworkVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Network
+    @app, @env = mock_action_data
+
+    @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)
+  end
+
+  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|
+        assert_equal "foo", options[:ip]
+        true
+      end
+
+      @klass.new(@app, @env)
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @klass.any_instance.stubs(:verify_no_bridge_collision)
+      @instance = @klass.new(@app, @env)
+
+      @interfaces = []
+      VirtualBox::Global.global.host.stubs(:network_interfaces).returns(@interfaces)
+    end
+
+    def mock_interface(options=nil)
+      options = {
+        :interface_type => :host_only,
+        :name => "foo"
+      }.merge(options || {})
+
+      interface = mock("interface")
+      options.each do |k,v|
+        interface.stubs(k).returns(v)
+      end
+
+      @interfaces << interface
+      interface
+    end
+
+    context "calling" do
+      setup do
+        @env.env.config.vm.network("foo")
+        @instance.stubs(:enable_network?).returns(false)
+      end
+
+      should "do nothing if network should not be enabled" do
+        @instance.expects(:assign_network).never
+        @app.expects(:call).with(@env).once
+        @vm.system.expects(:prepare_host_only_network).never
+        @vm.system.expects(:enable_host_only_network).never
+
+        @instance.call(@env)
+      end
+
+      should "assign and enable the network if networking enabled" do
+        @instance.stubs(:enable_network?).returns(true)
+
+        run_seq = sequence("run")
+        @instance.expects(:assign_network).once.in_sequence(run_seq)
+        @app.expects(:call).with(@env).once.in_sequence(run_seq)
+        @vm.system.expects(:prepare_host_only_network).once.in_sequence(run_seq)
+        @vm.system.expects(:enable_host_only_network).once.in_sequence(run_seq)
+
+        @instance.call(@env)
+      end
+    end
+
+    context "checking if network is enabled" do
+      should "return true if the network options are set" do
+        @env.env.config.vm.network("foo")
+        assert @instance.enable_network?
+      end
+
+      should "return false if the network was not set" do
+        assert !@instance.enable_network?
+      end
+    end
+
+    context "assigning the network" do
+      setup do
+        @network_name = "foo"
+        @instance.stubs(:network_name).returns(@network_name)
+
+        @network_adapters = []
+        @internal_vm.stubs(:network_adapters).returns(@network_adapters)
+
+        @options = {
+          :ip => "foo",
+          :adapter => 7
+        }
+
+        @env.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
+
+        @instance.assign_network
+      end
+    end
+
+    context "network name" do
+      setup do
+        @instance.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(:name => result)
+
+        @instance.expects(:matching_network?).with(interface, @options).returns(true)
+        assert_equal result, @instance.network_name(@options)
+      end
+
+      should "ignore non-host only interfaces" do
+        @options[:name] = "foo"
+        mock_interface(:name => @options[:name],
+                       :interface_type => :bridged)
+
+        @instance.network_name(@options)
+        assert @env.error?
+      end
+
+      should "return the network which matches the name if given" do
+        @options[:name] = "foo"
+
+        interface = mock_interface(:name => @options[:name])
+        assert_equal @options[:name], @instance.network_name(@options)
+      end
+
+      should "error and exit if the given network name is not found" do
+        @options[:name] = "foo"
+
+        @interfaces.expects(:create).never
+        @instance.network_name(@options)
+        assert @env.error?
+        assert_equal :network_not_found, @env.error.first
+      end
+
+      should "create a network for the IP and netmask" do
+        result = mock("result")
+        network_ip = :foo
+
+        interface = mock_interface(:name => result)
+        interface.expects(:enable_static).with(network_ip, @options[:netmask])
+        @interfaces.expects(:create).returns(interface)
+        @instance.expects(:network_ip).with(@options[:ip], @options[:netmask]).once.returns(network_ip)
+
+        assert_equal result, @instance.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 !@instance.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 @instance.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, @instance.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, @instance.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, @instance.network_ip(*args)
+        end
+      end
+    end
+
+  end
+end