Add tests for fullscreen mode and mouse lock mode.

chrome/test/functional/fullscreen_mouselock.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import logging
 import os
 import shutil
 
 import pyauto_functional  # Must be imported before pyauto
 import pyauto
 import test_utils
 from selenium.webdriver.common.keys import Keys
 
 
 class FullscreenMouselockTest(pyauto.PyUITest):
   """TestCase for Fullscreen and Mouse Lock."""
 
+  def setUp(self):
+    pyauto.PyUITest.setUp(self)
+    self._driver = self.NewWebDriver()
+
+  def Debug(self):
+    """Test method for experimentation.
+
+    This method will not run automatically.
+    """
+    driver = self.NewWebDriver()

[Nirnimesh, 2012/04/16 19:42:12]

why not use self._driver?

[dyu1, 2012/04/16 23:21:27]

Done.

+    page = settings.ContentSettingsPage.FromNavigation(driver)
+    import pdb
+    pdb.set_trace()
+
   def ExtraChromeFlags(self):
     """Ensures Chrome is launched with custom flags.
 
     Returns:
       A list of extra flags to pass to Chrome when it is launched.
     """
     # Extra flag needed by scroll performance tests.
     return super(FullscreenMouselockTest,
                  self).ExtraChromeFlags() + ['--enable-pointer-lock']
 
   def testFullScreenMouseLockHooks(self):
     """Verify fullscreen and mouse lock automation hooks work."""
-
-    from webdriver_pages import settings
-    from webdriver_pages.settings import Behaviors, ContentTypes
-    driver = self.NewWebDriver()
     self.NavigateToURL(self.GetHttpURLForDataPath(
         'fullscreen_mouselock', 'fullscreen_mouselock.html'))
 
     # Starting off we shouldn't be fullscreen
     self.assertFalse(self.IsFullscreenForBrowser())
     self.assertFalse(self.IsFullscreenForTab())
 
     # Go fullscreen
-    driver.find_element_by_id('enterFullscreen').click()
+    self._driver.find_element_by_id('enterFullscreen').click()
     self.assertTrue(self.WaitUntil(self.IsFullscreenForTab))
 
     # Bubble should be up prompting to allow fullscreen
     self.assertTrue(self.IsFullscreenBubbleDisplayed())
     self.assertTrue(self.IsFullscreenBubbleDisplayingButtons())
     self.assertTrue(self.IsFullscreenPermissionRequested())
 
     # Accept bubble, it should go away.
     self.AcceptCurrentFullscreenOrMouseLockRequest()
     self.assertTrue(self.WaitUntil(
         lambda: not self.IsFullscreenBubbleDisplayingButtons()))
 
     # Try to lock mouse, it won't lock yet but permision will be requested.
     self.assertFalse(self.IsMouseLocked())
-    driver.find_element_by_id('lockMouse1').click()
+    self._driver.find_element_by_id('lockMouse1').click()
     self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested))
     self.assertFalse(self.IsMouseLocked())
 
     # Deny mouse lock.
     self.DenyCurrentFullscreenOrMouseLockRequest()
     self.assertTrue(self.WaitUntil(
         lambda: not self.IsFullscreenBubbleDisplayingButtons()))
     self.assertFalse(self.IsMouseLocked())
 
     # Try mouse lock again, and accept it.
-    driver.find_element_by_id('lockMouse1').click()
+    self._driver.find_element_by_id('lockMouse1').click()
     self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested))
     self.AcceptCurrentFullscreenOrMouseLockRequest()
     self.assertTrue(self.WaitUntil(self.IsMouseLocked))
 
     # The following doesn't work - as sending the key to the input field isn't
     # picked up by the browser. :( Need an alternative way.
     #
     # # Ideally we wouldn't target a specific element, we'd just send keys to
     # # whatever the current keyboard focus was.
     # keys_target = driver.find_element_by_id('sendKeysTarget')
     #
     # # ESC key should exit fullscreen and mouse lock.
     #
     # print "# ESC key should exit fullscreen and mouse lock."
     # keys_target.send_keys(Keys.ESCAPE)
     # self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForBrowser()))
     # self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab()))
     # self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked()))
     #
     # # Check we can go browser fullscreen
     # print "# Check we can go browser fullscreen"
     # keys_target.send_keys(Keys.F11)
     # self.assertTrue(self.WaitUntil(self.IsFullscreenForBrowser))
 
+  def LaunchFullscreenMode(self):

[scheib, 2012/04/16 21:37:48]

Consider naming this so it's clear that it doesn't accept the fullscreen
transition. E.g. LaunchFullscreenAndExpectPrompt. Ok, that name is too long, but
it's confusing when used in tests below and then actions are taken to accept the
dialog.

[dyu1, 2012/04/16 23:21:27]

Done.

+    """Helper function to launch into Fullscreen mode."""
+    self.NavigateToURL(self.GetHttpURLForDataPath(
+        'fullscreen_mouselock', 'fullscreen_mouselock.html'))
+    # Should not be in fullscreen mode during initial launch.
+    self.assertFalse(self.IsFullscreenForBrowser())
+    self.assertFalse(self.IsFullscreenForTab())
+    # Go into fullscreen mode.
+    self._driver.find_element_by_id('enterFullscreen').click()
+    self.assertTrue(self.WaitUntil(self.IsFullscreenForTab))
+    # Bubble should display prompting to allow fullscreen.
+    self.assertTrue(self.IsFullscreenBubbleDisplayed())

[scheib, 2012/04/16 21:37:48]

FYI: Above these lines are duplicated when testing the automation hooks. In
production test code you should only need one of the asserts:
IsFullscreenBubbleDisplayed OR IsFullscreenBubbleDisplayingButtons OR
IsFullscreenPermissionRequested.

This code could easily get away with only IsFullscreenPermissionRequested. But
since it's not duplicated all over it won't do any harm.

[dyu1, 2012/04/16 23:21:27]

There could be a chance for additional duplicates so I kept
IsFullscreenPermissionRequested.

On 2012/04/16 21:37:48, scheib wrote:

+    self.assertTrue(self.IsFullscreenBubbleDisplayingButtons())
+    self.assertTrue(self.IsFullscreenPermissionRequested())
+
+  def _AcceptFullscreenOrMouseLockRequest(self):
+    """Helper function to accept Fullscreen or Mouse Lock request."""
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    self.assertTrue(self.WaitUntil(
+        lambda: not self.IsFullscreenBubbleDisplayingButtons()))
+
+  def EnableFullscreenAndMouseLockMode(self):
+    """Helper function to enable fullscreen and mouse lock mode."""
+    self.NavigateToURL(self.GetHttpURLForDataPath(
+        'fullscreen_mouselock', 'fullscreen_mouselock.html'))
+    self._driver.find_element_by_id('enterFullscreenAndLockMouse1').click()
+    self.assertTrue(self.WaitUntil(self.IsFullscreenForTab))

[Nirnimesh, 2012/04/16 19:42:12]

why not call LaunchFullscreenMode() instead of 127-130? The button to click
could be an arg

[dyu1, 2012/04/16 23:21:27]

Done.

+    # Allow fullscreen.
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested))

[scheib, 2012/04/16 21:37:48]

Please add a comment noting that this wait shouldn't be needed. It is there only
because of http://code.google.com/p/chromium/issues/detail?id=123396. One should
be able to click the "fullscreen & mouselock" button on that page, Then accept
both in a single action.

[dyu1, 2012/04/16 23:21:27]

Done.

+    # Allow mouse lock.
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    self.assertTrue(self.WaitUntil(self.IsMouseLocked))
+
+  def EnableMouseLockMode(self):

[Nirnimesh, 2012/04/16 19:42:12]

_ prefix?

[dyu1, 2012/04/16 23:21:27]

I didn't make this private since later on you'll be able to mouse lock without
depending on fullscreen.

On 2012/04/16 19:42:12, Nirnimesh wrote:

+    """Helper function to enable mouse lock mode."""

[Nirnimesh, 2012/04/16 19:42:12]

Declare the expectations. That the fullscreen_mouselock.html page should be
open, etc etc

[dyu1, 2012/04/16 23:21:27]

Done.

+    self._driver.find_element_by_id('lockMouse1').click()
+    self.assertTrue(self.IsMouseLockPermissionRequested())
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    self.assertTrue(self.IsMouseLocked())
+
+  def testPrefsLineEntryForFullscreenAllowed(self):
+    """Verify line entry when fullscreen is allowed."""
+    self.LaunchFullscreenMode()
+    self._AcceptFullscreenOrMouseLockRequest()
+    # Get the hostname pattern (e.g. http://127.0.0.1:57622).
+    hostname_pattern = (
+        '/'.join(self.GetHttpURLForDataPath('').split('/')[0:3]) + ',*')

[Nirnimesh, 2012/04/16 19:42:12]

this is incomprehensible. Don't split. Just remove '/files/' from the end.
hostname_pattern = re.sub('/files/$', '', self.GetHttpURLForDataPath(''))

ALso, it would be better to compute it in setUp() if you're going to use it in
several tests.

[dyu1, 2012/04/16 23:21:27]

Done and moved to setUp()

On 2012/04/16 19:42:12, Nirnimesh wrote:

+    content_settings = (
+        self.GetPrefsInfo().Prefs()['profile']['content_settings'])
+    self.assertEqual(
+        {hostname_pattern: {'fullscreen': 1}},  # Allow the hostname.
+        content_settings['pattern_pairs'])
+
+  def testPrefsLineEntryForFullscreenExit(self):
+    """Verify line entry is empty when exit fullscreen mode before allowing."""
+    self.LaunchFullscreenMode()
+    self._driver.find_element_by_id('exitFullscreen').click()
+    # Verify exit from fullscreen mode.
+    self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab()))
+    content_settings = (
+        self.GetPrefsInfo().Prefs()['profile']['content_settings'])
+    self.assertEqual({}, content_settings['pattern_pairs'])
+
+  def testPatternsForAllowFullscreenAndPointerLock(self):

[Nirnimesh, 2012/04/16 19:42:12]

the test names are getting too big. Makes it difficult to disable tests in
PYAUTO_TESTS (because of the 80 chars per line limit). Make it smaller:
testPatternsFS() is fine.

[dyu1, 2012/04/16 23:21:27]

Done.

+    """Verify hostname pattern and behavior for allowed pointer lock.
+
+    To lock the mouse, the browser needs to be in fullscreen mode.
+    """
+    self.EnableFullscreenAndMouseLockMode()
+    self.EnableMouseLockMode()
+    hostname_pattern = (
+        '/'.join(self.GetHttpURLForDataPath('').split('/')[0:3]) + ',*')
+    expected_pattern = (
+        {hostname_pattern: {'fullscreen': 1, 'mouselock': 1}})
+    content_settings = (
+        self.GetPrefsInfo().Prefs()['profile']['content_settings'])
+    self.assertEqual(expected_pattern, content_settings['pattern_pairs'])
+
+  def testPatternsForAllowMouseLock(self):
+    """Verify hostname pattern and behavior for allowed mouse lock.
+
+    Enable fullscreen mode and enable mouse lock separately.
+    """
+    self.LaunchFullscreenMode()
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    self.EnableMouseLockMode()
+    hostname_pattern = (
+        '/'.join(self.GetHttpURLForDataPath('').split('/')[0:3]) + ',*')
+    expected_pattern = (
+        {hostname_pattern: {'fullscreen': 1, 'mouselock': 1}})
+    content_settings = (
+        self.GetPrefsInfo().Prefs()['profile']['content_settings'])
+    self.assertEqual(expected_pattern, content_settings['pattern_pairs'])
+
+  def testNoMouseLockRequest(self):
+    """Verify mouse lock request does not appear.
+
+    When allowing all sites to disable the mouse cursor, the mouse lock request
+    bubble should not show. The mouse cursor should be automatically disabled
+    when clicking on a disable mouse button.
+    """
+    # Allow all sites to disable mouse cursor.
+    self.SetPrefs(pyauto.kDefaultContentSettings, {u'mouselock': 1})
+    self.LaunchFullscreenMode()
+    # Allow for fullscreen mode.
+    self._AcceptFullscreenOrMouseLockRequest()
+    self._driver.find_element_by_id('lockMouse1').click()
+    self.assertTrue(self.WaitUntil(
+        lambda: not self.IsMouseLockPermissionRequested()))
+    self.assertTrue(self.IsMouseLocked())
+
+  def testUnableToLockMouse(self):
+    """Verify mouse lock is disabled.
+
+    When not allowing any site to disable the mouse cursor, the mouse lock
+    request bubble should not show and the mouse cursor should not be disabled.
+    """
+    # Do not allow any site to disable mouse cursor.
+    self.SetPrefs(pyauto.kDefaultContentSettings, {u'mouselock': 2})
+    self.LaunchFullscreenMode()
+    # Allow for fullscreen mode.
+    self._AcceptFullscreenOrMouseLockRequest()
+    self._driver.find_element_by_id('lockMouse1').click()
+    self.assertTrue(self.WaitUntil(
+        lambda: not self.IsMouseLockPermissionRequested()))

[scheib, 2012/04/16 21:37:48]

I'm concerned that there is a race condition here. Mouse lock permission will be
be requested before we make the request, so it's likely to stay in that state
even after a click event. We must wait for some other signal that the click has
registered and that mouse lock state has changed. This is possible, but we must
modify the HTML to do it. Callbacks are specified in the mouse lock API, and you
can see that test page logs out success or failure of mouse lock transitions. I
recommend changing this test and testNoMouseLockRequest to wait for the
JavaScript response before checking on the PermissionRequested state.

[dyu1, 2012/04/16 23:21:27]

If the js callback is successful then check the two asserts and if it callback
fails then assert an error?

On 2012/04/16 21:37:48, scheib wrote:

[scheib, 2012/04/16 23:55:42]

If you can get your python test code to wait for some notification from JS, then
I would recommend having the pointer lock callbacks (both success and failure)
simply notify the test to continue. Then have the test assert that mouse lock
and permissions are true or false as appropriate (this test and the test above
expect different states).

[dyu1, 2012/04/23 18:50:26]

Done.

+    self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked()))
+
+  def SearchForTextOutsideOfContainer(self):
+    """Verify text outside of container is not visible when fullscreen.
+
+    Verify this test manually until there is a way to find text on screen
+    without using FindInPage().
+
+    The text that is outside of the fullscreen container should only be visible
+    when fullscreen is off. The text should not be visible while in fullscreen
+    mode.
+    """
+    self.NavigateToURL(self.GetHttpURLForDataPath(
+        'fullscreen_mouselock', 'fullscreen_mouselock.html'))
+    # Should not be in fullscreen mode during initial launch.
+    self.assertFalse(self.IsFullscreenForBrowser())
+    self.assertFalse(self.IsFullscreenForTab())
+    self.assertTrue(
+        self.WaitUntil(lambda: self.FindInPage(
+            'This text is outside of the container')['match_count'],
+                       expect_retval=1))
+    # Go into fullscreen mode.
+    self._driver.find_element_by_id('enterFullscreen').click()
+    self.assertTrue(self.WaitUntil(self.IsFullscreenForTab))
+    # TODO(dyu): find a way to verify on screen text instead of using
+    #            FindInPage() which searches for text in the HTML.
+
 
 if __name__ == '__main__':
   pyauto_functional.Main()