WIP

Author: alexeyzimarev

src/RestSharp/RestClient.Async.cs

@@ -89,10 +89,6 @@ async Task<HttpResponse> ExecuteRequestAsync(RestRequest request, CancellationTo
         var httpMethod = AsHttpMethod(request.Method);
         var url        = this.BuildUri(request);
 
-        using var message    = new HttpRequestMessage(httpMethod, url) { Content = requestContent.BuildContent() };
-        message.Headers.Host         = Options.BaseHost;
-        message.Headers.CacheControl = request.CachePolicy ?? Options.CachePolicy;
-
         using var timeoutCts = new CancellationTokenSource(request.Timeout > 0 ? request.Timeout : int.MaxValue);
         using var cts        = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, cancellationToken);
 
@@ -109,11 +105,46 @@ async Task<HttpResponse> ExecuteRequestAsync(RestRequest request, CancellationTo
                 .AddCookieHeaders(url, cookieContainer)
                 .AddCookieHeaders(url, Options.CookieContainer);
 
-            message.AddHeaders(headers);
+            HttpResponseMessage? responseMessage;
+
+            while (true) {
+                using var requestContent = new RequestContent(this, request);
+                using var message        = PrepareRequestMessage(httpMethod, url, requestContent, headers);
+
+                if (request.OnBeforeRequest != null) await request.OnBeforeRequest(message).ConfigureAwait(false);
+
+                responseMessage = await HttpClient.SendAsync(message, request.CompletionOption, ct).ConfigureAwait(false);
+
+                if (request.OnAfterRequest != null) await request.OnAfterRequest(responseMessage).ConfigureAwait(false);
+
+                if (!IsRedirect(responseMessage)) {
+                    // || !Options.FollowRedirects) {
+                    break;
+                }
+
+                var location = responseMessage.Headers.Location;
+
+                if (location == null) {
+                    break;
+                }
+
+                if (!location.IsAbsoluteUri) {
+                    location = new Uri(url, location);
+                }
 
-            if (request.OnBeforeRequest != null) await request.OnBeforeRequest(message).ConfigureAwait(false);
+                if (responseMessage.StatusCode == HttpStatusCode.RedirectMethod) {
+                    httpMethod = HttpMethod.Get;
+                }
 
-            var responseMessage = await HttpClient.SendAsync(message, request.CompletionOption, ct).ConfigureAwait(false);
+                url = location;
+
+                if (responseMessage.Headers.TryGetValues(KnownHeaders.SetCookie, out var cookiesHeader)) {
+                    // ReSharper disable once PossibleMultipleEnumeration
+                    cookieContainer.AddCookies(url, cookiesHeader);
+                    // ReSharper disable once PossibleMultipleEnumeration
+                    Options.CookieContainer?.AddCookies(url, cookiesHeader);
+                }
+            }
 
             // Parse all the cookies from the response and update the cookie jar with cookies
             if (responseMessage.Headers.TryGetValues(KnownHeaders.SetCookie, out var cookiesHeader)) {
@@ -132,6 +163,27 @@ async Task<HttpResponse> ExecuteRequestAsync(RestRequest request, CancellationTo
         }
     }
 
+    HttpRequestMessage PrepareRequestMessage(HttpMethod httpMethod, Uri url, RequestContent requestContent, RequestHeaders headers) {
+        var message = new HttpRequestMessage(httpMethod, url) { Content = requestContent.BuildContent() };
+        message.Headers.Host         = Options.BaseHost;
+        message.Headers.CacheControl = Options.CachePolicy;
+        message.AddHeaders(headers);
+
+        return message;
+    }
+
+    static bool IsRedirect(HttpResponseMessage responseMessage)
+        => responseMessage.StatusCode switch {
+            HttpStatusCode.MovedPermanently  => true,
+            HttpStatusCode.SeeOther          => true,
+            HttpStatusCode.TemporaryRedirect => true,
+            HttpStatusCode.Redirect          => true,
+#if NET
+            HttpStatusCode.PermanentRedirect => true,
+#endif
+            _ => false
+        };
+
     record HttpResponse(
         HttpResponseMessage? ResponseMessage,
         Uri                  Url,

test/RestSharp.Tests.Integrated/RedirectTests.cs

@@ -21,12 +21,14 @@ namespace RestSharp.Tests.Integrated;
 [Collection(nameof(TestServerCollection))]
 public class RedirectTests {
     readonly RestClient _client;
+    readonly string     _host;
 
     public RedirectTests(TestServerFixture fixture) {
         var options = new RestClientOptions(fixture.Server.Url) {
-            FollowRedirects = true
+            FollowRedirects = false
         };
         _client = new RestClient(options);
+        _host   = _client.Options.BaseUrl!.Host;
     }
 
     [Fact]
@@ -40,6 +42,17 @@ public async Task Can_Perform_GET_Async_With_Redirect() {
         response.Data!.Message.Should().Be(val);
     }
 
+    [Fact]
+    public async Task Can_Perform_GET_Async_With_Request_Cookies() {
+        var request = new RestRequest("get-cookies-redirect") {
+            CookieContainer = new CookieContainer(),
+        };
+        request.CookieContainer.Add(new Cookie("cookie", "value", null, _host));
+        request.CookieContainer.Add(new Cookie("cookie2", "value2", null, _host));
+        var response = await _client.ExecuteAsync(request);
+        response.Content.Should().Be("[\"cookie=value\",\"cookie2=value2\"]");
+    }
+
     class Response {
         public string? Message { get; set; }
     }

test/RestSharp.Tests.Integrated/Server/TestServer.cs

@@ -5,6 +5,7 @@
 using Microsoft.Extensions.Logging;
 using RestSharp.Tests.Integrated.Server.Handlers;
 using RestSharp.Tests.Shared.Extensions;
+
 // ReSharper disable ConvertClosureToMethodGroup
 
 namespace RestSharp.Tests.Integrated.Server;
@@ -36,12 +37,21 @@ public HttpServer(ITestOutputHelper? output = null) {
         _app.MapGet("headers", HeaderHandlers.HandleHeaders);
         _app.MapGet("request-echo", async context => await context.Request.BodyReader.AsStream().CopyToAsync(context.Response.BodyWriter.AsStream()));
         _app.MapDelete("delete", () => new TestResponse { Message = "Works!" });
+        _app.MapGet("redirect", () => Results.Redirect("/success", false, true));
 
         // Cookies
         _app.MapGet("get-cookies", CookieHandlers.HandleCookies);
         _app.MapGet("set-cookies", CookieHandlers.HandleSetCookies);
         _app.MapGet("redirect", () => Results.Redirect("/success", false, true));
 
+        _app.MapGet(
+            "get-cookies-redirect",
+            (HttpContext ctx) => {
+                ctx.Response.Cookies.Append("redirectCookie", "value1");
+                return Results.Redirect("/get-cookies", false, true);
+            }
+        );
+
         // PUT
         _app.MapPut(
             ContentResource,