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 re
 import shutil
 
 import pyauto_functional  # Must be imported before pyauto
 import pyauto
 import test_utils
 from selenium.webdriver.common.keys import Keys
+from webdriver_pages import settings
 
 
 class FullscreenMouselockTest(pyauto.PyUITest):
   """TestCase for Fullscreen and Mouse Lock."""
 
+  def setUp(self):
+    pyauto.PyUITest.setUp(self)
+    self._driver = self.NewWebDriver()
+    # Get the hostname pattern (e.g. http://127.0.0.1:57622).
+    self._hostname_pattern = (
+        re.sub('/files/$', '', self.GetHttpURLForDataPath('')))
+
+  def Debug(self):
+    """Test method for experimentation.
+
+    This method will not run automatically.
+    """
+    self._driver = self.NewWebDriver()
+    page = settings.ContentSettingsPage.FromNavigation(self._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 LaunchFSAndExpectPrompt(self, buttonAction='enterFullscreen'):

[dennis_jeffrey, 2012/04/17 17:57:14]

prefix function name with underscore if meant to be used internally to this
class

[dennis_jeffrey, 2012/04/17 17:57:14]

button_action, here and everywhere else in this file

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

Done.

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

Done.

+    """Helper function to launch fullscreen and expect a prompt.
+
+    Fullscreen is initiated and a bubble prompt appears asking to allow or
+    cancel from fullscreen mode. The actual fullscreen mode doesn't take place
+    until after approving the prompt.

[dennis_jeffrey, 2012/04/17 17:57:14]

(optional) maybe we should say that this helper will fail the current test if
it's not successful

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

Done.

+
+    Args:
+      buttonAction: The button id to click to initiate an action. Default is to
+      click enterFullscreen.

[dennis_jeffrey, 2012/04/17 17:57:14]

indent by 4 more spaces

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

Done.

+    """
+    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(buttonAction).click()
+    self.assertTrue(self.WaitUntil(self.IsFullscreenForTab))
+    # Bubble should display prompting to allow fullscreen.
+    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."""

[dennis_jeffrey, 2012/04/17 17:57:14]

nit: try to be consistent with capitalization of "Fullscreen" and "Mouse Lock"
when talking about those modes.  For example, it's capitalized in line 132
above, but not in the current line

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

Done.

+    self.LaunchFSAndExpectPrompt('enterFullscreenAndLockMouse1')

[dennis_jeffrey, 2012/04/17 17:57:14]

button_action=

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

Done

On 2012/04/17 17:57:14, dennis_jeffrey wrote:

+    # Allow fullscreen.
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    # The wait is needed due to crbug.com/123396. Should be able to click the
+    # fullscreen and mouselock button and be both accepted in a single action.
+    self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested))
+    # Allow mouse lock.
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    self.assertTrue(self.WaitUntil(self.IsMouseLocked))
+
+  def EnableMouseLockMode(self, buttonAction='lockMouse1'):
+    """Helper function to enable mouse lock mode.
+
+    For now, to lock the mouse, the browser needs to be in fullscreen mode.
+
+    Args:
+      buttonAction: The button id to click to initiate an action. Default is to
+      click lockMouse1.
+    """
+    self._driver.find_element_by_id(buttonAction).click()
+    self.assertTrue(self.IsMouseLockPermissionRequested())
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    self.assertTrue(self.IsMouseLocked())
+
+  def testPrefsLineEntryForFullscreenAllowed(self):
+    """Verify line entry when fullscreen is allowed."""
+    self.LaunchFSAndExpectPrompt()
+    self._AcceptFullscreenOrMouseLockRequest()
+    content_settings = (
+        self.GetPrefsInfo().Prefs()['profile']['content_settings'])
+    self.assertEqual(
+        {self._hostname_pattern + ',*': {'fullscreen': 1}},  # Allow hostname.
+        content_settings['pattern_pairs'])

[dennis_jeffrey, 2012/04/17 17:57:14]

nit: should we have a msg='' argument to provide an explanation in case the
assertion fails?  If so, you may want to consider doing the same for the other
assertions added to this CL (wherever you think it makes sense and would be
helpful)

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

I added it although the assertion error shows that the hostname does not match
when the test fails.

On 2012/04/17 17:57:14, dennis_jeffrey wrote:

+
+  def testPrefsLineEntryForFullscreenExit(self):
+    """Verify line entry is empty when exit fullscreen mode before allowing."""
+    self.LaunchFSAndExpectPrompt()
+    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 testPatternsForFSAndML(self):

[dennis_jeffrey, 2012/04/17 17:57:14]

there's some inconsistency in function names added to this CL.  Sometimes, you
abbreviate "Fullscreen" as "FS" and "MouseLock" as "ML".  For clarity, maybe we
should avoid abbreviations entirely, unless the function names are getting way
too long.  In this case, I don't think the function name would be too long if we
didn't abbreviate.

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

This test is disabled in PYAUTO_TESTS. The name is fully spelled out is too long
in that file. See Nirnimesh's original comments about 80 chars limit.

On 2012/04/17 17:57:14, dennis_jeffrey wrote:

+    """Verify hostname pattern and behavior for allowed mouse cursor lock.
+
+    To lock the mouse, the browser needs to be in fullscreen mode.
+    """
+    self.EnableFullscreenAndMouseLockMode()
+    self.EnableMouseLockMode()
+    expected_pattern = (
+        {self._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 cursor lock.
+
+    Enable fullscreen mode and enable mouse lock separately.
+    """
+    self.LaunchFSAndExpectPrompt()
+    self.AcceptCurrentFullscreenOrMouseLockRequest()
+    self.EnableMouseLockMode()
+    expected_pattern = (
+        {self._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.LaunchFSAndExpectPrompt()
+    # 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())

[dennis_jeffrey, 2012/04/17 17:57:14]

Perhaps the () are unnecessary, (e.g., see line 147 above).  Similar comment at
line 224 above

[dennis_jeffrey, 2012/04/17 19:12:07]

Sorry, please ignore this comment.  The parens are needed here because we're
calling assertTrue, which expects a "regular value" input argument, not a
callable.  So we actually want to invoke the function argument before
assertTrue() is invoked.

In contrast, line 147 above is calling WaitUntil, which expects a callable input
argument - so we should not have parens there (otherwise, the expression would
evaluate to the result of the function call, rather than to the function
itself).

+
+  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.LaunchFSAndExpectPrompt()
+    # 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.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()