boxcar 0.10005.1

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

@@ -0,0 +1,40 @@
+require "test_helper"
+
+class MatchMACAddressVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::MatchMACAddress
+    @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
+
+  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)
+    @app.expects(:call).with(@env).once.in_sequence(update_seq)
+
+    @env["vm.modify"].expects(:call).with() do |proc|
+      proc.call(@internal_vm)
+      true
+    end
+
+    @instance.call(@env)
+  end
+
+  should "raise an exception if no base MAC address is specified" do
+    @env.env.config.vm.base_mac = nil
+
+    assert_raises(Vagrant::Errors::VMBaseMacNotSpecified) {
+      @instance.call(@env)
+    }
+  end
+end

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

@@ -0,0 +1,38 @@
+require "test_helper"
+
+class ModifyVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Modify
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:ssh).returns(mock("ssh"))
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+
+    @instance = @klass.new(@app, @env)
+  end
+
+  context "initialization" do
+    should "have the vm.modify function setup in the environment" do
+      assert @env.has_key?("vm.modify")
+    end
+  end
+
+  context "calling" do
+    should "run the procs with the VM as an argument and save the VM" do
+      seq = sequence("procseq")
+
+      proc = Proc.new { |vm| }
+      @env["vm.modify"].call(proc)
+
+      proc.expects(:call).with(@internal_vm).once.in_sequence(seq)
+      @internal_vm.expects(:save).once.in_sequence(seq)
+      @vm.expects(:reload!).once.in_sequence(seq)
+
+      @instance.call(@env)
+    end
+  end
+end

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

@@ -0,0 +1,286 @@
+require "test_helper"
+
+class NetworkVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::Network
+    @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)
+  end
+
+  context "initializing" do
+    should "raise an error if on windows x64 and networking is enabled" do
+      Vagrant::Util::Platform.stubs(:windows?).returns(true)
+      Vagrant::Util::Platform.stubs(:bit64?).returns(true)
+      @env.env.config.vm.network("foo")
+
+      assert_raises(Vagrant::Errors::NetworkNotImplemented) {
+        @klass.new(@app, @env)
+      }
+    end
+
+    should "not raise an error if not on windows and networking is enabled" do
+      Vagrant::Util::Platform.stubs(:windows?).returns(false)
+      @env.env.config.vm.network("foo")
+
+      assert_nothing_raised {
+        @klass.new(@app, @env)
+      }
+    end
+
+    should "verify no bridge collisions for each network enabled" do
+      @env.env.config.vm.network("foo")
+      @klass.any_instance.expects(:verify_no_bridge_collision).returns(true).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)
+      end
+
+      def expect_adapter_setup(options=nil)
+        options = {
+          :ip => "foo",
+          :adapter => 7
+        }.merge(options || {})
+
+        @env["config"].vm.network(options[:ip], options)
+
+        @env["vm"].vm.network_adapters.clear
+        @env["vm"].vm.network_adapters[options[:adapter]] = adapter = mock("adapter")
+
+        adapter.expects(:enabled=).with(true)
+        adapter.expects(:attachment_type=).with(:host_only).once
+        adapter.expects(:host_only_interface=).with(@network_name).once
+
+        if options[:mac]
+          adapter.expects(:mac_address=).with(options[:mac].gsub(':', '')).once
+        else
+          adapter.expects(:mac_address=).never
+        end
+
+        adapter.expects(:save).once
+      end
+
+      should "setup the specified network adapter" do
+        expect_adapter_setup
+        @instance.assign_network
+      end
+
+      should "setup the specified network adapter's mac address if specified" do
+        expect_adapter_setup(:mac => "foo")
+        @instance.assign_network
+      end
+
+      should "properly remove : from mac address" do
+        expect_adapter_setup(:mac => "foo:bar")
+        @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)
+
+        assert_raises(Vagrant::Errors::NetworkNotFound) {
+          @instance.network_name(@options)
+        }
+      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
+        assert_raises(Vagrant::Errors::NetworkNotFound) {
+          @instance.network_name(@options)
+        }
+      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

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

@@ -0,0 +1,26 @@
+require "test_helper"
+
+class NFSHelpersVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Class.new do
+      include Vagrant::Action::VM::NFSHelpers
+    end
+
+    @app, @env = action_env
+
+    @instance = @klass.new
+  end
+
+  should "clear NFS exports for the environment if the host exists" do
+    @host = mock("host")
+    @env.env.stubs(:host).returns(@host)
+    @host.expects(:nfs_cleanup).once
+
+    @instance.clear_nfs_exports(@env)
+  end
+
+  should "not do anything if host is nil" do
+    @env.env.stubs(:host).returns(nil)
+    assert_nothing_raised { @instance.clear_nfs_exports(@env) }
+  end
+end

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

@@ -0,0 +1,260 @@
+require "test_helper"
+
+class NFSVMActionTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Action::VM::NFS
+    @app, @env = action_env
+
+    @vm = mock("vm")
+    @vm.stubs(:system).returns(mock("system"))
+    @env.env.stubs(:host).returns(Vagrant::Hosts::Base.new(@env))
+    @env.env.config.vm.network("192.168.55.1")
+    @env["vm"] = @vm
+
+    @internal_vm = mock("internal")
+    @vm.stubs(:vm).returns(@internal_vm)
+  end
+
+  context "initializing" do
+    should "not call verify settings if NFS is not enabled" do
+      @klass.any_instance.expects(:verify_settings).never
+      @klass.new(@app, @env)
+    end
+
+    should "call verify settings if NFS is enabled" do
+      @env.env.config.vm.share_folder("v-root", "/vagrant", ".", :nfs => true)
+      @klass.any_instance.expects(:verify_settings).once
+      @klass.new(@app, @env)
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @instance = @klass.new(@app, @env)
+    end
+
+    context "calling" do
+      setup do
+        @instance.stubs(:folders).returns([:a])
+
+        [:clear_nfs_exports, :extract_folders, :prepare_folders, :export_folders, :mount_folders].each do |meth|
+          @instance.stubs(meth)
+        end
+      end
+
+      should "call the proper sequence and succeed" do
+        seq = sequence('seq')
+        @instance.expects(:extract_folders).in_sequence(seq)
+        @instance.expects(:prepare_folders).in_sequence(seq)
+        @instance.expects(:clear_nfs_exports).with(@env).in_sequence(seq)
+        @instance.expects(:export_folders).in_sequence(seq)
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @instance.expects(:mount_folders).in_sequence(seq)
+        @instance.call(@env)
+      end
+
+      should "not export folders if folders is empty" do
+        @instance.stubs(:folders).returns([])
+
+        seq = sequence('seq')
+        @instance.expects(:extract_folders).in_sequence(seq)
+        @instance.expects(:prepare_folders).never
+        @instance.expects(:export_folders).never
+        @instance.expects(:clear_nfs_exports).never
+        @app.expects(:call).with(@env).in_sequence(seq)
+        @instance.expects(:mount_folders).never
+        @instance.call(@env)
+      end
+    end
+
+    context "recovery" do
+      setup do
+        @vm.stubs(:created?).returns(true)
+      end
+
+      should "clear NFS exports" do
+        @instance.expects(:clear_nfs_exports).with(@env).once
+        @instance.recover(@env)
+      end
+
+      should "do nothing if VM is not created" do
+        @vm.stubs(:created?).returns(false)
+        @instance.expects(:clear_nfs_exports).never
+        @instance.recover(@env)
+      end
+    end
+
+    context "extracting folders" do
+      setup do
+        @env.env.config.vm.shared_folders.clear
+        @env.env.config.vm.share_folder("v-foo", "/foo", ".", :nfs => true)
+        @env.env.config.vm.share_folder("v-bar", "/bar", ".", :nfs => true)
+      end
+
+      should "extract the NFS enabled folders" do
+        @instance.extract_folders
+        assert_equal 2, @instance.folders.length
+      end
+
+      should "mark the folders disabled from the original config" do
+        @instance.extract_folders
+        %W[v-foo v-bar].each do |key|
+          assert @env["config"].vm.shared_folders[key][:disabled]
+        end
+      end
+
+      should "expand the hostpath relative to the env root" do
+        @instance.extract_folders
+        %W[v-foo v-bar].each do |key|
+          opts = @env["config"].vm.shared_folders[key]
+          assert_equal File.expand_path(opts[:hostpath], @env.env.root_path), @instance.folders[key][:hostpath]
+        end
+      end
+    end
+
+    context "preparing UID/GID" do
+      setup do
+        @stat = mock("stat")
+        File.stubs(:stat).returns(@stat)
+      end
+
+      should "return nil if the perm is not set" do
+        @env.env.config.nfs.map_uid = nil
+        assert_nil @instance.prepare_permission(:uid, {:gid => 7})
+      end
+
+      should "return nil if the perm explicitly says nil" do
+        assert_nil @instance.prepare_permission(:uid, {:map_uid => nil})
+      end
+
+      should "return the set value if it is set" do
+        assert_equal 7, @instance.prepare_permission(:gid, {:map_gid => 7})
+      end
+
+      should "return the global config value if set and not explicitly set on folder" do
+        @env.env.config.nfs.map_gid = 12
+        assert_equal 12, @instance.prepare_permission(:gid, {})
+      end
+
+      should "return the stat result of the hostpath if :auto" do
+        opts = { :hostpath => "foo", :map_uid => :auto }
+        File.expects(:stat).with(opts[:hostpath]).returns(@stat)
+        @stat.stubs(:uid).returns(24)
+
+        assert_equal 24, @instance.prepare_permission(:uid, opts)
+      end
+    end
+
+    context "exporting folders" do
+      setup do
+        @instance.stubs(:folders).returns({})
+        @instance.stubs(:guest_ip).returns("192.168.33.10")
+      end
+
+      should "call nfs_export on the host" do
+        @env["host"].expects(:nfs_export).with(@instance.guest_ip, @instance.folders)
+        @instance.export_folders
+      end
+    end
+
+    context "mounting folders" do
+      setup do
+        @instance.stubs(:host_ip).returns("foo")
+        @instance.stubs(:folders).returns({ "v-data" => {:guestpath => "foo"}})
+      end
+
+      should "mount the folders on the system" do
+        @vm.system.expects(:mount_nfs).with(@instance.host_ip, @instance.folders)
+        @instance.mount_folders
+      end
+
+      should "not mount folders which have no guest path" do
+        @instance.stubs(:folders).returns({ "v-data" => {}})
+        @vm.system.expects(:mount_nfs).with(@instance.host_ip, {})
+        @instance.mount_folders
+      end
+    end
+
+    context "getting the host IP" do
+      setup do
+        @network_adapters = []
+        @internal_vm.stubs(:network_adapters).returns(@network_adapters)
+      end
+
+      def stub_interface(ip)
+        interface = mock("interface")
+        adapter = mock("adapter")
+        adapter.stubs(:host_interface_object).returns(interface)
+        interface.stubs(:ip_address).returns(ip)
+
+        @network_adapters << adapter
+        interface
+      end
+
+      should "return the IP of the first interface" do
+        ip = "192.168.1.1"
+        stub_interface(ip)
+
+        assert_equal ip, @instance.host_ip
+      end
+
+      should "return nil if no IP is found" do
+        assert_nil @instance.host_ip
+      end
+    end
+
+    context "getting the guest IP" do
+      should "return the first networked IP" do
+        ip = "192.168.33.10"
+        @env.env.config.vm.network(ip, :adapter => 1)
+        @env.env.config.vm.network("192.168.66.10", :adapter => 2)
+        assert_equal ip, @instance.guest_ip
+      end
+    end
+
+    context "nfs enabled" do
+      should "return false if no folders are marked for NFS" do
+        assert !@instance.nfs_enabled?
+      end
+
+      should "return true if a shared folder is marked for NFS" do
+        @env.env.config.vm.share_folder("v-foo", "/foo", "/bar", :nfs => true)
+        assert @instance.nfs_enabled?
+      end
+    end
+
+    context "verifying settings" do
+      setup do
+        @env.env.host.stubs(:nfs?).returns(true)
+      end
+
+      should "error environment if host is nil" do
+        @env.env.stubs(:host).returns(nil)
+        assert_raises(Vagrant::Errors::NFSHostRequired) {
+          @instance.verify_settings
+        }
+      end
+
+      should "error environment if host does not support NFS" do
+        @env.env.host.stubs(:nfs?).returns(false)
+        assert_raises(Vagrant::Errors::NFSNotSupported) {
+          @instance.verify_settings
+        }
+      end
+
+      should "error environment if host only networking is not enabled" do
+        @env.env.config.vm.network_options.clear
+        assert_raises(Vagrant::Errors::NFSNoHostNetwork) {
+          @instance.verify_settings
+        }
+      end
+
+      should "be fine if everything passes" do
+        @env.env.host.stubs(:nfs?).returns(true)
+        assert_nothing_raised {
+          @instance.verify_settings
+        }
+      end
+    end
+  end
+end