busser-behave 0.1.3

data/vendor/behave/bin/behave

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+# -- ENSURE: Use local path during development.
+import sys
+import os.path
+
+# ----------------------------------------------------------------------------
+# SETUP PATHS:
+# ----------------------------------------------------------------------------
+NAME = "behave"
+HERE = os.path.dirname(__file__)
+TOP  = os.path.join(HERE, "..")
+if os.path.isdir(os.path.join(TOP, NAME)):
+    sys.path.insert(0, os.path.abspath(TOP))
+
+# ----------------------------------------------------------------------------
+# BEHAVE-TWEAKS:
+# ----------------------------------------------------------------------------
+def setup_behave():
+    """
+    Apply tweaks, extensions and patches to "behave".
+    """
+    from behave.configuration import Configuration
+    # -- DISABLE: Timings to simplify issue.features/ tests.
+    # Configuration.defaults["format0"] = "pretty"
+    # Configuration.defaults["format0"] = "progress"
+    Configuration.defaults["show_timings"] = False
+
+def behave_main0():
+    # from behave.configuration import Configuration
+    from behave.__main__ import main as behave_main
+    setup_behave()
+    return behave_main()
+
+# ----------------------------------------------------------------------------
+# MAIN:
+# ----------------------------------------------------------------------------
+if __name__ == "__main__":
+    if "COVERAGE_PROCESS_START" in os.environ:
+        import coverage
+        coverage.process_startup()
+    sys.exit(behave_main0())

data/vendor/behave/bin/behave.cmd

@@ -0,0 +1,10 @@
+@echo off
+REM ==========================================================================
+REM BEHAVE
+REM ==========================================================================
+
+setlocal
+set HERE=%~dp0
+if not defined PYTHON   set PYTHON=python
+
+%PYTHON% %HERE%behave %*

data/vendor/behave/bin/behave.junit_filter.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+"""
+Filter JUnit XML reports to show only a subset of all information.
+
+JUNIT XML SCHEMA:
+
+    element:testsuite: failures="..." errors="..."
+        +-- element:testcase: name="..." status="..."
+"""
+
+from __future__ import absolute_import, print_function, with_statement
+import os.path
+import sys
+import argparse
+from fnmatch import fnmatch
+from xml.etree import ElementTree as ET
+from xml.dom import minidom
+from behave.textutil import indent
+
+__author = "Jens Engel"
+__status__ = "prototype"
+
+NAME = os.path.basename(__file__)
+VERSION = "0.1.0"
+REPORT_DIR = "reports"
+
+def xml_prettify(elem):
+    """Return a pretty-printed XML string for the XML element."""
+    text = ET.tostring(elem, "utf-8")
+    reparsed = minidom.parseString(text)
+    return reparsed.toprettyxml(indent=" ")
+
+def xml_select_testcases_with_status(tree, status):
+    return tree.findall(".//testcase[@status='%s']" % status)
+
+def path_select_files(paths, pattern="*.xml"):
+    if not paths:
+        paths = [REPORT_DIR]
+
+    selected = []
+    for pathname in paths:
+        if os.path.isdir(pathname):
+            for root, dirs, files in os.walk(pathname):
+                for filename in files:
+                    if fnmatch(filename, pattern):
+                        filename2 = os.path.join(root, filename)
+                        selected.append(os.path.normpath(filename2))
+        elif os.path.isfile(pathname) and fnmatch(pathname, pattern):
+            selected.append(pathname)
+    return selected
+
+def report_testcases(filename, testcases):
+    print(u"REPORT: {0}".format(filename))
+    for xml_testcase in testcases:
+        print("  TESTCASE: {0}".format(xml_testcase.get("name")))
+        xml_text = indent(xml_prettify(xml_testcase), "    ")
+        print(xml_text)
+
+def main(args=None):
+    """Filter JUnit XML reports to show only a subset of all information."""
+    if args is None:
+        args = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(prog=NAME,
+                                     description=main.__doc__)
+    parser.add_argument("-s", "--status", default="failed", required=False,
+                        choices=["passed", "failed", "skipped"],
+                        help="Status to select (passed, failed, skipped).")
+    parser.add_argument("xml_file", nargs="*",
+                        help="XML file(s) or directory with XML files.")
+    parser.add_argument("--version", action="version", version=VERSION)
+
+    options = parser.parse_args(args)
+
+    xml_files = options.xml_file
+    xml_reports = path_select_files(xml_files)
+    for xml_filename in xml_reports:
+        tree = ET.parse(xml_filename)
+        testcases = xml_select_testcases_with_status(tree, options.status)
+        if testcases:
+            report_testcases(xml_filename, testcases)
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

data/vendor/behave/bin/behave.step_durations.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Utility script to retrieve duration information from behave JSON output.
+
+REQUIRES: Python >= 2.6 (json module is part of Python standard library)
+LICENSE:  BSD
+"""
+
+from __future__ import absolute_import
+
+__author__    = "Jens Engel"
+__copyright__ = "(c) 2013 by Jens Engel"
+__license__   = "BSD"
+VERSION = "0.1.0"
+
+# -- IMPORTS:
+from behave import json_parser
+from behave.model import ScenarioOutline
+from optparse import OptionParser
+from operator import attrgetter
+import os.path
+import sys
+
+
+# ----------------------------------------------------------------------------
+# FUNCTIONS:
+# ----------------------------------------------------------------------------
+class StepDurationData(object):
+    def __init__(self, step=None):
+        self.step_name = None
+        self.min_duration = sys.maxint
+        self.max_duration = 0
+        self.durations = []
+        self.step = step
+        if step:
+            self.process_step(step)
+
+    @staticmethod
+    def make_step_name(step):
+        step_name = "%s %s" % (step.step_type.capitalize(), step.name)
+        return step_name
+
+    def process_step(self, step):
+        step_name = self.make_step_name(step)
+        if not self.step_name:
+            self.step_name = step_name
+        if self.min_duration > step.duration:
+            self.min_duration = step.duration
+        if self.max_duration < step.duration:
+            self.max_duration = step.duration
+        self.durations.append(step.duration)
+
+
+class BehaveDurationData(object):
+    def __init__(self):
+        self.step_registry = {}
+        self.all_steps = []
+        self.all_scenarios = []
+
+
+    def process_features(self, features):
+        for feature in features:
+            self.process_feature(feature)
+
+    def process_feature(self, feature):
+        if feature.background:
+            self.process_background(feature.background)
+        for scenario in feature.scenarios:
+            if isinstance(scenario, ScenarioOutline):
+                self.process_scenario_outline(scenario)
+            else:
+                self.process_scenario(scenario)
+
+    def process_step(self, step):
+        step_name = StepDurationData.make_step_name(step)
+        known_step = self.step_registry.get(step_name, None)
+        if known_step:
+            known_step.process_step(step)
+        else:
+            step_data = StepDurationData(step)
+            self.step_registry[step_name] = step_data
+        self.all_steps.append(step)
+
+    def process_background(self, scenario):
+        for step in scenario:
+            self.process_step(step)
+
+    def process_scenario(self, scenario):
+        for step in scenario:
+            self.process_step(step)
+
+    def process_scenario_outline(self, scenario_outline):
+        for scenario in scenario_outline:
+            self.process_scenario(scenario)
+
+    def report_step_durations(self, limit=None, min_duration=None, ostream=sys.stdout):
+        step_datas = list(self.step_registry.values())
+        steps_size = len(step_datas)
+        steps_by_longest_duration_first = sorted(step_datas,
+                                                 key=attrgetter("max_duration"),
+                                                 reverse=True)
+        ostream.write("STEP DURATIONS (longest first, size=%d):\n" % steps_size)
+        ostream.write("-" * 80)
+        ostream.write("\n")
+        for index, step in enumerate(steps_by_longest_duration_first):
+            ostream.write("% 4d.  %9.6fs  %s" % \
+                          (index+1, step.max_duration, step.step_name))
+            calls = len(step.durations)
+            if calls > 1:
+                ostream.write(" (%d calls, min: %.6fs)\n" % (calls, step.min_duration))
+            else:
+                ostream.write("\n")
+            if ((limit and index+1 >= limit) or
+                (step.max_duration < min_duration)):
+                remaining = steps_size - (index+1)
+                ostream.write("...\nSkip remaining %d steps.\n" % remaining)
+                break
+
+
+# ----------------------------------------------------------------------------
+# MAIN FUNCTION:
+# ----------------------------------------------------------------------------
+def main(args=None):
+    if args is None:
+        args = sys.argv[1:]
+
+    usage_ = """%prog [OPTIONS] JsonFile
+Read behave JSON data file and extract steps with longest duration."""
+    parser = OptionParser(usage=usage_, version=VERSION)
+    parser.add_option("-e", "--encoding", dest="encoding",
+                     default="UTF-8",
+                     help="Encoding to use (default: %default).")
+    parser.add_option("-l", "--limit", dest="limit", type="int",
+                     help="Max. number of steps (default: %default).")
+    parser.add_option("-m", "--min", dest="min_duration", default="0",
+                     help="Min. duration threshold (default: %default).")
+    options, filenames = parser.parse_args(args)
+    if not filenames:
+        parser.error("OOPS, no filenames provided.")
+    elif len(filenames) > 1:
+        parser.error("OOPS: Can only process one JSON file.")
+    min_duration = float(options.min_duration)
+    if min_duration < 0:
+        min_duration = None
+    json_filename = filenames[0]
+    if not os.path.exists(json_filename):
+        parser.error("JSON file '%s' not found" % json_filename)
+
+    # -- NORMAL PROCESSING: Read JSON, extract step durations and report them.
+    features = json_parser.parse(json_filename)
+    processor = BehaveDurationData()
+    processor.process_features(features)
+    processor.report_step_durations(options.limit, min_duration)
+    sys.stdout.write("Detected %d features.\n" % len(features))
+    return 0
+
+
+# ----------------------------------------------------------------------------
+# AUTO-MAIN:
+# ----------------------------------------------------------------------------
+if __name__ == "__main__":
+    sys.exit(main())

data/vendor/behave/bin/behave2cucumber_json.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# =============================================================================
+# CONVERT: behave JSON dialect to cucumber JSON dialect
+# =============================================================================
+# STATUS: __PROTOTYPE__
+# REQUIRES: Python >= 2.6
+# REQUIRES: https://github.com/behalfinc/b2c/
+# SEE: https://github.com/behave/behave/issues/267#issuecomment-249607191
+# =============================================================================
+"""
+Convert a file with behave JSON data into a file with cucumber JSON data.
+Note that both JSON dialects differ slightly.
+"""
+
+from __future__ import print_function
+import json
+import sys
+import os.path
+try:
+    import b2c
+except ImportError:
+    print("REQUIRE: https://github.com/behalfinc/b2c/  (not installed yet)")
+    print("INSTALL: pip install b2c")
+    sys.exit(2)
+
+
+NAME = os.path.basename(__file__)
+
+def convert_behave_to_cucumber_json(behave_filename, cucumber_filename,
+                                    encoding="UTF-8", pretty=True):
+    """Convert behave JSON dialect into cucumber JSON dialect.
+
+    .. param behave_filename:       Input filename with behave JSON data.
+    .. param cucumber_filename:     Output filename with cucumber JSON data.
+    """
+    dump_kwargs = {"encoding": encoding}
+    if pretty:
+        dump_kwargs.update(indent=2, sort_keys=True)
+
+    with open(behave_filename, "r") as behave_json:
+        with open(cucumber_filename, "w+") as output_file:
+            cucumber_json = b2c.convert(json.load(behave_json, encoding))
+            # cucumber_text = json.dumps(cucumber_json, **dump_kwargs)
+            # output_file.write(cucumber_text)
+            json.dump(cucumber_json, output_file, **dump_kwargs)
+    return 0
+
+def main(args=None):
+    """Main function to run the script."""
+    if args is None:
+        args = sys.argv[1:]
+    if len(args) != 2:
+        print("USAGE: %s BEHAVE_FILE.json CUCUMBER_FILE.json" % NAME)
+        print("Converts behave JSON dialect to cucumber JSON dialect.")
+        return 1
+
+    behave_filename = args[0]
+    cucumber_filename = args[1]
+    return convert_behave_to_cucumber_json(behave_filename, cucumber_filename)
+
+# -- AUTO-MAIN:
+if __name__ == "__main__":
+    sys.exit(main())

data/vendor/behave/bin/behave_cmd.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+# -- ENSURE: Use local path during development.
+import sys
+import os.path
+
+# ----------------------------------------------------------------------------
+# SETUP PATHS:
+# ----------------------------------------------------------------------------
+NAME = "behave"
+HERE = os.path.dirname(__file__)
+TOP  = os.path.join(HERE, "..")
+if os.path.isdir(os.path.join(TOP, NAME)):
+    sys.path.insert(0, os.path.abspath(TOP))
+
+# ----------------------------------------------------------------------------
+# BEHAVE-TWEAKS:
+# ----------------------------------------------------------------------------
+def setup_behave():
+    """
+    Apply tweaks, extensions and patches to "behave".
+    """
+    from behave.configuration import Configuration
+    # -- DISABLE: Timings to simplify issue.features/ tests.
+    # Configuration.defaults["format0"] = "pretty"
+    # Configuration.defaults["format0"] = "progress"
+    Configuration.defaults["show_timings"] = False
+
+def behave_main0():
+    # from behave.configuration import Configuration
+    from behave.__main__ import main as behave_main
+    setup_behave()
+    return behave_main()
+
+# ----------------------------------------------------------------------------
+# MAIN:
+# ----------------------------------------------------------------------------
+if __name__ == "__main__":
+    if "COVERAGE_PROCESS_START" in os.environ:
+        import coverage
+        coverage.process_startup()
+    sys.exit(behave_main0())

data/vendor/behave/bin/convert_i18n_yaml.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+# USAGE: convert_i18n_yaml.py [--data=i18n.yml] behave/i18n.py
+"""
+Generates I18N python module based on YAML description (i18n.yml).
+
+REQUIRES:
+  * argparse
+  * six
+  * PyYAML
+"""
+
+from __future__ import absolute_import, print_function
+import argparse
+import os.path
+import six
+import sys
+import pprint
+import yaml
+
+HERE = os.path.dirname(__file__)
+NAME = os.path.basename(__file__)
+__version__ = "1.0"
+
+def yaml_normalize(data):
+    for part in data:
+        keywords = data[part]
+        for k in keywords:
+            v = keywords[k]
+            # bloody YAML parser returns a mixture of unicode and str
+            if not isinstance(v, six.text_type):
+                v = v.decode("UTF-8")
+            keywords[k] = v.split("|")
+    return data
+
+def main(args=None):
+    if args is None:
+        args = sys.argv[1:]
+    parser = argparse.ArgumentParser(prog=NAME,
+                description="Generate python module i18n from YAML based data")
+    parser.add_argument("-d", "--data", dest="yaml_file",
+                default=os.path.join(HERE, "i18n.yml"),
+                help="Path to i18n.yml file (YAML file).")
+    parser.add_argument("output_file", default="stdout",
+                help="Filename of Python I18N module (as output).")
+    parser.add_argument("--version", action="version", version=__version__)
+
+    options = parser.parse_args(args)
+    if not os.path.isfile(options.yaml_file):
+        parser.error("YAML file not found: %s" % options.yaml_file)
+
+    # -- STEP 1: Load YAML data.
+    languages = yaml.load(open(options.yaml_file))
+    languages = yaml_normalize(languages)
+
+    # -- STEP 2: Generate python module with i18n data.
+    contents = u"""# -*- coding: UTF-8 -*-
+# -- FILE GENERATED BY: convert_i18n_yaml.py with i18n.yml
+# pylint: disable=line-too-long
+
+languages = \\
+"""
+    if options.output_file in ("-", "stdout"):
+        i18n_py = sys.stdout
+        should_close = False
+    else:
+        i18n_py = open(options.output_file, "w")
+        should_close = True
+    i18n_py.write(contents.encode("UTF-8"))
+    i18n_py.write(pprint.pformat(languages).encode("UTF-8"))
+    i18n_py.write(u"\n")
+    if should_close:
+        i18n_py.close()
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())