vagrantup 1.0.7 → 1.1.0

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

@@ -1,25 +0,0 @@
-require "test_helper"
-
-class DestroyVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::Destroy
-    @app, @env = action_env
-
-    @vm = mock("vm")
-    @env["vm"] = @vm
-
-    @internal_vm = mock("internal")
-    @vm.stubs(:vm).returns(@internal_vm)
-
-    @instance = @klass.new(@app, @env)
-  end
-
-  context "destroying the VM" do
-    should "destroy VM and attached images" do
-      @internal_vm.expects(:destroy).once
-      @env["vm"].expects(:vm=).with(nil).once
-      @app.expects(:call).with(@env).once
-      @instance.call(@env)
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-require "test_helper"
-
-class DestroyUnusedNetworkInterfacesVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::DestroyUnusedNetworkInterfaces
-    @app, @env = action_env
-
-    @vm = mock("vm")
-    @env["vm"] = @vm
-
-    @internal_vm = mock("internal")
-    @vm.stubs(:vm).returns(@internal_vm)
-
-    @instance = @klass.new(@app, @env)
-  end
-
-  context "calling" do
-    setup do
-      @interfaces = []
-      global = mock("global")
-      host = mock("host")
-      VirtualBox::Global.stubs(:global).returns(global)
-      global.stubs(:host).returns(host)
-      host.stubs(:network_interfaces).returns(@interfaces)
-    end
-
-    def stub_interface(length=5, type=:host_only)
-      interface = mock("interface")
-      interface.stubs(:interface_type).returns(type)
-      interface.stubs(:attached_vms).returns(Array.new(length))
-
-      @interfaces << interface
-      interface
-    end
-
-    should "destroy only the unused network interfaces" do
-      stub_interface(5)
-      stub_interface(7)
-      results = [stub_interface(0), stub_interface(0)]
-
-      results.each do |result|
-        result.expects(:destroy).once
-      end
-
-      @app.expects(:call).with(@env).once
-      @instance.call(@env)
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-require "test_helper"
-
-class DiscardStateVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::DiscardState
-    @app, @env = action_env
-
-    @vm = mock("vm")
-    @env["vm"] = @vm
-
-    @internal_vm = mock("internal")
-    @vm.stubs(:vm).returns(@internal_vm)
-
-    @instance = @klass.new(@app, @env)
-  end
-
-  context "calling" do
-    setup do
-      @vm.stubs(:created?).returns(true)
-      @internal_vm.stubs(:saved?).returns(false)
-    end
-
-    should "do nothing if the VM is not created" do
-      @vm.stubs(:created?).returns(false)
-      @internal_vm.expects(:discard_state).never
-      @app.expects(:call).with(@env).once
-      @instance.call(@env)
-    end
-
-    should "do nothing if not saved and continue chain" do
-      @internal_vm.expects(:saved?).returns(false)
-      @internal_vm.expects(:discard_state).never
-      @app.expects(:call).with(@env).once
-      @instance.call(@env)
-    end
-
-    should "discard state and continue chain" do
-      seq = sequence("sequence")
-      @internal_vm.expects(:saved?).returns(true).in_sequence(seq)
-      @internal_vm.expects(:discard_state).in_sequence(seq)
-      @app.expects(:call).with(@env).once.in_sequence(seq)
-      @instance.call(@env)
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-require "test_helper"
-
-class ExportVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::Export
-    @app, @env = action_env
-
-    @vm = mock("vm")
-    @env["vm"] = @vm
-
-    @internal_vm = mock("internal")
-    @vm.stubs(:vm).returns(@internal_vm)
-
-    @instance = @klass.new(@app, @env)
-  end
-
-  context "calling" do
-    setup do
-      @internal_vm.stubs(:powered_off?).returns(true)
-    end
-
-    should "call the proper methods then continue chain" do
-      seq = sequence("seq")
-      @instance.expects(:setup_temp_dir).in_sequence(seq)
-      @instance.expects(:export).in_sequence(seq)
-      @app.expects(:call).with(@env).in_sequence(seq)
-      @instance.expects(:recover).in_sequence(seq).with(@env)
-
-      @instance.call(@env)
-    end
-
-    should "halt the chain if not powered off" do
-      @internal_vm.stubs(:powered_off?).returns(false)
-      @instance.expects(:setup_temp_dir).never
-      @instance.expects(:export).never
-      @app.expects(:call).with(@env).never
-      @instance.expects(:recover).never
-
-      assert_raises(Vagrant::Errors::VMPowerOffToPackage) {
-        @instance.call(@env)
-      }
-    end
-  end
-
-  context "cleaning up" do
-    setup do
-      @temp_dir = "foo"
-      @instance.stubs(:temp_dir).returns(@temp_dir)
-      File.stubs(:exist?).returns(true)
-    end
-
-    should "delete the temporary file if it exists" do
-      File.expects(:unlink).with(@temp_dir).once
-      @instance.recover(nil)
-    end
-
-    should "not delete anything if it doesn't exist" do
-      File.stubs(:exist?).returns(false)
-      File.expects(:unlink).never
-      @instance.recover(nil)
-    end
-  end
-
-  context "setting up the temporary directory" do
-    setup do
-      @time_now = Time.now.to_i.to_s
-      Time.stubs(:now).returns(@time_now)
-
-      @temp_dir = @env.env.tmp_path.join(@time_now)
-      FileUtils.stubs(:mkpath)
-    end
-
-    should "create the temporary directory using the current time" do
-      FileUtils.expects(:mkpath).with(@temp_dir).once
-      @instance.setup_temp_dir
-    end
-
-    should "set to the environment" do
-      @instance.setup_temp_dir
-      assert_equal @temp_dir, @env["export.temp_dir"]
-      assert_equal @temp_dir, @instance.temp_dir
-    end
-  end
-
-  context "exporting" do
-    setup do
-      @ovf_path = mock("ovf_path")
-      @instance.stubs(:ovf_path).returns(@ovf_path)
-    end
-
-    should "call export on the runner with the ovf path" do
-      @internal_vm.expects(:export).with(@ovf_path).once
-      @instance.export
-    end
-  end
-
-  context "path to OVF file" do
-    setup do
-      @temp_dir = "foo"
-      @env["export.temp_dir"] = @temp_dir
-    end
-
-    should "be the temporary directory joined with the OVF filename" do
-      assert_equal File.join(@temp_dir, @env.env.config.vm.box_ovf), @instance.ovf_path
-    end
-  end
-end

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