Release/v3.x

CODEOWNERS

@@ -0,0 +1,8 @@
+# See https://help.github.com/articles/about-codeowners/
+# for more info about CODEOWNERS file
+#
+# It uses the same pattern rule for gitignore file
+# https://git-scm.com/docs/gitignore#_pattern_format
+#
+
+* @azure/azure-functions-extensions-bundle-admins

ExtensionBundle.Tests/DependencyValidationTests.cs

@@ -0,0 +1,203 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using Build;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Microsoft.Extensions.DependencyModel;
+using Xunit;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Azure.Functions.ExtensionBundle.Tests
+{
+    [Collection("Fixture")]
+    public class DependencyValidationTests
+    {
+        private readonly DependencyContextJsonReader _reader = new DependencyContextJsonReader();
+        private readonly IEnumerable<string> _rids = DependencyHelper.GetRuntimeFallbacks();
+        private readonly Fixture _fixture;
+
+        public DependencyValidationTests(Fixture fixture)
+        {
+            _fixture = fixture;
+        }
+
+        [InlineData("any_any_extensions.deps.json", "NetCoreApp3_any_any")]
+        [InlineData("win_x86_extensions.deps.json", "x86")]
+        [InlineData("win_x64_extensions.deps.json", "x64")]
+        [Theory]
+        public void Verify_DepsJsonChanges(string oldDepsJsonName, string newDepsJsonName)
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                return;
+            }
+
+            string oldDepsJson = Path.GetFullPath($"../../../TestData/{oldDepsJsonName}");
+            string webhostBinPath = Path.Combine("..", "..", "..", "..", "build_temp");
+            string newDepsJson = Directory.GetFiles(Path.GetFullPath(webhostBinPath), "extensions.deps.json", SearchOption.AllDirectories)
+                                            .Where(path => path.Contains(newDepsJsonName))
+                                            .FirstOrDefault();
+
+            Assert.True(File.Exists(oldDepsJson), $"{oldDepsJson} not found.");
+            Assert.True(File.Exists(newDepsJson), $"{newDepsJson} not found.");
+
+            (bool succeed, string output) = CompareDepsJsonFiles(oldDepsJson, newDepsJson);
+
+            if (succeed == true)
+            {
+                return;
+            }
+
+            Assert.True(succeed, output);
+        }
+
+        [Fact]
+        public void Verify_DepsJsonChanges_Linux_X64()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return;
+            }
+
+            string oldDepsJson = Path.GetFullPath("../../../TestData/linux_x64_extensions.deps.json");
+            string webhostBinPath = Path.Combine("..", "..", "..", "..", "build_temp");
+            string newDepsJson = Directory.GetFiles(Path.GetFullPath(webhostBinPath), "extensions.deps.json", SearchOption.AllDirectories)
+                                            .Where(path => path.Contains("x64"))
+                                            .FirstOrDefault();
+
+            Assert.True(File.Exists(oldDepsJson), $"{oldDepsJson} not found.");
+            Assert.True(File.Exists(newDepsJson), $"{newDepsJson} not found.");
+
+            (bool succeed, string output) = CompareDepsJsonFiles(oldDepsJson, newDepsJson);
+
+            if (succeed == true)
+            {
+                return;
+            }
+
+            Assert.True(succeed, output);
+        }
+
+
+        private (bool, string) CompareDepsJsonFiles(string oldDepsJson, string newDepsJson)
+        {
+            IEnumerable<RuntimeFile> oldAssets = GetRuntimeFiles(oldDepsJson);
+            IEnumerable<RuntimeFile> newAssets = GetRuntimeFiles(newDepsJson);
+
+            var comparer = new RuntimeFileComparer();
+            var assemblyToIgnore = "extensions.dll";
+
+            var removed = oldAssets.Except(newAssets, comparer).ToList();
+            removed = removed.Where(f => !(f.Path.Contains(assemblyToIgnore) && f.AssemblyVersion == null)).ToList();
+
+            var added = newAssets.Except(oldAssets, comparer).ToList();
+            added = added.Where(f => !(f.Path.Contains(assemblyToIgnore) && f.AssemblyVersion == null)).ToList();
+
+            bool succeed = removed.Count == 0 && added.Count == 0;
+
+            if (succeed)
+            {
+                return (succeed, null);
+            }
+
+            IList<RuntimeFile> changed = new List<RuntimeFile>();
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("IMPORTANT: The dependencies in extensions have changed and MUST be reviewed before proceeding. Please follow up with brettsam, fabiocav, nasoni or mathewc for approval.");
+            sb.AppendLine();
+            sb.AppendLine($"Previous file: {oldDepsJson}");
+            sb.AppendLine($"New file:      {newDepsJson}");
+            sb.AppendLine();
+            sb.AppendLine("  Changed:");
+            foreach (RuntimeFile oldFile in oldAssets)
+            {
+                string fileName = Path.GetFileName(oldFile.Path);
+
+                var newFile = newAssets.SingleOrDefault(p =>
+                {
+                    return Path.GetFileName(p.Path) == fileName
+                        && Version.TryParse(p.AssemblyVersion, out Version newVersion)
+                        && Version.TryParse(oldFile.AssemblyVersion, out Version oldVersion)
+                        && newVersion.Major != oldVersion.Major;
+                });
+
+                if (newFile != null)
+                {
+                    sb.AppendLine($"    - {fileName}: {oldFile.AssemblyVersion}/{oldFile.FileVersion} -> {newFile.AssemblyVersion}/{newFile.FileVersion}");
+                    changed.Add(oldFile);
+                    changed.Add(newFile);
+                }
+            }
+
+            sb.AppendLine();
+            sb.AppendLine("  Removed:");
+            foreach (RuntimeFile f in removed.Except(changed))
+            {
+                sb.AppendLine($"    - {Path.GetFileName(f.Path)}: {f.AssemblyVersion}/{f.FileVersion}");
+            }
+            sb.AppendLine();
+            sb.AppendLine("  Added:");
+            foreach (RuntimeFile f in added.Except(changed))
+            {
+                sb.AppendLine($"    - {Path.GetFileName(f.Path)}: {f.AssemblyVersion}/{f.FileVersion}");
+            }
+
+            return (succeed, sb.ToString());
+        }
+
+        private IEnumerable<RuntimeFile> GetRuntimeFiles(string depsJsonFileName)
+        {
+            using (Stream s = new FileStream(depsJsonFileName, FileMode.Open))
+            {
+                DependencyContext deps = _reader.Read(s);
+
+                return deps.RuntimeLibraries
+                    .SelectMany(l => SelectRuntimeAssemblyGroup(_rids, l.RuntimeAssemblyGroups))
+                    .OrderBy(p => Path.GetFileName(p.Path));
+            }
+        }
+
+        private static IEnumerable<RuntimeFile> SelectRuntimeAssemblyGroup(IEnumerable<string> rids, IReadOnlyList<RuntimeAssetGroup> runtimeAssemblyGroups)
+        {
+            // Attempt to load group for the current RID graph
+            foreach (var rid in rids)
+            {
+                var assemblyGroup = runtimeAssemblyGroups.FirstOrDefault(g => string.Equals(g.Runtime, rid, StringComparison.OrdinalIgnoreCase));
+                if (assemblyGroup != null)
+                {
+                    return assemblyGroup.RuntimeFiles;
+                }
+            }
+
+            // If unsuccessful, load default assets, making sure the path is flattened to reflect deployed files
+            return runtimeAssemblyGroups.GetDefaultRuntimeFileAssets();
+        }
+
+
+        private class RuntimeFileComparer : IEqualityComparer<RuntimeFile>
+        {
+            public bool Equals([AllowNull] RuntimeFile x, [AllowNull] RuntimeFile y)
+            {
+                return Version.TryParse(x.AssemblyVersion, out Version xVersion)
+                    && Version.TryParse(y.AssemblyVersion, out Version yVersion)
+                    && xVersion.Major == yVersion.Major;
+            }
+
+            public int GetHashCode([DisallowNull] RuntimeFile obj)
+            {
+                Version.TryParse(obj.AssemblyVersion, out Version objVersion);
+                if (objVersion != null)
+                {
+                    string code = objVersion.Major.ToString();
+                    return code.GetHashCode();
+                }
+
+                return 0;
+            }
+        }
+    }
+}

ExtensionBundle.Tests/ExtensionBundle.Tests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<OutputType>Exe</OutputType>
+		<TargetFramework>netcoreapp3.1</TargetFramework>
+		<AssemblyName>Microsoft.Azure.Functions.ExtensionBundle.Tests</AssemblyName>
+		<RootNamespace>Microsoft.Azure.Functions.ExtensionBundle.Tests</RootNamespace>
+		<SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.3" />
+		<PackageReference Include="xunit" Version="2.4.2" />
+		<PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+			<PrivateAssets>all</PrivateAssets>
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+		</PackageReference>
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\build\Build.csproj" />
+	</ItemGroup>
+
+</Project>

ExtensionBundle.Tests/Fixture.cs

@@ -0,0 +1,35 @@
+using Build;
+using System.Runtime.InteropServices;
+using Xunit;
+using static Build.BasePath;
+
+namespace Microsoft.Azure.Functions.ExtensionBundle.Tests
+{
+    public class Fixture
+    {
+        public Fixture()
+        {
+            path = "../../../..";
+
+            BuildSteps.Clean();
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                BuildSteps.BuildBundleBinariesForLinux();
+            }
+            else
+            {
+                BuildSteps.BuildBundleBinariesForWindows();
+            }
+
+        }
+    }
+
+    [CollectionDefinition("Fixture")]
+    public class TestFixture : ICollectionFixture<Fixture>
+    {
+        // This class has no code, and is never created. Its purpose is simply
+        // to be the place to apply [CollectionDefinition] and all the
+        // ICollectionFixture<> interfaces.
+    }
+}