add testst

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageSearch/PackageSearchArgs.cs

@@ -24,15 +24,15 @@ internal class PackageSearchArgs
 
         public PackageSearchArgs(string skip, string take, string format, string verbosity)
         {
-            Skip = VerifyInt(skip, DefaultSkip);
-            Take = VerifyInt(take, DefaultTake);
+            Skip = VerifyInt(skip, DefaultSkip, "--skip");
+            Take = VerifyInt(take, DefaultTake, "--take");
             JsonFormat = VerifyFormat(format);
             Verbosity = VerifyVerbosity(verbosity);
         }
 
         public PackageSearchArgs() { }
 
-        public int VerifyInt(string number, int defaultValue)
+        public int VerifyInt(string number, int defaultValue, string option)
         {
             if (string.IsNullOrEmpty(number))
             {
@@ -44,29 +44,50 @@ public int VerifyInt(string number, int defaultValue)
                 return verifiedNumber;
             }
 
-            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.Error_invalid_number, number));
+            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.Error_invalidOptionValue, number, option));
         }
 
         public bool VerifyFormat(string format)
         {
             if (!string.IsNullOrEmpty(format))
             {
-                return string.Equals(format, "json", StringComparison.CurrentCultureIgnoreCase);
+                if (string.Equals(format, "json", StringComparison.CurrentCultureIgnoreCase))
+                {
+                    return true;
+                }
+                else if (string.Equals(format, "table", StringComparison.CurrentCultureIgnoreCase))
+                {
+                    return false;
+                }
+                else
+                {
+                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.Error_invalidOptionValue, format, "--format"));
+                }
             }
 
             return false;
         }
 
         private PackageSearchVerbosity VerifyVerbosity(string verbosity)
         {
-            if (string.IsNullOrEmpty(verbosity) || string.Equals(verbosity, nameof(PackageSearchVerbosity.Detailed), StringComparison.CurrentCultureIgnoreCase))
+            if (verbosity != null)
             {
-                return PackageSearchVerbosity.Detailed;
-            }
-
-            if (string.Equals(verbosity, nameof(PackageSearchVerbosity.Minimal), StringComparison.CurrentCultureIgnoreCase))
-            {
-                return PackageSearchVerbosity.Minimal;
+                if (string.Equals(verbosity, nameof(PackageSearchVerbosity.Detailed), StringComparison.CurrentCultureIgnoreCase))
+                {
+                    return PackageSearchVerbosity.Detailed;
+                }
+                else if (string.Equals(verbosity, nameof(PackageSearchVerbosity.Normal), StringComparison.CurrentCultureIgnoreCase))
+                {
+                    return PackageSearchVerbosity.Normal;
+                }
+                else if (string.Equals(verbosity, nameof(PackageSearchVerbosity.Minimal), StringComparison.CurrentCultureIgnoreCase))
+                {
+                    return PackageSearchVerbosity.Minimal;
+                }
+                else
+                {
+                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.Error_invalidOptionValue, verbosity, "--verbosity"));
+                }
             }
 
             return PackageSearchVerbosity.Normal;

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageSearch/PackageSearchResultPackageDetailed.cs

@@ -22,6 +22,10 @@ internal class PackageSearchResultPackageDetailed : PackageSearchResultPackageNo
         [JsonProperty("projectUrl")]
         public Uri ProjectUrl { get; set; }
 
+        public PackageSearchResultPackageDetailed() : base()
+        {
+        }
+
         public PackageSearchResultPackageDetailed(IPackageSearchMetadata packageSearchMetadata, string deprecation) : base(packageSearchMetadata)
         {
             Description = packageSearchMetadata.Description;

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageSearch/PackageSearchResultPackageMinimal.cs

@@ -14,6 +14,8 @@ internal class PackageSearchResultPackageMinimal : IPackageSearchResultPackage
         [JsonProperty("latestVersion")]
         public string LatestVersion { get; set; }
 
+        public PackageSearchResultPackageMinimal() { }
+
         public PackageSearchResultPackageMinimal(IPackageSearchMetadata packageSearchMetadata)
         {
             PackageId = packageSearchMetadata.Identity.Id;

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageSearch/PackageSearchResultPackageNormal.cs

@@ -14,6 +14,8 @@ internal class PackageSearchResultPackageNormal : PackageSearchResultPackageMini
         [JsonProperty("authors")]
         public string Authors { get; set; }
 
+        public PackageSearchResultPackageNormal() : base() { }
+
         public PackageSearchResultPackageNormal(IPackageSearchMetadata packageSearchMetadata) : base(packageSearchMetadata)
         {
             Downloads = packageSearchMetadata.DownloadCount;

src/NuGet.Core/NuGet.CommandLine.XPlat/Strings.resx

@@ -842,9 +842,9 @@ Non-HTTPS access will be removed in a future version. Consider migrating to 'HTT
   <data name="pkgSearch_termDescription" xml:space="preserve">
     <value>Search term to filter package names, descriptions, and tags. Used as a literal value. Example: `dotnet package search some.package`. See also `--exact-match`.</value>
   </data>
-  <data name="Error_invalid_number" xml:space="preserve">
-    <value>{0} is not a valid integer.</value>
-    <comment>0 - The invalid number.</comment>
+  <data name="Error_invalidOptionValue" xml:space="preserve">
+    <value>Invalid value `{0}` for option {1}.</value>
+    <comment>0 - The invalid value. 1- the option.</comment>
   </data>
   <data name="Error_InvalidSource" xml:space="preserve">
     <value>The specified source '{0}' is invalid. Provide a valid source.</value>

test/NuGet.Core.Tests/NuGet.CommandLine.Xplat.Tests/PackageSearchCommandTests.cs

@@ -113,6 +113,87 @@ public void Register_withTakeOption_SetsTake()
             Assert.Equal(int.Parse(take), CapturedArgs.Take);
         }
 
+        [Theory]
+        [InlineData("table")]
+        [InlineData("json")]
+        public void Register_withFormatOption_SetsFormat(string format)
+        {
+            // Arrange
+            Register(App, GetLogger, SetupSettingsAndRunSearchAsync);
+
+            // Act
+            App.Execute(new[] { "search", "--format", format });
+
+            // Assert
+            if (format == "json")
+            {
+                Assert.True(CapturedArgs.JsonFormat);
+            }
+            else
+            {
+                Assert.False(CapturedArgs.JsonFormat);
+            }
+        }
+
+        [Fact]
+        public void Register_withInvalidFormattingOption_ShowsErrorMessage()
+        {
+            // Arrange
+            Register(App, GetLogger, SetupSettingsAndRunSearchAsync);
+            string invalidFormat = "invalid";
+            string expectedError = string.Format(CultureInfo.CurrentCulture, Strings.Error_invalidOptionValue, invalidFormat, "--format");
+
+            // Act
+            var exitCode = App.Execute(new[] { "search", "--format", invalidFormat });
+
+            // Assert
+            Assert.Equal(1, exitCode);
+            Assert.Contains(expectedError, StoredErrorMessage);
+        }
+
+        [Theory]
+        [InlineData("minimal")]
+        [InlineData("normal")]
+        [InlineData("detailed")]
+        public void Register_withVerbosityOption_SetsFormat(string verbosity)
+        {
+            // Arrange
+            Register(App, GetLogger, SetupSettingsAndRunSearchAsync);
+
+            // Act
+            App.Execute(new[] { "search", "--verbosity", verbosity });
+
+            // Assert
+            if (verbosity == "minimal")
+            {
+                Assert.Equal(PackageSearchVerbosity.Minimal, CapturedArgs.Verbosity);
+            }
+            else if (verbosity == "detailed")
+            {
+                Assert.Equal(PackageSearchVerbosity.Detailed, CapturedArgs.Verbosity);
+            }
+            else
+            {
+                Assert.Equal(PackageSearchVerbosity.Normal, CapturedArgs.Verbosity);
+            }
+        }
+
+        [Fact]
+        public void Register_withInvalidVerbosityOption_ShowsErrorMessage()
+        {
+            // Arrange
+            Register(App, GetLogger, SetupSettingsAndRunSearchAsync);
+            string invalidFormat = "invalid";
+            string expectedError = string.Format(CultureInfo.CurrentCulture, Strings.Error_invalidOptionValue, invalidFormat, "--verbosity");
+
+            // Act
+            var exitCode = App.Execute(new[] { "search", "--verbosity", invalidFormat });
+
+            // Assert
+            Assert.Equal(1, exitCode);
+            Assert.Contains(expectedError, StoredErrorMessage);
+        }
+
         [Fact]
         public void Register_withSkipOption_SetsSkip()
         {
@@ -135,7 +216,7 @@ public void Register_withInvalidTakeOption_ShowsErrorMessage()
             Register(App, GetLogger, SetupSettingsAndRunSearchAsync);
             string searchTerm = "nuget";
             string take = "invalid";
-            string expectedError = string.Format(CultureInfo.CurrentCulture, Strings.Error_invalid_number, take);
+            string expectedError = string.Format(CultureInfo.CurrentCulture, Strings.Error_invalidOptionValue, take, "--take");
 
             // Act
             var exitCode = App.Execute(new[] { "search", searchTerm, "--take", take });
@@ -152,7 +233,7 @@ public void Register_withInvalidSkipOption_ShowsErrorMessage()
             Register(App, GetLogger, SetupSettingsAndRunSearchAsync);
             string searchTerm = "nuget";
             string skip = "invalid";
-            string expectedError = string.Format(CultureInfo.CurrentCulture, Strings.Error_invalid_number, skip);
+            string expectedError = string.Format(CultureInfo.CurrentCulture, Strings.Error_invalidOptionValue, skip, "--skip");
 
             // Act
             var exitCode = App.Execute(new[] { "search", searchTerm, "--skip", skip });

test/NuGet.Core.Tests/NuGet.CommandLine.Xplat.Tests/PackageSearchResultJsonPrinterTests.cs

@@ -0,0 +1,118 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using Moq;
+using NuGet.CommandLine.XPlat;
+using NuGet.Configuration;
+using NuGet.Packaging.Core;
+using NuGet.Protocol.Core.Types;
+using NuGet.Versioning;
+using Xunit;
+
+namespace NuGet.CommandLine.Xplat.Tests
+{
+    public class PackageSearchResultJsonPrinterTests
+    {
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        public void Add_MultiplePackageSearchMetadata_RendersCorrectNumberOfPackages(int numberOfPackages)
+        {
+            // Arrange
+            var mockLoggerWithColor = new Mock<ILoggerWithColor>();
+            var printer = new PackageSearchResultJsonPrinter(mockLoggerWithColor.Object, PackageSearchVerbosity.Normal);
+            var mockSource = new Mock<PackageSource>("http://mocksource", "MockSource");
+            var completedSearch = new List<IPackageSearchMetadata>();
+            var mockMetadata = new Mock<IPackageSearchMetadata>();
+            var packageIdentity = new PackageIdentity("NuGet.Versioning", new NuGetVersion("4.3.0"));
+
+            mockMetadata.Setup(m => m.Identity).Returns(packageIdentity);
+            mockMetadata.Setup(m => m.Authors).Returns("Microsoft");
+            mockMetadata.Setup(m => m.DownloadCount).Returns(123456);
+            printer.Start();
+
+            for (int i = 0; i < numberOfPackages; i++)
+            {
+                completedSearch.Add(mockMetadata.Object);
+            }
+
+            // Act
+            printer.Add(mockSource.Object, completedSearch);
+            printer.Finish();
+
+            // Assert
+            var expectedZeroJson = $@"[
+  {{
+    ""sourceName"": ""MockSource"",
+    ""packages"": []
+  }}
+]";
+            var expectedOneJson = $@"[
+  {{
+    ""sourceName"": ""MockSource"",
+    ""packages"": [
+      {{
+        ""downloads"": 123456,
+        ""authors"": ""Microsoft"",
+        ""packageId"": ""NuGet.Versioning"",
+        ""latestVersion"": ""4.3.0""
+      }}
+    ]
+  }}
+]";
+
+            var expectedTwoJson = $@"[
+  {{
+    ""sourceName"": ""MockSource"",
+    ""packages"": [
+      {{
+        ""downloads"": 123456,
+        ""authors"": ""Microsoft"",
+        ""packageId"": ""NuGet.Versioning"",
+        ""latestVersion"": ""4.3.0""
+      }},
+      {{
+        ""downloads"": 123456,
+        ""authors"": ""Microsoft"",
+        ""packageId"": ""NuGet.Versioning"",
+        ""latestVersion"": ""4.3.0""
+      }}
+    ]
+  }}
+]";
+
+            if (numberOfPackages == 2)
+            {
+                mockLoggerWithColor.Verify(x => x.LogMinimal(expectedTwoJson), Times.Exactly(1));
+            }
+            else if (numberOfPackages == 0)
+            {
+                mockLoggerWithColor.Verify(x => x.LogMinimal(expectedZeroJson), Times.Exactly(1));
+            }
+            else
+            {
+                mockLoggerWithColor.Verify(x => x.LogMinimal(expectedOneJson), Times.Exactly(1));
+            }
+        }
+
+        [Fact]
+        public void Add_Error_ShouldLogError()
+        {
+            // Arrange
+            var mockLoggerWithColor = new Mock<ILoggerWithColor>();
+            var printer = new PackageSearchResultJsonPrinter(mockLoggerWithColor.Object, PackageSearchVerbosity.Minimal);
+            Mock<PackageSource> mockSource = new Mock<PackageSource>("http://errorsource", "ErrorTestSource");
+            string errorMessage = "An error occurred";
+
+            // Act
+            printer.Add(mockSource.Object, errorMessage);
+
+            // Assert
+            mockLoggerWithColor.Verify(x => x.LogMinimal("****************************************"), Times.Once);
+            mockLoggerWithColor.Verify(x => x.LogMinimal($"Source: ErrorTestSource (http://errorsource/)"), Times.Once);
+            mockLoggerWithColor.Verify(x => x.LogError(errorMessage), Times.Once);
+        }
+    }
+}