chore: roll driver to 1.56.1 (#3250)

Author: dgozman

README.md

@@ -3,9 +3,9 @@
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->140.0.7339.16<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->141.0.7390.37<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->26.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->141.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->142.0.1<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 Playwright for .NET is the official language port of [Playwright](https://playwright.dev), the library to automate [Chromium](https://www.chromium.org/Home), [Firefox](https://www.mozilla.org/en-US/firefox/new/) and [WebKit](https://webkit.org/) with a single API. Playwright is built to enable cross-browser web automation that is **ever-green**, **capable**, **reliable** and **fast**.
 

src/Common/Version.props

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <AssemblyVersion>1.55.0</AssemblyVersion>
     <PackageVersion>$(AssemblyVersion)</PackageVersion>
-    <DriverVersion>1.55.0-beta-1756314050000</DriverVersion>
+    <DriverVersion>1.56.1</DriverVersion>
     <ReleaseVersion>$(AssemblyVersion)</ReleaseVersion>
     <FileVersion>$(AssemblyVersion)</FileVersion>
     <NoDefaultExcludes>true</NoDefaultExcludes>

src/Playwright.TestingHarnessTest/package-lock.json

@@ -2,7 +2,7 @@
   "name": "playwright.testingharnesstest",
   "private": true,
   "devDependencies": {
-    "@playwright/test": "1.55.0-beta-1756314050000",
+    "@playwright/test": "1.56.1",
     "@types/node": "^22.12.0",
     "fast-xml-parser": "^4.5.0"
   }

src/Playwright.TestingHarnessTest/package.json

@@ -819,4 +819,23 @@ public async Task ToHaveRole()
         await Expect(Page.Locator("div")).ToHaveRoleAsync(AriaRole.Button);
         await Expect(Page.Locator("div")).Not.ToHaveRoleAsync(AriaRole.Checkbox);
     }
+
+    [PlaywrightTest("page/expect-misc.spec.ts", "strict mode violation error format")]
+    public async Task StrictModeViolationErrorFormat()
+    {
+        await Page.SetContentAsync(@"<div>hello</div><div>hi</div>");
+        var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => Expect(Page.Locator("div")).ToBeVisibleAsync());
+        StringAssert.Contains("Locator expected to be visible", exception.Message);
+        StringAssert.Contains("Error: strict mode violation: Locator(\"div\") resolved to 2 elements:", exception.Message);
+    }
+
+
+    [PlaywrightTest("page/expect-misc.spec.ts", "invalid selector error format")]
+    public async Task InvalidSelectorErrorFormat()
+    {
+        await Page.SetContentAsync(@"<div>a</div><div>b</div>");
+        var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => Expect(Page.Locator("##")).ToBeVisibleAsync());
+        StringAssert.Contains("Locator expected to be visible", exception.Message);
+        StringAssert.Contains("Error: Unexpected token \"#\" while parsing css selector \"##\".", exception.Message);
+    }
 }

src/Playwright.Tests/Assertions/LocatorAssertionsTests.cs

@@ -95,6 +95,10 @@ bool URLMatches(string baseURL, string url, string glob)
         Assert.False(URLMatches(null, "https://playwright.dev/foobar", "https://playwright.dev/fooBAR"));
         Assert.False(URLMatches(null, "https://playwright.dev/foobar?a=b", "https://playwright.dev/foobar?A=B"));
 
+        Assert.True(URLMatches(null, "https://localhost:3000/?a=b", "**/?a=b"));
+        Assert.True(URLMatches(null, "https://localhost:3000/?a=b", "**?a=b"));
+        Assert.True(URLMatches(null, "https://localhost:3000/?a=b", "**=b"));
+
         // This is not supported, we treat ? as a query separator.
         Assert.That("http://localhost:8080/Simple/path.js", Does.Not.Match(GlobToRegex("http://localhost:8080/?imple/path.js")));
         Assert.False(URLMatches(null, "http://playwright.dev/", "http://playwright.?ev"));

src/Playwright.Tests/InterceptionTests.cs

@@ -143,4 +143,16 @@ await Expect(Page.Locator("body")).ToMatchAriaSnapshotAsync(@"
                 - /url: /.*example.com/
         ");
     }
+
+    [PlaywrightTest("page-aria-snapshot.spec.ts", "match values both against regex and string")]
+    public async Task MatchValuesBothAgainstRegexAndString()
+    {
+        await Page.SetContentAsync(@"
+            <a href='/auth?r=/'>Log in</a>
+        ");
+        await Expect(Page.Locator("body")).ToMatchAriaSnapshotAsync(@"
+            - link ""Log in"":
+                - /url: /auth?r=/
+        ");
+    }
 }

src/Playwright.Tests/PageAriaSnapshotTests.cs

@@ -118,7 +118,7 @@ public async Task ShouldTriggerCorrectLog()
             Page.WaitForConsoleMessageAsync(),
             Page.EvaluateAsync("async url => fetch(url).catch (e => { })", Server.EmptyPage)
         );
-        StringAssert.Contains("Access-Control-Allow-Origin", messageEvent.Text);
+        Assert.True(messageEvent.Text.Contains("Access-Control-Allow-Origin") || messageEvent.Text.Contains("blocked by CORS policy"));
         Assert.AreEqual("error", messageEvent.Type);
     }
 
@@ -159,4 +159,25 @@ public async Task ShouldNotThrowWhenThereAreConsoleMessagesInDetachedIframes()
         // 4. Connect to the popup and make sure it doesn't throw.
         Assert.AreEqual(2, await popup.EvaluateAsync<int>("1 + 1"));
     }
+
+    [PlaywrightTest("page-event-console.spec.ts", "consoleMessages should work")]
+    public async Task ConsoleMessagesShouldWork()
+    {
+        await Page.EvaluateAsync(@"() => {
+          for (let i = 0; i < 301; i++)
+            console.log('message' + i);
+        }");
+
+        var messages = await Page.ConsoleMessagesAsync();
+        Assert.True(messages.Count >= 100, "should be at least 100 messages");
+
+        int firstIndex = messages.Count - 100;
+        for (int i = 0; i < 100; i++)
+        {
+            var message = messages[firstIndex + i];
+            Assert.AreEqual("message" + (201 + i), message.Text);
+            Assert.AreEqual("log", message.Type);
+            Assert.AreEqual(Page, message.Page);
+        }
+    }
 }

src/Playwright.Tests/PageEventConsoleTests.cs

@@ -131,4 +131,26 @@ public async Task ShouldHandleWindow()
 
         StringAssert.Contains(TestConstants.IsChromium ? "Window" : "[object Window]", error);
     }
+
+    [PlaywrightTest("page-event-pageerror.spec.ts", "pageErrors should work")]
+    public async Task PageErrorsShouldWork()
+    {
+        await Page.GotoAsync(Server.EmptyPage);
+        await Page.EvaluateAsync(@"async () => {
+          for (let i = 0; i < 301; i++)
+            window.setTimeout(() => { throw new Error('error' + i); }, 0);
+          await new Promise(f => window.setTimeout(f, 100));
+        }");
+
+        var errors = await Page.PageErrorsAsync();
+        Assert.True(errors.Count >= 100, "should be at least 100 errors");
+
+        // Check the last 100 errors (indices 201-300)
+        int firstIndex = errors.Count - 100;
+        for (int i = 0; i < 100; i++)
+        {
+            string error = errors[firstIndex + i];
+            Assert.True(error.StartsWith("Error: error" + (201 + i)), error);
+        }
+    }
 }

src/Playwright.Tests/PageEventPageErrorTests.cs

@@ -72,4 +72,47 @@ public async Task ShouldReportRequestsAndResponsesHandledByServiceWorker()
         Assert.AreEqual(Server.Prefix + "/serviceworkers/fetchdummy/foo", response.Url);
         Assert.AreEqual("responseFromServiceWorker:foo", await response.TextAsync());
     }
+
+    [PlaywrightTest("page-event-request.spec.ts", "should return last requests")]
+    public async Task ShouldReturnLastRequests()
+    {
+        await Page.GotoAsync(Server.Prefix + "/title.html");
+
+        // Set up routes for 200 requests
+        for (int i = 0; i < 200; ++i)
+        {
+            Server.SetRoute("/fetch-" + i, context =>
+            {
+                context.Response.StatusCode = 200;
+                return context.Response.WriteAsync("url:" + Server.Prefix + context.Request.Path);
+            });
+        }
+
+        // #0 is the navigation request, so start with #1.
+        for (int i = 0; i < 99; ++i)
+        {
+            await Page.EvaluateAsync("url => fetch(url)", Server.Prefix + "/fetch-" + i);
+        }
+        var first99Requests = (await Page.RequestsAsync()).ToList();
+        first99Requests.RemoveAt(0); // Remove the navigation request
+
+        for (int i = 99; i < 199; ++i)
+        {
+            await Page.EvaluateAsync("url => fetch(url)", Server.Prefix + "/fetch-" + i);
+        }
+        var last100Requests = await Page.RequestsAsync();
+        var allRequests = new List<IRequest>();
+        allRequests.AddRange(first99Requests);
+        allRequests.AddRange(last100Requests);
+
+        // All 199 requests are fully functional.
+        int index = 0;
+        foreach (var request in allRequests)
+        {
+            var response = await request.ResponseAsync();
+            Assert.AreEqual("url:" + Server.Prefix + "/fetch-" + index, await response.TextAsync());
+            Assert.AreEqual(Server.Prefix + "/fetch-" + index, request.Url);
+            index++;
+        }
+    }
 }