def test_robot_can_get_vars_from_env(self, mock_get_variables):
     os.environ["PO_BROWSER"] = "opera"
     try:
         handler = OptionHandler()
         self.assertEquals(handler.get("browser"), "opera")
     except Exception, e:
         raise e

 def test_robot_env_overrides_var_file(self, mock_get_variables):
     os.environ["PO_AUTHOR"] = "Twain"
     os.environ["PO_VAR_FILE"] = self.path_to_var_file
     try:
         handler = OptionHandler()
         self.assertEquals(handler.get("author"), "Twain")
     except Exception, e:
         raise e

 def test_robot_cmd_line_var_overrides_var_file(self, mock_get_variables):
     mock_get_variables.return_value = {"${author}": "Twain"}
     os.environ["PO_VAR_FILE"] = self.path_to_var_file
     try:
         handler = OptionHandler()
         self.assertEquals(handler.get("author"), "Twain")
     except Exception, e:
         raise e

 def test_robot_cmd_line_var_overrides_env_var(self, mock_get_variables):
     os.environ["PO_BROWSER"] = "firefox"
     mock_get_variables.return_value = {"${browser}": "chrome"}
     try:
         handler = OptionHandler()
         self.assertEquals(handler.get("browser"), "chrome")
     except Exception, e:
         raise e

    def __init__(self, *args, **kwargs):
        """
        Initializes the options used by the actions defined in this class.
        """
        #_ComponentsManager.__init__(self, *args, **kwargs)
        #_SelectorsManager.__init__(self, *args, **kwargs)
        super(_BaseActions, self).__init__(*args, **kwargs)

        self._option_handler = OptionHandler(self)
        self._is_robot = Context.in_robot()
        self.selenium_speed = self._option_handler.get("selenium_speed") or 0
        self.set_selenium_speed(self.selenium_speed)
        siw_opt = self._option_handler.get("selenium_implicit_wait")
        self.selenium_implicit_wait = siw_opt if siw_opt is not None else 10
        self.set_selenium_implicit_wait(self.selenium_implicit_wait)
        self.set_selenium_timeout(self.selenium_implicit_wait)

        self.baseurl = self._option_handler.get("baseurl")

 def test_robot(self, mock_get_variables):
     mock_get_variables.return_value = {"${browser}": "foobar"}
     handler = OptionHandler()
     self.assertEquals(handler.get("browser"), "foobar")

 def test_no_robot_var_file(self):
     os.environ["PO_VAR_FILE"] = self.path_to_var_file
     handler = OptionHandler()
     self.assertEquals(handler.get("author"), "Dickens")
     self.assertEquals(handler.get("dynamic"), "Python")

 def test_var_file_import_exception(self):
     os.environ["PO_VAR_FILE"] = "foo/bar/asdfsadf/asdf"
     handler = OptionHandler()
     handler.get("PO_VAR_FILE")

 def test_no_robot_ignore_lowercase_env_vars(self):
     os.environ["PO_BROWSEr"] = "firefox"
     handler = OptionHandler()
     self.assertIsNone(handler.get("browser"), "Mixed case environment variables should not be set")

 def test_no_robot_env_not_set_is_none(self):
     handler = OptionHandler()
     self.assertIsNone(handler.get("fasdfasdfasdfsadf"))

 def test_no_robot_get_env_var(self):
     os.environ["PO_FOO"] = "bar"
     handler = OptionHandler()
     self.assertEquals(handler.get("foo"), "bar")

 def test_get_options_from_page_object(self):
     p = MockPage()
     p.options = {'author': 'Twain'}
     handler = OptionHandler(p)
     self.assertEquals(handler.get("author"), "Twain")

class _BaseActions(_S2LWrapper):
    """
    Helper class that defines actions for PageObjectLibrary.
    """

    _abstracted_logger = Logger()

    def __init__(self, *args, **kwargs):
        """
        Initializes the options used by the actions defined in this class.
        """
        #_ComponentsManager.__init__(self, *args, **kwargs)
        #_SelectorsManager.__init__(self, *args, **kwargs)
        super(_BaseActions, self).__init__(*args, **kwargs)

        self._option_handler = OptionHandler(self)
        self._is_robot = Context.in_robot()
        self.selenium_speed = self._option_handler.get("selenium_speed") or 0
        self.set_selenium_speed(self.selenium_speed)
        siw_opt = self._option_handler.get("selenium_implicit_wait")
        self.selenium_implicit_wait = siw_opt if siw_opt is not None else 10
        self.set_selenium_implicit_wait(self.selenium_implicit_wait)
        self.set_selenium_timeout(self.selenium_implicit_wait)

        self.baseurl = self._option_handler.get("baseurl")

    def log(self, msg, level="INFO", is_console=True):
        """ Logs either to Robot log file or to a file called po_log.txt
        at the current directory.

        :param msg: The message to log
        :param level: The level to log at
        :type level: String corresponding to Robot or Python logging levels. See
        http://robot-framework.readthedocs.org/en/2.8.4/autodoc/robot.api.html?#log-levels for Robot log levels and
        http://docs.python.org/2/library/logging.html#levels for Python logging levels outside Robot.

        :param is_console: Whether or not to log to stdout
        :type is_console: Boolean

        Possible Robot levels are:

        - "WARN"
        - "INFO"
        - "DEBUG"
        - "TRACE"

        In Robot, you set the logging threshold using the --loglevel, or -L option
        to filter out logging chatter. For example, by default the logging level is
        set to "INFO" so if you logged "DEBUG" messages, the messages would not
        get reported.

        Robot logging messages get logged to stdout and to log.html.

        Outside of Robot, possible logging levels are:

         - "CRITICAL"
         - "ERROR"
         - "WARNING"
         - "INFO"
         - "DEBUG"
         - "NOSET"

        ...and you set the logging threshold level using the
        PO_LOG_LEVEL environment variable or log_level variable in a variable file.

        The Python logging module provides more logging levels than
        Robot provides; therefore, logging levels passed as strings to boththe log() method and the
        threshold level, are mapped to the closest supported Robot logging level and vice versa.

        The default threshold for both Robot and Python is "INFO".

        """

        return self._log(msg, self.name, level, is_console)

    def _log(self, msg, page_name, level="INFO", is_console=True):

        """ See :func:`log`."""
        self._abstracted_logger.log(msg, page_name, level, is_console)
        return self

    def wait_until_alert_is_present(self, timeout=None):
        alert_present = False
        self.wait_for(lambda: EC.alert_is_present(), timeout=timeout,
                      message="No alert was present after %s"
                              % self._format_timeout(timeout or self.selenium_implicit_wait))

    def wait_until_element_is_not_visible(self, locator, timeout=None, error=None):
        """Waits until element specified with `locator` is not visible.

        Fails if `timeout` expires before the element is not visible. See
        `introduction` for more information about `timeout` and its
        default value.

        `error` can be used to override the default error message.

        """
        def check_visibility():
            visible = self._is_visible(locator)
            if not visible:
#.........这里部分代码省略.........

 def get_threshold_level_as_str():
     ret = OptionHandler(object()).get("log_level") or "INFO"
     return ret.upper()