Implement Request.RedirectChain API (#387)

* Implement Request.RedirectChain API

* Self-review

Author: kblok

lib/PuppeteerSharp.Tests/NetworkTests/NetworkEventTests.cs

@@ -204,7 +204,7 @@ public async Task ShouldSupportRedirects()
             Page.RequestFailed += (sender, e) => events.Add($"FAIL {e.Request.Url}");
             Server.SetRedirect("/foo.html", "/empty.html");
             const string FOO_URL = TestConstants.ServerUrl + "/foo.html";
-            await Page.GoToAsync(FOO_URL);
+            var response = await Page.GoToAsync(FOO_URL);
             Assert.Equal(new[] {
                 $"GET {FOO_URL}",
                 $"302 {FOO_URL}",
@@ -213,6 +213,11 @@ public async Task ShouldSupportRedirects()
                 $"200 {TestConstants.EmptyPage}",
                 $"DONE {TestConstants.EmptyPage}"
             }, events);
+
+            // Check redirect chain
+            var redirectChain = response.Request.RedirectChain;
+            Assert.Single(redirectChain);
+            Assert.Contains("/foo.html", redirectChain[0].Url);
         }
     }
-}
+}

lib/PuppeteerSharp.Tests/PageTests/SetRequestInterceptionTests.cs

@@ -190,6 +190,18 @@ public async Task ShouldWorkWithRedirects()
             Assert.Contains("empty.html", response.Url);
             Assert.Equal(5, requests.Count);
             Assert.Equal(ResourceType.Document, requests[2].ResourceType);
+
+            // Check redirect chain
+            var redirectChain = response.Request.RedirectChain;
+            Assert.Equal(4, redirectChain.Length);
+            Assert.Contains("/non-existing-page.html", redirectChain[0].Url);
+            Assert.Contains("/non-existing-page-3.html", redirectChain[2].Url);
+
+            for (var i = 0; i < redirectChain.Length; ++i)
+            {
+                var request = redirectChain[i];
+                Assert.Equal(request, request.RedirectChain.ElementAt(i));
+            }
         }
 
         [Fact]
@@ -380,4 +392,4 @@ public async Task ShouldThrowIfInterceptionIsNotEnabled()
             Assert.Contains("Request Interception is not enabled", exception.Message);
         }
     }
-}
+}

lib/PuppeteerSharp/NetworkManager.cs

@@ -247,7 +247,14 @@ private async Task OnRequestInterceptedAsync(RequestInterceptedResponse e)
                 var request = _interceptionIdToRequest[e.InterceptionId];
 
                 HandleRequestRedirect(request, e.ResponseStatusCode, e.ResponseHeaders, false, false);
-                HandleRequestStart(request.RequestId, e.InterceptionId, e.RedirectUrl, e.ResourceType, e.Request, e.FrameId);
+                HandleRequestStart(
+                    request.RequestId,
+                    e.InterceptionId,
+                    e.RedirectUrl,
+                    e.ResourceType,
+                    e.Request,
+                    e.FrameId,
+                    request.RedirectChainList);
                 return;
             }
 
@@ -256,12 +263,26 @@ private async Task OnRequestInterceptedAsync(RequestInterceptedResponse e)
             if (requestId != null)
             {
                 _requestHashToRequestIds.Delete(requestHash, requestId);
-                HandleRequestStart(requestId, e.InterceptionId, e.Request.Url, e.ResourceType, e.Request, e.FrameId);
+                HandleRequestStart(
+                    requestId,
+                    e.InterceptionId,
+                    e.Request.Url,
+                    e.ResourceType,
+                    e.Request,
+                    e.FrameId,
+                    new List<Request>());
             }
             else
             {
                 _requestHashToInterceptionIds.Add(requestHash, e.InterceptionId);
-                HandleRequestStart(null, e.InterceptionId, e.Request.Url, e.ResourceType, e.Request, e.FrameId);
+                HandleRequestStart(
+                    null,
+                    e.InterceptionId,
+                    e.Request.Url,
+                    e.ResourceType,
+                    e.Request,
+                    e.FrameId,
+                    new List<Request>());
             }
         }
 
@@ -279,7 +300,8 @@ private void HandleRequestStart(
             string url,
             ResourceType resourceType,
             Payload requestPayload,
-            string frameId)
+            string frameId,
+            List<Request> redirectChain)
         {
             Frame frame = null;
 
@@ -296,7 +318,8 @@ private void HandleRequestStart(
                 url,
                 resourceType,
                 requestPayload,
-                frame);
+                frame,
+                redirectChain);
 
             if (!string.IsNullOrEmpty(requestId))
             {
@@ -331,6 +354,7 @@ private void HandleRequestRedirect(
                 securityDetails);
 
             request.Response = response;
+            request.RedirectChainList.Add(request);
             if (request.RequestId != null)
             {
                 _requestIdToRequest.Remove(request.RequestId);
@@ -355,6 +379,8 @@ private void HandleRequestRedirect(
 
         private void OnRequestWillBeSent(RequestWillBeSentResponse e)
         {
+            var redirectChain = new List<Request>();
+
             if (_protocolRequestInterceptionEnabled)
             {
                 // All redirects are handled in requestIntercepted.
@@ -388,9 +414,11 @@ private void OnRequestWillBeSent(RequestWillBeSentResponse e)
                     e.RedirectResponse.FromDiskCache,
                     e.RedirectResponse.FromServiceWorker,
                     e.RedirectResponse.SecurityDetails);
+
+                redirectChain = request.RedirectChainList;
             }
 
-            HandleRequestStart(e.RequestId, null, e.Request.Url, e.Type, e.Request, e.FrameId);
+            HandleRequestStart(e.RequestId, null, e.Request.Url, e.Type, e.Request, e.FrameId, redirectChain);
         }
 
         private async Task UpdateProtocolRequestInterceptionAsync()
@@ -420,4 +448,4 @@ await Task.WhenAll(
         }
         #endregion
     }
-}
+}

lib/PuppeteerSharp/Request.cs

@@ -29,8 +29,16 @@ public class Request : Payload
         internal Request()
         {
         }
-        internal Request(CDPSession client, string requestId, string interceptionId, bool allowInterception, string url,
-                      ResourceType resourceType, Payload payload, Frame frame)
+        internal Request(
+            CDPSession client,
+            string requestId,
+            string interceptionId,
+            bool allowInterception,
+            string url,
+            ResourceType resourceType,
+            Payload payload,
+            Frame frame,
+            List<Request> redirectChain)
         {
             _client = client;
             _allowInterception = allowInterception;
@@ -44,6 +52,7 @@ internal Request(CDPSession client, string requestId, string interceptionId, boo
             Method = payload.Method;
             PostData = payload.PostData;
             Frame = frame;
+            RedirectChainList = redirectChain;
 
             Headers = new Dictionary<string, object>();
             foreach (KeyValuePair<string, object> keyValue in payload.Headers)
@@ -87,9 +96,34 @@ internal Request(CDPSession client, string requestId, string interceptionId, boo
         /// <value>The frame.</value>
         public Frame Frame { get; }
 
+        /// <summary>
+        /// A redirectChain is a chain of requests initiated to fetch a resource.
+        /// If there are no redirects and the request was successful, the chain will be empty.
+        /// If a server responds with at least a single redirect, then the chain will contain all the requests that were redirected.
+        /// redirectChain is shared between all the requests of the same chain.
+        /// </summary>
+        /// <example>
+        /// For example, if the website http://example.com has a single redirect to https://example.com, then the chain will contain one request:
+        /// <code>
+        /// var response = await page.GoToAsync("http://example.com");
+        /// var chain = response.Request.RedirectChain;
+        /// Console.WriteLine(chain.Length); // 1
+        /// Console.WriteLine(chain[0].Url); // 'http://example.com'
+        /// </code>
+        /// If the website https://google.com has no redirects, then the chain will be empty:
+        /// <code>
+        /// var response = await page.GoToAsync("https://google.com");
+        /// var chain = response.Request.RedirectChain;
+        /// Console.WriteLine(chain.Length); // 0
+        /// </code>
+        /// </example>
+        /// <value>The redirect chain.</value>
+        public Request[] RedirectChain => RedirectChainList.ToArray();
+
         internal bool FromMemoryCache { get; set; }
         internal Task<bool> CompleteTask => CompleteTaskWrapper.Task;
         internal TaskCompletionSource<bool> CompleteTaskWrapper { get; set; }
+        internal List<Request> RedirectChainList { get; }
         #endregion
 
         #region Public Methods
@@ -115,10 +149,25 @@ public async Task ContinueAsync(Payload overrides = null)
             try
             {
                 var requestData = new Dictionary<string, object> { ["interceptionId"] = InterceptionId };
-                if (overrides?.Url != null) requestData["url"] = overrides.Url;
-                if (overrides?.Method != null) requestData["method"] = overrides.Method;
-                if (overrides?.PostData != null) requestData["postData"] = overrides.PostData;
-                if (overrides?.Headers != null) requestData["headers"] = overrides.Headers;
+                if (overrides?.Url != null)
+                {
+                    requestData["url"] = overrides.Url;
+                }
+
+                if (overrides?.Method != null)
+                {
+                    requestData["method"] = overrides.Method;
+                }
+
+                if (overrides?.PostData != null)
+                {
+                    requestData["postData"] = overrides.PostData;
+                }
+
+                if (overrides?.Headers != null)
+                {
+                    requestData["headers"] = overrides.Headers;
+                }
 
                 await _client.SendAsync("Network.continueInterceptedRequest", requestData);
             }