busser-behave 0.1.3

data/vendor/behave/behave4cmd0/command_util.py

@@ -0,0 +1,147 @@
+# -*- coding -*-
+"""
+Provides some command utility functions.
+
+TODO:
+  matcher that ignores empty lines and whitespace and has contains comparison
+"""
+
+from __future__ import absolute_import, print_function
+from behave4cmd0 import pathutil
+from behave4cmd0.__setup import TOP, TOPA
+import os.path
+import sys
+import shutil
+import time
+import tempfile
+from fnmatch import fnmatch
+
+# -----------------------------------------------------------------------------
+# CONSTANTS:
+# -----------------------------------------------------------------------------
+# HERE    = os.path.dirname(__file__)
+# TOP     = os.path.join(HERE, "..")
+# TOPA    = os.path.abspath(TOP)
+WORKDIR = os.path.join(TOP, "__WORKDIR__")
+
+
+# -----------------------------------------------------------------------------
+# UTILITY FUNCTIONS:
+# -----------------------------------------------------------------------------
+def workdir_save_coverage_files(workdir, destdir=None):
+    assert os.path.isdir(workdir)
+    if not destdir:
+        destdir = TOPA
+    if os.path.abspath(workdir) == os.path.abspath(destdir):
+        return  # -- SKIP: Source directory is destination directory (SAME).
+
+    for fname in os.listdir(workdir):
+        if fnmatch(fname, ".coverage.*"):
+            # -- MOVE COVERAGE FILES:
+            sourcename = os.path.join(workdir, fname)
+            shutil.move(sourcename, destdir)
+
+# def ensure_directory_exists(dirname):
+#     """
+#     Ensures that a directory exits.
+#     If it does not exist, it is automatically created.
+#     """
+#     if not os.path.exists(dirname):
+#         os.makedirs(dirname)
+#     assert os.path.exists(dirname)
+#     assert os.path.isdir(dirname)
+
+def ensure_context_attribute_exists(context, name, default_value=None):
+    """
+    Ensure a behave resource exists as attribute in the behave context.
+    If this is not the case, the attribute is created by using the default_value.
+    """
+    if not hasattr(context, name):
+        setattr(context, name, default_value)
+
+def ensure_workdir_exists(context):
+    """
+    Ensures that the work directory exists.
+    In addition, the location of the workdir is stored as attribute in
+    the context object.
+    """
+    ensure_context_attribute_exists(context, "workdir", None)
+    if not context.workdir:
+        context.workdir = os.path.abspath(WORKDIR)
+    pathutil.ensure_directory_exists(context.workdir)
+
+def ensure_workdir_not_exists(context):
+    """Ensures that the work directory does not exist."""
+    ensure_context_attribute_exists(context, "workdir", None)
+    if context.workdir:
+        orig_dirname = real_dirname = context.workdir
+        context.workdir = None
+        if os.path.exists(real_dirname):
+            renamed_dirname = tempfile.mktemp(prefix=os.path.basename(real_dirname),
+                                              suffix="_DEAD",
+                                          dir=os.path.dirname(real_dirname) or ".")
+            os.rename(real_dirname, renamed_dirname)
+            real_dirname = renamed_dirname
+        max_iterations = 2
+        if sys.platform.startswith("win"):
+            max_iterations = 15
+
+        for iteration in range(max_iterations):
+            if not os.path.exists(real_dirname):
+                if iteration > 1:
+                    print("REMOVE-WORKDIR after %s iterations" % (iteration+1))
+                break
+            shutil.rmtree(real_dirname, ignore_errors=True)
+            time.sleep(0.5)
+        assert not os.path.isdir(real_dirname), "ENSURE not-isa dir: %s" % real_dirname
+        assert not os.path.exists(real_dirname), "ENSURE dir not-exists: %s" % real_dirname
+        assert not os.path.isdir(orig_dirname), "ENSURE not-isa dir: %s" % orig_dirname
+
+
+# def create_textfile_with_contents(filename, contents):
+#     """
+#     Creates a textual file with the provided contents in the workdir.
+#     Overwrites an existing file.
+#     """
+#     ensure_directory_exists(os.path.dirname(filename))
+#     if os.path.exists(filename):
+#         os.remove(filename)
+#     outstream = open(filename, "w")
+#     outstream.write(contents)
+#     if not contents.endswith("\n"):
+#         outstream.write("\n")
+#     outstream.flush()
+#     outstream.close()
+#     assert os.path.exists(filename)
+
+# def text_remove_empty_lines(text):
+#     """
+#     Whitespace normalization:
+#       - Strip empty lines
+#       - Strip trailing whitespace
+#     """
+#     lines = [ line.rstrip()  for line in text.splitlines()  if line.strip() ]
+#     return "\n".join(lines)
+#
+# def text_normalize(text):
+#     """
+#     Whitespace normalization:
+#       - Strip empty lines
+#       - Strip leading whitespace  in a line
+#       - Strip trailing whitespace in a line
+#       - Normalize line endings
+#     """
+#     lines = [ line.strip()  for line in text.splitlines()  if line.strip() ]
+#     return "\n".join(lines)
+
+# def posixpath_normpath(pathname):
+#     """
+#     Convert path into POSIX path:
+#       - Normalize path
+#       - Replace backslash with slash
+#     """
+#     backslash = '\\'
+#     pathname = os.path.normpath(pathname)
+#     if backslash in pathname:
+#         pathname = pathname.replace(backslash, '/')
+#     return pathname

data/vendor/behave/behave4cmd0/failing_steps.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+"""
+Generic failing steps.
+Often needed in examples.
+
+EXAMPLES:
+
+    Given a step fails
+    When  another step fails
+    Then  a step fails
+
+    Given ...
+    When  ...
+    Then  it should fail because "the person is unknown".
+"""
+
+from __future__ import absolute_import
+from behave import step, then
+
+# -----------------------------------------------------------------------------
+# STEPS FOR: failing
+# -----------------------------------------------------------------------------
+@step(u'{word:w} step fails')
+def step_fails(context, word):
+    """Step that always fails, mostly needed in examples."""
+    assert False, "EXPECT: Failing step"
+
+@step(u'{word:w} step fails with "{message}"')
+def step_fails_with_message(context, word, message):
+    """Step that always fails, mostly needed in examples."""
+    assert False, "FAILED: %s" % message
+
+@step(u'{word:w} step fails with')
+def step_fails_with_text(context, word):
+    """Step that always fails, mostly needed in examples."""
+    assert context.text is not None, "REQUIRE: text"
+    step_fails_with_message(context, word, context.text)
+
+@then(u'it should fail because "{reason}"')
+def then_it_should_fail_because(context, reason):
+    """Self documenting step that indicates why this step should fail."""
+    assert False, "FAILED: %s" % reason
+
+# @step(u'an error should fail because "{reason}"')
+# def then_it_should_fail_because(context, reason):
+#     """
+#    Self documenting step that indicates why this step should fail.
+#    """
+#    assert False, reason

data/vendor/behave/behave4cmd0/log/__init__.py

@@ -0,0 +1 @@
+__author__ = 'jens'

data/vendor/behave/behave4cmd0/log/steps.py

@@ -0,0 +1,395 @@
+# -*- coding: utf-8 -*-
+"""
+Provides step definitions to perform tests with the Python logging subsystem.
+
+.. code-block: gherkin
+
+    Given I create log records with:
+        | category | level   | message |
+        | foo.bar  | WARN    | Hello LogRecord |
+        | bar      | CURRENT | Hello LogRecord |
+    And I create a log record with:
+        | category | level   | message |
+        | foo      | ERROR   | Hello Foo |
+    Then the command output should contain the following log records:
+        | category | level   | message |
+        | bar      | CURRENT | xxx     |
+    Then the command output should not contain the following log records:
+        | category | level   | message |
+        | bar      | CURRENT | xxx     |
+    Then the file "behave.log" should contain the log records:
+        | category | level   | message |
+        | bar      | CURRENT | xxx     |
+    Then the file "behave.log" should not contain the log records:
+        | category | level   | message |
+        | bar      | CURRENT | xxx     |
+
+    Given I define the log record schema:
+        | category | level   | message |
+        | root     | INFO    | Hello LogRecord |
+    And I create log records with:
+        | category | level   | message |
+        | foo.bar  | INFO    | Hello LogRecord |
+        | bar      | INFO    | Hello LogRecord |
+    Then the command output should contain log records from categories
+        | category |
+        | foo.bar  |
+        | bar      |
+
+    Given I use the log record configuration:
+        | property | value |
+        | format   | LOG.%(levelname)-8s %(name)s %(message)s |
+        | datefmt  |       |
+
+IDEA:
+
+.. code-block:: gherkin
+
+    Given I capture log records
+    When I create log records with:
+        | category | level   | message |
+        | foo.bar  | WARN    | Hello LogRecord |
+    Then the captured log should contain the following log records:
+        | category | level   | message |
+        | bar      | CURRENT | xxx     |
+    And the captured log should not contain the following log records:
+        | category | level   | message |
+        | bar      | CURRENT | xxx     |
+"""
+
+from __future__ import absolute_import
+from behave import given, when, then, step
+from behave4cmd0.command_steps import \
+    step_file_should_contain_multiline_text, \
+    step_file_should_not_contain_multiline_text
+from behave.configuration import LogLevel
+from behave.log_capture import LoggingCapture
+import logging
+
+# -----------------------------------------------------------------------------
+# STEP UTILS:
+# -----------------------------------------------------------------------------
+def make_log_record(category, level, message):
+    if category in ("root", "__ROOT__"):
+        category = None
+    logger = logging.getLogger(category)
+    logger.log(level, message)
+
+def make_log_record_output(category, level, message,
+                           format=None, datefmt=None, **kwargs):
+    """
+    Create the output for a log record, like performed by :mod:`logging` module.
+
+    :param category:    Name of the logger (as string or None).
+    :param level:       Log level (as number).
+    :param message:     Log message to use.
+    :returns: Log record output (as string)
+    """
+    if not category or (category == "__ROOT__"):
+        category = "root"
+    levelname = logging.getLevelName(level)
+    record_data = dict(name=category, levelname=levelname, msg=message)
+    record_data.update(kwargs)
+    record = logging.makeLogRecord(record_data)
+    formatter = logging.Formatter(format, datefmt=datefmt)
+    return formatter.format(record)
+
+class LogRecordTable(object):
+
+    @classmethod
+    def make_output_for_row(cls, row, format=None, datefmt=None, **kwargs):
+        category = row.get("category", None)
+        level = LogLevel.parse_type(row.get("level", "INFO"))
+        message = row.get("message", "__UNDEFINED__")
+        return make_log_record_output(category, level, message,
+                                      format, datefmt, **kwargs)
+
+    @staticmethod
+    def annotate_with_row_schema(table, row_schema):
+        """
+        Annotate/extend a table of log-records with additional columns from
+        the log-record schema if columns are missing.
+
+        :param table:   Table w/ log-records (as :class:`behave.model.Table`)
+        :param row_schema:  Log-record row schema (as dict).
+        """
+        for column, value in row_schema.items():
+            if column not in table.headings:
+                table.add_column(column, default_value=value)
+
+
+# -----------------------------------------------------------------------------
+# STEP DEFINITIONS:
+# -----------------------------------------------------------------------------
+# @step('I create log records for the following categories')
+# def step_I_create_logrecords_for_categories_with_text(context):
+#     assert context.text is not None, "REQUIRE: context.text"
+#     current_level = context.config.logging_level
+#     categories = context.text.split()
+#     for category_name in categories:
+#         logger = logging.getLogger(category_name)
+#         logger.log(current_level, "__LOG_RECORD__")
+
+@step('I create log records with')
+def step_I_create_logrecords_with_table(context):
+    """
+    Step definition that creates one more log records by using a table.
+
+    .. code-block: gherkin
+
+        When I create log records with:
+            | category | level | message   |
+            |  foo     | ERROR | Hello Foo |
+            |  foo.bar | WARN  | Hello Foo.Bar |
+
+    Table description
+    ------------------
+
+    | Column   | Type     | Required | Description |
+    | category | string   | yes      | Category (or logger) to use. |
+    | level    | LogLevel | yes      | Log level to use.   |
+    | message  | string   | yes      | Log message to use. |
+
+    .. code-block: python
+
+        import logging
+        from behave.configuration import LogLevel
+        for row in table.rows:
+            logger = logging.getLogger(row.category)
+            level  = LogLevel.parse_type(row.level)
+            logger.log(level, row.message)
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["category", "level", "message"])
+    for row in context.table.rows:
+        category = row["category"]
+        if category == "__ROOT__":
+            category = None
+        level = LogLevel.parse_type(row["level"])
+        message = row["message"]
+        make_log_record(category, level, message)
+
+
+@step('I create a log record with')
+def step_I_create_logrecord_with_table(context):
+    """
+    Create an log record by using a table to provide the parts.
+
+    .. seealso: :func:`step_I_create_logrecords_with_table()`
+    """
+    assert context.table, "REQUIRE: context.table"
+    assert len(context.table.rows) == 1, "REQUIRE: table.row.size == 1"
+    step_I_create_logrecords_with_table(context)
+
+@step('I define the log record schema')
+def step_I_define_logrecord_schema_with_table(context):
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["category", "level", "message"])
+    assert len(context.table.rows) == 1, \
+        "REQUIRE: context.table.rows.size(%s) == 1" % (len(context.table.rows))
+
+    row = context.table.rows[0]
+    row_schema = dict(category=row["category"], level=row["level"],
+                  message=row["message"])
+    context.log_record_row_schema = row_schema
+
+
+@then('the command output should contain the following log records')
+def step_command_output_should_contain_log_records(context):
+    """
+    Verifies that the command output contains the specified log records
+    (in any order).
+
+    .. code-block: gherkin
+
+        Then the command output should contain the following log records:
+            | category | level   | message |
+            | bar      | CURRENT | xxx     |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["category", "level", "message"])
+    format = getattr(context, "log_record_format", context.config.logging_format)
+    for row in context.table.rows:
+        output = LogRecordTable.make_output_for_row(row, format)
+        context.execute_steps(u'''
+            Then the command output should contain:
+                """
+                {expected_output}
+                """
+            '''.format(expected_output=output))
+
+
+@then('the command output should not contain the following log records')
+def step_command_output_should_not_contain_log_records(context):
+    """
+    Verifies that the command output contains the specified log records
+    (in any order).
+
+    .. code-block: gherkin
+
+        Then the command output should contain the following log records:
+            | category | level   | message |
+            | bar      | CURRENT | xxx     |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["category", "level", "message"])
+    format = getattr(context, "log_record_format", context.config.logging_format)
+    for row in context.table.rows:
+        output = LogRecordTable.make_output_for_row(row, format)
+        context.execute_steps(u'''
+            Then the command output should not contain:
+                """
+                {expected_output}
+                """
+            '''.format(expected_output=output))
+
+@then('the command output should contain the following log record')
+def step_command_output_should_contain_log_record(context):
+    assert context.table, "REQUIRE: context.table"
+    assert len(context.table.rows) == 1, "REQUIRE: table.row.size == 1"
+    step_command_output_should_contain_log_records(context)
+
+
+@then('the command output should not contain the following log record')
+def step_command_output_should_not_contain_log_record(context):
+    assert context.table, "REQUIRE: context.table"
+    assert len(context.table.rows) == 1, "REQUIRE: table.row.size == 1"
+    step_command_output_should_not_contain_log_records(context)
+
+@then('the command output should contain log records from categories')
+def step_command_output_should_contain_log_records_from_categories(context):
+    """
+    Verifies that the command output contains the specified log records
+    (in any order).
+
+    .. code-block: gherkin
+
+        Given I define a log record schema:
+            | category | level | message |
+            | root     | ERROR | __LOG_MESSAGE__ |
+        Then the command output should contain log records from categories:
+            | category |
+            | bar      |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_column("category")
+    record_schema = context.log_record_row_schema
+    LogRecordTable.annotate_with_row_schema(context.table, record_schema)
+    step_command_output_should_contain_log_records(context)
+    context.table.remove_columns(["level", "message"])
+
+
+@then('the command output should not contain log records from categories')
+def step_command_output_should_not_contain_log_records_from_categories(context):
+    """
+    Verifies that the command output contains not log records from
+    the provided log categories (in any order).
+
+    .. code-block: gherkin
+
+        Given I define the log record schema:
+            | category | level | message |
+            | root     | ERROR | __LOG_MESSAGE__ |
+        Then the command output should not contain log records from categories:
+            | category |
+            | bar      |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_column("category")
+    record_schema = context.log_record_row_schema
+    LogRecordTable.annotate_with_row_schema(context.table, record_schema)
+    step_command_output_should_not_contain_log_records(context)
+    context.table.remove_columns(["level", "message"])
+
+@then('the file "{filename}" should contain the log records')
+def step_file_should_contain_log_records(context, filename):
+    """
+    Verifies that the command output contains the specified log records
+    (in any order).
+
+    .. code-block: gherkin
+
+        Then the file "xxx.log" should contain the log records:
+            | category | level   | message |
+            | bar      | CURRENT | xxx     |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["category", "level", "message"])
+    format = getattr(context, "log_record_format", context.config.logging_format)
+    for row in context.table.rows:
+        output = LogRecordTable.make_output_for_row(row, format)
+        context.text = output
+        step_file_should_contain_multiline_text(context, filename)
+
+@then('the file "{filename}" should not contain the log records')
+def step_file_should_not_contain_log_records(context, filename):
+    """
+    Verifies that the command output contains the specified log records
+    (in any order).
+
+    .. code-block: gherkin
+
+        Then the file "xxx.log" should not contain the log records:
+            | category | level   | message |
+            | bar      | CURRENT | xxx     |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["category", "level", "message"])
+    format = getattr(context, "log_record_format", context.config.logging_format)
+    for row in context.table.rows:
+        output = LogRecordTable.make_output_for_row(row, format)
+        context.text = output
+        step_file_should_not_contain_multiline_text(context, filename)
+
+
+@step('I use "{log_record_format}" as log record format')
+def step_use_log_record_format_text(context, log_record_format):
+    context.log_record_format = log_record_format
+
+@step('I use the log record configuration')
+def step_use_log_record_configuration(context):
+    """
+    Define log record configuration parameters.
+
+    .. code-block: gherkin
+
+        Given I use the log record configuration:
+            | property | value |
+            | format   |       |
+            | datefmt  |       |
+    """
+    assert context.table, "REQUIRE: context.table"
+    context.table.require_columns(["property", "value"])
+    for row in context.table.rows:
+        property_name = row["property"]
+        value = row["value"]
+        if property_name == "format":
+            context.log_record_format = value
+        elif property_name == "datefmt":
+            context.log_record_datefmt = value
+        else:
+            raise KeyError("Unknown property=%s" % property_name)
+
+
+# -----------------------------------------------------------------------------
+# TODO: STEP DEFINITIONS:
+# -----------------------------------------------------------------------------
+@step('I capture log records with level "{level}" or above')
+def step_I_capture_logrecords(context, level):
+    raise NotImplementedError()
+
+
+@step('I capture log records')
+def step_I_capture_logrecords(context):
+    """
+
+    .. code-block: gherkin
+        Given I capture log records
+        When I capture log records
+
+    :param context:
+    """
+    raise NotImplementedError()
+    logcapture = getattr(context, "logcapture", None)
+    if not logcapture:
+        context.logcapture = LoggingCapture()