Add remote webdriver support

This allows us to take advantage of SauceLabs as well as docker-selenium,
among other things. Exciting stuff!

Author: Brandon Duffany

codebender_testing/config.py

@@ -1,7 +1,7 @@
 import os
 
 from selenium import webdriver
-
+from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
 
 def _rel_path(*args):
     """Forms a path relative to this file's directory."""
@@ -55,18 +55,55 @@ def _get_firefox_profile():
     )
     return firefox_profile
 
-# Webdrivers to be used for testing. Specifying additional webdrivers here
-# will cause every test to be re-run using that webdriver.
-# These webdrivers are specified as lambdas to allow for "lazy" evaluation.
-# The lambda invocation will return the actual webdriver and open up a
-# browser window, and we don't want a browser window to open whenever this
-# module is imported (hence the need for lazy evaluation).
-WEBDRIVERS = {
-    "firefox": lambda: webdriver.Firefox(firefox_profile=_get_firefox_profile()),
-    # "chrome": lambda: webdriver.Chrome()
-}
 
-# Credentials to use when logging into the site via selenium
+def _get_chrome_profile():
+    # TODO
+    return None
+
+
+def get_browsers(config_path=None):
+    """Returns a list of capabilities. Each item in the list will cause
+    the entire suite of tests to be re-run for a browser with those
+    particular capabilities."""
+    # TODO: read from browsers.yaml, and allow specifying custom config file.
+    return [
+        {
+            "browserName": "firefox", # OK with other defaults for now.
+        }
+    ]
+
+
+def create_webdriver(command_executor, desired_capabilities):
+    """Creates a new remote webdriver with the following properties:
+      - The remote URL of the webdriver is defined by `command_executor`.
+      - desired_capabilities is a dict with the same interpretation as
+        it is used elsewhere in selenium. If no browserName key is present,
+        we default to firefox.
+    """
+    if 'browserName' not in desired_capabilities:
+        desired_capabilities['browserName'] = 'firefox'
+    browser_name = desired_capabilities['browserName']
+    # Fill in defaults from DesiredCapabilities.{CHROME,FIREFOX} if they are
+    # missing from the desired_capabilities dict above.
+    _capabilities = desired_capabilities
+    if browser_name == "chrome":
+        desired_capabilities = DesiredCapabilities.CHROME.copy()
+        desired_capabilities.update(_capabilities)
+        browser_profile = _get_chrome_profile()
+    elif browser_name == "firefox":
+        desired_capabilities = DesiredCapabilities.FIREFOX.copy()
+        desired_capabilities.update(_capabilities)
+        browser_profile = _get_firefox_profile()
+    else:
+        raise ValueError("Invalid webdriver %s (only chrome and firefox are supported)" % browser_name)
+    return webdriver.Remote(
+        command_executor=command_executor,
+        desired_capabilities=desired_capabilities,
+        browser_profile=browser_profile,
+    )
+
+
+# Credentials to use when logging into the bachelor site
 TEST_CREDENTIALS = {
     "username": "tester",
     "password": "testerPASS"
@@ -75,4 +112,4 @@ def _get_firefox_profile():
 TEST_PROJECT_NAME = "test_project"
 
 # How long we wait until giving up on trying to locate an element
-ELEMENT_FIND_TIMEOUT = 5
+ELEMENT_FIND_TIMEOUT = 10

codebender_testing/utils.py

@@ -20,7 +20,6 @@
 from codebender_testing.config import ELEMENT_FIND_TIMEOUT
 from codebender_testing.config import TEST_CREDENTIALS
 from codebender_testing.config import TEST_PROJECT_NAME
-from codebender_testing.config import WEBDRIVERS
 
 
 # Time to wait until we give up on a DOM property becoming available.
@@ -92,16 +91,13 @@ class CodebenderSeleniumBot(object):
     # It is set via command line option in _testcase_attrs (below)
     site_url = None
 
-    def start(url=None, webdriver=None):
-        """Create the selenium webdriver, operating on `url`. We can't do this
-        in an __init__ method, otherwise py.test complains about
-        SeleniumTestCase having an init method.
-        The webdriver that is created is specified as a key into the WEBDRIVERS
-        dict (in codebender_testing.config)
+    def init(self, url=None, webdriver=None):
+        """Create a bot with the given selenium webdriver, operating on `url`.
+        We can't do this in an __init__ method, otherwise py.test complains,
+        presumably because it does something special with __init__ for test
+        cases.
         """
-        if webdriver is None:
-            webdriver = WEBDRIVERS.keys()[0]
-        self.driver = WEBDRIVERS[webdriver]()
+        self.driver = webdriver
 
         if url is None:
             url = BASE_URL
@@ -186,17 +182,22 @@ def upload_project(self, test_fname, project_name=None):
 
         return last_project.text, last_project.get_attribute('href')
 
-    def login(self):
-        """Performs a login."""
+    def login(self, credentials=None):
+        """Performs a login. Note that the current URL may change to an
+        unspecified location when calling this function.
+        `credentials` should be a dict with keys 'username' and 'password',
+        mapped to the appropriate values."""
+        if credentials is None:
+            credentials = TEST_CREDENTIALS
         try:
             self.open()
             login_button = self.driver.find_element_by_id('login_btn')
             login_button.send_keys(Keys.ENTER)
             # Enter credentials and log in
             user_field = self.driver.find_element_by_id('username')
-            user_field.send_keys(TEST_CREDENTIALS['username'])
+            user_field.send_keys(credentials['username'])
             pass_field = self.driver.find_element_by_id('password')
-            pass_field.send_keys(TEST_CREDENTIALS['password'])
+            pass_field.send_keys(credentials['password'])
             do_login = self.driver.find_element_by_id('_submit')
             do_login.send_keys(Keys.ENTER)
         except NoSuchElementException:
@@ -346,11 +347,15 @@ def _testcase_attrs(cls, webdriver, testing_url, testing_full):
         cls.run_full_compile_tests = testing_full
 
     @pytest.fixture(scope="class")
-    def tester_login(self):
-        self.login()
+    def tester_login(self, testing_credentials):
+        """A fixture to perform a login with the credentials provided by the
+        `testing_credentials` fixture.
+        """
+        self.login(credentials=testing_credentials)
 
     @pytest.fixture(scope="class")
     def tester_logout(self):
+        """A fixture to guarantee that we are logged out before running a test."""
         self.logout()
 
 

tests/conftest.py

@@ -6,49 +6,91 @@
 This is also where command-line arguments and pytest markers are defined.
 """
 
+import os
+import sys
+
 import pytest
 
 from codebender_testing import config
 
 
-@pytest.fixture(scope="session", params=config.WEBDRIVERS.keys())
-def webdriver(request):
-    """Returns a webdriver that persists across the entire test session,
-    and registers a finalizer to close the browser once the session is
-    complete. The entire test session is repeated once per driver.
-    """
-    driver = config.WEBDRIVERS[request.param]()
-    request.addfinalizer(lambda: driver.quit())
-    return driver
-
 def pytest_addoption(parser):
-    """Adds command line options to py.test."""
+    """Adds command line options to the testing suite."""
+
     parser.addoption("--url", action="store", default=config.BASE_URL,
                      help="URL to use for testing, e.g. http://localhost, http://codebender.cc")
+
     parser.addoption("--full", action="store_true", default=False,
-                     help="Whether to run the complete set of compile tests.")
+                     help="Run the complete set of compile tests (a minimal set of tests is run by default).")
 
     parser.addoption("--source", action="store", default=config.SOURCE_BACHELOR,
                      help="Indicate the source used to generate the repo. "
                           "By default, we assume `bachelor`.")
 
+
+@pytest.fixture(scope="session", params=config.get_browsers())
+def webdriver(request):
+    """Returns a webdriver that persists across the entire test session,
+    and registers a finalizer to close the browser once the session is
+    complete. The entire test session is repeated once per driver.
+    """
+
+    # TODO: maybe have a different way of specifying this (?)
+    command_executor = os.environ['CODEBENDER_SELENIUM_HUB_URL']
+    desired_capabilities = request.param
+
+    driver = config.create_webdriver(command_executor, desired_capabilities)
+
+    # TODO: update sauce status via SauceClient, but only if the command_executor
+    # is a sauce URL.
+    def finalizer():
+        # print("Link to your job: https://saucelabs.com/jobs/%s" % driver.session_id)
+        try:
+            pass
+            # TODO:
+            # if sys.exc_info() == (None, None, None):
+            #     sauce.jobs.update_job(driver.session_id, passed=True)
+            # else:
+            #     sauce.jobs.update_job(driver.session_id, passed=False)
+        finally:
+            driver.quit()
+
+    request.addfinalizer(finalizer)
+    return driver
+
+
 @pytest.fixture(scope="class")
 def testing_url(request):
     """A fixture to get the --url parameter."""
     return request.config.getoption("--url")
 
+
 @pytest.fixture(scope="class")
 def source(request):
     """A fixture to specify the source repository from which the site was
     derived (e.g. bachelor or codebender_cc)
     """
     return request.config.getoption("--source")
 
+
+@pytest.fixture(scope="class")
+def testing_credentials(request):
+    """A fixture to get testing credentials specified via the environment
+    variables CODEBENDER_TEST_USER and CODEBENDER_TEST_PASS. Defaults to the
+    credentials specified in config.TEST_CREDENTIALS.
+    """
+    return {
+        'username': os.environ.get('CODEBENDER_TEST_USER', config.TEST_CREDENTIALS['username']),
+        'password': os.environ.get('CODEBENDER_TEST_PASS', config.TEST_CREDENTIALS['password']),
+    }
+
+
 @pytest.fixture(scope="class")
 def testing_full(request):
     """A fixture to get the --full parameter."""
     return request.config.getoption("--full")
 
+
 @pytest.fixture(autouse=True)
 def requires_source(request, source):
     """Skips tests that require a certain source version (e.g. bachelor or
@@ -67,6 +109,7 @@ def test_some_feature():
         if required_source != source:
             pytest.skip('skipped test that requires --source=' + source)
 
+
 @pytest.fixture(autouse=True)
 def requires_url(request, testing_url):
     """Skips tests that require a certain site URL in order to run properly.

tests/sketch/test_sketch.py

@@ -1,8 +1,6 @@
 import time
 
-from selenium.common.exceptions import StaleElementReferenceException
 from selenium.webdriver.common.by import By
-from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.support import expected_conditions
 from selenium.webdriver.support.select import Select
 from selenium.webdriver.support.ui import WebDriverWait
@@ -81,7 +79,6 @@ def test_serial_monitor_disables_fields(self):
         ports_field = self.get_element(By.ID, 'ports_placeholder')
         assert ports_field.get_attribute('disabled') == 'true'
 
-
     def test_clone_project(self):
         """Tests that clicking the 'Clone Project' link brings us to a new
         sketch with the title 'test_project clone'."""