Allow webdriver users to choose between sending the key events when...

chrome/test/webdriver/chromedriver_tests.py

 #!/usr/bin/python
 
 # Copyright (c) 2011 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.
 
 """Tests for ChromeDriver.
 
 If your test is testing a specific part of the WebDriver API, consider adding
 it to the appropriate place in the WebDriver tree instead.
 """
 
 import platform
 import os
 import sys
 import unittest
 import urllib2
 import urlparse
 
 from chromedriver_launcher import ChromeDriverLauncher
 import chromedriver_paths
 from gtest_text_test_runner import GTestTextTestRunner
 
 sys.path += [chromedriver_paths.SRC_THIRD_PARTY]
 sys.path += [chromedriver_paths.PYTHON_BINDINGS]
 
 import simplejson as json
 
 from selenium.webdriver.remote.webdriver import WebDriver
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
 
 
 class Request(urllib2.Request):
   """Extends urllib2.Request to support all HTTP request types."""
 
   def __init__(self, url, method=None, data=None):
     """Initialise a new HTTP request.
 
     Arguments:
       url: The full URL to send the request to.
@@ skipping 62 matching lines @@
 
   def testShouldGetA404WhenAttemptingToDeleteAnUnknownSession(self):
     request_url = self._launcher.GetURL() + '/session/unkown_session_id'
     try:
       SendRequest(request_url, method='DELETE')
       self.fail('Should have raised a urllib.HTTPError for returned 404')
     except urllib2.HTTPError, expected:
       self.assertEquals(404, expected.code)
 
   def testCanStartChromeDriverOnSpecificPort(self):
-    launcher = ChromeDriverLauncher(port=9520)
+    self.launcher = ChromeDriverLauncher(port=9520)
     self.assertEquals(9520, launcher.GetPort())
-    driver = WebDriver(launcher.GetURL(), 'chrome', 'any')
+    driver = WebDriver(launcher.GetURL(), {})
     driver.quit()
     launcher.Kill()
 
 
+class NativeInputTest(unittest.TestCase):
+  """Native input ChromeDriver tests."""
+
+  SEARCH = "http://www.google.com/webhp?hl=en"
+
+  def setUp(self):
+    self._launcher = ChromeDriverLauncher()
+    self.capabilities = DesiredCapabilities.CHROME
+    self.capabilities["chrome"] = { "nativeEvents" : True }
+
+  def tearDown(self):
+    self._launcher.Kill()
+
+  def testCanStartsWithNativeEvents(self):
+    driver = WebDriver(self._launcher.GetURL(), self.capabilities)
+    self.assertTrue(driver.capabilities["chrome"].has_key("nativeEvents"))
+    self.assertTrue(driver.capabilities["chrome"]["nativeEvents"])
+
+  def testSendKeysNative(self):
+    driver = WebDriver(self._launcher.GetURL(), self.capabilities)
+    driver.get(self.SEARCH)
+    # Find the Google search Button.
+    q = driver.find_element_by_name("q")
+    # Send some keys.
+    q.send_keys("tokyo")
+    self.assertEqual(q.value, "tokyo")
+
+  #TODO(timothe): run this test on a machine with an IME enabled.

[kkania, 2011/03/11 16:32:13]

how are you planning on doing this? you can just disable the test instead of
commenting it.

[timothe, 2011/03/21 18:02:05]

@unittest.skip only works for python 2.7+, is it okay to use it?

+  #def testSendKeysNativeProcessedByIME(self):
+    #driver = WebDriver(self._launcher.GetURL(), self.capabilities)
+    #driver.get(self.SEARCH)
+    #q = driver.find_element_by_name("q")
+    # Send key combination to turn IME on.
+    #q.send_keys(Keys.F7)
+    #q.send_keys("toukyou")
+    #self.assertEqual(q.value, "\xe6\x9d\xb1\xe4\xba\xac")
+
+
 class CookieTest(unittest.TestCase):
   """Cookie test for the json webdriver protocol"""
 
   SEARCH = "http://www.google.com/webhp?hl=en"
 
   def setUp(self):
     self._launcher = ChromeDriverLauncher()
-    self._driver = WebDriver(self._launcher.GetURL(), 'chrome', 'any')
+    self._driver = WebDriver(self._launcher.GetURL(), {})
 
   def tearDown(self):
     self._driver.quit()
     self._launcher.Kill()
 
   def testAddCookie(self):
     self._driver.get(self.SEARCH)
     cookie_dict = None
     cookie_dict = self._driver.get_cookie("chromedriver_cookie_test")
     cookie_dict = {}
@@ skipping 30 matching lines @@
     self.assertTrue(isinstance(data, dict))
     self.assertEquals(0, data['status'])
 
     url_parts = urlparse.urlparse(self.session_url)[2].split('/')
     self.assertEquals(3, len(url_parts))
     self.assertEquals('', url_parts[0])
     self.assertEquals('session', url_parts[1])
     self.assertEquals(data['sessionId'], url_parts[2])
 
   def testShouldBeGivenCapabilitiesWhenStartingASession(self):
-    driver = WebDriver(self._launcher.GetURL(), 'chrome', 'any')
+    driver = WebDriver(self._launcher.GetURL(), {})
     capabilities = driver.capabilities
 
     self.assertEquals('chrome', capabilities['browserName'])
     self.assertTrue(capabilities['javascriptEnabled'])
 
     # Value depends on what version the server is starting.
     self.assertTrue('version' in capabilities)
     self.assertTrue(
         isinstance(capabilities['version'], unicode),
         'Expected a %s, but was %s' % (unicode,
                                        type(capabilities['version'])))
 
     system = platform.system()
     if system == 'Linux':
       self.assertEquals('linux', capabilities['platform'].lower())
     elif system == 'Windows':
       self.assertEquals('windows', capabilities['platform'].lower())
     elif system == 'Darwin':
       self.assertEquals('mac', capabilities['platform'].lower())
     else:
       # No python on ChromeOS, so we won't have a platform value, but
       # the server will know and return the value accordingly.
       self.assertEquals('chromeos', capabilities['platform'].lower())
     driver.quit()
 
   def testSessionCreationDeletion(self):
-    driver = WebDriver(self._launcher.GetURL(), 'chrome', 'any')
+    driver = WebDriver(self._launcher.GetURL(), {})
     driver.quit()
 
   def testMultipleSessionCreationDeletion(self):
     for i in range(10):
-      driver = WebDriver(self._launcher.GetURL(), 'chrome', 'any')
+      driver = WebDriver(self._launcher.GetURL(), {})
       driver.quit()
 
   def testSessionCommandsAfterSessionDeletionReturn404(self):
-    driver = WebDriver(self._launcher.GetURL(), 'chrome', 'any')
+    driver = WebDriver(self._launcher.GetURL(), {})
     session_id = driver.session_id
     driver.quit()
     try:
       response = SendRequest(self._launcher.GetURL() + '/session/' + session_id,
                              method='GET')
       self.fail('Should have thrown 404 exception')
     except urllib2.HTTPError, expected:
       self.assertEquals(404, expected.code)
 
   def testMultipleConcurrentSessions(self):
     drivers = []
     for i in range(10):
-      drivers += [WebDriver(self._launcher.GetURL(), 'chrome', 'any')]
+      drivers += [WebDriver(self._launcher.GetURL(), {})]
     for driver in drivers:
       driver.quit()
 
 
 class MouseTest(unittest.TestCase):
   """Mouse command tests for the json webdriver protocol"""
 
   def setUp(self):
     self._launcher = ChromeDriverLauncher(root_path=os.path.dirname(__file__))
-    self._driver = WebDriver(self._launcher.GetURL(), 'chrome', 'any')
+    self._driver = WebDriver(self._launcher.GetURL(), {})
 
   def tearDown(self):
     self._driver.quit()
     self._launcher.Kill()
 
   def testClickElementThatNeedsScrolling(self):
     self._driver.get(self._launcher.GetURL() + '/test_page.html')
     self._driver.find_element_by_name('hidden_scroll').click()
     self.assertTrue(self._driver.execute_script('return window.success'))
 
@@ skipping 28 matching lines @@
     self.assertEquals('', url_parts[0])
     self.assertEquals('wd', url_parts[1])
     self.assertEquals('hub', url_parts[2])
     self.assertEquals('session', url_parts[3])
     self.assertEquals(data['sessionId'], url_parts[4])
 
 
 if __name__ == '__main__':
   unittest.main(module='chromedriver_tests',
                 testRunner=GTestTextTestRunner(verbosity=1))