test: add test_frames (microsoft#27)

Author: pavelfeldman

playwright/helper.py

@@ -80,14 +80,15 @@ def set_default_timeout(self, timeout):
     self.timeout = timeout
 
 class Error(BaseException):
-  def __init__(self, message: str) -> None:
+  def __init__(self, message: str, stack: str = None) -> None:
     self.message = message
+    self.stack = stack
 
 def serialize_error(ex: BaseException) -> ErrorPayload:
   return dict(message=str(ex))
 
 def parse_error(error: ErrorPayload):
-  return Error('%s\n%s' % (error['message'], error['stack']))
+  return Error(error['message'], error['stack'])
 
 def is_function_body(expression: str) -> bool:
   expression = expression.strip()

playwright/page.py

@@ -106,15 +106,11 @@ def _on_request_failed(self, request: Request, failure_text: str = None) -> None
   def _on_frame_attached(self, frame: Frame) -> None:
     frame._page = self
     self._frames.append(frame)
-    if frame._parent_frame:
-      frame._parent_frame._child_frames.append(frame)
     self.emit(Page.Events.FrameAttached, frame)
 
   def _on_frame_detached(self, frame: Frame) -> None:
     self._frames.remove(frame)
     frame._detached = True
-    if frame._parent_frame:
-      frame._parent_frame._child_frames.remove(frame)
     self.emit(Page.Events.FrameDetached, frame)
 
   def _on_frame_navigated(self, frame: Frame, url: str, name: str) -> None:

tests/conftest.py

@@ -79,7 +79,7 @@ async def start_http_server():
     resource = File(static_path)
     site = web_server.Site(resource)
     reactor.listenTCP(server_object.PORT, site)
-    t = threading.Thread(target=reactor.run)
+    t = threading.Thread(target=lambda: reactor.run(installSignalHandlers=0))
     t.start()
     yield
     reactor.stop()

tests/test_frames.py

@@ -12,14 +12,215 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-async def test_frames_respect_name(page):
-  await page.setContent('<iframe name=target></iframe>')
-  assert page.frame(name='bogus') is None
-  frame = page.frame(name='target')
-  assert frame
-  assert frame == (page.mainFrame.childFrames[0])
-
-async def test_frames_respect_url(page, server):
-  await page.setContent(f'<iframe src="{server.EMPTY_PAGE}"></iframe>')
-  assert page.frame(url='bogus') is None
-  assert page.frame(url=f'**/empty.html').url == (f'http://localhost:{server.PORT}/empty.html')
+import asyncio
+from playwright.helper import Error
+
+async def test_evaluate_handle(page, server):
+  await page.goto(server.EMPTY_PAGE)
+  main_frame = page.mainFrame
+  window_handle = await main_frame.evaluateHandle('window')
+  assert window_handle
+
+async def test_frame_element(page, server, utils):
+  await page.goto(server.EMPTY_PAGE)
+  frame1 = await utils.attach_frame(page, 'frame1', server.EMPTY_PAGE)
+  await utils.attach_frame(page, 'frame2', server.EMPTY_PAGE)
+  frame3 = await utils.attach_frame(page, 'frame3', server.EMPTY_PAGE)
+  frame1handle1 = await page.querySelector('#frame1')
+  frame1handle2 = await frame1.frameElement()
+  frame3handle1 = await page.querySelector('#frame3')
+  frame3handle2 = await frame3.frameElement()
+  assert await frame1handle1.evaluate('(a, b) => a === b', frame1handle2)
+  assert await frame3handle1.evaluate('(a, b) => a === b', frame3handle2)
+  assert await frame1handle1.evaluate('(a, b) => a === b', frame3handle1) == False
+
+async def test_frame_element_with_content_frame(page, server, utils):
+  await page.goto(server.EMPTY_PAGE)
+  frame = await utils.attach_frame(page, 'frame1', server.EMPTY_PAGE)
+  handle = await frame.frameElement()
+  contentFrame = await handle.contentFrame()
+  assert contentFrame == frame
+
+async def test_frame_element_throw_when_detached(page, server, utils):
+  await page.goto(server.EMPTY_PAGE)
+  frame1 = await utils.attach_frame(page, 'frame1', server.EMPTY_PAGE)
+  await page.evalOnSelector('#frame1', 'e => e.remove()')
+  error = None
+  try:
+    await frame1.frameElement()
+  except Error as e:
+    error = e
+  assert error.message == 'Frame has been detached.'
+
+async def test_evaluate_throw_for_detached_frames(page, server, utils):
+  frame1 = await utils.attach_frame(page, 'frame1', server.EMPTY_PAGE)
+  await utils.detach_frame(page, 'frame1')
+  error = None
+  try:
+    await frame1.evaluate('7 * 8')
+  except Error as e:
+    error = e
+  assert 'Execution Context is not available in detached frame' in error.message
+
+async def test_evaluate_isolated_between_frames(page, server, utils):
+  await page.goto(server.EMPTY_PAGE)
+  await utils.attach_frame(page, 'frame1', server.EMPTY_PAGE)
+  assert len(page.frames) == 2
+  [frame1, frame2] = page.frames
+  assert frame1 != frame2
+
+  await asyncio.gather(
+    frame1.evaluate('window.a = 1'),
+    frame2.evaluate('window.a = 2')
+  )
+  [a1, a2] = await asyncio.gather(
+    frame1.evaluate('window.a'),
+    frame2.evaluate('window.a')
+  )
+  assert a1 == 1
+  assert a2 == 2
+
+async def test_should_handle_nested_frames(page, server, utils):
+  await page.goto(server.PREFIX + '/frames/nested-frames.html')
+  assert utils.dump_frames(page.mainFrame) == [
+    'http://localhost:<PORT>/frames/nested-frames.html',
+    '    http://localhost:<PORT>/frames/frame.html (aframe)',
+    '    http://localhost:<PORT>/frames/two-frames.html (2frames)',
+    '        http://localhost:<PORT>/frames/frame.html (dos)',
+    '        http://localhost:<PORT>/frames/frame.html (uno)',
+  ]
+
+async def test_should_send_events_when_frames_are_manipulated_dynamically(page, server, utils):
+  await page.goto(server.EMPTY_PAGE)
+  # validate frameattached events
+  attached_frames = []
+  page.on('frameattached', lambda frame: attached_frames.append(frame))
+  await utils.attach_frame(page, 'frame1', './assets/frame.html')
+  assert len(attached_frames) == 1
+  assert '/assets/frame.html' in attached_frames[0].url
+
+  # validate framenavigated events
+  navigated_frames = []
+  page.on('framenavigated', lambda frame: navigated_frames.append(frame))
+  await page.evaluate('''() => {
+    frame = document.getElementById('frame1')
+    frame.src = './empty.html'
+    return new Promise(x => frame.onload = x)
+  }''')
+
+  assert len(navigated_frames) == 1
+  assert navigated_frames[0].url == server.EMPTY_PAGE
+
+  # validate framedetached events
+  detached_frames = list()
+  page.on('framedetached', lambda frame: detached_frames.append(frame))
+  await utils.detach_frame(page, 'frame1')
+  assert len(detached_frames) == 1
+  assert detached_frames[0].isDetached()
+
+async def test_framenavigated_when_navigating_on_anchor_urls(page, server):
+  await page.goto(server.EMPTY_PAGE)
+  await asyncio.gather(
+    page.goto(server.EMPTY_PAGE + '#foo'),
+    page.waitForEvent('framenavigated')
+  )
+  assert page.url == server.EMPTY_PAGE + '#foo'
+
+async def test_persist_main_frame_on_cross_process_navigation(page, server):
+  await page.goto(server.EMPTY_PAGE)
+  main_frame = page.mainFrame
+  await page.goto(server.CROSS_PROCESS_PREFIX + '/empty.html')
+  assert page.mainFrame == main_frame
+
+async def test_should_not_send_attach_detach_events_for_main_frame(page, server):
+  has_events = list()
+  page.on('frameattached', lambda frame: has_events.append(True))
+  page.on('framedetached', lambda frame: has_events.append(True))
+  await page.goto(server.EMPTY_PAGE)
+  assert has_events == []
+
+async def test_detach_child_frames_on_navigation(page, server):
+  attached_frames = []
+  detached_frames = []
+  navigated_frames = []
+  page.on('frameattached', lambda frame: attached_frames.append(frame))
+  page.on('framedetached', lambda frame: detached_frames.append(frame))
+  page.on('framenavigated', lambda frame: navigated_frames.append(frame))
+  await page.goto(server.PREFIX + '/frames/nested-frames.html')
+  assert len(attached_frames) == 4
+  assert len(detached_frames) == 0
+  assert len(navigated_frames) == 5
+
+  attached_frames = []
+  detached_frames = []
+  navigated_frames = []
+  await page.goto(server.EMPTY_PAGE)
+  assert len(attached_frames) == 0
+  assert len(detached_frames) == 4
+  assert len(navigated_frames) == 1
+
+async def test_framesets(page, server):
+  attached_frames = []
+  detached_frames = []
+  navigated_frames = []
+  page.on('frameattached', lambda frame: attached_frames.append(frame))
+  page.on('framedetached', lambda frame: detached_frames.append(frame))
+  page.on('framenavigated', lambda frame: navigated_frames.append(frame))
+  await page.goto(server.PREFIX + '/frames/frameset.html')
+  assert len(attached_frames) == 4
+  assert len(detached_frames) == 0
+  assert len(navigated_frames) == 5
+
+  attached_frames = []
+  detached_frames = []
+  navigated_frames = []
+  await page.goto(server.EMPTY_PAGE)
+  assert len(attached_frames) == 0
+  assert len(detached_frames) == 4
+  assert len(navigated_frames) == 1
+
+async def test_frame_from_inside_shadow_dom(page, server):
+  await page.goto(server.PREFIX + '/shadow.html')
+  await page.evaluate('''async url => {
+    frame = document.createElement('iframe');
+    frame.src = url;
+    document.body.shadowRoot.appendChild(frame);
+    await new Promise(x => frame.onload = x);
+  }''', server.EMPTY_PAGE)
+  assert len(page.frames) == 2
+  assert page.frames[1].url == server.EMPTY_PAGE
+
+async def test_frame_name(page, server, utils):
+  await utils.attach_frame(page, 'theFrameId', server.EMPTY_PAGE)
+  await page.evaluate('''url => {
+    frame = document.createElement('iframe');
+    frame.name = 'theFrameName';
+    frame.src = url;
+    document.body.appendChild(frame);
+    return new Promise(x => frame.onload = x);
+  }''', server.EMPTY_PAGE)
+  assert page.frames[0].name == ''
+  assert page.frames[1].name == 'theFrameId'
+  assert page.frames[2].name == 'theFrameName'
+
+async def test_frame_parent(page, server, utils):
+  await utils.attach_frame(page, 'frame1', server.EMPTY_PAGE)
+  await utils.attach_frame(page, 'frame2', server.EMPTY_PAGE)
+  assert page.frames[0].parentFrame == None
+  assert page.frames[1].parentFrame == page.mainFrame
+  assert page.frames[2].parentFrame == page.mainFrame
+
+async def test_should_report_different_frame_instance_when_frame_re_attaches(page, server, utils):
+  frame1 = await utils.attach_frame(page, 'frame1', server.EMPTY_PAGE)
+  await page.evaluate('''() => {
+    window.frame = document.querySelector('#frame1')
+    window.frame.remove()
+  }''')
+
+  assert frame1.isDetached()
+  [frame2, _] = await asyncio.gather(
+    page.waitForEvent('frameattached'),
+    page.evaluate('() => document.body.appendChild(window.frame)'),
+  )
+  assert frame2.isDetached() == False
+  assert frame1 != frame2

tests/utils.py

@@ -12,16 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import re
+from typing import List
+
+from playwright.frame import Frame
+from playwright.page import Page
+
 class Utils:
-  async def attach_frame(self, page, frameId, url):
-    handle = await page.evaluateHandle('''async ({ frameId, url }) => {
+  async def attach_frame(self, page: Page, frame_id: str, url: str):
+    handle = await page.evaluateHandle('''async ({ frame_id, url }) => {
       const frame = document.createElement('iframe');
       frame.src = url;
-      frame.id = frameId;
+      frame.id = frame_id;
       document.body.appendChild(frame);
       await new Promise(x => frame.onload = x);
       return frame;
-    }''', { 'frameId': frameId, 'url': url })
+    }''', { 'frame_id': frame_id, 'url': url })
     return await handle.asElement().contentFrame()
 
+  async def detach_frame(self, page: Page, frame_id: str):
+    await page.evaluate('frame_id => document.getElementById(frame_id).remove()', frame_id)
+
+  def dump_frames(self, frame: Frame, indentation: str = '') -> List[str]:
+    indentation = indentation or ''
+    description = re.sub(r':\d+/', ':<PORT>/', frame.url)
+    if frame.name:
+      description += ' (' + frame.name + ')'
+    result = [indentation + description]
+    sorted_frames = sorted(frame.childFrames, key=lambda frame: frame.url + frame.name)
+    for child in sorted_frames:
+      result = result + utils.dump_frames(child, '    ' + indentation)
+    return result
+
 utils = Utils()