vagrant 1.0.7 → 1.5.0

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

@@ -1,77 +0,0 @@
-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,
-        :accessible? => 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 which aren't accessible" do
-      @vms << mock_vm(:accessible? => 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/unit_legacy/vagrant/action/vm/forward_ports_test.rb

@@ -1,197 +0,0 @@
-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
-    @env["vm.modify"] = mock("proc")
-  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)
-      @env.env.config.vm.forwarded_ports.clear
-    end
-
-    should "issue a warning for ports less than 1024" do
-      @env.env.config.vm.forward_port("foo", 22, 222)
-
-      @env.ui.expects(:warn).once
-      @klass.new(@app, @env)
-    end
-
-    should "not issue a warning for ports greater than 1024" do
-      @env.env.config.vm.forward_port("foo", 22, 2222)
-
-      @env.ui.expects(:warn).never
-      @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")
-
-        @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)
-      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
-
-        @instance.forward_ports(@internal_vm)
-      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)
-
-        @instance.forward_ports(@internal_vm)
-      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 = @env.env.config.vm.forwarded_ports.keys.first
-        opts = @env.env.config.vm.forwarded_ports[name]
-
-        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(@internal_vm, name, opts)
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-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/unit_legacy/vagrant/action/vm/host_name_test.rb

@@ -1,36 +0,0 @@
-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/unit_legacy/vagrant/action/vm/import_test.rb

@@ -1,66 +0,0 @@
-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