adamralph · adamralph · Feb 1, 2022 · Feb 1, 2022 · Jan 5, 2022
diff --git a/MinVer.Lib/MajorMinor.cs b/MinVer.Lib/MajorMinor.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace MinVer.Lib
 {
@@ -30,9 +31,9 @@ public MajorMinor(int major, int minor)
 
         public static string ValidValues => "1.0, 1.1, 2.0, etc.";
 
-        public static bool TryParse(string value, out MajorMinor majorMinor)
+        public static bool TryParse(string value, [NotNullWhen(returnValue: true)] out MajorMinor? majorMinor)
         {
-            majorMinor = Zero;
+            majorMinor = null;
 
             if (string.IsNullOrWhiteSpace(value))
             {

diff --git a/MinVer.Lib/Version.cs b/MinVer.Lib/Version.cs
@@ -101,7 +101,7 @@ public int CompareTo(Version? other)
 
         public Version Satisfying(MajorMinor minMajorMinor, string defaultPreReleasePhase)
         {
-            minMajorMinor ??= MajorMinor.Zero;
+            minMajorMinor = minMajorMinor ?? throw new ArgumentNullException(nameof(minMajorMinor));
 
             return minMajorMinor.Major < this.major || (minMajorMinor.Major == this.major && minMajorMinor.Minor <= this.minor)
                 ? this
@@ -127,8 +127,8 @@ public Version AddBuildMetadata(string buildMetadata)
 
         public static bool TryParse(string text, [NotNullWhen(returnValue: true)] out Version? version, string prefix = "")
         {
-            text ??= "";
-            prefix ??= "";
+            text = text ?? throw new ArgumentNullException(nameof(text));
+            prefix = prefix ?? throw new ArgumentNullException(nameof(prefix));
 
             version = null;
 

diff --git a/MinVer.Lib/Versioner.cs b/MinVer.Lib/Versioner.cs
@@ -54,7 +54,7 @@ private static Version GetVersion(string workDir, string tagPrefix, VersionPart
                 .OrderBy(candidate => candidate.Version)
                 .ThenByDescending(candidate => candidate.Index).ToList();
 
-            var tagWidth = log.IsDebugEnabled ? orderedCandidates.Max(candidate => candidate.Tag?.Length ?? 2) : 0;
+            var tagWidth = log.IsDebugEnabled ? orderedCandidates.Max(candidate => candidate.Tag.Length) : 0;
             var versionWidth = log.IsDebugEnabled ? orderedCandidates.Max(candidate => candidate.Version.ToString().Length) : 0;
             var heightWidth = log.IsDebugEnabled ? orderedCandidates.Max(candidate => candidate.Height).ToString(CultureInfo.CurrentCulture).Length : 0;
 

diff --git a/MinVer/VerbosityMap.cs b/MinVer/VerbosityMap.cs
@@ -1,11 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace MinVer
 {
     internal static class VerbosityMap
     {
-        private static readonly Dictionary<string, Verbosity> map = new Dictionary<string, Verbosity>(StringComparer.OrdinalIgnoreCase);
+        private static readonly Dictionary<string, Verbosity?> map = new Dictionary<string, Verbosity?>(StringComparer.OrdinalIgnoreCase);
 
         static VerbosityMap()
         {
@@ -26,6 +27,6 @@ static void Add(Verbosity verbosity, int shortLength)
         public static string ValidValues => "q[uiet], m[inimal] (default), n[ormal], d[etailed], or diag[nostic] (case insensitive)";
 
         // spell-checker:enable
-        public static bool TryMap(string value, out Verbosity verbosity) => map.TryGetValue(value, out verbosity);
+        public static bool TryMap(string value, [NotNullWhen(returnValue: true)] out Verbosity? verbosity) => map.TryGetValue(value, out verbosity);
     }
 }
diff --git a/MinVerTests.Infra/MinVerCli.cs b/MinVerTests.Infra/MinVerCli.cs
@@ -6,12 +6,12 @@ namespace MinVerTests.Infra
 {
     public static class MinVerCli
     {
-        public static async Task<(string StandardOutput, string StandardError)> ReadAsync(string workingDirectory, string configuration = Configuration.Current, params (string, string)[] envVars)
+        public static async Task<(string StandardOutput, string StandardError)> ReadAsync(string workingDirectory, string configuration = Configuration.Current, string args = "", params (string, string)[] envVars)
         {
             var environmentVariables = envVars.ToDictionary(envVar => envVar.Item1, envVar => envVar.Item2, StringComparer.OrdinalIgnoreCase);
             _ = environmentVariables.TryAdd("MinVerVerbosity".ToAltCase(), "trace");
 
-            return await CommandEx.ReadLoggedAsync("dotnet", $"exec {GetPath(configuration)}", workingDirectory, environmentVariables).ConfigureAwait(false);
+            return await CommandEx.ReadLoggedAsync("dotnet", $"exec {GetPath(configuration)} {args}", workingDirectory, environmentVariables).ConfigureAwait(false);
         }
 
         public static string GetPath(string configuration) =>

diff --git a/MinVerTests.Infra/Sdk.cs b/MinVerTests.Infra/Sdk.cs
@@ -19,7 +19,7 @@ public static class Sdk
 
         public static async Task CreateSolution(string path, string[] projectNames, string configuration = Configuration.Current)
         {
-            projectNames ??= Array.Empty<string>();
+            projectNames = projectNames ?? throw new ArgumentNullException(nameof(projectNames));
 
             FileSystem.EnsureEmptyDirectory(path);
 

diff --git a/MinVerTests.Packages/OptionMasking.cs b/MinVerTests.Packages/OptionMasking.cs
@@ -0,0 +1,148 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+using MinVerTests.Infra;
+using Xunit;
+
+namespace MinVerTests.Packages
+{
+    public static class OptionMasking
+    {
+        [Theory]
+        [InlineData("patch")]
+        public static async Task AutoIncrementBackToDefault(string value)
+        {
+            // arrange
+            var path = MethodBase.GetCurrentMethod().GetTestDirectory();
+            FileSystem.EnsureEmptyDirectory(path);
+
+            await Git.Init(path);
+            await Git.Commit(path);
+            await Git.Tag(path, "2.3.4");
+            await Git.Commit(path);
+
+            var envVars = ("MinVerAutoIncrement".ToAltCase(), "minor");
+            var args = $"--auto-increment {value}";
+
+            var expected = Package.WithVersion(2, 3, 5, new[] { "alpha", "0" }, 1);
+
+            // act
+            var (cliStandardOutput, _) = await MinVerCli.ReadAsync(path, args: args, envVars: envVars);
+
+            // assert
+            Assert.Equal(expected.Version, cliStandardOutput.Trim());
+        }
+
+        [Theory]
+        [InlineData("\"\"")]
+
+        public static async Task BuildMetadataBackToDefault(string value)
+        {
+            // arrange
+            var path = MethodBase.GetCurrentMethod().GetTestDirectory();
+            FileSystem.EnsureEmptyDirectory(path);
+
+            var envVars = ("MinVerBuildMetadata", "build.123");
+            var args = $"--build-metadata {value}";
+
+            var expected = Package.WithVersion(0, 0, 0, new[] { "alpha", "0" }, 0);
+
+            // act
+            var (cliStandardOutput, _) = await MinVerCli.ReadAsync(path, args: args, envVars: envVars);
+
+            // assert
+            Assert.Equal(expected.Version, cliStandardOutput.Trim());
+        }
+
+        [Theory]
+        [InlineData("alpha")]
+        public static async Task DefaultPreReleasePhaseBackToDefault(string value)
+        {
+            // arrange
+            var path = MethodBase.GetCurrentMethod().GetTestDirectory();
+            FileSystem.EnsureEmptyDirectory(path);
+
+            await Git.Init(path);
+            await Git.Commit(path);
+            await Git.Tag(path, "2.3.4");
+            await Git.Commit(path);
+
+            var envVars = ("MinVerDefaultPreReleasePhase".ToAltCase(), "preview");
+            var args = $"--default-pre-release-phase {value}";
+
+            var expected = Package.WithVersion(2, 3, 5, new[] { "alpha", "0" }, 1);
+
+            // act
+            var (cliStandardOutput, _) = await MinVerCli.ReadAsync(path, args: args, envVars: envVars);
+
+            // assert
+            Assert.Equal(expected.Version, cliStandardOutput.Trim());
+        }
+
+        [Theory]
+        [InlineData("0.0")]
+        public static async Task MinimumMajorMinorBackToDefault(string value)
+        {
+            // arrange
+            var path = MethodBase.GetCurrentMethod().GetTestDirectory();
+            FileSystem.EnsureEmptyDirectory(path);
+
+            await Git.Init(path);
+            await Git.Commit(path);
+            await Git.Tag(path, "2.3.4");
+
+            var envVars = ("MinVerMinimumMajorMinor".ToAltCase(), "3.0");
+            var args = $"--minimum-major-minor {value}";
+
+            var expected = Package.WithVersion(2, 3, 4);
+
+            // act
+            var (cliStandardOutput, _) = await MinVerCli.ReadAsync(path, args: args, envVars: envVars);
+
+            // assert
+            Assert.Equal(expected.Version, cliStandardOutput.Trim());
+        }
+
+        [Theory]
+        [InlineData("\"\"")]
+        public static async Task TagPrefixBackToDefault(string value)
+        {
+            // arrange
+            var path = MethodBase.GetCurrentMethod().GetTestDirectory();
+            FileSystem.EnsureEmptyDirectory(path);
+
+            await Git.Init(path);
+            await Git.Commit(path);
+            await Git.Tag(path, "2.3.4-alpha.5");
+
+            var envVars = ("MinVerTagPrefix", "v.");
+            var args = $"--tag-prefix {value}";
+
+            var expected = Package.WithVersion(2, 3, 4, new[] { "alpha", "5" });
+
+            // act
+            var (cliStandardOutput, _) = await MinVerCli.ReadAsync(path, args: args, envVars: envVars);
+
+            // assert
+            Assert.Equal(expected.Version, cliStandardOutput.Trim());
+        }
+
+        [Theory]
+        [InlineData("info")]
+        public static async Task VerbosityBackToDefault(string value)
+        {
+            // arrange
+            var path = MethodBase.GetCurrentMethod().GetTestDirectory();
+            FileSystem.EnsureEmptyDirectory(path);
+
+            var envVars = ("MinVerVerbosity", "error");
+            var args = $"--verbosity {value}";
+
+            // act
+            var (_, cliStandardError) = await MinVerCli.ReadAsync(path, args: args, envVars: envVars);
+
+            // assert
+            Assert.Contains("MinVer:", cliStandardError, StringComparison.Ordinal);
+        }
+    }
+}
diff --git a/minver-cli/Logger.cs b/minver-cli/Logger.cs
@@ -27,7 +27,7 @@ internal class Logger : ILogger
 
         public static void ErrorInvalidEnvVar(string name, string value, string validValueString)
         {
-            if (validValueString == null)
+            if (validValueString.Length == 0)
             {
                 Error($"Invalid environment variable '{name}' '{value}'.");
             }