示例#1
0
 def __init__(self,
              driver_type='chrome',
              capabilities=None,
              pasta_user=None,
              wait_time=DEFAULT_WAIT_TIME,
              remote_driver='',
              existing_driver=None,
              **kwargs):
     """Class constructor."""
     if driver_type == 'saucelabs' and pasta_user is None:
         raise TypeError('A Sauce Labs user is required for remote testing')
     self.pasta = pasta_user
     self.remote_driver = remote_driver
     if existing_driver:
         self.driver = existing_driver
     else:
         driver = driver_type if not pasta_user else 'saucelabs'
         self.driver = self.run_on(driver_type=driver,
                                   pasta_user=self.pasta,
                                   capabilities=capabilities)
         self.driver.implicitly_wait(wait_time)
     self.wait = WebDriverWait(self.driver, wait_time)
     self.wait_time = wait_time
     self.page = Page(self.driver, self.wait_time)
     # super(Helper, self).__init__(**kwargs)
     super(Helper, self).__init__()
示例#2
0
文件: helper.py 项目: sisiz/staxing
 def __init__(self,
              driver_type='chrome',
              capabilities=None,
              pasta_user=None,
              wait_time=DEFAULT_WAIT_TIME,
              opera_driver='',
              existing_driver=None,
              **kwargs):
     """Class constructor."""
     if driver_type == 'saucelabs' and pasta_user is None:
         raise TypeError('A Sauce Labs user is required for remote testing')
     self.pasta = pasta_user
     self.opera_driver = opera_driver
     if existing_driver:
         self.driver = existing_driver
     else:
         driver = driver_type if not pasta_user else 'saucelabs'
         self.driver = self.run_on(driver_type=driver,
                                   pasta_user=self.pasta,
                                   capabilities=capabilities)
         self.driver.implicitly_wait(wait_time)
     self.wait = WebDriverWait(self.driver, wait_time)
     self.wait_time = wait_time
     self.page = Page(self.driver, self.wait_time)
     super(Helper, self).__init__(**kwargs)
 def setUp(self):
     """Pretest settings."""
     option_set = options.Options()
     option_set.add_argument("disable-infobars")
     option_set.add_argument('disable-geolocation')
     option_set.add_argument('headless')
     option_set.add_experimental_option(
         'prefs', {
             'credentials_enable_service': False,
             'profile': {
                 'password_manager_enabled': False
             }
         }
     )
     self.driver = webdriver.Chrome(chrome_options=option_set)
     self.driver.implicitly_wait(0)
     self.wait = SeleniumWait(self.driver)
示例#4
0
    def delete_reading(self, driver, title, description, periods, readings,
                       status):
        """Delete a reading assignment."""
        print('Delete Reading: %s' % title)
        wait = WebDriverWait(driver, Assignment.WAIT_TIME * 4)
        due_date = ''
        for period in periods:
            _, due_date = periods[period]
            break
        url = driver.current_url.split('/')
        date = due_date.split('/')
        temp = []
        temp.append(date[2])
        temp.append(date[0])
        temp.append(date[1])
        date = '-'.join(temp)
        url.append('month')
        url.append(date)
        url = '/'.join(url)
        driver.get(url)
        page = Page(driver, Assignment.WAIT_TIME)
        page.wait_for_page_load()
        wait.until(
            expect.presence_of_element_located(
                (By.XPATH, '//div[div[label[text()="%s"]]]' % title)
            )
        ).click()
        time.sleep(0.3)

        try:
            modal = driver.find_element(
                By.XPATH,
                '//div[@class="modal-footer"]/a[2]'
            )
            Assignment.scroll_to(driver, modal)
            modal.click()
        except Exception:
            pass
        page.wait_for_page_load()

        time.sleep(3)
        wait.until(
            expect.visibility_of_element_located(
                (By.XPATH, '//button[contains(@class, "delete-link")]')
            )
        ).click()
        wait.until(
            expect.visibility_of_element_located(
                (By.XPATH, '//div[@class="controls"]/button[text()="Yes"]')
            )
        ).click()
        page.wait_for_page_load()
示例#5
0
 def delete_reading(self, driver, title, description, periods, readings,
                    status):
     """Delete a reading assignment."""
     # raise NotImplementedError(inspect.currentframe().f_code.co_name)
     wait = WebDriverWait(driver, Assignment.WAIT_TIME * 4)
     wait.until(
         expect.visibility_of_element_located(
             (By.XPATH, '//ul/a[contains(@class,"navbar-brand")]')
         )
     ).click()
     due_date = ''
     for period in periods:
         _, due_date = periods[period]
         break
     url = driver.current_url.split('/')
     date = due_date.split('/')
     temp = []
     temp.append(date[2])
     temp.append(date[0])
     temp.append(date[1])
     date = '-'.join(temp)
     url[-2] = date
     url = '/'.join(url)
     driver.get(url)
     page = Page(driver, Assignment.WAIT_TIME)
     page.wait_for_page_load()
     wait.until(
         expect.presence_of_element_located(
             (By.XPATH, '//a[label[text()="%s"]]' % title)
         )
     ).click()
     time.sleep(0.3)
     try:
         modal = driver.find_element(By.CLASS_NAME, '-edit-assignment')
         Assignment.scroll_to(driver, modal)
         modal.click()
     except:
         pass
     page.wait_for_page_load()
     wait.until(
         expect.presence_of_element_located(
             (By.CLASS_NAME, 'delete-link')
         )
     ).click()
     wait.until(
         expect.presence_of_element_located(
             (By.XPATH, '//div[@class="controls"]/button[text()="Yes"]')
         )
     ).click()
     page.wait_for_page_load()
示例#6
0
文件: helper.py 项目: sisiz/staxing
class Helper(object):
    """Primary parent control class."""

    CONDENSED_WIDTH = 767  # pixels wide
    DEFAULT_WAIT_TIME = 15  # seconds
    CAPABILITIES = {
        'android': DesiredCapabilities.ANDROID,
        'chrome': DesiredCapabilities.CHROME,
        'firefox': DesiredCapabilities.FIREFOX,
        'htmlunit': DesiredCapabilities.HTMLUNIT,
        'htmlunitwithjs': DesiredCapabilities.HTMLUNITWITHJS,
        'internetexplorer': DesiredCapabilities.INTERNETEXPLORER,
        'ipad': DesiredCapabilities.IPAD,
        'iphone': DesiredCapabilities.IPHONE,
        'microsoftedge': DesiredCapabilities.EDGE,
        'opera': DesiredCapabilities.OPERA,
        'phantomjs': DesiredCapabilities.PHANTOMJS,
        'safari': DesiredCapabilities.SAFARI,
    }

    def __init__(self,
                 driver_type='chrome',
                 capabilities=None,
                 pasta_user=None,
                 wait_time=DEFAULT_WAIT_TIME,
                 opera_driver='',
                 existing_driver=None,
                 **kwargs):
        """Class constructor."""
        if driver_type == 'saucelabs' and pasta_user is None:
            raise TypeError('A Sauce Labs user is required for remote testing')
        self.pasta = pasta_user
        self.opera_driver = opera_driver
        if existing_driver:
            self.driver = existing_driver
        else:
            driver = driver_type if not pasta_user else 'saucelabs'
            self.driver = self.run_on(driver_type=driver,
                                      pasta_user=self.pasta,
                                      capabilities=capabilities)
            self.driver.implicitly_wait(wait_time)
        self.wait = WebDriverWait(self.driver, wait_time)
        self.wait_time = wait_time
        self.page = Page(self.driver, self.wait_time)
        super(Helper, self).__init__(**kwargs)

    def __enter__(self):
        """Entry point."""
        return self

    def __del__(self):
        """Class destructor."""
        self.delete()

    def __exit__(self, exc_type, exc_val, exc_tb):
        """Class exitor."""
        self.delete()

    def delete(self):
        """Webdriver destructor."""
        self.wait = None
        try:
            self.driver.quit()
        except:
            pass

    @classmethod
    def default_capabilities(cls, browser='chrome'):
        """Return the default browser capabilities."""
        browser = browser.lower()
        browser = ''.join(browser.split())
        return Helper.CAPABILITIES[browser].copy()

    def run_on(self, driver_type, pasta_user=None, capabilities={}):
        """Webdriver activation.

        driver_type (string): web browser type
        pasta_user (PastaSauce): optional API access for saucelabs
        capabilities (dict): browser settings; copy object to avoid overwrite
            Defaults:
                DesiredCapabilities.ANDROID.copy()
                DesiredCapabilities.CHROME.copy()
                DesiredCapabilities.EDGE.copy()
                DesiredCapabilities.FIREFOX.copy()
                DesiredCapabilities.HTMLUNIT.copy()
                DesiredCapabilities.HTMLUNITWITHJS.copy()
                DesiredCapabilities.INTERNETEXPLORER.copy()
                DesiredCapabilities.IPAD.copy()
                DesiredCapabilities.IPHONE.copy()
                DesiredCapabilities.ORERA.copy()
                DesiredCapabilities.PHANTOMJS.copy()
                DesiredCapabilities.SAFARI.copy()
            Keys:
                platform
                browserName
                version
                javascriptEnabled
        wait (int): standard time, in seconds, to wait for Selenium commands
        opera_driver (string): Chromium location
        """
        if pasta_user:
            driver = 'saucelabs'
        elif driver_type:
            driver = driver_type
        else:
            driver = 'chrome'
        try:
            return {
                'firefox': lambda: webdriver.Firefox(),
                'chrome': lambda: webdriver.Chrome(),
                'ie': lambda: webdriver.Ie(),
                'opera': lambda: self.start_opera(self.opera_driver),
                'phantomjs': lambda: webdriver.PhantomJS(),
                # 'safari': lambda: webdriver.Safari(),
                'saucelabs': lambda: webdriver.Remote(
                    command_executor=(
                        'http://%s:%[email protected]:80/wd/hub' %
                        (pasta_user.get_user(), pasta_user.get_access_key())),
                    desired_capabilities=capabilities
                ),
            }[driver]()
        except WebDriverException as err:
            raise FileNotFoundError(err)
        except Exception as err:
            raise err

    def start_opera(self, location):
        """Opera initiator."""
        webdriver_service = service.Service(location)
        webdriver_service.start()
        return webdriver.Remote(
            webdriver_service.service_url,
            DesiredCapabilities.OPERA.copy()
        )

    def change_wait_time(self, new_wait):
        """Change the max action wait time."""
        if new_wait <= 0:
            raise ValueError('Wait time must be 1 or higher.')
        self.driver.implicitly_wait(new_wait)
        self.wait = WebDriverWait(self.driver, new_wait)
        self.wait_time = new_wait

    def date_string(self, day_delta=0, str_format='%m/%d/%Y'):
        """System date format for Tutor."""
        return (datetime.date.today() + datetime.timedelta(days=day_delta)). \
            strftime(str_format)

    def get(self, url):
        """Return the current URL."""
        self.driver.get(url)
        self.page.wait_for_page_load()

    def get_window_size(self, dimension=None):
        """Return the current window dimensions."""
        get_size = self.driver.get_window_size()
        if dimension is None:
            return get_size
        if dimension not in get_size:
            raise IndexError('Unknown dimension: %s' % dimension)
        return get_size[dimension]

    def set_window_size(self, width=0, height=0, maximize=False):
        """Attempt to change the browser window size."""
        if maximize:
            self.driver.maximize_window()
        elif width >= 1 and height >= 1:
            self.driver.set_window_size(width, height)
            sleep(1.0)
        return self.get_window_size()

    def set_window_position(self, x_=0, y_=0):
        """Move the browser window anchor."""
        if x_ >= 0 and y_ >= 0:
            self.driver.set_window_position(x_, y_)
            sleep(1.0)

    def sleep(self, seconds=1):
        """Stop execution for the specified time in seconds."""
        sleep(seconds)

    def find(self, by, value):
        """Find element."""
        return self.driver.find_element(by=by, value=value)

    def find_all(self, by, value):
        """Find elements."""
        return self.driver.find_elements(by=by, value=value)
class TestStaxingSeleniumWait(unittest.TestCase):
    """Staxing case tests for the page loading wait."""

    def setUp(self):
        """Pretest settings."""
        option_set = options.Options()
        option_set.add_argument("disable-infobars")
        option_set.add_argument('disable-geolocation')
        option_set.add_argument('headless')
        option_set.add_experimental_option(
            'prefs', {
                'credentials_enable_service': False,
                'profile': {
                    'password_manager_enabled': False
                }
            }
        )
        self.driver = webdriver.Chrome(chrome_options=option_set)
        self.driver.implicitly_wait(0)
        self.wait = SeleniumWait(self.driver)

    def tearDown(self):
        """Test destructor."""
        try:
            self.driver.__del__()
            self.wait.__del__()
        except Exception:
            pass

    def test_wait_for_page_load(self):
        """Verify successful waits."""
        self.driver.implicitly_wait(0)
        self.driver.get('https://openstax.org')
        # immediate element search should fail
        # with self.assertRaises(NoSuchElementException):
        #     self.driver.find_element_by_id('main')

        self.driver.get('https://openstax.org')
        # yield execution until the page is stale and content is loaded
        self.wait.wait_for_page_load()
        self.driver.find_element_by_id('main')

    def test_wait_for_loading_staleness(self):
        """Test for loading staleness."""
        self.driver.implicitly_wait(15)
        self.driver.get('http://www.ikea.com/us/en/')
        assert(self.wait.wait_for_loading_staleness(_id='SlideIndiacator')), \
            'transition not stale'
        pass

    def test_is_pseduo_valid(self):
        """Validate the pseudo selectors."""
        self.driver.get(
            'https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements'
        )
        pseudos = self.driver.find_elements_by_css_selector(
            '#Index_of_pseudo-elements + ul > li code'
        )
        for i, _ in enumerate(pseudos):
            pseudos[i] = pseudos[i].get_attribute('innerHTML')
        for pseudo in pseudos:
            assert(self.wait.is_valid_pseudo(pseudo)), \
                '%s is not a valid pseudo element' % pseudo
示例#8
0
class Helper(object):
    """Primary parent control class."""

    CONDENSED_WIDTH = 767  # pixels wide
    DEFAULT_WAIT_TIME = 15  # seconds
    CAPABILITIES = {
        'android': DesiredCapabilities.ANDROID,
        'chrome': DesiredCapabilities.CHROME,
        'firefox': DesiredCapabilities.FIREFOX,
        'headlesschrome': DesiredCapabilities.CHROME,
        'htmlunit': DesiredCapabilities.HTMLUNIT,
        'htmlunitwithjs': DesiredCapabilities.HTMLUNITWITHJS,
        'internetexplorer': DesiredCapabilities.INTERNETEXPLORER,
        'ipad': DesiredCapabilities.IPAD,
        'iphone': DesiredCapabilities.IPHONE,
        'microsoftedge': DesiredCapabilities.EDGE,
        'opera': DesiredCapabilities.OPERA,
        'safari': DesiredCapabilities.SAFARI,
    }

    def __init__(self,
                 driver_type='chrome',
                 capabilities=None,
                 pasta_user=None,
                 wait_time=DEFAULT_WAIT_TIME,
                 remote_driver='',
                 existing_driver=None,
                 **kwargs):
        """Class constructor."""
        if driver_type == 'saucelabs' and pasta_user is None:
            raise TypeError('A Sauce Labs user is required for remote testing')
        self.pasta = pasta_user
        self.remote_driver = remote_driver
        if existing_driver:
            self.driver = existing_driver
        else:
            driver = driver_type if not pasta_user else 'saucelabs'
            self.driver = self.run_on(driver_type=driver,
                                      pasta_user=self.pasta,
                                      capabilities=capabilities)
            self.driver.implicitly_wait(wait_time)
        self.wait = WebDriverWait(self.driver, wait_time)
        self.wait_time = wait_time
        self.page = Page(self.driver, self.wait_time)
        # super(Helper, self).__init__(**kwargs)
        super(Helper, self).__init__()

    def __enter__(self):
        """Entry point."""
        return self

    def __del__(self):
        """Class destructor."""
        self.delete()

    def __exit__(self, exc_type, exc_val, exc_tb):
        """Class exitor."""
        self.delete()

    def delete(self):
        """Webdriver destructor."""
        self.wait = None
        try:
            self.driver.quit()
        except:
            pass

    @classmethod
    def default_capabilities(cls, browser='chrome'):
        """Return the default browser capabilities."""
        browser = browser.lower()
        browser = ''.join(browser.split())
        return Helper.CAPABILITIES[browser].copy()

    def run_on(self, driver_type, pasta_user=None, capabilities={}):
        """Webdriver activation.

        driver_type (string): web browser type
        pasta_user (PastaSauce): optional API access for saucelabs
        capabilities (dict): browser settings; copy object to avoid overwrite
            Defaults:
                DesiredCapabilities.ANDROID.copy()
                DesiredCapabilities.CHROME.copy()
                DesiredCapabilities.EDGE.copy()
                DesiredCapabilities.FIREFOX.copy()
                DesiredCapabilities.HTMLUNIT.copy()
                DesiredCapabilities.HTMLUNITWITHJS.copy()
                DesiredCapabilities.INTERNETEXPLORER.copy()
                DesiredCapabilities.IPAD.copy()
                DesiredCapabilities.IPHONE.copy()
                DesiredCapabilities.ORERA.copy()
                DesiredCapabilities.SAFARI.copy()
            Keys:
                platform
                browserName
                version
                javascriptEnabled
        wait (int): standard time, in seconds, to wait for Selenium commands
        opera_driver (string): Chromium location
        """
        print('Driver type input: %s' % driver_type)
        if pasta_user:
            driver = 'saucelabs'
            print('Driver type: %s' % driver)
        elif driver_type and driver_type is not 'chrome':
            driver = driver_type
            print('Driver type: %s' % driver)
        else:
            option_set = options.Options()
            option_set.add_argument("disable-infobars")
            option_set.add_experimental_option(
                'prefs', {
                    'credentials_enable_service': False,
                    'profile': {
                        'password_manager_enabled': False
                    }
                })
            driver = 'chrome'
            print('Driver type: %s' % driver)
        try:
            return {
                'firefox':
                lambda: webdriver.Firefox(),
                'chrome':
                lambda: webdriver.Chrome(chrome_options=option_set),
                'headlesschrome':
                lambda: self.start_headless(),
                'ie':
                lambda: webdriver.Ie(),
                'opera':
                lambda: self.start_opera(self.opera_driver),
                'safari':
                lambda: webdriver.Safari(),
                'saucelabs':
                lambda: webdriver.Remote(command_executor=(
                    'http://%s:%[email protected]:80/wd/hub' %
                    (pasta_user.get_user(), pasta_user.get_access_key())),
                                         desired_capabilities=capabilities),
            }[driver]()
        except WebDriverException as err:
            raise FileNotFoundError(err)
        except Exception as err:
            raise err

    def start_headless(self):
        """Headless Chrome initiator."""
        print('Start headless browser')
        option_set = options.Options()
        option_set.add_arguments("test-type")
        option_set.add_arguments("start-maximized")
        option_set.add_arguments("--js-flags=--expose-gc")
        option_set.add_arguments("--enable-precise-memory-info")
        option_set.add_argument('headless')
        option_set.add_argument('disable-notifications')
        option_set.add_argument('disable-gpu')
        option_set.add_argument('disable-infobars')
        option_set.add_arguments("--disable-default-apps")
        option_set.add_arguments("test-type=browser")
        option_set.add_experimental_option(
            'prefs', {
                'credentials_enable_service': False,
                'profile': {
                    'password_manager_enabled': False
                }
            })
        option_set.binary_location = os.getenv(
            'CHROME_CANARY', '/Applications/Google Chrome Canary.app' +
            '/Contents/MacOS/Google Chrome Canary')
        webdriver_service = service.Service(
            os.getenv('CHROMEDRIVER', '/Applications/chromedriver'))
        webdriver_service.start()
        print('Service started; returning Remote webdriver')
        return webdriver.Remote(webdriver_service.service_url,
                                option_set.to_capabilities())

    def start_opera(self, location):
        """Opera initiator."""
        webdriver_service = service.Service(location)
        webdriver_service.start()
        return webdriver.Remote(webdriver_service.service_url,
                                DesiredCapabilities.OPERA.copy())

    def change_wait_time(self, new_wait):
        """Change the max action wait time."""
        if new_wait <= 0:
            raise ValueError('Wait time must be 1 or higher.')
        self.driver.implicitly_wait(new_wait)
        self.wait = WebDriverWait(self.driver, new_wait)
        self.wait_time = new_wait

    def date_string(self, day_delta=0, str_format='%m/%d/%Y'):
        """System date format for Tutor."""
        return (datetime.date.today() + datetime.timedelta(days=day_delta)). \
            strftime(str_format)

    def get(self, url):
        """Return the current URL."""
        self.driver.get(url)
        self.page.wait_for_page_load()

    def get_window_size(self, dimension=None):
        """Return the current window dimensions."""
        get_size = self.driver.get_window_size()
        if dimension is None:
            return get_size
        if dimension not in get_size:
            raise IndexError('Unknown dimension: %s' % dimension)
        return get_size[dimension]

    def set_window_size(self, width=0, height=0, maximize=False):
        """Attempt to change the browser window size."""
        if maximize:
            self.driver.maximize_window()
        elif width >= 1 and height >= 1:
            self.driver.set_window_size(width, height)
            sleep(1.0)
        return self.get_window_size()

    def set_window_position(self, x_=0, y_=0):
        """Move the browser window anchor."""
        if x_ >= 0 and y_ >= 0:
            self.driver.set_window_position(x_, y_)
            sleep(1.0)

    def sleep(self, seconds=1):
        """Stop execution for the specified time in seconds."""
        sleep(seconds)

    def find(self, by, value):
        """Find element."""
        return self.driver.find_element(by=by, value=value)

    def find_all(self, by, value):
        """Find elements."""
        return self.driver.find_elements(by=by, value=value)
示例#9
0
class Helper(object):
    """Primary parent control class."""

    CONDENSED_WIDTH = 767  # pixels wide
    DEFAULT_WAIT_TIME = 15  # seconds
    CAPABILITIES = {
        'android': DesiredCapabilities.ANDROID,
        'chrome': DesiredCapabilities.CHROME,
        'firefox': DesiredCapabilities.FIREFOX,
        'headlesschrome': DesiredCapabilities.CHROME,
        'htmlunit': DesiredCapabilities.HTMLUNIT,
        'htmlunitwithjs': DesiredCapabilities.HTMLUNITWITHJS,
        'internetexplorer': DesiredCapabilities.INTERNETEXPLORER,
        'ipad': DesiredCapabilities.IPAD,
        'iphone': DesiredCapabilities.IPHONE,
        'microsoftedge': DesiredCapabilities.EDGE,
        'opera': DesiredCapabilities.OPERA,
        'safari': DesiredCapabilities.SAFARI,
    }

    def __init__(self,
                 driver_type='chrome',
                 capabilities=None,
                 pasta_user=None,
                 wait_time=DEFAULT_WAIT_TIME,
                 remote_driver='',
                 existing_driver=None,
                 **kwargs):
        """Class constructor."""
        if driver_type == 'saucelabs' and pasta_user is None:
            raise TypeError('A Sauce Labs user is required for remote testing')
        self.pasta = pasta_user
        self.remote_driver = remote_driver
        self.driver_type = driver_type.lower()
        if existing_driver:
            self.driver = existing_driver
        else:
            driver = driver_type if not pasta_user else 'saucelabs'
            self.driver = self.run_on(driver_type=driver,
                                      pasta_user=self.pasta,
                                      capabilities=capabilities)
            self.driver.implicitly_wait(wait_time)
        self.wait = WebDriverWait(self.driver, wait_time)
        self.wait_time = wait_time
        self.page = Page(self.driver, self.wait_time)
        super(Helper, self).__init__()

    def __enter__(self):
        """Entry point."""
        return self

    def __del__(self):
        """Class destructor."""
        self.delete()

    def __exit__(self, exc_type, exc_val, exc_tb):
        """Class exitor."""
        self.delete()

    def delete(self):
        """Webdriver destructor."""
        self.wait = None
        try:
            self.driver.quit()
        except Exception:
            pass

    @classmethod
    def default_capabilities(cls, browser='chrome'):
        """Return the default browser capabilities."""
        browser = browser.lower()
        browser = ''.join(browser.split())
        return Helper.CAPABILITIES[browser].copy()

    def run_on(self, driver_type, pasta_user=None, capabilities={}):
        """Webdriver activation.

        driver_type (string): web browser type
        pasta_user (PastaSauce): optional API access for saucelabs
        capabilities (dict): browser settings; copy object to avoid overwrite
            Defaults:
                DesiredCapabilities.ANDROID.copy()
                DesiredCapabilities.CHROME.copy()
                DesiredCapabilities.EDGE.copy()
                DesiredCapabilities.FIREFOX.copy()
                DesiredCapabilities.HTMLUNIT.copy()
                DesiredCapabilities.HTMLUNITWITHJS.copy()
                DesiredCapabilities.INTERNETEXPLORER.copy()
                DesiredCapabilities.IPAD.copy()
                DesiredCapabilities.IPHONE.copy()
                DesiredCapabilities.ORERA.copy()
                DesiredCapabilities.SAFARI.copy()
            Keys:
                platform
                browserName
                version
                javascriptEnabled
        wait (int): standard time, in seconds, to wait for Selenium commands
        opera_driver (string): Chromium location
        """
        if pasta_user:
            driver = 'saucelabs'
        elif driver_type and 'chrome' not in driver_type:
            driver = driver_type
        else:
            option_set = options.Options()
            option_set.add_argument('disable-infobars')
            option_set.add_argument('disable-geolocation')
            option_set.add_experimental_option(
                'prefs', {
                    'credentials_enable_service': False,
                    'profile': {
                        'password_manager_enabled': False
                    }
                })
            if 'headless' in driver_type:
                option_set.add_argument('headless')
                driver = 'headlesschrome'
            else:
                driver = 'chrome'
        try:
            return {
                'firefox':
                lambda: webdriver.Firefox(),
                'chrome':
                lambda: webdriver.Chrome(chrome_options=option_set),
                'headlesschrome':
                lambda: webdriver.Chrome(chrome_options=option_set),
                'ie':
                lambda: webdriver.Ie(),
                'opera':
                lambda: self.start_opera(self.opera_driver),
                'safari':
                lambda: webdriver.Safari(),
                'saucelabs':
                lambda: webdriver.Remote(command_executor=(
                    'http://%s:%[email protected]:80/wd/hub' %
                    (pasta_user.get_user(), pasta_user.get_access_key())),
                                         desired_capabilities=capabilities),
            }[driver]()
        except WebDriverException as err:
            raise FileNotFoundError(err)
        except Exception as err:
            raise err

    def start_opera(self, location):
        """Opera initiator."""
        webdriver_service = service.Service(location)
        webdriver_service.start()
        return webdriver.Remote(webdriver_service.service_url,
                                DesiredCapabilities.OPERA.copy())

    def change_wait_time(self, new_wait):
        """Change the max action wait time."""
        if new_wait <= 0:
            raise ValueError('Wait time must be greater than zero (0).')
        self.driver.implicitly_wait(new_wait)
        self.wait = WebDriverWait(self.driver, new_wait)
        self.wait_time = new_wait

    def date_string(self, day_delta=0, str_format='%m/%d/%Y'):
        """System date format pass-through."""
        return Assignment().to_date_string(day_delta, str_format)

    def get(self, url):
        """Return the current URL."""
        self.driver.get(url)
        self.page.wait_for_page_load()

    def get_window_size(self, dimension=None):
        """Return the current window dimensions."""
        get_size = self.driver.get_window_size()
        if not dimension:
            return get_size
        if dimension not in get_size:
            raise IndexError('Unknown dimension: %s' % dimension)
        return get_size[dimension]

    def set_window_size(self, width=0, height=0, maximize=False):
        """Attempt to change the browser window size."""
        if maximize:
            self.driver.maximize_window()
        elif width >= 1 and height >= 1:
            self.driver.set_window_size(width, height)
            sleep(1.0)
        return self.get_window_size()

    def set_window_position(self, x_=0, y_=0):
        """Move the browser window anchor."""
        if x_ >= 0 and y_ >= 0:
            self.driver.set_window_position(x_, y_)
            sleep(1.0)

    def sleep(self, seconds=1.0):
        """Stop execution for the specified time in seconds."""
        sleep(seconds)

    def find(self, by, value):
        """Find element."""
        return self.driver.find_element(by=by, value=value)

    def find_all(self, by, value):
        """Find elements."""
        return self.driver.find_elements(by=by, value=value)

    def scroll_to(self, target):
        """Scroll the browser window to bring the target into view."""
        Assignment.scroll_to(self.driver, target)
        return target

    def url_parse(self, site):
        """Parse the url into a valid url."""
        parse = list(
            urlparse(site if urlparse(site).scheme else '%s%s' % ('//', site)))
        parse[0] = b'https'
        for index, value in enumerate(parse):
            parse[index] = value.decode('utf-8') if isinstance(value, bytes) \
                else value
        parse = ParseResult(*parse)
        return parse.geturl()