Merge pull request #712 from mjcheetham/all-protos

Update generic provider to support all protocols

Author: mjcheetham

src/shared/Core.Tests/GenericHostProviderTests.cs

@@ -17,9 +17,18 @@ public class GenericHostProviderTests
         [InlineData("https", true)]
         [InlineData("HTTPS", true)]
         [InlineData("hTtPs", true)]
-        [InlineData("ssh", false)]
-        [InlineData("SSH", false)]
-        [InlineData("sSh", false)]
+        [InlineData("ssh", true)]
+        [InlineData("SSH", true)]
+        [InlineData("sSh", true)]
+        [InlineData("smpt", true)]
+        [InlineData("SmtP", true)]
+        [InlineData("SMTP", true)]
+        [InlineData("imap", true)]
+        [InlineData("iMAp", true)]
+        [InlineData("IMAP", true)]
+        [InlineData("file", true)]
+        [InlineData("fIlE", true)]
+        [InlineData("FILE", true)]
         [InlineData("", false)]
         [InlineData(null, false)]
         public void GenericHostProvider_IsSupported(string protocol, bool expected)
@@ -90,7 +99,6 @@ public async Task GenericHostProvider_CreateCredentialAsync_WiaNotAllowed_Return
             basicAuthMock.Verify(x => x.GetCredentials(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
         }
 
-
         [Fact]
         public async Task GenericHostProvider_CreateCredentialAsync_LegacyAuthorityBasic_ReturnsBasicCredentialNoWiaCheck()
         {
@@ -125,6 +133,37 @@ public async Task GenericHostProvider_CreateCredentialAsync_LegacyAuthorityBasic
             basicAuthMock.Verify(x => x.GetCredentials(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
         }
 
+        [Fact]
+        public async Task GenericHostProvider_CreateCredentialAsync_NonHttpProtocol_ReturnsBasicCredentialNoWiaCheck()
+        {
+            var input = new InputArguments(new Dictionary<string, string>
+            {
+                ["protocol"] = "smtp",
+                ["host"]     = "example.com",
+            });
+
+            const string testUserName = "basicUser";
+            const string testPassword = "basicPass";
+            var basicCredential = new GitCredential(testUserName, testPassword);
+
+            var context = new TestCommandContext();
+            var basicAuthMock = new Mock<IBasicAuthentication>();
+            basicAuthMock.Setup(x => x.GetCredentials(It.IsAny<string>(), It.IsAny<string>()))
+                .Returns(basicCredential)
+                .Verifiable();
+            var wiaAuthMock = new Mock<IWindowsIntegratedAuthentication>();
+
+            var provider = new GenericHostProvider(context, basicAuthMock.Object, wiaAuthMock.Object);
+
+            ICredential credential = await provider.GenerateCredentialAsync(input);
+
+            Assert.NotNull(credential);
+            Assert.Equal(testUserName, credential.Account);
+            Assert.Equal(testPassword, credential.Password);
+            wiaAuthMock.Verify(x => x.GetIsSupportedAsync(It.IsAny<Uri>()), Times.Never);
+            basicAuthMock.Verify(x => x.GetCredentials(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+        }
+
         [PlatformFact(Platforms.Posix)]
         public async Task GenericHostProvider_CreateCredentialAsync_NonWindows_WiaSupported_ReturnsBasicCredential()
         {

src/shared/Core/GenericHostProvider.cs

@@ -40,8 +40,8 @@ public GenericHostProvider(ICommandContext context,
 
         public override bool IsSupported(InputArguments input)
         {
-            return input != null && (StringComparer.OrdinalIgnoreCase.Equals(input.Protocol, "http") ||
-                                     StringComparer.OrdinalIgnoreCase.Equals(input.Protocol, "https"));
+            // The generic provider should support all possible protocols (HTTP, HTTPS, SMTP, IMAP, etc)
+            return input != null && !string.IsNullOrWhiteSpace(input.Protocol);
         }
 
         public override async Task<ICredential> GenerateCredentialAsync(InputArguments input)
@@ -51,7 +51,12 @@ public override async Task<ICredential> GenerateCredentialAsync(InputArguments i
             Uri uri = input.GetRemoteUri();
 
             // Determine the if the host supports Windows Integration Authentication (WIA)
-            if (IsWindowsAuthAllowed)
+            if (!StringComparer.OrdinalIgnoreCase.Equals(uri.Scheme, "http") &&
+                !StringComparer.OrdinalIgnoreCase.Equals(uri.Scheme, "https"))
+            {
+                // Cannot check WIA support for non-HTTP based protocols
+            }
+            else if (IsWindowsAuthAllowed)
             {
                 if (PlatformUtils.IsWindows())
                 {

src/shared/Core/HostProviderRegistry.cs

@@ -154,12 +154,16 @@ public async Task<IHostProvider> GetProviderAsync(InputArguments input)
                 throw new Exception("Unable to detect host provider without a remote URL");
             }
 
+            // We can only probe HTTP(S) URLs - for SMTP, IMAP, etc we cannot do network probing
+            bool canProbeUri = StringComparer.OrdinalIgnoreCase.Equals(uri.Scheme, "http") ||
+                               StringComparer.OrdinalIgnoreCase.Equals(uri.Scheme, "https");
+
             var probeTimeout = TimeSpan.FromMilliseconds(_context.Settings.AutoDetectProviderTimeout);
             _context.Trace.WriteLine($"Auto-detect probe timeout is {probeTimeout.TotalSeconds} ms.");
 
             HttpResponseMessage probeResponse = null;
 
-            async Task<IHostProvider> MatchProviderAsync(HostProviderPriority priority)
+            async Task<IHostProvider> MatchProviderAsync(HostProviderPriority priority, bool probe)
             {
                 if (_hostProviders.TryGetValue(priority, out ICollection<IHostProvider> providers))
                 {
@@ -174,7 +178,7 @@ async Task<IHostProvider> MatchProviderAsync(HostProviderPriority priority)
                     // Try matching using the HTTP response from a query to the remote URL (expensive).
                     // The user may have disabled this feature with a zero or negative timeout for performance reasons.
                     // We only probe the remote once and reuse the same response for all providers.
-                    if (probeTimeout.TotalMilliseconds > 0)
+                    if (probe && probeTimeout.TotalMilliseconds > 0)
                     {
                         if (probeResponse is null)
                         {
@@ -215,9 +219,9 @@ async Task<IHostProvider> MatchProviderAsync(HostProviderPriority priority)
             }
 
             // Match providers starting with the highest priority
-            IHostProvider match = await MatchProviderAsync(HostProviderPriority.High) ??
-                                  await MatchProviderAsync(HostProviderPriority.Normal) ??
-                                  await MatchProviderAsync(HostProviderPriority.Low) ??
+            IHostProvider match = await MatchProviderAsync(HostProviderPriority.High, canProbeUri) ??
+                                  await MatchProviderAsync(HostProviderPriority.Normal, canProbeUri) ??
+                                  await MatchProviderAsync(HostProviderPriority.Low, canProbeUri) ??
                                   throw new Exception("No host provider available to service this request.");
 
             // If we ended up making a network call then set the host provider explicitly