Made Plugin Folder Unit tests & Expanding enviroment search (#6600)

* Made Plugin Folder Unit tests. Fixes '>' not recursive searching (with max). Added that paths with an UnauthorizedAccessException are ignored. Added expanding enviroment search.

* Fixed some merging errors

* Added feedback from review

* Made the change that  ryanbodrug-microsoft suggested

* Stupid merge request... fixed

Co-authored-by: p-storm <paul.de.man@gmail.com>

src/modules/launcher/Plugins/Microsoft.Plugin.Folder.UnitTests/InternalQueryFolderTests.cs

@@ -0,0 +1,159 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using Microsoft.Plugin.Folder.Sources;
+using Microsoft.Plugin.Folder.Sources.Result;
+using Moq;
+using NUnit.Framework;
+
+namespace Microsoft.Plugin.Folder.UnitTests
+{
+    [TestFixture]
+    public class InternalQueryFolderTests
+    {
+        private static readonly HashSet<string> DirectoryExist = new HashSet<string>()
+        {
+            @"c:",
+            @"c:\",
+            @"c:\Test\",
+            @"c:\Test\A\",
+            @"c:\Test\b\",
+        };
+
+        private static readonly HashSet<string> FilesExist = new HashSet<string>()
+        {
+            @"c:\bla.txt",
+            @"c:\Test\test.txt",
+            @"c:\Test\more-test.png",
+        };
+
+        private static Mock<IQueryFileSystemInfo> _queryFileSystemInfoMock;
+
+        [SetUp]
+        public void SetupMock()
+        {
+            var queryFileSystemInfoMock = new Mock<IQueryFileSystemInfo>();
+            queryFileSystemInfoMock.Setup(r => r.Exists(It.IsAny<string>()))
+                .Returns<string>(path => ContainsDirectory(path));
+
+            queryFileSystemInfoMock.Setup(r => r.MatchFileSystemInfo(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<SearchOption>()))
+                .Returns<string, string, SearchOption>(MatchFileSystemInfo);
+
+            _queryFileSystemInfoMock = queryFileSystemInfoMock;
+        }
+
+        // Windows supports C:\\\\\ => C:\
+        private static bool ContainsDirectory(string path)
+        {
+            return DirectoryExist.Contains(TrimDirectoryEnd(path));
+        }
+
+        private static string TrimDirectoryEnd(string path)
+        {
+            var trimEnd = path.TrimEnd('\\');
+
+            if (path.EndsWith('\\'))
+            {
+                trimEnd += '\\';
+            }
+
+            return trimEnd;
+        }
+
+        private static IEnumerable<DisplayFileInfo> MatchFileSystemInfo(string search, string incompleteName, SearchOption searchOption)
+        {
+            Func<string, bool> folderSearchFunc;
+            Func<string, bool> fileSearchFunc;
+            switch (searchOption)
+            {
+                case SearchOption.TopDirectoryOnly:
+                    folderSearchFunc = s => s.Equals(search, StringComparison.CurrentCultureIgnoreCase);
+
+                    var regexSearch = TrimDirectoryEnd(search);
+
+                    fileSearchFunc = s => Regex.IsMatch(s, $"^{Regex.Escape(regexSearch)}[^\\\\]*$");
+                    break;
+                case SearchOption.AllDirectories:
+                    folderSearchFunc = s => s.StartsWith(search, StringComparison.CurrentCultureIgnoreCase);
+                    fileSearchFunc = s => s.StartsWith(search, StringComparison.CurrentCultureIgnoreCase);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(searchOption), searchOption, null);
+            }
+
+            var directories = DirectoryExist.Where(s => folderSearchFunc(s))
+                .Select(dir => new DisplayFileInfo()
+                {
+                    Type = DisplayType.Directory,
+                    FullName = dir,
+                });
+
+            var files = FilesExist.Where(s => fileSearchFunc(s))
+                .Select(file => new DisplayFileInfo()
+                {
+                    Type = DisplayType.File,
+                    FullName = file,
+                });
+
+            return directories.Concat(files);
+        }
+
+        [Test]
+        public void Query_ThrowsException_WhenCalledNull()
+        {
+            // Setup
+            var queryInternalDirectory = new QueryInternalDirectory(new FolderSettings(), _queryFileSystemInfoMock.Object);
+
+            // Act & Assert
+            Assert.Throws<ArgumentNullException>(() => queryInternalDirectory.Query(null).ToArray());
+        }
+
+        [TestCase(@"c", 0, 0, false, Reason = "String empty is nothing")]
+        [TestCase(@"c:", 1, 1, false, Reason = "Root without \\")]
+        [TestCase(@"c:\", 1, 1, false, Reason = "Normal root")]
+        [TestCase(@"c:\Test", 1, 2, false, Reason = "Select yourself")]
+        [TestCase(@"c:\>", 2, 2, true, Reason = "Max Folder test recursive")]
+        [TestCase(@"c:\Test>", 2, 2, true, Reason = "2 Folders recursive")]
+        [TestCase(@"c:\not-exist", 1, 1, false, Reason = "Folder not exist, return root")]
+        [TestCase(@"c:\not-exist>", 2, 2, true, Reason = "Folder not exist, return root recursive")]
+        [TestCase(@"c:\not-exist\not-exist2", 0, 0, false, Reason = "Folder not exist, return root")]
+        [TestCase(@"c:\not-exist\not-exist2>", 0, 0, false, Reason = "Folder not exist, return root recursive")]
+        [TestCase(@"c:\bla.t", 1, 1, false, Reason = "Partial match file")]
+        public void Query_WhenCalled(string search, int folders, int files, bool truncated)
+        {
+            const int maxFolderSetting = 2;
+
+            // Setup
+            var folderSettings = new FolderSettings()
+            {
+                MaxFileResults = maxFolderSetting,
+                MaxFolderResults = maxFolderSetting,
+            };
+
+            var queryInternalDirectory = new QueryInternalDirectory(folderSettings, _queryFileSystemInfoMock.Object);
+
+            // Act
+            var isDriveOrSharedFolder = queryInternalDirectory.Query(search)
+                .ToLookup(r => r.GetType());
+
+            // Assert
+            Assert.AreEqual(files, isDriveOrSharedFolder[typeof(FileItemResult)].Count(), "File count doesn't match");
+            Assert.AreEqual(folders, isDriveOrSharedFolder[typeof(FolderItemResult)].Count(), "folder count doesn't match");
+
+            // Always check if there is less than max folders
+            Assert.LessOrEqual(isDriveOrSharedFolder[typeof(FileItemResult)].Count(), maxFolderSetting, "Files are not limited");
+            Assert.LessOrEqual(isDriveOrSharedFolder[typeof(FolderItemResult)].Count(), maxFolderSetting, "Folders are not limited");
+
+            // Checks if CreateOpenCurrentFolder is displayed
+            Assert.AreEqual(Math.Min(folders + files, 1), isDriveOrSharedFolder[typeof(CreateOpenCurrentFolderResult)].Count(), "CreateOpenCurrentFolder displaying is incorrect");
+
+            Assert.AreEqual(truncated, isDriveOrSharedFolder[typeof(TruncatedItemResult)].Count() == 1, "CreateOpenCurrentFolder displaying is incorrect");
+        }
+    }
+}