Implements the ability to stop automatic redirects.

Author: joncloud

src/https/Program.cs

@@ -261,20 +261,8 @@ public async Task<int> RunAsync(string[] args)
             var stdoutWriter = new StreamWriter(stdout) { AutoFlush = true };
             {
                 var renderer = new Renderer(stdoutWriter, stderrWriter);
-                
-                var http = options.IgnoreCertificate
-                    ? new HttpClient(
-                        new HttpClientHandler
-                        {
-                            ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
-                        }
-                    )
-                    : new HttpClient();
 
-                if (options.Timeout.HasValue)
-                {
-                    http.Timeout = options.Timeout.Value;
-                }
+                var http = CreateHttpClient(options);
 
                 var request = new HttpRequestMessage(
                     command.Method ?? HttpMethod.Get,
@@ -341,6 +329,35 @@ public async Task<int> RunAsync(string[] args)
 
             return 0;
         }
+
+        static HttpClient CreateHttpClient(Options options)
+        {
+            var http = default(HttpClient);
+            if (options.RequiresHandler)
+            {
+                var handler = new HttpClientHandler();
+                if (options.IgnoreCertificate)
+                {
+                    handler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
+                }
+                if (options.StopAutoRedirects)
+                {
+                    handler.AllowAutoRedirect = false;
+                }
+                http = new HttpClient(handler);
+            }
+            else
+            {
+                http = new HttpClient();
+            }
+
+            if (options.Timeout.HasValue)
+            {
+                http.Timeout = options.Timeout.Value;
+            }
+
+            return http;
+        }
     }
 
     enum ContentType
@@ -358,16 +375,19 @@ class Options
         public TimeSpan? Timeout { get; }
         public bool Version { get; }
         public bool Help { get; }
+        public bool StopAutoRedirects { get; }
 
+        public bool RequiresHandler => IgnoreCertificate || StopAutoRedirects;
 
-        public Options(ContentType requestContentType, string xmlRootName, bool ignoreCertificate, TimeSpan? timeout, bool version, bool help)
+        public Options(ContentType requestContentType, string xmlRootName, bool ignoreCertificate, TimeSpan? timeout, bool version, bool help, bool stopAutoRedirects)
         {
             RequestContentType = requestContentType;
             XmlRootName = xmlRootName;
             IgnoreCertificate = ignoreCertificate;
             Timeout = timeout;
             Version = version;
             Help = help;
+            StopAutoRedirects = stopAutoRedirects;
         }
 
         public static IEnumerable<string> GetOptionHelp()
@@ -379,6 +399,7 @@ public static IEnumerable<string> GetOptionHelp()
             yield return "--timeout=<VALUE>     Sets the timeout of the request using System.TimeSpan.TryParse (https://docs.microsoft.com/en-us/dotnet/api/system.timespan.parse)";
             yield return "--version             Displays the application verison.";
             yield return "--xml=<ROOT_NAME>     Renders the content arguments as application/xml using the optional xml root name.";
+            yield return "--stop-auto-redirects Prevents redirects from automatically being processed.";
         }
 
         static int GetArgValueIndex(string arg)
@@ -400,6 +421,7 @@ public static Options Parse(IEnumerable<string> args)
             var timeout = default(TimeSpan?);
             var help = false;
             var version = false;
+            var stopAutoRedirects = false;
             foreach (var arg in args)
             {
                 if (arg.StartsWith("--json"))
@@ -451,8 +473,12 @@ public static Options Parse(IEnumerable<string> args)
                 {
                     help = true;
                 }
+                else if (arg.StartsWith("--stop-auto-redirects"))
+                {
+                    stopAutoRedirects = true;
+                }
             }
-            return new Options(requestContentType, xmlRootName, ignoreCertificate, timeout, version, help);
+            return new Options(requestContentType, xmlRootName, ignoreCertificate, timeout, version, help, stopAutoRedirects);
         }
     }
 

tests/https.Tests/HttpsResult.cs

@@ -33,7 +33,7 @@ public HttpsResult(int exitCode, MemoryStream stdout, MemoryStream stderr)
                 if (pos > -1)
                 {
                     var key = line.Substring(0, pos);
-                    var value = line.Substring(pos + 1);
+                    var value = line.Substring(pos + 2);
                     headers[key] = value;
                 }
             }

tests/https.Tests/IntegrationTests.cs

@@ -15,13 +15,27 @@ public async Task MirrorTests()
         {
             var args = new[]
             {
-                "post", _fixture.Url, "--json", "foo=bar", "lorem=ipsum"
+                "post", $"{_fixture.Url}/Mirror", "--json", "foo=bar", "lorem=ipsum"
             };
 
             var result = await Https.ExecuteAsync(args);
 
             var json = new StreamReader(result.StdOut).ReadToEnd();
             Assert.Equal("{\"foo\":\"bar\",\"lorem\":\"ipsum\"}", json);
         }
+
+        [Fact]
+        public async Task RedirectTest_ShouldShow3XXResponse_GivenStopAutoRedirects()
+        {
+            var args = new[]
+            {
+                "get", "http://localhost:5000/Redirect", "--stop-auto-redirects"
+            };
+
+            var result = await Https.ExecuteAsync(args);
+
+            Assert.Equal("HTTP/1.1 301 Moved Permanently", result.Status);
+            Assert.Equal("http://localhost:5000/Mirror", result.Headers["Location"]);
+        }
     }
 }

tests/https.Tests/MirrorMiddleware.cs

@@ -0,0 +1,28 @@
+using Microsoft.AspNetCore.Http;
+using System.Threading.Tasks;
+
+namespace Https.Tests
+{
+    class MirrorMiddleware
+    {
+        readonly RequestDelegate _next;
+        public MirrorMiddleware(RequestDelegate next) =>
+            _next = next;
+        public async Task InvokeAsync(HttpContext context)
+        {
+            if (context.Request.Path.StartsWithSegments("/Mirror"))
+            {
+                if (!string.IsNullOrEmpty(context.Request.ContentType))
+                {
+                    context.Response.ContentType = context.Request.ContentType;
+                }
+
+                await context.Request.Body.CopyToAsync(context.Response.Body);
+            }
+            else
+            {
+                await _next(context);
+            }
+        }
+    }
+}

tests/https.Tests/RedirectMiddleware.cs

@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Http;
+using System.Threading.Tasks;
+
+namespace Https.Tests
+{
+    class RedirectMiddleware
+    {
+        readonly RequestDelegate _next;
+        public RedirectMiddleware(RequestDelegate next) =>
+            _next = next;
+        public async Task InvokeAsync(HttpContext context)
+        {
+            if (context.Request.Path.StartsWithSegments("/Redirect"))
+            {
+                context.Response.StatusCode = StatusCodes.Status301MovedPermanently;
+                context.Response.Headers.Add("Location", "http://localhost:5000/Mirror");
+            }
+            else
+            {
+                await _next(context);
+            }
+        }
+    }
+}

tests/https.Tests/Startup.cs

@@ -1,20 +1,19 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
 
 namespace Https.Tests
 {
     public class Startup
     {   
         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
         {
+            app.UseMiddleware<RedirectMiddleware>();
+            app.UseMiddleware<MirrorMiddleware>();
+
             app.Run(async (context) =>
             {
-                if (!string.IsNullOrEmpty(context.Request.ContentType))
-                {
-                    context.Response.ContentType = context.Request.ContentType;
-                }
-
-                await context.Request.Body.CopyToAsync(context.Response.Body);
+                await context.Response.WriteAsync("Hello!");
             });
         }
     }