write tests for packaging an app in all supported configurations

Author: baronfel

Microsoft.NET.Build.Containers/Registry.cs

@@ -74,12 +74,16 @@ async Task<HttpResponseMessage> GetBlob(string digest) {
         }
 
         async Task<Image?> TryPickBestImageFromManifestList(ManifestListV2 manifestList, string runtimeIdentifier) {
+            // TODO: we probably need to pull in actual RID parsing code and look for 'platform' here.
+            // 'win' can take a version number and we'd break.
+            // Also, there are more specific linux RIDs (like rhel) that we should instead be looking for the correct 'family' for?
+            // we probably also need to look at the 'variant' field if the RID contains a version.
             (string os, string arch, string? variant) = runtimeIdentifier.Split('-') switch {
                 ["linux", "x64"] => ("linux", "amd64", null),
                 ["linux", "x86"] => ("linux", "386", null),
                 ["linux", "arm"] => ("linux", "arm", "v7"),
                 ["linux", "arm64"] => ("linux", "arm64", "v8"),
-                ["windows", "x64"] => ("windows", "amd64", null),
+                ["win", "x64"] => ("windows", "amd64", null),
                 var parts => throw new ArgumentException($"Unknown OS/platform combination {String.Join(' ', parts)}")
             };
 

Test.Microsoft.NET.Build.Containers.Filesystem/DockerRegistryManager.cs

@@ -8,9 +8,10 @@ public class DockerRegistryManager
 {
     public const string BaseImage = "dotnet/runtime";
     public const string BaseImageSource = "mcr.microsoft.com/";
-    public const string BaseImageTag = "6.0";
+    public const string Net6ImageTag = "6.0";
+    public const string Net7ImageTag = "7.0";
     public const string LocalRegistry = "localhost:5010";
-    public const string FullyQualifiedBaseImageDefault = $"{BaseImageSource}{BaseImage}:{BaseImageTag}";
+    public const string FullyQualifiedBaseImageDefault = $"{BaseImageSource}{BaseImage}:{Net6ImageTag}";
     private static string s_registryContainerId;
 
     private static void Exec(string command, string args) {
@@ -53,9 +54,11 @@ public static void StartAndPopulateDockerRegistry(TestContext context)
 
         s_registryContainerId = registryContainerId;
 
-        Exec("docker", $"pull {BaseImageSource}{BaseImage}:{BaseImageTag}");
-        Exec("docker", $"tag {BaseImageSource}{BaseImage}:{BaseImageTag} {LocalRegistry}/{BaseImage}:{BaseImageTag}");
-        Exec("docker", $"push {LocalRegistry}/{BaseImage}:{BaseImageTag}");
+        foreach (var tag in new [] { Net6ImageTag, Net7ImageTag}) {
+            Exec("docker", $"pull {BaseImageSource}{BaseImage}:{tag}");
+            Exec("docker", $"tag {BaseImageSource}{BaseImage}:{tag} {LocalRegistry}/{BaseImage}:{tag}");
+            Exec("docker", $"push {LocalRegistry}/{BaseImage}:{tag}");
+        }
         LocateMSBuild();
     }
 

Test.Microsoft.NET.Build.Containers.Filesystem/EndToEnd.cs

@@ -31,7 +31,7 @@ public async Task ApiEndToEndWithRegistryPushAndPull()
 
         Registry registry = new Registry(ContainerHelpers.TryExpandRegistryToUri(DockerRegistryManager.LocalRegistry));
 
-        Image x = await registry.GetImageManifest(DockerRegistryManager.BaseImage, DockerRegistryManager.BaseImageTag, "linux-x64");
+        Image x = await registry.GetImageManifest(DockerRegistryManager.BaseImage, DockerRegistryManager.Net6ImageTag, "linux-x64");
 
         Layer l = Layer.FromDirectory(publishDirectory, "/app");
 
@@ -69,7 +69,7 @@ public async Task ApiEndToEndWithLocalLoad()
 
         Registry registry = new Registry(ContainerHelpers.TryExpandRegistryToUri(DockerRegistryManager.LocalRegistry));
 
-        Image x = await registry.GetImageManifest(DockerRegistryManager.BaseImage, DockerRegistryManager.BaseImageTag, "linux-x64");
+        Image x = await registry.GetImageManifest(DockerRegistryManager.BaseImage, DockerRegistryManager.Net6ImageTag, "linux-x64");
 
         Layer l = Layer.FromDirectory(publishDirectory, "/app");
 
@@ -91,15 +91,15 @@ public async Task ApiEndToEndWithLocalLoad()
         Assert.AreEqual(0, run.ExitCode);
     }
 
-    private static async Task<string> BuildLocalApp()
+    private static async Task<string> BuildLocalApp(string tfm = "net6.0", string rid = "linux-x64")
     {
         DirectoryInfo d = new DirectoryInfo("MinimalTestApp");
         if (d.Exists)
         {
             d.Delete(recursive: true);
         }
 
-        ProcessStartInfo psi = new("dotnet", "new console -f net6.0 -o MinimalTestApp")
+        ProcessStartInfo psi = new("dotnet", $"new console -f {tfm} -o MinimalTestApp")
         {
             RedirectStandardOutput = true,
             RedirectStandardError = true,
@@ -109,16 +109,17 @@ private static async Task<string> BuildLocalApp()
 
         Assert.IsNotNull(dotnetNew);
         await dotnetNew.WaitForExitAsync();
-        Assert.AreEqual(0, dotnetNew.ExitCode, await dotnetNew.StandardOutput.ReadToEndAsync() + await dotnetNew.StandardError.ReadToEndAsync());
+        Assert.AreEqual(0, dotnetNew.ExitCode, await dotnetNew.StandardOutput.ReadToEndAsync() + Environment.NewLine + await dotnetNew.StandardError.ReadToEndAsync());
 
-        // Build project
-
-        Process publish = Process.Start("dotnet", "publish -bl MinimalTestApp -r linux-x64");
+        ProcessStartInfo publishPSI = rid is null ? new("dotnet", $"publish -bl MinimalTestApp") : new("dotnet", $"publish -bl MinimalTestApp -r {rid}"); 
+        publishPSI.RedirectStandardOutput = true;
+        publishPSI.RedirectStandardError = true;
+        Process publish = Process.Start(publishPSI);
         Assert.IsNotNull(publish);
         await publish.WaitForExitAsync();
-        Assert.AreEqual(0, publish.ExitCode);
+        Assert.AreEqual(0, publish.ExitCode, await publish.StandardOutput.ReadToEndAsync() + Environment.NewLine + await publish.StandardError.ReadToEndAsync());
 
-        string publishDirectory = Path.Join("MinimalTestApp", "bin", "Debug", "net6.0", "linux-x64", "publish");
+        string publishDirectory = Path.Join("MinimalTestApp", "bin", "Debug", tfm, rid, "publish");
         return publishDirectory;
     }
 
@@ -274,4 +275,56 @@ public async Task EndToEnd_NoAPI()
         newProjectDir.Delete(true);
         privateNuGetAssets.Delete(true);
     }
+
+    [DataRow("linux-x86", false, "/app")] // packaging framework-dependent because missing runtime packs for x86 linux.
+    [DataRow("linux-x64", true, "/app")]
+    [DataRow("linux-arm", false, "/app")] // packaging framework-dependent because emulating arm on x64 Docker host doesn't work
+    [DataRow("linux-arm64", false, "/app")] // packaging framework-dependent because emulating arm64 on x64 Docker host doesn't work
+    [DataRow("win-x64", true, "C:\\app")]
+    [TestMethod]
+    public async Task CanPackageForAllSupportedContainerRIDs(string rid, bool isRIDSpecific, string workingDir) {
+        if (rid == "win-x64") {
+            Assert.Inconclusive("Cannot run Windows containers on Linux hosts (or at the same time as Linux containers), so skipping for now");
+            return;
+        }
+        string publishDirectory = await BuildLocalApp(tfm : "net7.0", rid : (isRIDSpecific ? rid : null));
+
+        // Build the image
+        Registry registry = new Registry(ContainerHelpers.TryExpandRegistryToUri(DockerRegistryManager.LocalRegistry));
+
+        Image x = await registry.GetImageManifest(DockerRegistryManager.BaseImage, DockerRegistryManager.Net7ImageTag, rid);
+
+        Layer l = Layer.FromDirectory(publishDirectory, "/app");
+
+        x.AddLayer(l);
+        x.WorkingDirectory = workingDir;
+
+        var entryPoint = DecideEntrypoint(rid, isRIDSpecific, "MinimalTestApp", workingDir);
+        x.SetEntrypoint(entryPoint);
+
+        // Load the image into the local Docker daemon
+
+        await LocalDocker.Load(x, NewImageName(), rid, DockerRegistryManager.BaseImage);
+
+        // Run the image
+
+        ProcessStartInfo runInfo = new("docker", $"run --rm --tty {NewImageName()}:{rid}") {
+            RedirectStandardError = true,
+            RedirectStandardOutput = true,
+        };
+        Process run = Process.Start(runInfo);
+        Assert.IsNotNull(run);
+        await run.WaitForExitAsync();
+
+        Assert.AreEqual(0, run.ExitCode, run.StandardOutput.ReadToEnd() + Environment.NewLine + run.StandardError.ReadToEnd());
+
+        string[] DecideEntrypoint(string rid, bool isRIDSpecific, string appName, string workingDir) {
+            var binary = rid.StartsWith("win") ? $"{appName}.exe" : appName;
+            if (isRIDSpecific) {
+                return new[] { $"{workingDir}/{binary}" };
+            } else {
+                return new[] { "dotnet", $"{workingDir}/{binary}.dll" };
+            }
+        }
+    }
 }

Test.Microsoft.NET.Build.Containers.Filesystem/RegistryTests.cs

@@ -15,7 +15,7 @@ public async Task GetFromRegistry()
     {
         Registry registry = new Registry(ContainerHelpers.TryExpandRegistryToUri(DockerRegistryManager.LocalRegistry));
 
-        Image downloadedImage = await registry.GetImageManifest(DockerRegistryManager.BaseImage, DockerRegistryManager.BaseImageTag, "linux-x64");
+        Image downloadedImage = await registry.GetImageManifest(DockerRegistryManager.BaseImage, DockerRegistryManager.Net6ImageTag, "linux-x64");
 
         Assert.IsNotNull(downloadedImage);
     }