red: Repackaging.DoesNotRecreatePackage

MinVerTests.Infra/Sdk.cs

@@ -52,23 +52,39 @@ public static async Task CreateSolution(string path, string[] projectNames, stri
             }
         }
 
-        public static async Task CreateProject(string path, string configuration = Configuration.Current)
+        public static async Task CreateProject(string path, string configuration = Configuration.Current, bool multiTarget = false)
         {
             FileSystem.EnsureEmptyDirectory(path);
 
             CreateGlobalJsonIfRequired(path);
 
-            await CreateProject(path, configuration, "test").ConfigureAwait(false);
+            await CreateProject(path, configuration, "test", multiTarget).ConfigureAwait(false);
         }
 
-        private static async Task CreateProject(string path, string configuration, string name)
+        private static async Task CreateProject(string path, string configuration, string name, bool multiTarget = false)
         {
-            var source = Solution.GetFullPath($"MinVer/bin/{configuration}/");
+            _ = await DotNet($"new classlib --name {name} --output {path}{(multiTarget ? " --langVersion 8.0" : "")}", path).ConfigureAwait(false);
 
+            var source = Solution.GetFullPath($"MinVer/bin/{configuration}/");
             var minVerPackageVersion = Path.GetFileNameWithoutExtension(Directory.EnumerateFiles(source, "*.nupkg").First()).Split("MinVer.", 2)[1];
 
-            _ = await DotNet($"new classlib --name {name} --output {path}", path).ConfigureAwait(false);
             _ = await DotNet($"add package MinVer --source {source} --version {minVerPackageVersion} --package-directory packages", path).ConfigureAwait(false);
+
+            if (multiTarget)
+            {
+                var project = Path.Combine(path, $"{name}.csproj");
+                var lines = await File.ReadAllLinesAsync(project).ConfigureAwait(false);
+
+                var editedLines = lines
+                    .Select(line => line.Contains("<TargetFramework>", StringComparison.OrdinalIgnoreCase)
+                        ? line
+                            .Replace("TargetFramework", "TargetFrameworks", StringComparison.OrdinalIgnoreCase)
+                            .Replace("</TargetFrameworks>", ";netstandard2.1</TargetFrameworks>", StringComparison.Ordinal)
+                        : line);
+
+                await File.WriteAllLinesAsync(project, editedLines).ConfigureAwait(false);
+            }
+
             _ = await DotNet($"restore --source {source} --packages packages", path).ConfigureAwait(false);
         }
 
@@ -115,7 +131,19 @@ private static void CreateGlobalJsonIfRequired(string path)
             return (packages.ToList(), result);
         }
 
-        private static Task<Result> DotNet(string args, string path, IDictionary<string, string>? envVars = null)
+        public static async Task<Result> Pack(string path, params (string, string)[] envVars)
+        {
+            var environmentVariables = envVars.ToDictionary(envVar => envVar.Item1, envVar => envVar.Item2, StringComparer.OrdinalIgnoreCase);
+            _ = environmentVariables.TryAdd("MinVerVerbosity".ToAltCase(), "diagnostic");
+            _ = environmentVariables.TryAdd("NoPackageAnalysis", "true");
+
+            return await DotNet(
+                $"pack --no-restore{(!Version.StartsWith("2.", StringComparison.Ordinal) ? " --nologo" : "")}",
+                path,
+                environmentVariables).ConfigureAwait(false);
+        }
+
+        public static Task<Result> DotNet(string args, string path, IDictionary<string, string>? envVars = null)
         {
             envVars ??= new Dictionary<string, string>();
 

MinVerTests.Packages/Cleaning.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.FileSystemGlobbing;
+using MinVerTests.Infra;
+using Xunit;
+
+namespace MinVerTests.Packages
+{
+    public static class Cleaning
+    {
+        [Theory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public static async Task PackagesAreCleaned(bool multiTarget)
+        {
+            // arrange
+            var path = MethodBase.GetCurrentMethod().GetTestDirectory(tag: multiTarget);
+            await Sdk.CreateProject(path, multiTarget: multiTarget);
+
+            await Git.Init(path);
+            await Git.Commit(path);
+            await Git.Tag(path, "2.3.4");
+
+            _ = await Sdk.BuildProject(path);
+
+            var packages = new Matcher().AddInclude("**/bin/Debug/*.nupkg");
+            Assert.NotEmpty(packages.GetResultsInFullPath(path));
+
+            // act
+            _ = await Sdk.DotNet("clean", path, new Dictionary<string, string> { { "GeneratePackageOnBuild", "true" } });
+
+            // assert
+            Assert.Empty(packages.GetResultsInFullPath(path));
+        }
+    }
+}

MinVerTests.Packages/Repackaging.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+using MinVerTests.Infra;
+using Xunit;
+
+namespace MinVerTests.Packages
+{
+    public static class Repackaging
+    {
+        [Theory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public static async Task DoesNotRecreatePackage(bool multiTarget)
+        {
+            // arrange
+            var path = MethodBase.GetCurrentMethod().GetTestDirectory(tag: multiTarget);
+            await Sdk.CreateProject(path, multiTarget: multiTarget);
+
+            await Git.Init(path);
+            await Git.Commit(path);
+            await Git.Tag(path, "2.3.4");
+
+            var (_, result) = await Sdk.BuildProject(path);
+
+            Assert.Contains("Successfully created package", result.StandardOutput, StringComparison.OrdinalIgnoreCase);
+
+            // act
+            result = await Sdk.Pack(path);
+
+            // assert
+            Assert.DoesNotContain("Successfully created package", result.StandardOutput, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}