Merge pull request #13 from ai-traders/fix-no-deps

Fix missing dependencies in registration

Author: tomzo

CHANGELOG.md

@@ -1,4 +1,8 @@
-### 0.2.0 (2018-Nov-11)
+### 0.2.1 (2018-Oct-22)
+
+ * Fixed missing dependencies in V3 endpoints \#12
+
+### 0.2.0 (2018-Oct-11)
 
  * Added V2 implementation from LiGet
  * Added compatibility mode with LiGet to keep the same endpoints
@@ -7,7 +11,7 @@
  * added importer to complete migration from LiGet
  * fix/adjust for deployments with root-owned volumes
 
-### 0.1.0 (2018-Nov-09)
+### 0.1.0 (2018-Oct-09)
 
 First release with a changelog.
  - added unit, integration tests and e2e tests with paket and nuget cli.

e2e/test_proxy/01_proxy.bats

@@ -22,3 +22,8 @@ load '/opt/bats-assert/load.bash'
   assert_equal "$status" 0
   assert [ -e 'paket-constraint/packages/log4net/log4net.2.0.8.nupkg' ]
 }
+
+@test "paket.lock has dependencies" {
+  run /bin/bash -c "cat paket-constraint/paket.lock"
+  assert_output --partial "(>="
+}

src/BaGet.Core/Legacy/PackageExtensions.cs

@@ -36,7 +36,7 @@ public static string ToDependenciesString(this IEnumerable<Entities.PackageDepen
             return string.Join("|", texts);
         }
 
-        private static bool IsFrameworkDependency(Entities.PackageDependency dependency)
+        public static bool IsFrameworkDependency(this Entities.PackageDependency dependency)
         {
             return dependency.Id == null && dependency.VersionRange == null;
         }

src/BaGet.Web/Controllers/Registration/CacheRegistrationIndexModule.cs

@@ -103,7 +103,8 @@ private RegistrationIndexLeaf ToRegistrationIndexLeaf(HttpRequest request, IPack
                 catalogEntry: new CatalogEntry(
                     package: package,
                     catalogUri: $"https://api.nuget.org/v3/catalog0/data/2015.02.01.06.24.15/{package.Identity.Id}.{package.Identity.Version}.json",
-                    packageContent: request.PackageDownload(package.Identity.Id, package.Identity.Version, "cache")),
+                    packageContent: request.PackageDownload(package.Identity.Id, package.Identity.Version, "cache"),
+                    getRegistrationUrl: id => new System.Uri(request.PackageRegistration(id, "cache"))),
                 packageContent: request.PackageDownload(package.Identity.Id, package.Identity.Version, "cache"));
 
     }

src/BaGet.Web/Controllers/Registration/RegistrationIndexModule.cs

@@ -32,7 +32,7 @@ public RegistrationIndexModule(IPackageService packageService)
             {
                 string id = routeData.As<string>("id");
                 // Documentation: https://docs.microsoft.com/en-us/nuget/api/registration-base-url-resource
-                var packages = await _packages.FindAsync(id);
+                var packages = await _packages.FindAsync(id, includeUnlisted: false, includeDependencies: true);
                 var versions = packages.Select(p => p.Version).ToList();
 
                 if (!packages.Any())
@@ -71,7 +71,7 @@ await res.AsJson(new
                     return;
                 }
 
-                var package = await _packages.FindAsync(id, nugetVersion);
+                var package = await _packages.FindAsync(id, nugetVersion, false, includeDependencies: false);
 
                 if (package == null)
                 {
@@ -98,7 +98,8 @@ private RegistrationIndexLeaf ToRegistrationIndexLeaf(HttpRequest request, Packa
                 catalogEntry: new CatalogEntry(
                     package: package,
                     catalogUri: $"https://api.nuget.org/v3/catalog0/data/2015.02.01.06.24.15/{package.Id}.{package.Version}.json",
-                    packageContent: request.PackageDownload(package.Id, package.Version, "")),
+                    packageContent: request.PackageDownload(package.Id, package.Version, ""),
+                    getRegistrationUrl: id => new System.Uri(request.PackageRegistration(id, ""))),
                 packageContent: request.PackageDownload(package.Id, package.Version, ""));
     }
 }

src/BaGet.Web/Models/CatalogEntry.cs

@@ -1,21 +1,25 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using BaGet.Core.Entities;
+using BaGet.Core.Legacy;
 using Newtonsoft.Json;
+using NuGet.Frameworks;
 using NuGet.Protocol.Core.Types;
 
 namespace BaGet.Web.Models
 {
     public class CatalogEntry
     {
-        public CatalogEntry(Package package, string catalogUri, string packageContent)
+        public CatalogEntry(Package package, string catalogUri, string packageContent, Func<string, Uri> getRegistrationUrl)
         {
             if (package == null) throw new ArgumentNullException(nameof(package));
 
             CatalogUri = catalogUri ?? throw new ArgumentNullException(nameof(catalogUri));
 
             PackageId = package.Id;
             Version = package.VersionString;
-            Authors = string.Join(", ", package.Authors);
+            Authors = package.Authors == null ? null : string.Join(", ", package.Authors);
             Description = package.Description;
             Downloads = package.Downloads;
             HasReadme = package.HasReadme;
@@ -33,9 +37,66 @@ public CatalogEntry(Package package, string catalogUri, string packageContent)
             Summary = package.Summary;
             Tags = package.Tags;
             Title = package.Title;
+            DependencyGroups = ToDependencyGroups(package.Dependencies, catalogUri, getRegistrationUrl);
         }
 
-        public CatalogEntry(IPackageSearchMetadata package, string catalogUri, string packageContent)
+        public static DependencyGroup[] ToDependencyGroups(List<Core.Entities.PackageDependency> dependencies, 
+            string catalogUri, Func<string, Uri> getRegistrationUrl)
+        {
+            if(dependencies == null || !dependencies.Any())
+                return null;
+
+            var groups = new List<DependencyGroup>();
+            var frameworkDeps = dependencies.Where(d => d.IsFrameworkDependency()).Select(d => d.TargetFramework).Distinct();
+            foreach(var frameworkDep in frameworkDeps) {
+                var g = new DependencyGroup() {
+                    CatalogUrl = catalogUri + $"#dependencygroup/.{frameworkDep}",
+                    TargetFramework = frameworkDep
+                };
+                groups.Add(g);
+            }
+            // empty string key implies no target framework
+            Dictionary<string, List<PackageDependency>> dependenciesByFramework = new Dictionary<string, List<PackageDependency>>();
+            foreach (var packageDependency in dependencies.Where(d => !d.IsFrameworkDependency()))
+            {
+                var dep = new PackageDependency() {
+                    Id = packageDependency.Id,
+                    Range = packageDependency.VersionRange
+                };
+                string framework = packageDependency.TargetFramework == null ? "" : packageDependency.TargetFramework;
+                List<PackageDependency> deps = new List<PackageDependency>();
+                if (!dependenciesByFramework.TryGetValue(framework, out deps)) {
+                    deps = new List<PackageDependency>();
+                    dependenciesByFramework.Add(framework, deps);
+                }
+                deps.Add(dep);
+            }
+            var perFrameworkDeps = 
+                dependenciesByFramework.GroupBy(d => d.Key)
+                .Select(grouppedDeps => 
+                {
+                    var framework = string.IsNullOrEmpty(grouppedDeps.Key) ? null : grouppedDeps.Key;
+                    string catalogForGroup = catalogUri + "#dependencygroup";
+                    if(framework != null)
+                        catalogForGroup = catalogUri + $"#dependencygroup/.{framework}";
+                    var g = new DependencyGroup() {         
+                        CatalogUrl = catalogForGroup,           
+                        TargetFramework = framework,
+                        Dependencies = grouppedDeps.SelectMany(d => d.Value)
+                            .Select(d => new PackageDependency() {
+                                CatalogUrl = catalogUri + $"#dependencygroup/.{grouppedDeps.Key}/{d.Id}",
+                                Id = d.Id,
+                                Range = d.Range,
+                                Registration = getRegistrationUrl(d.Id).AbsoluteUri
+                            }).ToArray()
+                    };
+                    return g;
+                });
+
+            return groups.Concat(perFrameworkDeps).ToArray();
+        }
+
+        public CatalogEntry(IPackageSearchMetadata package, string catalogUri, string packageContent, Func<string, Uri> getRegistrationUrl)
         {
             if (package == null) throw new ArgumentNullException(nameof(package));
 
@@ -61,6 +122,36 @@ public CatalogEntry(IPackageSearchMetadata package, string catalogUri, string pa
             Summary = package.Summary;
             Tags = package.Tags == null ? null : package.Tags.Split(',');
             Title = package.Title;
+            DependencyGroups = ToDependencyGroups(package.DependencySets, catalogUri, getRegistrationUrl);
+        }
+
+        public static DependencyGroup[] ToDependencyGroups(IEnumerable<NuGet.Packaging.PackageDependencyGroup> dependencies, string catalogUri,
+            Func<string, Uri> getRegistrationUrl)
+        {
+            return dependencies.Select(grouppedDeps => {
+                string targetFramework;
+                if(grouppedDeps.TargetFramework == null || grouppedDeps.TargetFramework.Equals(NuGetFramework.AnyFramework))
+                    targetFramework = null;
+                else
+                    targetFramework = grouppedDeps.TargetFramework.GetShortFolderName();
+                string catalogForGroup = catalogUri + "#dependencygroup";
+                if(targetFramework != null)
+                    catalogForGroup = catalogUri + $"#dependencygroup/.{targetFramework}";
+                var g = new DependencyGroup() {         
+                    CatalogUrl = catalogForGroup,           
+                    TargetFramework = targetFramework,
+                    Dependencies = grouppedDeps.Packages
+                        .Select(d => new PackageDependency() {
+                            CatalogUrl = catalogUri + $"#dependencygroup/.{targetFramework}/{d.Id}",
+                            Id = d.Id,
+                            Range = d.VersionRange.ToNormalizedString(),
+                            Registration = getRegistrationUrl(d.Id).AbsoluteUri
+                        }).ToArray()
+                };
+                if(g.Dependencies.Length == 0)
+                    g.Dependencies = null;
+                return g;
+                }).ToArray();
         }
 
         private string NullSafeToString(object prop)
@@ -95,5 +186,7 @@ private string NullSafeToString(object prop)
         public string Summary { get; }
         public string[] Tags { get; }
         public string Title { get; }
+
+        public DependencyGroup[] DependencyGroups { get; }
     }
 }

src/BaGet.Web/Models/DependencyGroup.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+
+namespace BaGet.Web.Models
+{
+    // see https://docs.microsoft.com/en-us/nuget/api/registration-base-url-resource#package-dependency-group
+    public class DependencyGroup
+    {
+        public DependencyGroup() {
+            Type = "PackageDependencyGroup";
+        }
+
+        [JsonProperty(PropertyName = "@id")]
+        public string CatalogUrl { get; set; }
+
+        [JsonProperty(PropertyName = "@type")]
+        public string Type { get; set; }
+
+        public string TargetFramework { get; set; }
+
+        public PackageDependency[] Dependencies { get; set; }
+    }
+}

src/BaGet.Web/Models/PackageDependency.cs

@@ -0,0 +1,24 @@
+using Newtonsoft.Json;
+
+namespace BaGet.Web.Models
+{
+    // https://docs.microsoft.com/en-us/nuget/api/registration-base-url-resource#package-dependency
+    public class PackageDependency
+    {
+        public PackageDependency() {
+            Type = "PackageDependency";
+        }
+
+        [JsonProperty(PropertyName = "@id")]
+        public string CatalogUrl { get; set; }
+
+        [JsonProperty(PropertyName = "@type")]
+        public string Type { get; set; }
+
+        public string Id { get; set; }
+
+        public string Range { get; set; }
+
+        public string Registration { get; set; }
+    }
+}

tasks.sh

@@ -68,6 +68,7 @@ case "${command}" in
     rm -rf e2e/data/db/*
     rm -rf e2e/data/packages/*
     rm -rf e2e/data/cache/*
+    rm e2e/test_*/nuget*/*/ -rf
     ide --idefile Idefile.e2e-docker "./e2e/run.sh"
     ;;
   stress_docker)

tests/BaGet.Tests/Controllers/CacheRegistrationIndexModuleTest.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using BaGet.Core.Mirror;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Newtonsoft.Json.Linq;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+using NuGet.Protocol;
+using NuGet.Protocol.Core.Types;
+using NuGet.Versioning;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BaGet.Tests.Controllers
+{
+    public class CacheRegistrationIndexModuleTest
+    {
+        protected readonly ITestOutputHelper Helper;
+
+        readonly string RegistrationIndexUrlFormatString = "cache/v3/registration/{0}/index.json";
+
+        public CacheRegistrationIndexModuleTest(ITestOutputHelper helper)
+        {
+            Helper = helper ?? throw new ArgumentNullException(nameof(helper));
+        }
+
+        [Fact]
+        public async Task RegistrationIndexCatalogEntryShouldContainDependencyGroups()
+        {
+            var pkgService = new Mock<IMirrorService>(MockBehavior.Strict);
+            Mock<IPackageSearchMetadata> abcPackage = new Mock<IPackageSearchMetadata>();
+            abcPackage.SetupGet(a => a.Identity).Returns(new NuGet.Packaging.Core.PackageIdentity("abc", NuGetVersion.Parse("1.2.3")));
+            abcPackage.SetupGet(a => a.DependencySets).Returns(new PackageDependencyGroup[1] {
+                new PackageDependencyGroup(NuGetFramework.Parse("netstandard2.0"), new NuGet.Packaging.Core.PackageDependency[0])
+            });
+            pkgService.Setup(p => p.FindUpstreamMetadataAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new List<IPackageSearchMetadata>() {
+                    abcPackage.Object
+                });
+            using (TestServer server = TestServerBuilder.Create()
+                .TraceToTestOutputHelper(Helper, LogLevel.Error)
+                .WithMock(typeof(IMirrorService), pkgService)
+                .Build())
+            {
+                var services = server.Host.Services;
+                Assert.Equal(pkgService.Object, services.GetRequiredService<IMirrorService>());
+                // https://docs.microsoft.com/en-us/nuget/api/registration-base-url-resource#registration-pages-and-leaves
+                var response = await  server.CreateClient().GetAsync(string.Format(RegistrationIndexUrlFormatString, "abc"));
+                Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
+                var jsonString = await response.Content.ReadAsStringAsync();
+                var actual = JObject.Parse(jsonString);
+                var groups = actual["items"][0]["items"][0]["catalogEntry"]["dependencyGroups"];
+                var expected = new JArray(
+                    new JObject {
+                        { "@id", $"https://api.nuget.org/v3/catalog0/data/2015.02.01.06.24.15/abc.1.2.3.json#dependencygroup/.netstandard2.0" },
+                        { "@type", "PackageDependencyGroup" },
+                        { "targetFramework", "netstandard2.0" },
+                        { "dependencies", null }
+                    }
+                );
+                string message = "Actual part of response: \n" + groups.ToString();
+                Assert.True(JToken.DeepEquals(expected, groups), message);
+            }
+        }
+    }
+}