vagrant 1.0.7 → 2.4.4

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

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

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

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

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

@@ -1,25 +0,0 @@
-require "test_helper"
-
-class PackageVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::Package
-    @app, @env = action_env
-    @env["export.temp_dir"] = "foo"
-
-    @instance = @klass.new(@app, @env)
-  end
-
-  should "be a subclass of general packaging middleware" do
-    assert @instance.is_a?(Vagrant::Action::General::Package)
-  end
-
-  should "set the package directory then call parent" do
-    @instance.expects(:general_call).once.with() do |env|
-      assert env["package.directory"]
-      assert_equal env["package.directory"], env["export.temp_dir"]
-      true
-    end
-
-    @instance.call(@env)
-  end
-end

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

@@ -1,46 +0,0 @@
-require "test_helper"
-
-class PackageVagrantfileVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::PackageVagrantfile
-    @app, @env = action_env
-
-    @vm = mock("vm")
-    @env["vm"] = @vm
-    @env["export.temp_dir"] = "foo"
-
-    @internal_vm = mock("internal")
-    @vm.stubs(:vm).returns(@internal_vm)
-    @instance = @klass.new(@app, @env)
-  end
-
-  context "calling" do
-    should "create the vagrantfile then continue chain" do
-      seq = sequence("sequence")
-      @instance.expects(:create_vagrantfile).in_sequence(seq)
-      @app.expects(:call).with(@env).in_sequence(seq)
-
-      @instance.call(@env)
-    end
-  end
-
-  context "creating vagrantfile" do
-    setup do
-      @network_adapter = mock("nic")
-      @network_adapter.stubs(:mac_address).returns("mac_address")
-      @internal_vm.stubs(:network_adapters).returns([@network_adapter])
-    end
-
-    should "write the rendered vagrantfile to temp_path Vagrantfile" do
-      f = mock("file")
-      rendered = mock("rendered")
-      File.expects(:open).with(File.join(@env["export.temp_dir"], "Vagrantfile"), "w").yields(f)
-      Vagrant::Util::TemplateRenderer.expects(:render).returns(rendered).with("package_Vagrantfile", {
-                                                                                :base_mac => @internal_vm.network_adapters.first.mac_address
-                                                                              })
-      f.expects(:write).with(rendered)
-
-      @instance.create_vagrantfile
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-require "test_helper"
-
-class ProvisionVMActionTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Action::VM::Provision
-    @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 "with an instance" do
-    setup do
-      # Set provisioner to nil so the provisioner isn't loaded on init
-      @env["config"].vm.provisioners.clear
-      @instance = @klass.new(@app, @env)
-    end
-
-    context "loading a provisioner" do
-      should "instantiate and prepare each provisioner" do
-        @env["config"].vm.provision :chef_solo
-        @env["config"].vm.provision :chef_solo
-        provisioners = @instance.enabled_provisioners
-
-        assert_equal 2, provisioners.length
-      end
-
-      should "set the config for each provisioner" do
-        @env["config"].vm.provision :chef_solo do |chef|
-          chef.cookbooks_path = "foo"
-        end
-
-        provisioners = @instance.enabled_provisioners
-
-        assert_equal "foo", provisioners.first.config.cookbooks_path
-      end
-    end
-
-    context "calling" do
-      should "provision and continue chain" do
-        provisioners = [mock("one"), mock("two")]
-        seq = sequence("seq")
-        @instance.stubs(:enabled_provisioners).returns(provisioners)
-
-        provisioners.each do |prov|
-          prov.expects(:prepare).in_sequence(seq)
-        end
-
-        @app.expects(:call).with(@env).in_sequence(seq)
-
-        provisioners.each do |prov|
-          prov.expects(:provision!).in_sequence(seq)
-        end
-
-        @instance.call(@env)
-      end
-    end
-  end
-end