Add sharedfx and targeting pack tests (#23045) (#23070)

* Add sharedfx and targeting pack tests (#23045)

* Add test for assembly versions

* Add test for framework list

* Add some hardcoded lists for sharedfx and targeting pack content

* Fix failing tests

* Fix targeting pack tests

* Feedback

Author: John Luo

src/Framework/test/Microsoft.AspNetCore.App.UnitTests.csproj

@@ -86,7 +86,7 @@
     <ItemGroup>
       <AssemblyAttribute Include="Microsoft.AspNetCore.TestData">
         <_Parameter1>TargetingPackDependencies</_Parameter1>
-        <_Parameter2>@(_TargetingPackDependencies)</_Parameter2>
+        <_Parameter2>@(_TargetingPackDependencies->'%(FileName)')</_Parameter2>
       </AssemblyAttribute>
 
       <AssemblyAttribute Include="Microsoft.AspNetCore.TestData">

src/Framework/test/SharedFxTests.cs

@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using Newtonsoft.Json.Linq;
@@ -26,6 +25,30 @@ public SharedFxTests(ITestOutputHelper output)
             _sharedFxRoot = Path.Combine(TestData.GetTestDataValue("SharedFrameworkLayoutRoot"), "shared", "Microsoft.AspNetCore.App", TestData.GetTestDataValue("RuntimePackageVersion"));
         }
 
+        [Fact]
+        public void SharedFrameworkContainsListedAssemblies()
+        {
+            var actualAssemblies = Directory.GetFiles(_sharedFxRoot, "*.dll")
+                .Select(Path.GetFileNameWithoutExtension)
+                .ToHashSet();
+
+            _output.WriteLine("==== actual assemblies ====");
+            _output.WriteLine(string.Join('\n', actualAssemblies.OrderBy(i => i)));
+            _output.WriteLine("==== expected assemblies ====");
+            _output.WriteLine(string.Join('\n', TestData.ListedSharedFxAssemblies.OrderBy(i => i)));
+
+            var missing = TestData.ListedSharedFxAssemblies.Except(actualAssemblies);
+            var unexpected = actualAssemblies.Except(TestData.ListedSharedFxAssemblies);
+
+            _output.WriteLine("==== missing assemblies from the framework ====");
+            _output.WriteLine(string.Join('\n', missing));
+            _output.WriteLine("==== unexpected assemblies in the framework ====");
+            _output.WriteLine(string.Join('\n', unexpected));
+
+            Assert.Empty(missing);
+            Assert.Empty(unexpected);
+        }
+
         [Fact]
         public void SharedFrameworkContainsExpectedFiles()
         {

src/Framework/test/TargetingPackTests.cs

@@ -9,7 +9,7 @@
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
 using System.Runtime.CompilerServices;
-using Newtonsoft.Json.Linq;
+using System.Xml.Linq;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -18,6 +18,7 @@ namespace Microsoft.AspNetCore
     public class TargetingPackTests
     {
         private readonly string _expectedRid;
+        private readonly string _targetingPackTfm;
         private readonly string _targetingPackRoot;
         private readonly ITestOutputHelper _output;
         private readonly bool _isTargetingPackBuilding;
@@ -26,10 +27,66 @@ public TargetingPackTests(ITestOutputHelper output)
         {
             _output = output;
             _expectedRid = TestData.GetSharedFxRuntimeIdentifier();
+            _targetingPackTfm = "netcoreapp" + TestData.GetSharedFxVersion().Substring(0, 3);
             _targetingPackRoot = Path.Combine(TestData.GetTestDataValue("TargetingPackLayoutRoot"), "packs", "Microsoft.AspNetCore.App.Ref", TestData.GetTestDataValue("TargetingPackVersion"));
             _isTargetingPackBuilding = bool.Parse(TestData.GetTestDataValue("IsTargetingPackBuilding"));
         }
 
+        [Fact]
+        public void TargetingPackContainsListedAssemblies()
+        {
+            if (!_isTargetingPackBuilding)
+            {
+                return;
+            }
+
+            var actualAssemblies = Directory.GetFiles(Path.Combine(_targetingPackRoot, "ref", _targetingPackTfm), "*.dll")
+                .Select(Path.GetFileNameWithoutExtension)
+                .ToHashSet();
+            var listedTargetingPackAssemblies = TestData.ListedTargetingPackAssemblies.Keys.ToHashSet();
+
+            _output.WriteLine("==== actual assemblies ====");
+            _output.WriteLine(string.Join('\n', actualAssemblies.OrderBy(i => i)));
+            _output.WriteLine("==== expected assemblies ====");
+            _output.WriteLine(string.Join('\n', listedTargetingPackAssemblies.OrderBy(i => i)));
+
+            var missing = listedTargetingPackAssemblies.Except(actualAssemblies);
+            var unexpected = actualAssemblies.Except(listedTargetingPackAssemblies);
+
+            _output.WriteLine("==== missing assemblies from the framework ====");
+            _output.WriteLine(string.Join('\n', missing));
+            _output.WriteLine("==== unexpected assemblies in the framework ====");
+            _output.WriteLine(string.Join('\n', unexpected));
+
+            Assert.Empty(missing);
+            Assert.Empty(unexpected);
+        }
+
+        [Fact]
+        public void RefAssembliesHaveExpectedAssemblyVersions()
+        {
+            if (!_isTargetingPackBuilding)
+            {
+                return;
+            }
+
+            IEnumerable<string> dlls = Directory.GetFiles(Path.Combine(_targetingPackRoot, "ref", _targetingPackTfm), "*.dll", SearchOption.AllDirectories);
+            Assert.NotEmpty(dlls);
+
+            Assert.All(dlls, path =>
+            {
+                var fileName = Path.GetFileNameWithoutExtension(path);
+                var assemblyName = AssemblyName.GetAssemblyName(path);
+                using var fileStream = File.OpenRead(path);
+                using var peReader = new PEReader(fileStream, PEStreamOptions.Default);
+                var reader = peReader.GetMetadataReader(MetadataReaderOptions.Default);
+                var assemblyDefinition = reader.GetAssemblyDefinition();
+
+                TestData.ListedTargetingPackAssemblies.TryGetValue(fileName, out var expectedVersion);
+                Assert.Equal(expectedVersion, assemblyDefinition.Version.ToString());
+            });
+        }
+
         [Fact]
         public void AssembliesAreReferenceAssemblies()
         {
@@ -131,5 +188,61 @@ public void PlatformManifestListsAllFiles()
                 Assert.True(Version.TryParse(parts[3], out _), "File version must be convertable to System.Version");
             });
         }
+
+        [Fact]
+        public void FrameworkListListsContainsCorrectEntries()
+        {
+            if (!_isTargetingPackBuilding)
+            {
+                return;
+            }
+
+            var frameworkListPath = Path.Combine(_targetingPackRoot, "data", "FrameworkList.xml");
+            var expectedAssemblies = TestData.GetTargetingPackDependencies()
+                .Split(';', StringSplitOptions.RemoveEmptyEntries)
+                .ToHashSet();
+            expectedAssemblies.Remove("aspnetcorev2_inprocess");
+
+            AssertEx.FileExists(frameworkListPath);
+
+            var frameworkListDoc = XDocument.Load(frameworkListPath);
+            var frameworkListEntries = frameworkListDoc.Root.Descendants();
+
+            _output.WriteLine("==== file contents ====");
+            _output.WriteLine(string.Join('\n', frameworkListEntries.Select(i => i.Attribute("Path").Value).OrderBy(i => i)));
+            _output.WriteLine("==== expected assemblies ====");
+            _output.WriteLine(string.Join('\n', expectedAssemblies.OrderBy(i => i)));
+
+             var actualAssemblies = frameworkListEntries
+                .Select(i =>
+                {
+                    var fileName = i.Attribute("Path").Value;
+                    return fileName.EndsWith(".dll", StringComparison.Ordinal)
+                        ? fileName.Substring(0, fileName.Length - 4)
+                        : fileName;
+                })
+                .ToHashSet();
+
+            var missing = expectedAssemblies.Except(actualAssemblies);
+            var unexpected = actualAssemblies.Except(expectedAssemblies);
+
+            _output.WriteLine("==== missing assemblies from the framework list ====");
+            _output.WriteLine(string.Join('\n', missing));
+            _output.WriteLine("==== unexpected assemblies in the framework list ====");
+            _output.WriteLine(string.Join('\n', unexpected));
+
+            Assert.Empty(missing);
+            Assert.Empty(unexpected);
+
+            Assert.All(frameworkListEntries, i =>
+            {
+                var assemblyPath = i.Attribute("Path").Value;
+                var assemblyVersion = i.Attribute("AssemblyVersion").Value;
+                var fileVersion = i.Attribute("FileVersion").Value;
+
+                Assert.True(Version.TryParse(assemblyVersion, out _), $"{assemblyPath} has assembly version {assemblyVersion}. Assembly version must be convertable to System.Version");
+                Assert.True(Version.TryParse(fileVersion, out _), $"{assemblyPath} has file version {fileVersion}. File version must be convertable to System.Version");
+            });
+        }
     }
 }