test: add test_navigation.py (part 1) (#82)

Author: pavelfeldman

README.md

@@ -128,12 +128,12 @@ async def run():
   browser = await chromium.launch()
   page = await browser.newPage()
 
-  async def log_and_continue_request(route, request):
+  def log_and_continue_request(route, request):
     print(request.url)
-    await route.continue_()
+    await asyncio.create_task(route.continue_())
 
   # Log and continue all network requests
-  await page.route('**', lambda route, request: asyncio.ensure_future(log_and_continue_request(route, request)))
+  await page.route('**', lambda route, request: log_and_continue_request(route, request))
 
   await page.goto('http://todomvc.com')
   await browser.close()

playwright/browser_context.py

@@ -76,27 +76,23 @@ def _on_route(self, route: Route, request: Request) -> None:
             if handler_entry.matcher.matches(request.url):
                 handler_entry.handler(route, request)
                 return
-        asyncio.ensure_future(route.continue_())
+        asyncio.create_task(route.continue_())
 
     def _on_binding(self, binding_call: BindingCall) -> None:
         func = self._bindings.get(binding_call._initializer["name"])
         if func is None:
             return
-        asyncio.ensure_future(binding_call.call(func))
+        asyncio.create_task(binding_call.call(func))
 
     def setDefaultNavigationTimeout(self, timeout: int) -> None:
         self._timeout_settings.set_navigation_timeout(timeout)
-        asyncio.ensure_future(
-            self._channel.send(
-                "setDefaultNavigationTimeoutNoReply", dict(timeout=timeout)
-            )
+        self._channel.send_no_reply(
+            "setDefaultNavigationTimeoutNoReply", dict(timeout=timeout)
         )
 
     def setDefaultTimeout(self, timeout: int) -> None:
         self._timeout_settings.set_timeout(timeout)
-        asyncio.ensure_future(
-            self._channel.send("setDefaultTimeoutNoReply", dict(timeout=timeout))
-        )
+        self._channel.send_no_reply("setDefaultTimeoutNoReply", dict(timeout=timeout))
 
     @property
     def pages(self) -> List[Page]:

playwright/connection.py

@@ -41,6 +41,11 @@ async def send(self, method: str, params: dict = None) -> Any:
             return result[key]
         return result
 
+    def send_no_reply(self, method: str, params: dict = None) -> None:
+        if params is None:
+            params = dict()
+        self._scope.send_message_to_server_no_reply(self._guid, method, params)
+
 
 class ChannelOwner(BaseEventEmitter):
     def __init__(
@@ -95,7 +100,13 @@ def dispose(self) -> None:
             self._parent._children.remove(self)
 
     async def send_message_to_server(self, guid: str, method: str, params: Dict) -> Any:
-        return await self._connection._send_message_to_server(guid, method, params)
+        callback = self._connection._send_message_to_server(guid, method, params)
+        return await callback.future
+
+    def send_message_to_server_no_reply(
+        self, guid: str, method: str, params: Dict
+    ) -> Any:
+        self._connection._send_message_to_server(guid, method, params)
 
     def create_remote_object(self, type: str, guid: str, initializer: Dict) -> Any:
         result: ChannelOwner
@@ -140,9 +151,9 @@ async def wait_for_object_with_known_name(self, guid: str) -> Any:
         self._waiting_for_object[guid] = callback
         return await callback
 
-    async def _send_message_to_server(
+    def _send_message_to_server(
         self, guid: str, method: str, params: Dict
-    ) -> Any:
+    ) -> ProtocolCallback:
         self._last_id += 1
         id = self._last_id
         message = dict(
@@ -154,7 +165,7 @@ async def _send_message_to_server(
         self._transport.send(message)
         callback = ProtocolCallback(self._loop)
         self._callbacks[id] = callback
-        return await callback.future
+        return callback
 
     def _dispatch(self, msg: ParsedMessagePayload) -> None:
 

playwright/page.py

@@ -225,7 +225,7 @@ def _on_route(self, route: Route, request: Request) -> None:
     def _on_binding(self, binding_call: "BindingCall") -> None:
         func = self._bindings.get(binding_call._initializer["name"])
         if func:
-            asyncio.ensure_future(binding_call.call(func))
+            asyncio.create_task(binding_call.call(func))
         self._browser_context._on_binding(binding_call)
 
     def _on_worker(self, worker: Worker) -> None:
@@ -273,17 +273,13 @@ def frames(self) -> List[Frame]:
 
     def setDefaultNavigationTimeout(self, timeout: int) -> None:
         self._timeout_settings.set_navigation_timeout(timeout)
-        asyncio.ensure_future(
-            self._channel.send(
-                "setDefaultNavigationTimeoutNoReply", dict(timeout=timeout)
-            )
+        self._channel.send_no_reply(
+            "setDefaultNavigationTimeoutNoReply", dict(timeout=timeout)
         )
 
     def setDefaultTimeout(self, timeout: int) -> None:
         self._timeout_settings.set_timeout(timeout)
-        asyncio.ensure_future(
-            self._channel.send("setDefaultTimeoutNoReply", dict(timeout=timeout))
-        )
+        self._channel.send_no_reply("setDefaultTimeoutNoReply", dict(timeout=timeout))
 
     async def querySelector(self, selector: str) -> Optional[ElementHandle]:
         return await self._main_frame.querySelector(selector)
@@ -723,6 +719,6 @@ async def call(self, func: FunctionWithSource) -> None:
             await self._channel.send("resolve", dict(result=serialize_argument(result)))
         except Exception as e:
             tb = sys.exc_info()[2]
-            asyncio.ensure_future(
+            asyncio.create_task(
                 self._channel.send("reject", dict(error=serialize_error(e, tb)))
             )

playwright/sync_base.py

@@ -34,7 +34,7 @@ def __init__(
         wait_helper.reject_on_timeout(
             timeout or 30000, f'Timeout while waiting for event "${event}"'
         )
-        self._future = asyncio.ensure_future(
+        self._future = asyncio.create_task(
             wait_helper.wait_for_event(sync_base._async_obj, event, predicate)
         )
 

playwright/wait_helper.py

@@ -37,15 +37,15 @@ def reject_on_timeout(self, timeout: int, message: str) -> None:
         if timeout == 0:
             return
         self.reject_on(
-            asyncio.ensure_future(asyncio.sleep(timeout / 1000)), TimeoutError(message)
+            asyncio.create_task(asyncio.sleep(timeout / 1000)), TimeoutError(message)
         )
 
     def reject_on(self, future: asyncio.Future, error: Error) -> None:
         async def future_wrapper() -> Error:
             await future
             return error
 
-        result = asyncio.ensure_future(future_wrapper())
+        result = asyncio.create_task(future_wrapper())
         result.add_done_callback(lambda f: future.cancel())
         self._failures.append(result)
 

tests/assets/historyapi.html

@@ -0,0 +1,5 @@
+<script>
+window.addEventListener('DOMContentLoaded', () => {
+  history.pushState({}, '', '#1');
+});
+</script>

tests/assets/self-request.html

@@ -0,0 +1,5 @@
+<script>
+var req = new XMLHttpRequest();
+req.open('GET', '/self-request.html');
+req.send(null);
+</script>

tests/test_browsercontext.py

@@ -136,7 +136,7 @@ async def test_close_should_work_for_empty_context(browser):
 
 async def test_close_should_abort_wait_for_event(browser):
     context = await browser.newContext()
-    promise = asyncio.ensure_future(context.waitForEvent("page"))
+    promise = asyncio.create_task(context.waitForEvent("page"))
     await context.close()
     with pytest.raises(Error) as exc_info:
         await promise
@@ -425,7 +425,7 @@ def handle(route, request):
         assert request.resourceType == "document"
         assert request.frame == page.mainFrame
         assert request.frame.url == "about:blank"
-        asyncio.ensure_future(route.continue_())
+        asyncio.create_task(route.continue_())
 
     await context.route("**/empty.html", lambda route, request: handle(route, request))
     page = await context.newPage()
@@ -442,7 +442,7 @@ async def test_route_should_unroute(context, server):
 
     def handler(route, request, ordinal):
         intercepted.append(ordinal)
-        asyncio.ensure_future(route.continue_())
+        asyncio.create_task(route.continue_())
 
     def handler1(route, request):
         handler(route, request, 1)
@@ -473,15 +473,15 @@ def handler1(route, request):
 async def test_route_should_yield_to_page_route(context, server):
     await context.route(
         "**/empty.html",
-        lambda route, request: asyncio.ensure_future(
+        lambda route, request: asyncio.create_task(
             route.fulfill(status=200, body="context")
         ),
     )
 
     page = await context.newPage()
     await page.route(
         "**/empty.html",
-        lambda route, request: asyncio.ensure_future(
+        lambda route, request: asyncio.create_task(
             route.fulfill(status=200, body="page")
         ),
     )
@@ -494,15 +494,15 @@ async def test_route_should_yield_to_page_route(context, server):
 async def test_route_should_fall_back_to_context_route(context, server):
     await context.route(
         "**/empty.html",
-        lambda route, request: asyncio.ensure_future(
+        lambda route, request: asyncio.create_task(
             route.fulfill(status=200, body="context")
         ),
     )
 
     page = await context.newPage()
     await page.route(
         "**/non-empty.html",
-        lambda route, request: asyncio.ensure_future(
+        lambda route, request: asyncio.create_task(
             route.fulfill(status=200, body="page")
         ),
     )
@@ -647,16 +647,16 @@ async def test_page_event_should_report_when_a_new_page_is_created_and_closed(
 
 
 async def test_page_event_should_report_initialized_pages(context, server):
-    page_promise = asyncio.ensure_future(context.waitForEvent("page"))
-    asyncio.ensure_future(context.newPage())
-    newPage = await page_promise
+    page_event_promise = asyncio.create_task(context.waitForEvent("page"))
+    asyncio.create_task(context.newPage())
+    newPage = await page_event_promise
     assert newPage.url == "about:blank"
 
-    popup_promise = asyncio.ensure_future(context.waitForEvent("page"))
-    evaluate_promise = asyncio.ensure_future(
+    popup_event_promise = asyncio.create_task(context.waitForEvent("page"))
+    evaluate_promise = asyncio.create_task(
         newPage.evaluate("window.open('about:blank')")
     )
-    popup = await popup_promise
+    popup = await popup_event_promise
     assert popup.url == "about:blank"
     await evaluate_promise
 

tests/test_click.py

@@ -187,7 +187,7 @@ async def click():
         await page.click("button", timeout=0)
         done.append(True)
 
-    clicked = asyncio.ensure_future(click())
+    clicked = asyncio.create_task(click())
     await give_it_a_chance_to_click(page)
     assert await page.evaluate("result") == "Was not clicked"
     assert done == []
@@ -206,7 +206,7 @@ async def click():
         await page.click("button", timeout=0)
         done.append(True)
 
-    clicked = asyncio.ensure_future(click())
+    clicked = asyncio.create_task(click())
     await give_it_a_chance_to_click(page)
     assert await page.evaluate("result") == "Was not clicked"
     assert done == []
@@ -249,7 +249,7 @@ async def click():
         await page.click("button", timeout=0)
         done.append(True)
 
-    clicked = asyncio.ensure_future(click())
+    clicked = asyncio.create_task(click())
     await give_it_a_chance_to_click(page)
     assert done == []
     await page.evalOnSelector("button", "b => b.parentElement.style.display = 'block'")
@@ -561,7 +561,7 @@ async def click():
         await page.click("button")
         clicked.append(True)
 
-    click_promise = asyncio.ensure_future(click())
+    click_promise = asyncio.create_task(click())
     assert clicked == [False]
 
     await page.evalOnSelector(".flyover", "flyOver => flyOver.style.left = '0'")
@@ -628,7 +628,7 @@ async def click():
         await page.click("text=Click target")
         done.append(True)
 
-    click_promise = asyncio.ensure_future(click())
+    click_promise = asyncio.create_task(click())
     await give_it_a_chance_to_click(page)
     assert await page.evaluate("() => window.__CLICKED") is None
     assert done == []
@@ -661,7 +661,7 @@ async def click():
         await page.click("input")
         done.append(True)
 
-    click_promise = asyncio.ensure_future(click())
+    click_promise = asyncio.create_task(click())
     await give_it_a_chance_to_click(page)
     assert await page.evaluate("window.__CLICKED") is None
     assert done == []
@@ -680,7 +680,7 @@ async def click():
         await page.click("select")
         done.append(True)
 
-    click_promise = asyncio.ensure_future(click())
+    click_promise = asyncio.create_task(click())
     await give_it_a_chance_to_click(page)
     assert await page.evaluate("window.__CLICKED") is None
     assert done == []
@@ -725,7 +725,7 @@ async def click():
         await page.click("text=Click target")
         done.append(True)
 
-    click_promise = asyncio.ensure_future(click())
+    click_promise = asyncio.create_task(click())
     await give_it_a_chance_to_click(page)
     assert await page.evaluate("window.__CLICKED") is None
     assert done == []
@@ -742,7 +742,7 @@ async def test_wait_for_LABEL_to_be_clickable_when_it_has_pointer_events_none(
     await page.setContent(
         '<label onclick="javascript:window.__CLICKED=true;" style="pointer-events:none"><span>Click target</span></label>'
     )
-    click_promise = asyncio.ensure_future(page.click("text=Click target"))
+    click_promise = asyncio.create_task(page.click("text=Click target"))
     #  Do a few roundtrips to the page.
     for _ in range(5):
         assert await page.evaluate("window.__CLICKED") is None
@@ -803,7 +803,8 @@ async def test_fail_when_element_detaches_after_animation(page, server):
     await page.goto(server.PREFIX + "/input/animating-button.html")
     await page.evaluate("addButton()")
     handle = await page.querySelector("button")
-    promise = asyncio.ensure_future(handle.click())
+    promise = asyncio.create_task(handle.click())
+    await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
     await page.evaluate("stopButton(true)")
     error = None
     try:
@@ -823,7 +824,8 @@ async def click():
         await page.click("button")
         clicked.append(True)
 
-    promise = asyncio.ensure_future(click())
+    promise = asyncio.create_task(click())
+    await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
     assert clicked == []
     assert await page.evaluate("window.clicked") is None
     await page.evaluate("stopButton(true)")
@@ -864,7 +866,8 @@ async def test_retry_when_element_is_animating_from_outside_the_viewport(page, s
         """
     )
     handle = await page.querySelector("button")
-    promise = asyncio.ensure_future(handle.click())
+    promise = asyncio.create_task(handle.click())
+    await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
     await handle.evaluate("button => button.className = 'animated'")
     await promise
     assert await page.evaluate("window.clicked")
@@ -896,7 +899,8 @@ async def test_fail_when_element_is_animating_from_outside_the_viewport_with_for
         """
     )
     handle = await page.querySelector("button")
-    promise = asyncio.ensure_future(handle.click(force=True))
+    promise = asyncio.create_task(handle.click(force=True))
+    await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
     await handle.evaluate("button => button.className = 'animated'")
     error = None
     try:
@@ -943,7 +947,8 @@ async def test_click_the_button_when_window_inner_width_is_corrupted(page, serve
 
 
 async def test_timeout_when_click_opens_alert(page, server):
-    dialog_promise = asyncio.ensure_future(page.waitForEvent("dialog"))
+    dialog_promise = asyncio.create_task(page.waitForEvent("dialog"))
+    await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
     await page.setContent('<div onclick="window.alert(123)">Click me</div>')
     error = None
     try: