From 18f286cf736326ca2a21d42a059f1b9356a1897e Mon Sep 17 00:00:00 2001
From: Nick Guerrera <nicholg@microsoft.com>
Date: Mon, 21 Aug 2017 16:09:42 -0700
Subject: [PATCH] Bump default versions for self-contained apps

Ported along with corresponding tests from f8d2186f3c48e63add882a7b240cced9d70cb160
---
 .../Microsoft.NET.Sdk.DefaultItems.targets    | 67 +++++++++-----
 .../GivenThatWeWantToBuildANetCoreApp.cs      | 88 +++++++++++++------
 .../Commands/MSBuildTest.cs                   |  4 +
 .../Commands/TestCommand.cs                   |  1 +
 .../ProjectConstruction/TestProject.cs        | 13 ++-
 test/Microsoft.NET.TestFramework/RepoInfo.cs  |  8 ++
 6 files changed, 131 insertions(+), 50 deletions(-)

diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/build/Microsoft.NET.Sdk.DefaultItems.targets b/src/Tasks/Microsoft.NET.Build.Tasks/build/Microsoft.NET.Sdk.DefaultItems.targets
index 02192d06a92b..77d3d1245415 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/build/Microsoft.NET.Sdk.DefaultItems.targets
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/build/Microsoft.NET.Sdk.DefaultItems.targets
@@ -55,7 +55,7 @@ Copyright (c) .NET Foundation. All rights reserved.
   </PropertyGroup>
   
   <!--  
-    Determine the NetCoreImplicitPackageVersion and RuntimeFrameworkVersion when targeting .NET Core
+    Determine the RuntimeFrameworkVersion when targeting .NET Core
     
     When targeting .NET Core, the TargetFramework is generally used to specify which version of the runtime to use.
     
@@ -64,30 +64,51 @@ Copyright (c) .NET Foundation. All rights reserved.
     
     The framework version that is written to the runtimeconfig.json file is based on the actual resolved package version
     of Microsoft.NETCore.App.  This is to allow floating the verion number.
-  
+    
+    If RuntimeFrameworkVersion is not specified, the following logic applies
+
+    - Self-contained apps use the latest corresponding patch version (from when the SDK shipped)
+    - Framework-dependent app targeting netcoreapp1.0 and netcoreapp1.1 use v1.0.5 and v1.1.2, respectively
+        - This is done for compatibility with previous releases that bumped the self-contained and framework-dependent versions together.
   -->
+  <!-- These properties are here as a test hook so that we can test with the versions bumped before the actual framework
+       builds are available. -->
+  <PropertyGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' And '$(RuntimeFrameworkVersion)' == ''"> 
+    <ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0
+      Condition="'$(ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0)' == ''">1.0.6</ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0>
+    <ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1
+      Condition="'$(ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1)' == ''">1.1.3</ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1>
+  </PropertyGroup>
 
-  <PropertyGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <!-- If targeting .NET Core, and the RuntimeFrameworkVersion is not specified, use the latest patch version of that runtime that we know about.
-    
-      This ensures that if a self-contained app is published where RuntimeFrameworkVersion is not specified, the latest patch
-      version of the runtime (that the SDK knew about when it shipped) will be used.
-      
-      This also will fix an issue where Microsoft.NETCore.App 1.1.0 included a version of the Microsoft.DiaSymReader.Native package
-      that was authored in such a way that Microsoft.DiaSymReader.Native.amd64.dll and Microsoft.DiaSymReader.Native.x86.dll would
-      be copied to the output folder.  Using Microsoft.NETCore.App 1.1.1 fixes this, as it references an updated version of the
-      DiaSymReader package with the issue fixed.  (See https://github.com/dotnet/corefx/issues/14627)
-      
-      Using the latest patch version that the SDK knows about does mean that an update to the SDK could change the version of
-      the runtime that a project targets.  In general, this should be OK.  If a project wants to opt out of this, it can specify
-      the exact version of the runtime to use with the RuntimeFrameworkVersion property.    
-    -->
-    <!-- If targeting netcoreapp1.1, and RuntimeFrameworkVersion is not specified, use version 1.1.1 -->
-    <RuntimeFrameworkVersion Condition="'$(RuntimeFrameworkVersion)' == '' And '$(_TargetFrameworkVersionWithoutV)' == '1.0'">1.0.5</RuntimeFrameworkVersion>
-    <RuntimeFrameworkVersion Condition="'$(RuntimeFrameworkVersion)' == '' And '$(_TargetFrameworkVersionWithoutV)' == '1.1'">1.1.2</RuntimeFrameworkVersion>
-    
-    <!-- Default to use the version of the framework runtime matching the target framework version-->
-    <RuntimeFrameworkVersion Condition="'$(RuntimeFrameworkVersion)' == ''">$(_TargetFrameworkVersionWithoutV)</RuntimeFrameworkVersion>
+  <!-- Select implicit runtime framework versions -->
+  <Choose>
+    <!-- If not targeting .NET Core, or if RuntimeFrameworkVersion is already set, do nothing -->
+    <When Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp' Or '$(RuntimeFrameworkVersion)' != ''" />
+
+    <When Condition="'$(_TargetFrameworkVersionWithoutV)' == '1.0'">
+      <PropertyGroup>
+        <ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>1.0.5</ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>
+        <ImplicitRuntimeFrameworkVersionForSelfContainedApp>$(ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0)</ImplicitRuntimeFrameworkVersionForSelfContainedApp>
+      </PropertyGroup>
+    </When>
+    <When Condition="'$(_TargetFrameworkVersionWithoutV)' == '1.1'">
+      <PropertyGroup>
+        <ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>1.1.2</ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>
+        <ImplicitRuntimeFrameworkVersionForSelfContainedApp>$(ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1)</ImplicitRuntimeFrameworkVersionForSelfContainedApp>
+      </PropertyGroup>
+    </When>
+
+    <!-- If not covered by the previous cases, use the target framework version for the implicit RuntimeFrameworkVersions -->
+    <Otherwise>
+      <PropertyGroup>
+        <ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>$(_TargetFrameworkVersionWithoutV)</ImplicitRuntimeFrameworkVersionForFrameworkDependentApp>
+        <ImplicitRuntimeFrameworkVersionForSelfContainedApp>$(_TargetFrameworkVersionWithoutV)</ImplicitRuntimeFrameworkVersionForSelfContainedApp>
+      </PropertyGroup>
+    </Otherwise>
+  </Choose>
+  <PropertyGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' And '$(RuntimeFrameworkVersion)' == ''">
+    <RuntimeFrameworkVersion Condition="'$(RuntimeIdentifier)' != '' ">$(ImplicitRuntimeFrameworkVersionForSelfContainedApp)</RuntimeFrameworkVersion>
+    <RuntimeFrameworkVersion Condition="'$(RuntimeIdentifier)' == '' ">$(ImplicitRuntimeFrameworkVersionForFrameworkDependentApp)</RuntimeFrameworkVersion>
   </PropertyGroup>
 
   <UsingTask TaskName="CheckForImplicitPackageReferenceOverrides" AssemblyFile="$(MicrosoftNETBuildTasksAssembly)" />
diff --git a/test/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildANetCoreApp.cs b/test/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildANetCoreApp.cs
index 957416415ac7..da150715834a 100644
--- a/test/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildANetCoreApp.cs
+++ b/test/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildANetCoreApp.cs
@@ -31,46 +31,84 @@ public class GivenThatWeWantToBuildANetCoreApp : SdkTest
         public void It_targets_the_right_shared_framework(string targetFramework, string runtimeFrameworkVersion,
             string expectedPackageVersion, string expectedRuntimeVersion)
         {
+            string testIdentifier = "SharedFrameworkTargeting_" + string.Join("_", targetFramework, runtimeFrameworkVersion ?? "null");
+
+            It_targets_the_right_framework(testIdentifier, targetFramework, runtimeFrameworkVersion,
+                selfContained: false, isExe: true,
+                expectedPackageVersion: expectedPackageVersion, expectedRuntimeVersion: expectedRuntimeVersion);
+        }
+
+        //  Test behavior when implicit version differs for framework-dependent and self-contained apps
+        [Theory]
+        [InlineData("netcoreapp1.0", false, true, "1.0.5")]
+        [InlineData("netcoreapp1.0", true, true, RepoInfo.ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0)]
+        [InlineData("netcoreapp1.0", false, false, "1.0.5")]
+        [InlineData("netcoreapp1.1", false, true, "1.1.2")]
+        [InlineData("netcoreapp1.1", true, true, RepoInfo.ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1)]
+        [InlineData("netcoreapp1.1", false, false, "1.1.2")]
+        public void It_targets_the_right_framework_depending_on_output_type(string targetFramework, bool selfContained, bool isExe, string expectedFrameworkVersion)
+        {
+            string testIdentifier = "Framework_targeting_" + (isExe ? "App_" : "Lib_") + (selfContained ? "SelfContained" : "FrameworkDependent");
+
+            It_targets_the_right_framework(testIdentifier, targetFramework, null, selfContained, isExe, expectedFrameworkVersion, expectedFrameworkVersion);
+        }
+
+        private void It_targets_the_right_framework(
+            string testIdentifier,
+            string targetFramework,
+            string runtimeFrameworkVersion,
+            bool selfContained,
+            bool isExe,
+            string expectedPackageVersion,
+            string expectedRuntimeVersion,
+            string extraMSBuildArguments = null)
+        {
+            string runtimeIdentifier = null;
+            if (selfContained)
+            {
+                runtimeIdentifier = EnvironmentInfo.GetCompatibleRid(targetFramework);
+            }
+
             var testProject = new TestProject()
             {
-                Name = "SharedFrameworkTest",
+                Name = "FrameworkTargetTest",
                 TargetFrameworks = targetFramework,
+                RuntimeFrameworkVersion = runtimeFrameworkVersion,
                 IsSdkProject = true,
-                IsExe = true
+                IsExe = isExe,
+                RuntimeIdentifier = runtimeIdentifier
             };
 
-            string testIdentifier = string.Join("_", targetFramework, runtimeFrameworkVersion ?? "null");
+            var extraArgs = extraMSBuildArguments?.Split(' ') ?? Array.Empty<string>();
 
-            var testAsset = _testAssetsManager.CreateTestProject(testProject, nameof(It_targets_the_right_shared_framework), testIdentifier);
-
-            testAsset = testAsset.WithProjectChanges(project =>
-            {
-                var ns = project.Root.Name.Namespace;
-                var propertyGroup = new XElement(ns + "PropertyGroup");
-                project.Root.Add(propertyGroup);
-
-                if (runtimeFrameworkVersion != null)
-                {
-                    propertyGroup.Add(new XElement(ns + "RuntimeFrameworkVersion", runtimeFrameworkVersion));
-                }
-            });
-
-            testAsset = testAsset.Restore(testProject.Name);
+            var testAsset = _testAssetsManager.CreateTestProject(testProject, testIdentifier)
+                .Restore(testProject.Name, extraArgs);
 
             var buildCommand = new BuildCommand(Stage0MSBuild, Path.Combine(testAsset.TestRoot, testProject.Name));
 
             buildCommand
-                .Execute()
+                .Execute(extraArgs)
                 .Should()
                 .Pass();
 
-            var outputDirectory = buildCommand.GetOutputDirectory(targetFramework);
-            string runtimeConfigFile = Path.Combine(outputDirectory.FullName, testProject.Name + ".runtimeconfig.json");
-            string runtimeConfigContents = File.ReadAllText(runtimeConfigFile);
-            JObject runtimeConfig = JObject.Parse(runtimeConfigContents);
+            var outputDirectory = buildCommand.GetOutputDirectory(targetFramework, runtimeIdentifier: runtimeIdentifier);
+            if (isExe)
+            {
+                //  Self-contained apps don't write a framework version to the runtimeconfig, so only check this for framework-dependent apps
+                if (!selfContained)
+                {
+                    string runtimeConfigFile = Path.Combine(outputDirectory.FullName, testProject.Name + ".runtimeconfig.json");
+                    string runtimeConfigContents = File.ReadAllText(runtimeConfigFile);
+                    JObject runtimeConfig = JObject.Parse(runtimeConfigContents);
+
+                    string actualRuntimeFrameworkVersion = ((JValue)runtimeConfig["runtimeOptions"]["framework"]["version"]).Value<string>();
+                    actualRuntimeFrameworkVersion.Should().Be(expectedRuntimeVersion);
+                }
 
-            string actualRuntimeFrameworkVersion = ((JValue)runtimeConfig["runtimeOptions"]["framework"]["version"]).Value<string>();
-            actualRuntimeFrameworkVersion.Should().Be(expectedRuntimeVersion);
+                var runtimeconfigDevFileName = testProject.Name + ".runtimeconfig.dev.json";
+                outputDirectory.Should()
+                        .HaveFile(runtimeconfigDevFileName);
+            }
 
             LockFile lockFile = LockFileUtilities.GetLockFile(Path.Combine(buildCommand.ProjectRootPath, "obj", "project.assets.json"), NullLogger.Instance);
 
diff --git a/test/Microsoft.NET.TestFramework/Commands/MSBuildTest.cs b/test/Microsoft.NET.TestFramework/Commands/MSBuildTest.cs
index 66b1884912d2..1b1686c37af5 100644
--- a/test/Microsoft.NET.TestFramework/Commands/MSBuildTest.cs
+++ b/test/Microsoft.NET.TestFramework/Commands/MSBuildTest.cs
@@ -50,6 +50,10 @@ private ICommand CreateCommand(params string[] args)
 
             command = command.EnvironmentVariable("MSBuildSDKsPath", RepoInfo.SdksPath);
 
+            command = command
+                .EnvironmentVariable(nameof(RepoInfo.ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0), RepoInfo.ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0)
+                .EnvironmentVariable(nameof(RepoInfo.ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1), RepoInfo.ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1);
+
             return command;
         }
     }
diff --git a/test/Microsoft.NET.TestFramework/Commands/TestCommand.cs b/test/Microsoft.NET.TestFramework/Commands/TestCommand.cs
index b2b598032f9c..2dfdf4bb3609 100644
--- a/test/Microsoft.NET.TestFramework/Commands/TestCommand.cs
+++ b/test/Microsoft.NET.TestFramework/Commands/TestCommand.cs
@@ -46,6 +46,7 @@ private string FindProjectFile(string relativePathToProject)
 
         public virtual DirectoryInfo GetOutputDirectory(string targetFramework, string configuration = "Debug", string runtimeIdentifier = "")
         {
+            runtimeIdentifier = runtimeIdentifier ?? "";
             string output = Path.Combine(ProjectRootPath, "bin", configuration, targetFramework, runtimeIdentifier);
             return new DirectoryInfo(output);
         }
diff --git a/test/Microsoft.NET.TestFramework/ProjectConstruction/TestProject.cs b/test/Microsoft.NET.TestFramework/ProjectConstruction/TestProject.cs
index 41ff16e11d3b..999b1ac00223 100644
--- a/test/Microsoft.NET.TestFramework/ProjectConstruction/TestProject.cs
+++ b/test/Microsoft.NET.TestFramework/ProjectConstruction/TestProject.cs
@@ -18,6 +18,10 @@ public class TestProject
         //  Applies to SDK Projects
         public string TargetFrameworks { get; set; }
 
+        public string RuntimeFrameworkVersion { get; set; }
+
+        public string RuntimeIdentifier { get; set; }
+
         //  TargetFrameworkVersion applies to non-SDK projects
         public string TargetFrameworkVersion { get; set; }
 
@@ -129,9 +133,14 @@ internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder)
                     propertyGroup.Add(new XElement(ns + "TargetFramework", this.TargetFrameworks));
                 }
 
-                if (this.IsExe && targetFrameworks.Any(identifier => GetShortTargetFrameworkIdentifier(identifier).Equals("net", StringComparison.OrdinalIgnoreCase)))
+                if (!string.IsNullOrEmpty(this.RuntimeFrameworkVersion))
+                {
+                    propertyGroup.Add(new XElement(ns + "RuntimeFrameworkVersion", this.RuntimeFrameworkVersion));
+                }
+
+                if (!string.IsNullOrEmpty(this.RuntimeIdentifier))
                 {
-                    propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", "win7-x86"));
+                    propertyGroup.Add(new XElement(ns + "RuntimeIdentifier", this.RuntimeIdentifier));
                 }
 
                 //  Update SDK reference to the version under test
diff --git a/test/Microsoft.NET.TestFramework/RepoInfo.cs b/test/Microsoft.NET.TestFramework/RepoInfo.cs
index e443d37a29c9..8d828838c477 100644
--- a/test/Microsoft.NET.TestFramework/RepoInfo.cs
+++ b/test/Microsoft.NET.TestFramework/RepoInfo.cs
@@ -84,6 +84,14 @@ private static string FindConfigurationInBasePath()
             return new DirectoryInfo(GetBaseDirectory()).Parent.Name;
         }
 
+        // For test purposes, override the implicit .NETCoreApp version for self-contained apps that to builds thare 
+        //  (1) different from the fixed framework-dependent defaults (1.0.5, 1.1.2, 2.0.0)
+        //  (2) currently available on nuget.org
+        //
+        // This allows bumping the versions before builds without causing tests to fail.
+        public const string ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_0 = "1.0.4";
+        public const string ImplicitRuntimeFrameworkVersionForSelfContainedNetCoreApp1_1 = "1.1.1";
+
         private static string GetBaseDirectory()
         {
 #if NET451