more tests

Author: Nigusu-Allehu

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/Package/Download/PackageDownloadRunner.cs

@@ -240,7 +240,7 @@ await ResolvePackageDownloadVersion(
             return (versionToDownload, downloadSourceRepository);
         }
 
-        private static IReadOnlyList<SourceRepository> GetMappedRepositories(
+        internal static IReadOnlyList<SourceRepository> GetMappedRepositories(
             IReadOnlyList<string> mappedNames,
             IReadOnlyList<SourceRepository> allRepos,
             string packageId,

test/NuGet.Core.FuncTests/NuGet.XPlat.FuncTest/Package/Download/PackageDownloadRunnerTests.cs

@@ -638,7 +638,7 @@ public async Task RunAsync_WhenSourceMappingMapsToInsecureSource_AndAllowInsecur
         exit.Should().Be(PackageDownloadRunner.ExitCodeError);
         logger.Verify(
             l => l.LogError(expectedError),
-            Times.AtLeastOnce);
+            Times.Once);
 
     }
 
@@ -701,7 +701,7 @@ public async Task RunAsync_WhenSourceMappingEnabled_PackageMapsToNoSource_Fails(
     {
         // Arrange
         using var context = new SimpleTestPathContext();
-        PackageSource source = new("http://contoso.test/v3/index.json", "Insecure");
+        PackageSource source = new(context.PackageSource, "source");
         context.Settings.AddSource(source.Name, source.SourceUri.OriginalString);
         context.Settings.AddPackageSourceMapping(source.Name, "Contoso.Not.*");
         var settings = Settings.LoadSettingsGivenConfigPaths([context.Settings.ConfigPath]);
@@ -711,10 +711,10 @@ public async Task RunAsync_WhenSourceMappingEnabled_PackageMapsToNoSource_Fails(
         var version = "1.0.0";
 
         string expectedError = string.Format(
-                CultureInfo.CurrentCulture,
-                Strings.PackageDownloadCommand_PackageSourceMapping_NoSourcesMapped,
-                id,
-                source);
+            CultureInfo.CurrentCulture,
+            Strings.PackageDownloadCommand_PackageSourceMapping_NoSourcesMapped,
+            id,
+            source);
 
         // arguments
         var logger = new Mock<ILoggerWithColor>(MockBehavior.Loose);

test/NuGet.Core.Tests/NuGet.CommandLine.Xplat.Tests/Commands/Package/Download/PackageDownloadRunnerTests.cs

@@ -4,6 +4,7 @@
 #nullable disable
 
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -202,4 +203,102 @@ public async Task ResolvePackageDownloadVersion_UnlistedPackage_BehavesAsExpecte
             foundRepo.Should().BeNull();
         }
     }
+
+    [Theory]
+    [InlineData("A", "a")]
+    [InlineData("a", "A")]
+    [InlineData("SourceA", "sourcea")]
+    [InlineData("SOURCEA", "sourcea")]
+    public void GetMappedRepositories_WithVariousSourceCasing_ReturnsOnlyApplicableSources(string sourceNameConfig, string sourceNameMapped)
+    {
+        // Arrange
+        var packageId = "Contoso.Package";
+        var packageSource = new PackageSource(sourceNameConfig, sourceNameConfig);
+        var repository = new Mock<SourceRepository>();
+        repository.Setup(r => r.PackageSource).Returns(packageSource);
+        var allRepos = new List<SourceRepository> { repository.Object };
+        var mappedNames = new List<string> { sourceNameMapped };
+        var logger = new Mock<ILoggerWithColor>(MockBehavior.Loose);
+
+        // Act
+        var result = PackageDownloadRunner.GetMappedRepositories(
+            mappedNames,
+            allRepos,
+            packageId,
+            logger.Object);
+
+        // Assert
+        result.Should().HaveCount(1);
+        result[0].PackageSource.Name.Should().Be(sourceNameConfig);
+    }
+
+    [Fact]
+    public void GetMappedRepositories_WhenSourceMissing_LogsVerbose()
+    {
+        // Arrange
+        var packageId = "Contoso.Package";
+
+        var existingRepo = new Mock<SourceRepository>();
+        existingRepo.Setup(r => r.PackageSource).Returns(new PackageSource("A", "A"));
+
+        var allRepos = new List<SourceRepository> { existingRepo.Object };
+        string mappedName = "MissingSource";
+        var mappedNames = new List<string> { mappedName };
+
+        string captured = "";
+        var logger = new Mock<ILoggerWithColor>(MockBehavior.Loose);
+        logger.Setup(l => l.LogVerbose(It.IsAny<string>()))
+            .Callback<string>(msg => captured += msg);
+
+        string expectedLog = string.Format(
+            CultureInfo.CurrentCulture,
+            XPlat.Strings.PackageDownloadCommand_PackageSourceMapping_NoSuchSource,
+            mappedName,
+            packageId);
+
+        // Act
+        var result = PackageDownloadRunner.GetMappedRepositories(
+            mappedNames,
+            allRepos,
+            packageId,
+            logger.Object);
+
+        // Assert
+        result.Should().BeEmpty();
+        captured.Should().Contain(expectedLog);
+    }
+
+    [Fact]
+    public void GetMappedRepositories_WhenAllMappedSourcesExist_ReturnsAllMatchedRepositories()
+    {
+        // Arrange
+        var packageId = "Contoso.Package";
+
+        var packageSourceA = new PackageSource("Source1", "Source1");
+        var packageSourceB = new PackageSource("Source2", "Source2");
+
+        var repoA = new Mock<SourceRepository>();
+        repoA.Setup(r => r.PackageSource).Returns(packageSourceA);
+
+        var repoB = new Mock<SourceRepository>();
+        repoB.Setup(r => r.PackageSource).Returns(packageSourceB);
+
+        var allRepos = new List<SourceRepository> { repoA.Object, repoB.Object };
+        var mappedNames = new List<string> { "Source1", "source2" };
+
+        var logger = new Mock<ILoggerWithColor>(MockBehavior.Loose);
+
+        // Act
+        var result = PackageDownloadRunner.GetMappedRepositories(
+            mappedNames,
+            allRepos,
+            packageId,
+            logger.Object);
+
+        // Assert
+        Assert.Equal(2, result.Count);
+        Assert.Equal(packageSourceA.Name, result[0].PackageSource.Name);
+        Assert.Equal(packageSourceB.Name, result[1].PackageSource.Name);
+        logger.Verify(l => l.LogVerbose(It.IsAny<string>()), Times.Never);
+    }
 }