busser-behave 0.1.3

data/vendor/behave/behave/importer.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+"""
+Importer module for lazy-loading/importing modules and objects.
+
+REQUIRES: importlib (provided in Python2.7, Python3.2...)
+"""
+
+from __future__ import absolute_import
+import importlib
+from behave._types import Unknown
+
+def parse_scoped_name(scoped_name):
+    """
+    SCHEMA: my.module_name:MyClassName
+    EXAMPLE:
+        behave.formatter.plain:PlainFormatter
+    """
+    scoped_name = scoped_name.strip()
+    if "::" in scoped_name:
+        # -- ALTERNATIVE: my.module_name::MyClassName
+        scoped_name = scoped_name.replace("::", ":")
+    module_name, object_name = scoped_name.rsplit(":", 1)
+    return module_name, object_name
+
+def load_module(module_name):
+    return importlib.import_module(module_name)
+
+
+class LazyObject(object):
+    """
+    Provides a placeholder for an object that should be loaded lazily.
+    """
+
+    def __init__(self, module_name, object_name=None):
+        if ":" in module_name and not object_name:
+            module_name, object_name = parse_scoped_name(module_name)
+        assert ":" not in module_name
+        self.module_name = module_name
+        self.object_name = object_name
+        self.resolved_object = None
+
+    def __get__(self, obj=None, type=None):     # pylint: disable=redefined-builtin
+        """
+        Implement descriptor protocol,
+        useful if this class is used as attribute.
+        :return: Real object (lazy-loaded if necessary).
+        :raise ImportError: If module or object cannot be imported.
+        """
+        __pychecker__ = "unusednames=obj,type"
+        resolved_object = None
+        if not self.resolved_object:
+            # -- SETUP-ONCE: Lazy load the real object.
+            module = load_module(self.module_name)
+            resolved_object = getattr(module, self.object_name, Unknown)
+            if resolved_object is Unknown:
+                msg = "%s: %s is Unknown" % (self.module_name, self.object_name)
+                raise ImportError(msg)
+            self.resolved_object = resolved_object
+        return resolved_object
+
+    def __set__(self, obj, value):
+        """Implement descriptor protocol."""
+        __pychecker__ = "unusednames=obj"
+        self.resolved_object = value
+
+    def get(self):
+        return self.__get__()
+
+
+class LazyDict(dict):
+    """
+    Provides a dict that supports lazy loading of objects.
+    A LazyObject is provided as placeholder for a value that should be
+    loaded lazily.
+    """
+
+    def __getitem__(self, key):
+        """
+        Provides access to stored dict values.
+        Implements lazy loading of item value (if necessary).
+        When lazy object is loaded, its value with the dict is replaced
+        with the real value.
+
+        :param key:  Key to access the value of an item in the dict.
+        :return: value
+        :raises: KeyError if item is not found
+        :raises: ImportError for a LazyObject that cannot be imported.
+        """
+        value = dict.__getitem__(self, key)
+        if isinstance(value, LazyObject):
+            # -- LAZY-LOADING MECHANISM: Load object and replace with lazy one.
+            value = value.__get__()
+            self[key] = value
+        return value
+
+    def load_all(self, strict=False):
+        for key in self.keys():
+            try:
+                self.__getitem__(key)
+            except ImportError:
+                if strict:
+                    raise

data/vendor/behave/behave/json_parser.py

@@ -0,0 +1,264 @@
+# -*- coding: utf-8 -*-
+"""
+Read behave's JSON output files and store retrieved information in
+:mod:`behave.model` elements.
+
+Utility to retrieve runtime information from behave's JSON output.
+
+REQUIRES: Python >= 2.6 (json module is part of Python standard library)
+"""
+
+from __future__ import absolute_import
+import codecs
+from behave import model
+from behave.model_core import Status
+try:
+    import json
+except ImportError:
+    # -- PYTHON 2.5 backward compatible: Use simplejson module.
+    import simplejson as json
+
+
+__author__ = "Jens Engel"
+
+
+# ----------------------------------------------------------------------------
+# FUNCTIONS:
+# ----------------------------------------------------------------------------
+def parse(json_filename, encoding="UTF-8"):
+    """
+    Reads behave JSON output file back in and stores information in
+    behave model elements.
+
+    :param json_filename:  JSON filename to process.
+    :return: List of feature objects.
+    """
+    with codecs.open(json_filename, "rU", encoding=encoding) as input_file:
+        json_data = json.load(input_file, encoding=encoding)
+        json_processor = JsonParser()
+        features = json_processor.parse_features(json_data)
+        return features
+
+
+# ----------------------------------------------------------------------------
+# CLASSES:
+# ----------------------------------------------------------------------------
+class JsonParser(object):
+
+    def __init__(self):
+        self.current_scenario_outline = None
+
+    def parse_features(self, json_data):
+        assert isinstance(json_data, list)
+        features = []
+        json_features = json_data
+        for json_feature in json_features:
+            feature = self.parse_feature(json_feature)
+            features.append(feature)
+        return features
+
+    def parse_feature(self, json_feature):
+        name = json_feature.get("name", u"")
+        keyword = json_feature.get("keyword", None)
+        tags = json_feature.get("tags", [])
+        description = json_feature.get("description", [])
+        location = json_feature.get("location", u"")
+        filename, line = location.split(":")
+        feature = model.Feature(filename, line, keyword, name, tags, description)
+
+        json_elements = json_feature.get("elements", [])
+        for json_element in json_elements:
+            self.add_feature_element(feature, json_element)
+        return feature
+
+
+    def add_feature_element(self, feature, json_element):
+        datatype = json_element.get("type", u"")
+        category = datatype.lower()
+        if category == "background":
+            background = self.parse_background(json_element)
+            feature.background = background
+        elif category == "scenario":
+            scenario = self.parse_scenario(json_element)
+            feature.add_scenario(scenario)
+        elif category == "scenario_outline":
+            scenario_outline = self.parse_scenario_outline(json_element)
+            feature.add_scenario(scenario_outline)
+            self.current_scenario_outline = scenario_outline
+        # elif category == "examples":
+        #     examples = self.parse_examples(json_element)
+        #     self.current_scenario_outline.examples = examples
+        else:
+            raise KeyError("Invalid feature-element keyword: %s" % category)
+
+
+    def parse_background(self, json_element):
+        """
+        self.add_feature_element({
+            'keyword': background.keyword,
+            'location': background.location,
+            'steps': [],
+        })
+        """
+        keyword = json_element.get("keyword", u"")
+        name = json_element.get("name", u"")
+        location = json_element.get("location", u"")
+        json_steps = json_element.get("steps", [])
+        steps = self.parse_steps(json_steps)
+        filename, line = location.split(":")
+        background = model.Background(filename, line, keyword, name, steps)
+        return background
+
+    def parse_scenario(self, json_element):
+        """
+        self.add_feature_element({
+            'keyword': scenario.keyword,
+            'name': scenario.name,
+            'tags': scenario.tags,
+            'location': scenario.location,
+            'steps': [],
+        })
+        """
+        keyword = json_element.get("keyword", u"")
+        name = json_element.get("name", u"")
+        description = json_element.get("description", [])
+        tags = json_element.get("tags", [])
+        location = json_element.get("location", u"")
+        json_steps = json_element.get("steps", [])
+        steps = self.parse_steps(json_steps)
+        filename, line = location.split(":")
+        scenario = model.Scenario(filename, line, keyword, name, tags, steps)
+        scenario.description = description
+        return scenario
+
+    def parse_scenario_outline(self, json_element):
+        """
+        self.add_feature_element({
+            'keyword': scenario_outline.keyword,
+            'name': scenario_outline.name,
+            'tags': scenario_outline.tags,
+            'location': scenario_outline.location,
+            'steps': [],
+            'examples': [],
+        })
+        """
+        keyword = json_element.get("keyword", u"")
+        name = json_element.get("name", u"")
+        description = json_element.get("description", [])
+        tags = json_element.get("tags", [])
+        location = json_element.get("location", u"")
+        json_steps = json_element.get("steps", [])
+        json_examples = json_element.get("examples", [])
+        steps = self.parse_steps(json_steps)
+        examples = []
+        if json_examples:
+            # pylint: disable=redefined-variable-type
+            examples = self.parse_examples(json_examples)
+        filename, line = location.split(":")
+        scenario_outline = model.ScenarioOutline(filename, line, keyword, name,
+                                                 tags=tags, steps=steps,
+                                                 examples=examples)
+        scenario_outline.description = description
+        return scenario_outline
+
+    def parse_steps(self, json_steps):
+        steps = []
+        for json_step in json_steps:
+            step = self.parse_step(json_step)
+            steps.append(step)
+        return steps
+
+    def parse_step(self, json_element):
+        """
+        s = {
+            'keyword': step.keyword,
+            'step_type': step.step_type,
+            'name': step.name,
+            'location': step.location,
+        }
+
+        if step.text:
+            s['text'] = step.text
+        if step.table:
+            s['table'] = self.make_table(step.table)
+        element = self.current_feature_element
+        element['steps'].append(s)
+        """
+        keyword = json_element.get("keyword", u"")
+        name = json_element.get("name", u"")
+        step_type = json_element.get("step_type", u"")
+        location = json_element.get("location", u"")
+        text = json_element.get("text", None)
+        if isinstance(text, list):
+            text = "\n".join(text)
+        table = None
+        json_table = json_element.get("table", None)
+        if json_table:
+            table = self.parse_table(json_table)
+        filename, line = location.split(":")
+        step = model.Step(filename, line, keyword, step_type, name)
+        step.text = text
+        step.table = table
+        json_result = json_element.get("result", None)
+        if json_result:
+            self.add_step_result(step, json_result)
+        return step
+
+    @staticmethod
+    def add_step_result(step, json_result):
+        """
+        steps = self.current_feature_element['steps']
+        steps[self._step_index]['result'] = {
+            'status': result.status.name,
+            'duration': result.duration,
+        }
+        """
+        status_name = json_result.get("status", u"")
+        duration = json_result.get("duration", 0)
+        error_message = json_result.get("error_message", None)
+        if isinstance(error_message, list):
+            error_message = "\n".join(error_message)
+        step.status = Status.from_name(status_name)
+        step.duration = duration
+        step.error_message = error_message
+
+    @staticmethod
+    def parse_table(json_table):
+        """
+        table_data = {
+            'headings': table.headings,
+            'rows': [ list(row) for row in table.rows ]
+        }
+        return table_data
+        """
+        headings = json_table.get("headings", [])
+        rows = json_table.get("rows", [])
+        table = model.Table(headings, rows=rows)
+        return table
+
+
+    def parse_examples(self, json_element):
+        """
+        e = {
+            'keyword': examples.keyword,
+            'name': examples.name,
+            'location': examples.location,
+        }
+
+        if examples.table:
+            e['table'] = self.make_table(examples.table)
+
+        element = self.current_feature_element
+        element['examples'].append(e)
+        """
+        keyword = json_element.get("keyword", u"")
+        name = json_element.get("name", u"")
+        location = json_element.get("location", u"")
+
+        table = None
+        json_table = json_element.get("table", None)
+        if json_table:
+            table = self.parse_table(json_table)
+        filename, line = location.split(":")
+        examples = model.Examples(filename, line, keyword, name, table)
+        return examples

data/vendor/behave/behave/log_capture.py

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import, print_function
+from logging.handlers import BufferingHandler
+import logging
+import functools
+import re
+
+
+class RecordFilter(object):
+    """Implement logging record filtering as per the configuration
+    --logging-filter option.
+    """
+    def __init__(self, names):
+        self.include = set()
+        self.exclude = set()
+        for name in names.split(','):
+            if name[0] == '-':
+                self.exclude.add(name[1:])
+            else:
+                self.include.add(name)
+
+    def filter(self, record):
+        if self.exclude:
+            return record.name not in self.exclude
+        return record.name in self.include
+
+
+# originally from nostetsts logcapture plugin
+class LoggingCapture(BufferingHandler):
+    """Capture logging events in a memory buffer for later display or query.
+
+    Captured logging events are stored on the attribute
+    :attr:`~LoggingCapture.buffer`:
+
+    .. attribute:: buffer
+
+       This is a list of captured logging events as `logging.LogRecords`_.
+
+    .. _`logging.LogRecords`:
+       http://docs.python.org/library/logging.html#logrecord-objects
+
+    By default the format of the messages will be::
+
+        '%(levelname)s:%(name)s:%(message)s'
+
+    This may be overridden using standard logging formatter names in the
+    configuration variable ``logging_format``.
+
+    The level of logging captured is set to ``logging.NOTSET`` by default. You
+    may override this using the configuration setting ``logging_level`` (which
+    is set to a level name.)
+
+    Finally there may be `filtering of logging events`__ specified by the
+    configuration variable ``logging_filter``.
+
+    .. __: behave.html#command-line-arguments
+    """
+
+    def __init__(self, config, level=None):
+        BufferingHandler.__init__(self, 1000)
+        self.config = config
+        self.old_handlers = []
+        self.old_level = None
+
+        # set my formatter
+        log_format = datefmt = None
+        if config.logging_format:
+            log_format = config.logging_format
+        else:
+            log_format = '%(levelname)s:%(name)s:%(message)s'
+        if config.logging_datefmt:
+            datefmt = config.logging_datefmt
+        formatter = logging.Formatter(log_format, datefmt)
+        self.setFormatter(formatter)
+
+        # figure the level we're logging at
+        if level is not None:
+            self.level = level
+        elif config.logging_level:
+            self.level = config.logging_level
+        else:
+            self.level = logging.NOTSET
+
+        # construct my filter
+        if config.logging_filter:
+            self.addFilter(RecordFilter(config.logging_filter))
+
+    def __bool__(self):
+        return bool(self.buffer)
+
+    def flush(self):
+        pass  # do nothing
+
+    def truncate(self):
+        self.buffer = []
+
+    def getvalue(self):
+        return '\n'.join(self.formatter.format(r) for r in self.buffer)
+
+    def find_event(self, pattern):
+        """Search through the buffer for a message that matches the given
+        regular expression.
+
+        Returns boolean indicating whether a match was found.
+        """
+        pattern = re.compile(pattern)
+        for record in self.buffer:
+            if pattern.search(record.getMessage()) is not None:
+                return True
+        return False
+
+    def any_errors(self):
+        """Search through the buffer for any ERROR or CRITICAL events.
+
+        Returns boolean indicating whether a match was found.
+        """
+        return any(record for record in self.buffer
+                   if record.levelname in ('ERROR', 'CRITICAL'))
+
+    def inveigle(self):
+        """Turn on logging capture by replacing all existing handlers
+        configured in the logging module.
+
+        If the config var logging_clear_handlers is set then we also remove
+        all existing handlers.
+
+        We also set the level of the root logger.
+
+        The opposite of this is :meth:`~LoggingCapture.abandon`.
+        """
+        root_logger = logging.getLogger()
+        if self.config.logging_clear_handlers:
+            # kill off all the other log handlers
+            for logger in logging.Logger.manager.loggerDict.values():
+                if hasattr(logger, "handlers"):
+                    for handler in logger.handlers:
+                        self.old_handlers.append((logger, handler))
+                        logger.removeHandler(handler)
+
+        # sanity check: remove any existing LoggingCapture
+        for handler in root_logger.handlers[:]:
+            if isinstance(handler, LoggingCapture):
+                root_logger.handlers.remove(handler)
+            elif self.config.logging_clear_handlers:
+                self.old_handlers.append((root_logger, handler))
+                root_logger.removeHandler(handler)
+
+        # right, we're it now
+        root_logger.addHandler(self)
+
+        # capture the level we're interested in
+        self.old_level = root_logger.level
+        root_logger.setLevel(self.level)
+
+    def abandon(self):
+        """Turn off logging capture.
+
+        If other handlers were removed by :meth:`~LoggingCapture.inveigle` then
+        they are reinstated.
+        """
+        root_logger = logging.getLogger()
+        for handler in root_logger.handlers[:]:
+            if handler is self:
+                root_logger.handlers.remove(handler)
+
+        if self.config.logging_clear_handlers:
+            for logger, handler in self.old_handlers:
+                logger.addHandler(handler)
+
+        if self.old_level is not None:
+            # -- RESTORE: Old log.level before inveigle() was used.
+            root_logger.setLevel(self.old_level)
+            self.old_level = None
+
+# pre-1.2 backwards compatibility
+MemoryHandler = LoggingCapture
+
+
+def capture(*args, **kw):
+    """Decorator to wrap an *environment file function* in log file capture.
+
+    It configures the logging capture using the *behave* context - the first
+    argument to the function being decorated (so don't use this to decorate
+    something that doesn't have *context* as the first argument.)
+
+    The basic usage is:
+
+    .. code-block: python
+
+        @capture
+        def after_scenario(context, scenario):
+            ...
+
+    The function prints any captured logging (at the level determined by the
+    ``log_level`` configuration setting) directly to stdout, regardless of
+    error conditions.
+
+    It is mostly useful for debugging in situations where you are seeing a
+    message like::
+
+        No handlers could be found for logger "name"
+
+    The decorator takes an optional "level" keyword argument which limits the
+    level of logging captured, overriding the level in the run's configuration:
+
+    .. code-block: python
+
+        @capture(level=logging.ERROR)
+        def after_scenario(context, scenario):
+            ...
+
+    This would limit the logging captured to just ERROR and above, and thus
+    only display logged events if they are interesting.
+    """
+    def create_decorator(func, level=None):
+        def f(context, *args):
+            h = LoggingCapture(context.config, level=level)
+            h.inveigle()
+            try:
+                func(context, *args)
+            finally:
+                h.abandon()
+            v = h.getvalue()
+            if v:
+                print("Captured Logging:")
+                print(v)
+        return f
+
+    if not args:
+        return functools.partial(create_decorator, level=kw.get("level"))
+    else:
+        return create_decorator(args[0])