Implement package type filtering on local folder search (#7505)

Author: zivkan

src/NuGet.Core/NuGet.Protocol/LocalRepositories/LocalPackageSearchResource.cs

@@ -11,6 +11,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using NuGet.Common;
+using NuGet.Packaging.Core;
 using NuGet.Protocol.Core.Types;
 using NuGet.Versioning;
 
@@ -30,7 +31,7 @@ public LocalPackageSearchResource(FindLocalPackagesResource localResource)
             _localResource = localResource;
         }
 
-        public override bool SupportsPackageTypeFiltering => false;
+        public override bool SupportsPackageTypeFiltering => true;
 
         public async override Task<IEnumerable<IPackageSearchMetadata>> SearchAsync(
             string searchTerm,
@@ -63,6 +64,12 @@ public async override Task<IEnumerable<IPackageSearchMetadata>> SearchAsync(
                     query = query.Where(package => ContainsAnyTerm(terms, package));
                 }
 
+                // Filter on package type
+                if (!string.IsNullOrEmpty(filters?.PackageType))
+                {
+                    query = query.Where(package => MatchesPackageType(package, filters.PackageType));
+                }
+
                 // Collapse to the highest version per id, if necessary
                 var collapsedQuery = filters?.Filter == SearchFilterType.IsLatestVersion ||
                                      filters?.Filter == SearchFilterType.IsAbsoluteLatestVersion
@@ -103,6 +110,27 @@ private static bool ContainsAnyTerm(string[] terms, LocalPackageInfo package)
             return false;
         }
 
+        private static bool MatchesPackageType(LocalPackageInfo package, string packageType)
+        {
+            IReadOnlyList<PackageType> packageTypes = package.Nuspec.GetPackageTypes();
+
+            // A package that does not declare any package type is implicitly a "Dependency" package.
+            if (packageTypes.Count == 0)
+            {
+                return PackageType.PackageTypeNameComparer.Equals(packageType, PackageType.Dependency.Name);
+            }
+
+            foreach (PackageType type in packageTypes.NoAllocEnumerate())
+            {
+                if (PackageType.PackageTypeNameComparer.Equals(type.Name, packageType))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         private static bool ContainsTerm(string search, string property)
         {
             int? pos = property?.IndexOf(search, StringComparison.OrdinalIgnoreCase);

test/NuGet.Core.Tests/NuGet.Protocol.Tests/LocalResourceTests/LocalPackageSearchResourceTests.cs

@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using System.Xml.Linq;
 using NuGet.Common;
+using NuGet.Packaging.Core;
 using NuGet.Protocol.Core.Types;
 using NuGet.Protocol.Tests.Plugins.Helpers;
 using NuGet.Test.Utility;
@@ -732,5 +733,77 @@ public async Task LocalPackageSearchResource_SearchNoFilter_AllversionsMatch(boo
                 Assert.Equal(0, testLogger.Errors);
             }
         }
+
+        [Fact]
+        public void LocalPackageSearchResource_SupportsPackageTypeFiltering()
+        {
+            // Arrange
+            var localResource = new FindLocalPackagesResourceV2(root: ".");
+            var resource = new LocalPackageSearchResource(localResource);
+
+            // Act & Assert
+            Assert.True(resource.SupportsPackageTypeFiltering);
+        }
+
+        [Theory]
+        [InlineData("Dependency")]
+        [InlineData("dependency")]
+        public async Task LocalPackageSearchResource_FilterOnPackageType_MatchesExplicitTypeAndImplicitDependencyAsync(string packageTypeFilter)
+        {
+            using (var root = TestDirectory.Create())
+            {
+                // Arrange
+                var testLogger = new TestLogger();
+
+                // Package that explicitly declares the Dependency package type.
+                var dependencyPackage = new SimpleTestPackageContext()
+                {
+                    Id = "dependencyPackage",
+                    Version = "1.0.0",
+                    PackageTypes = { PackageType.Dependency }
+                };
+
+                // Package that does not declare any package type (implicitly Dependency).
+                var implicitPackage = new SimpleTestPackageContext()
+                {
+                    Id = "implicitPackage",
+                    Version = "1.0.0"
+                };
+
+                // Package with a different package type that should be filtered out.
+                var toolPackage = new SimpleTestPackageContext()
+                {
+                    Id = "toolPackage",
+                    Version = "1.0.0",
+                    PackageTypes = { PackageType.DotnetTool }
+                };
+
+                await SimpleTestPackageUtility.CreatePackagesAsync(root, dependencyPackage, implicitPackage, toolPackage);
+
+                var localResource = new FindLocalPackagesResourceV2(root);
+                var resource = new LocalPackageSearchResource(localResource);
+
+                var filter = new SearchFilter(includePrerelease: true)
+                {
+                    PackageType = packageTypeFilter
+                };
+
+                // Act
+                var packages = (await resource.SearchAsync(
+                        searchTerm: "",
+                        filter,
+                        skip: 0,
+                        take: 30,
+                        log: testLogger,
+                        token: CancellationToken.None))
+                        .OrderBy(p => p.Identity.Id)
+                        .ToList();
+
+                // Assert
+                Assert.Equal(2, packages.Count);
+                Assert.Equal("dependencyPackage", packages[0].Identity.Id);
+                Assert.Equal("implicitPackage", packages[1].Identity.Id);
+            }
+        }
     }
 }