vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/linux/cap/mount_virtual_box_shared_folder_test.rb

@@ -1,225 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestLinux::Cap::MountVirtualBoxSharedFolder" do
-  let(:caps) do
-    VagrantPlugins::GuestLinux::Plugin
-      .components
-      .guest_capabilities[:linux]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-  let(:mount_owner){ "vagrant" }
-  let(:mount_group){ "vagrant" }
-  let(:mount_uid){ "1000" }
-  let(:mount_gid){ "1000" }
-  let(:mount_name){ "vagrant" }
-  let(:mount_guest_path){ "/vagrant" }
-  let(:folder_options) do
-    {
-      owner: mount_owner,
-      group: mount_group,
-      hostpath: "/host/directory/path"
-    }
-  end
-  let(:cap){ caps.get(:mount_virtualbox_shared_folder) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  after do
-    comm.verify_expectations!
-  end
-
-  describe ".mount_virtualbox_shared_folder" do
-
-    before do
-      allow(comm).to receive(:sudo).with(any_args)
-      allow(comm).to receive(:execute).with(any_args)
-    end
-
-    it "generates the expected default mount command" do
-      expect(comm).to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-      expect(comm).to receive(:execute).with("getent group #{mount_group}", anything).and_yield(:stdout, "vagrant:x:#{mount_gid}:")
-      expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{mount_uid},gid=#{mount_gid} #{mount_name} #{mount_guest_path}", anything)
-      cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-    end
-
-    it "automatically chown's the mounted directory on guest" do
-      expect(comm).to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-      expect(comm).to receive(:execute).with("getent group #{mount_group}", anything).and_yield(:stdout, "vagrant:x:#{mount_gid}:")
-      expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{mount_uid},gid=#{mount_gid} #{mount_name} #{mount_guest_path}", anything)
-      expect(comm).to receive(:sudo).with("chown #{mount_uid}:#{mount_gid} #{mount_guest_path}")
-      cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-    end
-
-    context "with owner user ID explicitly defined" do
-
-      before do
-        expect(comm).to receive(:execute).with("getent group #{mount_group}", anything).and_yield(:stdout, "vagrant:x:#{mount_gid}:")
-      end
-
-      context "with user ID provided as Integer" do
-        let(:mount_owner){ 2000 }
-
-        it "generates the expected mount command using mount_owner directly" do
-          expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{mount_owner},gid=#{mount_gid} #{mount_name} #{mount_guest_path}", anything)
-          expect(comm).to receive(:sudo).with("chown #{mount_owner}:#{mount_gid} #{mount_guest_path}")
-          cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-        end
-      end
-
-      context "with user ID provided as String" do
-        let(:mount_owner){ "2000" }
-
-        it "generates the expected mount command using mount_owner directly" do
-          expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{mount_owner},gid=#{mount_gid} #{mount_name} #{mount_guest_path}", anything)
-          expect(comm).to receive(:sudo).with("chown #{mount_owner}:#{mount_gid} #{mount_guest_path}")
-          cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-        end
-      end
-
-    end
-
-    context "with owner group ID explicitly defined" do
-
-      before do
-        expect(comm).to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-      end
-
-      context "with owner group ID provided as Integer" do
-        let(:mount_group){ 2000 }
-
-        it "generates the expected mount command using mount_group directly" do
-          expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{mount_uid},gid=#{mount_group} #{mount_name} #{mount_guest_path}", anything)
-          expect(comm).to receive(:sudo).with("chown #{mount_uid}:#{mount_group} #{mount_guest_path}")
-          cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-        end
-      end
-
-      context "with owner group ID provided as String" do
-        let(:mount_group){ "2000" }
-
-        it "generates the expected mount command using mount_group directly" do
-          expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{mount_uid},gid=#{mount_group} #{mount_name} #{mount_guest_path}", anything)
-          expect(comm).to receive(:sudo).with("chown #{mount_uid}:#{mount_group} #{mount_guest_path}")
-          cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-        end
-      end
-
-    end
-
-    context "with non-existent default owner group" do
-
-      it "fetches the effective group ID of the user" do
-        expect(comm).to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-        expect(comm).to receive(:execute).with("getent group #{mount_group}", anything).and_raise(Vagrant::Errors::VirtualBoxMountFailed, {command: '', output: ''})
-        expect(comm).to receive(:execute).with("id -g #{mount_owner}", anything).and_yield(:stdout, "1").and_return(0)
-        cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-      end
-    end
-
-    context "with non-existent owner group" do
-
-      it "raises an error" do
-        expect(comm).to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-        expect(comm).to receive(:execute).with("getent group #{mount_group}", anything).and_raise(Vagrant::Errors::VirtualBoxMountFailed, {command: '', output: ''})
-        expect do
-          cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-        end.to raise_error Vagrant::Errors::VirtualBoxMountFailed
-      end
-    end
-
-    context "with read-only option defined" do
-
-      it "does not chown mounted guest directory" do
-        expect(comm).to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-        expect(comm).to receive(:execute).with("getent group #{mount_group}", anything).and_yield(:stdout, "vagrant:x:#{mount_gid}:")
-        expect(comm).to receive(:sudo).with("mount -t vboxsf -o ro,uid=#{mount_uid},gid=#{mount_gid} #{mount_name} #{mount_guest_path}", anything)
-        expect(comm).not_to receive(:sudo).with("chown #{mount_uid}:#{mount_gid} #{mount_guest_path}")
-        cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options.merge(mount_options: ["ro"]))
-      end
-    end
-
-    context "with upstart init" do
-
-      it "emits mount event" do
-        expect(comm).to receive(:sudo).with(/initctl emit/)
-        cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-      end
-    end
-
-    context "with custom mount options" do
-
-      let(:ui){ double(:ui) }
-      before do
-        allow(ui).to receive(:warn)
-        allow(machine).to receive(:ui).and_return(ui)
-      end
-
-      context "with uid defined" do
-        let(:options_uid){ '1234' }
-
-        it "should only include uid defined within mount options" do
-          expect(comm).not_to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-          expect(comm).to receive(:execute).with("getent group #{mount_group}", anything).and_yield(:stdout, "vagrant:x:#{mount_gid}:")
-          expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{options_uid},gid=#{mount_gid} #{mount_name} #{mount_guest_path}", anything)
-          cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options.merge(mount_options: ["uid=#{options_uid}"]))
-        end
-      end
-
-      context "with gid defined" do
-        let(:options_gid){ '1234' }
-
-        it "should only include gid defined within mount options" do
-          expect(comm).to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-          expect(comm).not_to receive(:execute).with("getent group #{mount_group}", anything).and_yield(:stdout, "vagrant:x:#{mount_gid}:")
-          expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{mount_uid},gid=#{options_gid} #{mount_name} #{mount_guest_path}", anything)
-          cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options.merge(mount_options: ["gid=#{options_gid}"]))
-        end
-      end
-
-      context "with uid and gid defined" do
-        let(:options_gid){ '1234' }
-        let(:options_uid){ '1234' }
-
-        it "should only include uid and gid defined within mount options" do
-          expect(comm).not_to receive(:execute).with("id -u #{mount_owner}", anything).and_yield(:stdout, mount_uid)
-          expect(comm).not_to receive(:execute).with("getent group #{mount_group}", anything).and_yield(:stdout, "vagrant:x:#{options_gid}:")
-          expect(comm).to receive(:sudo).with("mount -t vboxsf -o uid=#{options_uid},gid=#{options_gid} #{mount_name} #{mount_guest_path}", anything)
-          cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options.merge(mount_options: ["gid=#{options_gid}", "uid=#{options_uid}"]))
-        end
-      end
-    end
-
-    context "with guest builtin vboxsf module" do
-      let(:vbox_stderr){ <<-EOF
-mount.vboxsf cannot be used with mainline vboxsf; instead use:
-
-    mount -cit vboxsf NAME MOUNTPOINT
-EOF
-      }
-      it "should perform guest mount using builtin module" do
-        expect(comm).to receive(:sudo).with(/mount -t vboxsf/, any_args).and_yield(:stderr, vbox_stderr).and_return(1)
-        expect(comm).to receive(:sudo).with(/mount -cit/, any_args)
-        cap.mount_virtualbox_shared_folder(machine, mount_name, mount_guest_path, folder_options)
-      end
-    end
-  end
-
-  describe ".unmount_virtualbox_shared_folder" do
-
-    after { cap.unmount_virtualbox_shared_folder(machine, mount_guest_path, folder_options) }
-
-    it "unmounts shared directory and deletes directory on guest" do
-      expect(comm).to receive(:sudo).with("umount #{mount_guest_path}", anything).and_return(0)
-      expect(comm).to receive(:sudo).with("rmdir #{mount_guest_path}", anything)
-    end
-
-    it "does not delete guest directory if unmount fails" do
-      expect(comm).to receive(:sudo).with("umount #{mount_guest_path}", anything).and_return(1)
-      expect(comm).not_to receive(:sudo).with("rmdir #{mount_guest_path}", anything)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/linux/cap/network_interfaces_test.rb

@@ -1,84 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestLinux::Cap::NetworkInterfaces" do
-  let(:caps) do
-    VagrantPlugins::GuestLinux::Plugin
-      .components
-      .guest_capabilities[:linux]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  after do
-    comm.verify_expectations!
-  end
-
-  describe ".network_interfaces" do
-    let(:cap){ caps.get(:network_interfaces) }
-
-    it "sorts discovered classic interfaces" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "eth1\neth2\neth0")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["eth0", "eth1", "eth2"])
-    end
-
-    it "sorts discovered predictable network interfaces" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "enp0s8\nenp0s3\nenp0s5")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["enp0s3", "enp0s5", "enp0s8"])
-    end
-
-    it "sorts discovered classic interfaces naturally" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "eth1\neth2\neth12\neth0\neth10")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["eth0", "eth1", "eth2", "eth10", "eth12"])
-    end
-
-    it "sorts discovered predictable network interfaces naturally" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "enp0s8\nenp0s3\nenp0s5\nenp0s10\nenp1s3")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["enp0s3", "enp0s5", "enp0s8", "enp0s10", "enp1s3"])
-    end
-
-    it "sorts ethernet devices discovered with classic naming first in list" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "eth1\neth2\ndocker0\nbridge0\neth0")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["eth0", "eth1", "eth2", "bridge0", "docker0"])
-    end
-
-    it "sorts ethernet devices discovered with predictable network interfaces naming first in list" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "enp0s8\ndocker0\nenp0s3\nbridge0\nenp0s5")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["enp0s3", "enp0s5", "enp0s8", "bridge0", "docker0"])
-    end
-
-    it "sorts ethernet devices discovered with predictable network interfaces naming first in list with less" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "enp0s3\nenp0s8\ndocker0")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["enp0s3", "enp0s8", "docker0"])
-    end
-
-    it "does not include ethernet devices aliases within prefix device listing" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "eth1\neth2\ndocker0\nbridge0\neth0\ndocker1\neth0:0")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["eth0", "eth1", "eth2", "bridge0", "docker0", "docker1", "eth0:0"])
-    end
-
-    it "does not include ethernet devices aliases within prefix device listing with dot separators" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "eth1\neth2\ndocker0\nbridge0\neth0\ndocker1\neth0.1@eth0")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["eth0", "eth1", "eth2", "bridge0", "docker0", "docker1", "eth0.1@eth0"])
-    end
-
-    it "properly sorts non-consistent device name formats" do
-      expect(comm).to receive(:sudo).twice.and_yield(:stdout, "eth0\neth1\ndocker0\nveth437f7f9\nveth06b3e44\nveth8bb7081")
-      result = cap.network_interfaces(machine)
-      expect(result).to eq(["eth0", "eth1", "docker0", "veth8bb7081", "veth437f7f9", "veth06b3e44"])
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/linux/cap/nfs_client_test.rb

@@ -1,29 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestLinux::Cap::NFSClient" do
-  let(:caps) do
-    VagrantPlugins::GuestLinux::Plugin
-      .components
-      .guest_capabilities[:linux]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  after do
-    comm.verify_expectations!
-  end
-
-  describe ".nfs_client_installed" do
-    let(:cap) { caps.get(:nfs_client_installed) }
-
-    it "installs nfs client utilities" do
-      comm.expect_command("test -x /sbin/mount.nfs")
-      cap.nfs_client_installed(machine)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/linux/cap/port_test.rb

@@ -1,30 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestLinux::Cap::Port" do
-  let(:caps) do
-    VagrantPlugins::GuestLinux::Plugin
-      .components
-      .guest_capabilities[:linux]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  after do
-    comm.verify_expectations!
-  end
-
-  describe ".port_open_check" do
-    let(:cap) { caps.get(:port_open_check) }
-
-    it "checks if the port is open" do
-      port = 8080
-      comm.expect_command("nc -z -w2 127.0.0.1 #{port}")
-      cap.port_open_check(machine, port)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/linux/cap/remove_public_key_test.rb

@@ -1,32 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestLinux::Cap::RemovePublicKey" do
-  let(:caps) do
-    VagrantPlugins::GuestLinux::Plugin
-      .components
-      .guest_capabilities[:linux]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  after do
-    comm.verify_expectations!
-  end
-
-  describe ".remove_public_key" do
-    let(:cap) { caps.get(:remove_public_key) }
-
-    it "removes the public key" do
-      cap.remove_public_key(machine, "ssh-rsa ...")
-      expect(comm.received_commands[0]).to match(/grep -v -x -f '\/tmp\/vagrant-(.+)' ~\/\.ssh\/authorized_keys > ~\/.ssh\/authorized_keys\.tmp/)
-      expect(comm.received_commands[0]).to match(/mv ~\/.ssh\/authorized_keys\.tmp ~\/.ssh\/authorized_keys/)
-      expect(comm.received_commands[0]).to match(/chmod 0600 ~\/.ssh\/authorized_keys/)
-      expect(comm.received_commands[0]).to match(/rm -f '\/tmp\/vagrant-(.+)'/)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/linux/cap/rsync_test.rb

@@ -1,97 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestLinux::Cap::Rsync" do
-  let(:caps) do
-    VagrantPlugins::GuestLinux::Plugin
-      .components
-      .guest_capabilities[:linux]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-  let(:guest_directory){ "/guest/directory/path" }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  after do
-    comm.verify_expectations!
-  end
-
-  describe ".rsync_installed" do
-    let(:cap) { caps.get(:rsync_installed) }
-
-    it "checks if the command is installed" do
-      comm.expect_command("which rsync")
-      cap.rsync_installed(machine)
-    end
-  end
-
-  describe ".rsync_command" do
-    let(:cap) { caps.get(:rsync_command) }
-
-    it "provides the rsync command to use" do
-      expect(cap.rsync_command(machine)).to eq("sudo rsync")
-    end
-  end
-
-  describe ".rsync_pre" do
-    let(:cap) { caps.get(:rsync_pre) }
-
-    it "creates target directory on guest" do
-      comm.expect_command("mkdir -p #{guest_directory}")
-      cap.rsync_pre(machine, :guestpath => guest_directory)
-    end
-  end
-
-  describe ".rsync_post" do
-    let(:cap) { caps.get(:rsync_post) }
-    let(:host_directory){ '.' }
-    let(:owner) { "vagrant-user" }
-    let(:group) { "vagrant-group" }
-    let(:excludes) { false }
-    let(:options) do
-      {
-        hostpath: host_directory,
-        guestpath: guest_directory,
-        owner: owner,
-        group: group,
-        exclude: excludes
-      }
-    end
-
-    it "chowns files within the guest directory" do
-      comm.expect_command(
-        "find #{guest_directory} '!' -type l -a '(' ! -user #{owner} -or " \
-          "! -group #{group} ')' -exec chown #{owner}:#{group} '{}' +"
-      )
-      cap.rsync_post(machine, options)
-    end
-
-    context "with excludes provided" do
-      let(:excludes){ ["tmp", "state/*", "path/with a/space"] }
-
-      it "ignores files that are excluded" do
-        # comm.expect_command(
-        #   "find #{guest_directory} -path #{Shellwords.escape(File.join(guest_directory, excludes.first))} -prune -o " \
-        #     "-path #{Shellwords.escape(File.join(guest_directory, excludes.last))} -prune -o '!' " \
-        #     "-path -type l -a '(' ! -user " \
-        #     "#{owner} -or ! -group #{group} ')' -exec chown #{owner}:#{group} '{}' +"
-        # )
-        cap.rsync_post(machine, options)
-        excludes.each do |ex_path|
-          expect(comm.received_commands.first).to include("-path #{Shellwords.escape(File.join(guest_directory, ex_path))} -prune")
-        end
-      end
-
-      it "properly escapes excluded directories" do
-        cap.rsync_post(machine, options)
-        exclude_with_space = excludes.detect{|ex| ex.include?(' ')}
-        escaped_exclude_with_space = Shellwords.escape(exclude_with_space)
-        expect(comm.received_commands.first).not_to include(exclude_with_space)
-        expect(comm.received_commands.first).to include(escaped_exclude_with_space)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/linux/cap/shell_expand_guest_path_test.rb

@@ -1,44 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestLinux::Cap::ShellExpandGuestPath" do
-  let(:caps) do
-    VagrantPlugins::GuestLinux::Plugin
-      .components
-      .guest_capabilities[:linux]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  describe "#shell_expand_guest_path" do
-    let(:cap) { caps.get(:shell_expand_guest_path) }
-
-    it "expands the path" do
-      path = "/home/vagrant/folder"
-      allow(machine.communicate).to receive(:execute).
-        with(any_args).and_yield(:stdout, "/home/vagrant/folder")
-
-      cap.shell_expand_guest_path(machine, path)
-    end
-
-    it "raises an exception if no path was detected" do
-      path = "/home/vagrant/folder"
-      expect { cap.shell_expand_guest_path(machine, path) }.
-        to raise_error(Vagrant::Errors::ShellExpandFailed)
-    end
-
-    it "returns a path with a space in it" do
-      path = "/home/vagrant folder/folder"
-      path_with_spaces = "/home/vagrant\\ folder/folder"
-      allow(machine.communicate).to receive(:execute).
-        with(any_args).and_yield(:stdout, path_with_spaces)
-
-      expect(machine.communicate).to receive(:execute).with("echo; printf #{path_with_spaces}")
-      cap.shell_expand_guest_path(machine, path)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/netbsd/cap/shell_expand_guest_path_test.rb

@@ -1,44 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestNetBSD::Cap::ShellExpandGuestPath" do
-  let(:caps) do
-    VagrantPlugins::GuestNetBSD::Plugin
-      .components
-      .guest_capabilities[:netbsd]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  describe "#shell_expand_guest_path" do
-    let(:cap) { caps.get(:shell_expand_guest_path) }
-
-    it "expands the path" do
-      path = "/home/vagrant/folder"
-      allow(machine.communicate).to receive(:execute).
-        with(any_args).and_yield(:stdout, "/home/vagrant/folder")
-
-      cap.shell_expand_guest_path(machine, path)
-    end
-
-    it "raises an exception if no path was detected" do
-      path = "/home/vagrant/folder"
-      expect { cap.shell_expand_guest_path(machine, path) }.
-        to raise_error(Vagrant::Errors::ShellExpandFailed)
-    end
-
-    it "returns a path with a space in it" do
-      path = "/home/vagrant folder/folder"
-      path_with_spaces = "/home/vagrant\\ folder/folder"
-      allow(machine.communicate).to receive(:execute).
-        with(any_args).and_yield(:stdout, path_with_spaces)
-
-      expect(machine.communicate).to receive(:execute).with("printf #{path_with_spaces}")
-      cap.shell_expand_guest_path(machine, path)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/omnios/cap/change_host_name_test.rb

@@ -1,41 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestOmniOS::Cap:RSync" do
-  let(:caps) do
-    VagrantPlugins::GuestOmniOS::Plugin
-      .components
-      .guest_capabilities[:omnios]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  after do
-    comm.verify_expectations!
-  end
-
-  describe ".change_host_name" do
-    let(:cap) { caps.get(:change_host_name) }
-
-    let(:name) { "banana-rama.example.com" }
-
-    it "sets the hostname if unset" do
-      comm.stub_command("hostname -f | grep '^#{name}$'", exit_code: 1)
-      cap.change_host_name(machine, name)
-
-      expect(comm.received_commands[1]).to match(/echo '#{name}' > \/etc\/nodename/)
-      expect(comm.received_commands[1]).to match(/hostname '#{name}'/)
-    end
-
-    it "does not set the hostname if set" do
-      comm.stub_command("hostname -f | grep '^#{name}$'", exit_code: 0)
-      cap.change_host_name(machine, name)
-
-      expect(comm.received_commands.size).to eq(1)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/guests/omnios/cap/mount_nfs_folder_test.rb

@@ -1,45 +0,0 @@
-require_relative "../../../../base"
-
-describe "VagrantPlugins::GuestOmniOS::Cap:RSync" do
-  let(:caps) do
-    VagrantPlugins::GuestOmniOS::Plugin
-      .components
-      .guest_capabilities[:omnios]
-  end
-
-  let(:machine) { double("machine") }
-  let(:comm) { VagrantTests::DummyCommunicator::Communicator.new(machine) }
-
-  before do
-    allow(machine).to receive(:communicate).and_return(comm)
-  end
-
-  after do
-    comm.verify_expectations!
-  end
-
-  describe ".mount_nfs_folder" do
-    let(:cap) { caps.get(:mount_nfs_folder) }
-
-    let(:ip) { "1.2.3.4" }
-
-    let(:hostpath) { "/host" }
-    let(:guestpath) { "/guest" }
-
-    it "mounts the folder" do
-      folders = {
-        "/vagrant-nfs" => {
-          type: :nfs,
-          guestpath: "/guest",
-          hostpath: "/host",
-        }
-      }
-      cap.mount_nfs_folder(machine, ip, folders)
-
-      expect(comm.received_commands[0]).to match(/mkdir -p '#{guestpath}'/)
-      expect(comm.received_commands[0]).to match(/'1.2.3.4:#{hostpath}' '#{guestpath}'/)
-    end
-
-    it "mounts with options"
-  end
-end