v1.4 API Review (microsoft#885)

* API Review closes https://github.com/hardkoded/playwright-sharp/issues/641 * dotnet format * Fix build
kblok · Oct 1, 2020 · ac2cc6e · ac2cc6e
1 parent 3f4255b
commit ac2cc6e
Show file tree

Hide file tree

Showing 43 changed files with 1,543 additions and 1,035 deletions.
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -15,7 +15,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v1.6.0
         with:
           dotnet-version: 3.1.100
       - name: Create Certificate
@@ -38,7 +38,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v1.6.0
         with:
           dotnet-version: 3.1.100
       - name: Create Certificate
@@ -61,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v1.6.0
         with:
           dotnet-version: 3.1.100
       - name: Create Certificate

diff --git a/src/PlaywrightSharp.Tests/Autowaiting/AutoWaitingTests.cs b/src/PlaywrightSharp.Tests/Autowaiting/AutoWaitingTests.cs
@@ -205,7 +205,7 @@ await Page.SetContentAsync($@"
                 <a href=""{ TestConstants.EmptyPage}"" target=target>empty.html</a>
                 <iframe name=target></iframe>");
 
-            var frame = Page.Frames.FirstOrDefault(f => f.Name == "target");
+            var frame = Page.GetFrame("target");
 
             await TaskUtils.WhenAll(
                 Page.ClickAsync("a").ContinueWith(t => messages.Add("click")),

diff --git a/src/PlaywrightSharp.Tests/ElementHandle/ElementHandleClickTests.cs b/src/PlaywrightSharp.Tests/ElementHandle/ElementHandleClickTests.cs
@@ -132,7 +132,7 @@ await Page.EvaluateAsync(@"() => {
             }");
 
             var button = await Page.QuerySelectorAsync("button");
-            await button.DoubleClickAsync();
+            await button.DblClickAsync();
 
             Assert.True(await Page.EvaluateAsync<bool>("double"));
             Assert.Equal("Clicked", await Page.EvaluateAsync<string>("() => result"));

diff --git a/src/PlaywrightSharp.Tests/Frame/FrameWaitForFunctionTests.cs b/src/PlaywrightSharp.Tests/Frame/FrameWaitForFunctionTests.cs
@@ -54,7 +54,7 @@ public async Task ShouldPollOnInterval()
                     return false;
                 }
                 return Date.now() - window.__startTime;
-            }", pollingInterval: polling);
+            }", polling: polling);
             int value = (await timeDelta.GetJsonValueAsync<int>());
 
             Assert.True(value >= polling);
@@ -74,7 +74,7 @@ public async Task ShouldAvoidSideEffectsAfterTimeout()
                   window.counter = (window.counter || 0) + 1;
                   console.log(window.counter);
                 }",
-                pollingInterval: 1,
+                polling: 1,
                 timeout: 1000));
 
             int savedCounter = counter;
@@ -170,7 +170,7 @@ public void ShouldThrowOnBadPollingValue()
         public async Task ShouldThrowNegativePollingInterval()
         {
             var exception = await Assert.ThrowsAsync<PlaywrightSharpException>(()
-                => Page.WaitForFunctionAsync("() => !!document.body", pollingInterval: -10));
+                => Page.WaitForFunctionAsync("() => !!document.body", -10));
 
             Assert.Contains("Cannot poll with non-positive interval", exception.Message);
         }
@@ -236,12 +236,13 @@ public async Task ShouldRespectDefaultTimeout()
         [Fact(Timeout = PlaywrightSharp.Playwright.DefaultTimeout)]
         public async Task ShouldDisableTimeoutWhenItsSetTo0()
         {
-            var watchdog = Page.WaitForFunctionAsync(@"() => {
-                window.__counter = (window.__counter || 0) + 1;
-                return window.__injected;
-            }",
-            timeout: 0,
-            pollingInterval: 10);
+            var watchdog = Page.WaitForFunctionAsync(
+                @"() => {
+                    window.__counter = (window.__counter || 0) + 1;
+                    return window.__injected;
+                }",
+                polling: 10,
+                timeout: 0);
             await Page.WaitForFunctionAsync("() => window.__counter > 10");
             await Page.EvaluateAsync("window.__injected = true");
             await watchdog;

diff --git a/src/PlaywrightSharp.Tests/Page/PageClickTests.cs b/src/PlaywrightSharp.Tests/Page/PageClickTests.cs
@@ -427,7 +427,7 @@ await Page.EvaluateAsync(@"{
                });
             }");
             var button = await Page.QuerySelectorAsync("button");
-            await button.DoubleClickAsync();
+            await button.DblClickAsync();
             Assert.True(await Page.EvaluateAsync<bool>("double"));
             Assert.Equal("Clicked", await Page.EvaluateAsync<string>("result"));
         }

diff --git a/src/PlaywrightSharp.ruleset b/src/PlaywrightSharp.ruleset
@@ -29,5 +29,6 @@
     <Rule Id="CA1304" Action="None" /><!-- ToLower with locale-->
     <Rule Id="CA1305" Action="None" /><!-- ChangeType with locale-->
     <Rule Id="CA1307" Action="None" /><!-- GetHashCode with locale settings-->
+    <Rule Id="CA1725" Action="Error" /><!-- Parameter names should match base declaration-->
   </Rules>
 </RuleSet>
diff --git a/src/PlaywrightSharp/Browser.cs b/src/PlaywrightSharp/Browser.cs
@@ -85,6 +85,7 @@ public Task<IBrowserContext> NewContextAsync(
             Credentials httpCredentials = null,
             bool? hasTouch = null,
             bool? acceptDownloads = null,
+            bool? ignoreHTTPSErrors = null,
             ColorScheme? colorScheme = null,
             string locale = null,
             Dictionary<string, string> extraHttpHeaders = null)
@@ -105,6 +106,7 @@ public Task<IBrowserContext> NewContextAsync(
                 AcceptDownloads = acceptDownloads,
                 ColorScheme = colorScheme,
                 Locale = locale,
+                IgnoreHTTPSErrors = ignoreHTTPSErrors,
                 ExtraHttpHeaders = extraHttpHeaders,
             });
 
@@ -171,6 +173,7 @@ public Task<IPage> NewPageAsync(
             Credentials httpCredentials = null,
             bool? hasTouch = null,
             bool? acceptDownloads = null,
+            bool? ignoreHTTPSErrors = null,
             ColorScheme? colorScheme = null,
             string locale = null,
             Dictionary<string, string> extraHttpHeaders = null)
@@ -189,6 +192,7 @@ public Task<IPage> NewPageAsync(
                 HttpCredentials = httpCredentials,
                 HasTouch = hasTouch,
                 AcceptDownloads = acceptDownloads,
+                IgnoreHTTPSErrors = ignoreHTTPSErrors,
                 ColorScheme = colorScheme,
                 Locale = locale,
                 ExtraHttpHeaders = extraHttpHeaders,

diff --git a/src/PlaywrightSharp/BrowserContext.cs b/src/PlaywrightSharp/BrowserContext.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Text.Json;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using PlaywrightSharp.Helpers;
 using PlaywrightSharp.Transport;
@@ -201,32 +202,32 @@ public Task SetGeolocationAsync(decimal latitude, decimal longitude, decimal acc
         public async ValueTask DisposeAsync() => await CloseAsync().ConfigureAwait(false);
 
         /// <inheritdoc/>
-        public Task ExposeBindingAsync(string name, Action<BindingSource> playwrightFunction)
-            => ExposeBindingAsync(name, (Delegate)playwrightFunction);
+        public Task ExposeBindingAsync(string name, Action<BindingSource> playwrightBinding)
+            => ExposeBindingAsync(name, (Delegate)playwrightBinding);
 
         /// <inheritdoc/>
-        public Task ExposeBindingAsync<T>(string name, Action<BindingSource, T> playwrightFunction)
-            => ExposeBindingAsync(name, (Delegate)playwrightFunction);
+        public Task ExposeBindingAsync<T>(string name, Action<BindingSource, T> playwrightBinding)
+            => ExposeBindingAsync(name, (Delegate)playwrightBinding);
 
         /// <inheritdoc/>
-        public Task ExposeBindingAsync<TResult>(string name, Func<BindingSource, TResult> playwrightFunction)
-            => ExposeBindingAsync(name, (Delegate)playwrightFunction);
+        public Task ExposeBindingAsync<TResult>(string name, Func<BindingSource, TResult> playwrightBinding)
+            => ExposeBindingAsync(name, (Delegate)playwrightBinding);
 
         /// <inheritdoc/>
-        public Task ExposeBindingAsync<T, TResult>(string name, Func<BindingSource, T, TResult> playwrightFunction)
-            => ExposeBindingAsync(name, (Delegate)playwrightFunction);
+        public Task ExposeBindingAsync<T, TResult>(string name, Func<BindingSource, T, TResult> playwrightBinding)
+            => ExposeBindingAsync(name, (Delegate)playwrightBinding);
 
         /// <inheritdoc/>
-        public Task ExposeBindingAsync<T1, T2, TResult>(string name, Func<BindingSource, T1, T2, TResult> playwrightFunction)
-            => ExposeBindingAsync(name, (Delegate)playwrightFunction);
+        public Task ExposeBindingAsync<T1, T2, TResult>(string name, Func<BindingSource, T1, T2, TResult> playwrightBinding)
+            => ExposeBindingAsync(name, (Delegate)playwrightBinding);
 
         /// <inheritdoc/>
-        public Task ExposeBindingAsync<T1, T2, T3, TResult>(string name, Func<BindingSource, T1, T2, T3, TResult> playwrightFunction)
-            => ExposeBindingAsync(name, (Delegate)playwrightFunction);
+        public Task ExposeBindingAsync<T1, T2, T3, TResult>(string name, Func<BindingSource, T1, T2, T3, TResult> playwrightBinding)
+            => ExposeBindingAsync(name, (Delegate)playwrightBinding);
 
         /// <inheritdoc/>
-        public Task ExposeBindingAsync<T1, T2, T3, T4, TResult>(string name, Func<BindingSource, T1, T2, T3, T4, TResult> playwrightFunction)
-            => ExposeBindingAsync(name, (Delegate)playwrightFunction);
+        public Task ExposeBindingAsync<T1, T2, T3, T4, TResult>(string name, Func<BindingSource, T1, T2, T3, T4, TResult> playwrightBinding)
+            => ExposeBindingAsync(name, (Delegate)playwrightBinding);
 
         /// <inheritdoc/>
         public Task ExposeFunctionAsync(string name, Action playwrightFunction)
@@ -278,65 +279,90 @@ public async Task<T> WaitForEvent<T>(PlaywrightEvent<T> e, Func<T, bool> predica
         }
 
         /// <inheritdoc />
-        public Task AddInitScriptAsync(string script = null, object[] args = null, string path = null, string content = null)
+        public Task AddInitScriptAsync(string script = null, object[] arg = null, string path = null, string content = null)
         {
             if (string.IsNullOrEmpty(script))
             {
                 script = ScriptsHelper.EvaluationScript(content, path);
             }
 
-            return _channel.AddInitScriptAsync(ScriptsHelper.SerializeScriptCall(script, args));
+            return _channel.AddInitScriptAsync(ScriptsHelper.SerializeScriptCall(script, arg));
         }
 
         /// <inheritdoc />
-        public Task SetHttpCredentialsAsync(Credentials credentials) => _channel.SetHttpCredentialsAsync(credentials);
+        public Task SetHttpCredentialsAsync(Credentials httpCredentials) => _channel.SetHttpCredentialsAsync(httpCredentials);
 
         /// <inheritdoc />
-        public Task SetOfflineAsync(bool enabled) => _channel.SetOfflineAsync(enabled);
+        public Task SetOfflineAsync(bool offline) => _channel.SetOfflineAsync(offline);
 
         /// <inheritdoc />
         public async Task<ICDPSession> NewCDPSessionAsync(IPage page) => (await _channel.NewCDPSessionAsync(page).ConfigureAwait(false))?.Object;
 
         /// <inheritdoc />
         public Task RouteAsync(string url, Action<Route, IRequest> handler)
-        {
-            _routes.Add(new RouteSetting
-            {
-                Url = url,
-                Handler = handler,
-            });
+            => RouteAsync(
+                new RouteSetting
+                {
+                    Url = url,
+                    Handler = handler,
+                });
 
-            if (_routes.Count == 1)
-            {
-                return _channel.SetNetworkInterceptionEnabledAsync(true);
-            }
+        /// <inheritdoc />
+        public Task RouteAsync(Regex url, Action<Route, IRequest> handler)
+            => RouteAsync(
+                new RouteSetting
+                {
+                    Regex = url,
+                    Handler = handler,
+                });
 
-            return Task.CompletedTask;
-        }
+        /// <inheritdoc />
+        public Task RouteAsync(Func<string, bool> url, Action<Route, IRequest> handler)
+            => RouteAsync(
+                new RouteSetting
+                {
+                    Function = url,
+                    Handler = handler,
+                });
 
         /// <inheritdoc />
         public Task UnrouteAsync(string url, Action<Route, IRequest> handler = null)
-        {
-            var newRoutesList = new List<RouteSetting>();
-            newRoutesList.AddRange(_routes.Where(r => r.Url != url || (handler != null && r.Handler != handler)));
-            _routes = newRoutesList;
+            => UnrouteAsync(
+                new RouteSetting
+                {
+                    Url = url,
+                    Handler = handler,
+                });
 
-            if (_routes.Count == 0)
-            {
-                return _channel.SetNetworkInterceptionEnabledAsync(false);
-            }
+        /// <inheritdoc />
+        public Task UnrouteAsync(Regex url, Action<Route, IRequest> handler = null)
+            => UnrouteAsync(
+                new RouteSetting
+                {
+                    Regex = url,
+                    Handler = handler,
+                });
 
-            return Task.CompletedTask;
-        }
+        /// <inheritdoc />
+        public Task UnrouteAsync(Func<string, bool> url, Action<Route, IRequest> handler = null)
+            => UnrouteAsync(
+                new RouteSetting
+                {
+                    Function = url,
+                    Handler = handler,
+                });
 
         /// <inheritdoc />
-        public Task SetExtraHttpHeadersAsync(IDictionary<string, string> headers) => _channel.SetExtraHttpHeadersAsync(headers);
+        public Task SetExtraHttpHeadersAsync(Dictionary<string, string> headers) => _channel.SetExtraHttpHeadersAsync(headers);
 
         internal void OnRoute(Route route, Request request)
         {
             foreach (var item in _routes)
             {
-                if (request.Url.UrlMatches(item.Url))
+                if (
+                    (item.Url != null && request.Url.UrlMatches(item.Url)) ||
+                    (item.Regex?.IsMatch(request.Url) == true) ||
+                    (item.Function?.Invoke(request.Url) == true))
                 {
                     item.Handler(route, request);
                     return;
@@ -346,6 +372,36 @@ internal void OnRoute(Route route, Request request)
             _ = route.ContinueAsync();
         }
 
+        private Task RouteAsync(RouteSetting setting)
+        {
+            _routes.Add(setting);
+
+            if (_routes.Count == 1)
+            {
+                return _channel.SetNetworkInterceptionEnabledAsync(true);
+            }
+
+            return Task.CompletedTask;
+        }
+
+        private Task UnrouteAsync(RouteSetting setting)
+        {
+            var newRoutesList = new List<RouteSetting>();
+            newRoutesList.AddRange(_routes.Where(r =>
+                (setting.Url != null && r.Url != setting.Url) ||
+                (setting.Regex != null && r.Regex != setting.Regex) ||
+                (setting.Function != null && r.Function != setting.Function) ||
+                (setting.Handler != null && r.Handler != setting.Handler)));
+            _routes = newRoutesList;
+
+            if (_routes.Count == 0)
+            {
+                return _channel.SetNetworkInterceptionEnabledAsync(false);
+            }
+
+            return Task.CompletedTask;
+        }
+
         private void Channel_Closed(object sender, EventArgs e)
         {
             _isClosedOrClosing = true;

diff --git a/src/PlaywrightSharp/BrowserServer.cs b/src/PlaywrightSharp/BrowserServer.cs