busser-behave 0.1.3

data/vendor/behave/behave4cmd0/command_shell_proc.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+This module provides pre-/post-processors for the mod:`behave4cmd0.command_shell`.
+"""
+
+from __future__ import absolute_import, print_function
+import re
+import sys
+from six import string_types
+
+
+# -----------------------------------------------------------------------------
+# UTILITY:
+# -----------------------------------------------------------------------------
+def posixpath_normpath(filename):
+    if not filename:
+        return filename
+    return filename.replace("\\", "/").replace("//", "/")
+
+
+# -----------------------------------------------------------------------------
+# LINE PROCESSORS:
+# -----------------------------------------------------------------------------
+class LineProcessor(object):
+    """Function-like object that may perform text-line transformations."""
+    def __init__(self, marker=None):
+        self.marker = marker
+
+    def reset(self):
+        pass
+
+    def __call__(self, text):
+        return text
+
+
+class TracebackLineNormalizer(LineProcessor):
+    """Line processor that tries to normalize path lines in a traceback dump."""
+    marker = "Traceback (most recent call last):"
+    file_pattern = re.compile(r'\s\s+File "(?P<path>.*)", line .*')
+
+    def __init__(self):
+        super(TracebackLineNormalizer, self).__init__(self.marker)
+        self.traceback_section = False
+
+    def reset(self):
+        self.traceback_section = False
+
+    def __call__(self, line):
+        """Process a line and optionally transform it.
+
+        :param line: line to process (as text)
+        :return: Same line or transformed/normalized line (as text).
+        """
+        marker = self.marker
+        stripped_line = line.strip()
+        if marker == stripped_line:
+            assert not self.traceback_section
+            self.traceback_section = True
+            # print("XXX: TRACEBACK-START")
+        elif self.traceback_section:
+            matched = self.file_pattern.match(line)
+            if matched:
+                # matched_range = matched.regs[1]
+                filename = matched.groups()[0]
+                new_filename = posixpath_normpath(filename)
+                if new_filename != filename:
+                    # print("XXX: %r => %r" % (filename, new_filename))
+                    line = line.replace(filename, new_filename)
+            elif not stripped_line or line[0].isalpha():
+                # -- DETECTED TRCAEBACK-END: exception-description
+                # print("XXX: TRACEBACK-END")
+                self.traceback_section = False
+        return line
+
+
+class ExceptionWithPathNormalizer(LineProcessor):
+    """Normalize filename path in Exception line (for Windows)."""
+    # http://myregexp.com/examples.html
+    # Windows File Name Regexp
+    # (?i) ^ (?! ^ (PRN | AUX | CLOCK\$ | NUL | CON | COM\d | LPT\d |\..* )(\..+)?$)
+    # [ ^\\\./:\ * \?\"<>\|][^\\/:\*\?\"<>\|]{0,254}$
+    problematic_path_patterns = [
+        'ConfigError: No steps directory in "(?P<path>.*)"',
+        'ParserError: Failed to parse "(?P<path>.*)"',
+        "Error: [Errno 2] No such file or directory: '(?P<path>.*)'",
+    ]
+
+    def __init__(self, pattern, marker_text=None):
+        super(ExceptionWithPathNormalizer, self).__init__(marker_text)
+        self.pattern = re.compile(pattern, re.UNICODE)
+        self.marker = marker_text
+
+    def __call__(self, line):
+        matched = self.pattern.search(line)
+        if matched:
+            # -- ONLY: One pattern per line should match.
+            filename = matched.groupdict()["path"]
+            new_filename = posixpath_normpath(filename)
+            if new_filename != filename:
+                line = line.replace(filename, new_filename)
+        return line
+
+
+# -----------------------------------------------------------------------------
+# COMMAND OUTPUT PROCESSORS:
+# -----------------------------------------------------------------------------
+class CommandPostProcessor(object):
+    """Syntactic sugar to mark a command post-processor."""
+
+
+class CommandOutputProcessor(CommandPostProcessor):
+    """Abstract base class functionality for a CommandPostProcessor that
+    post-processes the output of a command.
+    """
+    enabled = True
+    output_parts = ("stderr", "stdout")
+
+    def __init__(self, enabled=None, output_parts=None):
+        if enabled is None:
+            # -- AUTO-DETECT: Enabled on Windows platform
+            enabled = self.__class__.enabled
+        if output_parts is None:
+            output_parts = self.__class__.output_parts
+        self.enabled = enabled
+        self.output_parts = output_parts
+
+    def matches_output(self, text):
+        """Abstract method that should be overwritten."""
+        # pylint: disable=no-self-use, unused-argument
+        return False
+
+    def process_output(self, text):   # pylint: disable=no-self-use
+        """Abstract method that should be overwritten."""
+        changed = False
+        return changed, text
+
+    def __call__(self, command_result):
+        """Core functionality of command output processor.
+
+        :param command_result:  As value object w/ command execution details.
+        :return: Command result
+        """
+        if not self.enabled:
+            return command_result
+
+        changes = 0
+        for output_name in self.output_parts:
+            output = getattr(command_result, output_name)
+            if output and self.matches_output(output):
+                changed, new_output = self.process_output(output)
+                if changed:
+                    changes += 1
+                    setattr(command_result, output_name, new_output)
+
+        if changes:
+            # -- RESET: Composite output
+            # pylint: disable=protected-access
+            command_result._output = None
+        return command_result
+
+
+class LineCommandOutputProcessor(CommandOutputProcessor):
+    """Provides functionality to process text in line-oriented way by using
+    a number of line processors. The line processors perform the actual work
+    for transforming/normalizing the text.
+    """
+    enabled = True
+    line_processors = [TracebackLineNormalizer()]
+
+    def __init__(self, line_processors=None):
+        if line_processors is None:
+            line_processors = self.__class__.line_processors
+        super(LineCommandOutputProcessor, self).__init__(self.enabled)
+        self.line_processors = line_processors
+        self.markers = [p.marker for p in self.line_processors if p.marker]
+
+    def matches_output(self, text):
+        """Indicates it text contains sections of interest.
+        :param text:    Text to inspect (as string).
+        :return: True, if text contains Traceback sections. False, otherwise.
+        """
+        if self.markers:
+            for marker in self.markers:
+                if marker in text:
+                    return True
+        # -- OTHERWISE:
+        return False
+
+    def process_output(self, text):
+        """Normalizes multi-line text by applying the line processors.
+
+        :param text:    Text to process (as string).
+        :return: Tuple (changed : bool, new_text : string)
+        """
+        new_lines = []
+        changed = False
+        for line_processor in self.line_processors:
+            line_processor.reset()
+
+        for line in text.splitlines():
+            # -- LINE PROCESSING PIPELINE:
+            original_line = line
+            for line_processor in self.line_processors:
+                line = line_processor(line)
+
+            if line != original_line:
+                changed = True
+            new_lines.append(line)
+
+        if changed:
+            text = "\n".join(new_lines) + "\n"
+        return changed, text
+
+class TextProcessor(CommandOutputProcessor):
+    """Provides an adapter that uses an :class:`CommandOutputProcessor`
+    as text processor (normalizer).
+    """
+
+    def __init__(self, command_output_processor):
+        self.command_output_processor = command_output_processor
+        self.enabled = self.command_output_processor.enabled
+        self.output_parts = self.command_output_processor.output_parts
+
+    def process_output(self, text):
+        return self.command_output_processor.process_output(text)
+
+    def __call__(self, command_result):
+        if isinstance(command_result, string_types):
+            text = command_result
+            return self.command_output_processor.process_output(text)[1]
+        else:
+            return self.command_output_processor(command_result)
+
+
+class BehaveWinCommandOutputProcessor(LineCommandOutputProcessor):
+    """Command output post-processor for :mod:`behave` on Windows platform.
+    Mostly, normalizes windows paths in output and exceptions to conform to
+    POSIX path conventions.
+    """
+    enabled = sys.platform.startswith("win") or True
+    line_processors = [
+        TracebackLineNormalizer(),
+        ExceptionWithPathNormalizer(
+            "ConfigError: No steps directory in '(?P<path>.*)'",
+            "ConfigError: No steps directory in"),
+        ExceptionWithPathNormalizer(
+            'ParserError: Failed to parse "(?P<path>.*)"',
+            "ParserError: Failed to parse"),
+        ExceptionWithPathNormalizer(
+            "No such file or directory: '(?P<path>.*)'",
+            "[Errno 2] No such file or directory:"),  # IOError
+        ExceptionWithPathNormalizer(
+            '^\s*File "(?P<path>.*)", line \d+, in ',
+            'File "'),
+    ]

data/vendor/behave/behave4cmd0/command_steps.py

@@ -0,0 +1,532 @@
+# -*- coding -*-
+"""
+Provides step definitions to:
+
+    * run commands, like behave
+    * create textual files within a working directory
+
+TODO:
+  matcher that ignores empty lines and whitespace and has contains comparison
+"""
+
+from __future__ import absolute_import, print_function
+from behave import given, when, then, step, matchers
+from behave4cmd0 import command_shell, command_util, pathutil, textutil
+from behave4cmd0.pathutil import posixpath_normpath
+from behave4cmd0.command_shell_proc import \
+    TextProcessor, BehaveWinCommandOutputProcessor
+import contextlib
+import difflib
+import os
+import shutil
+from hamcrest import assert_that, equal_to, is_not, contains_string
+
+# -----------------------------------------------------------------------------
+# INIT:
+# -----------------------------------------------------------------------------
+matchers.register_type(int=int)
+DEBUG = False
+file_contents_normalizer = None
+if BehaveWinCommandOutputProcessor.enabled:
+    file_contents_normalizer = TextProcessor(BehaveWinCommandOutputProcessor())
+
+
+# -----------------------------------------------------------------------------
+# UTILITIES:
+# -----------------------------------------------------------------------------
+@contextlib.contextmanager
+def on_assert_failed_print_details(actual, expected):
+    """
+    Print text details in case of assertation failed errors.
+
+    .. sourcecode:: python
+
+        with on_assert_failed_print_details(actual_text, expected_text):
+            assert actual == expected
+    """
+    try:
+        yield
+    except AssertionError:
+        # diff = difflib.unified_diff(expected.splitlines(), actual.splitlines(),
+        #                            "expected", "actual")
+        diff = difflib.ndiff(expected.splitlines(), actual.splitlines())
+        diff_text = u"\n".join(diff)
+        print(u"DIFF (+ ACTUAL, - EXPECTED):\n{0}\n".format(diff_text))
+        if DEBUG:
+            print(u"expected:\n{0}\n".format(expected))
+            print(u"actual:\n{0}\n".format(actual))
+        raise
+
+@contextlib.contextmanager
+def on_error_print_details(actual, expected):
+    """
+    Print text details in case of assertation failed errors.
+
+    .. sourcecode:: python
+
+        with on_error_print_details(actual_text, expected_text):
+            ... # Do something
+    """
+    try:
+        yield
+    except Exception:
+        diff = difflib.ndiff(expected.splitlines(), actual.splitlines())
+        diff_text = u"\n".join(diff)
+        print(u"DIFF (+ ACTUAL, - EXPECTED):\n{0}\n".format(diff_text))
+        if DEBUG:
+            print(u"expected:\n{0}\n".format(expected))
+            print(u"actual:\n{0}".format(actual))
+        raise
+
+# -----------------------------------------------------------------------------
+# STEPS: WORKING DIR
+# -----------------------------------------------------------------------------
+@given(u'a new working directory')
+def step_a_new_working_directory(context):
+    """Creates a new, empty working directory."""
+    command_util.ensure_context_attribute_exists(context, "workdir", None)
+    # MAYBE: command_util.ensure_workdir_not_exists(context)
+    command_util.ensure_workdir_exists(context)
+    # OOPS:
+    shutil.rmtree(context.workdir, ignore_errors=True)
+    command_util.ensure_workdir_exists(context)
+
+@given(u'I use the current directory as working directory')
+def step_use_curdir_as_working_directory(context):
+    """
+    Uses the current directory as working directory
+    """
+    context.workdir = os.path.abspath(".")
+    command_util.ensure_workdir_exists(context)
+
+# -----------------------------------------------------------------------------
+# STEPS: Create files with contents
+# -----------------------------------------------------------------------------
+@given(u'a file named "{filename}" and encoding="{encoding}" with')
+def step_a_file_named_filename_and_encoding_with(context, filename, encoding):
+    """Creates a textual file with the content provided as docstring."""
+    __encoding_is_valid = True
+    assert context.text is not None, "ENSURE: multiline text is provided."
+    assert not os.path.isabs(filename)
+    assert __encoding_is_valid
+    command_util.ensure_workdir_exists(context)
+    filename2 = os.path.join(context.workdir, filename)
+    pathutil.create_textfile_with_contents(filename2, context.text, encoding)
+
+
+@given(u'a file named "{filename}" with')
+def step_a_file_named_filename_with(context, filename):
+    """Creates a textual file with the content provided as docstring."""
+    step_a_file_named_filename_and_encoding_with(context, filename, "UTF-8")
+
+    # -- SPECIAL CASE: For usage with behave steps.
+    if filename.endswith(".feature"):
+        command_util.ensure_context_attribute_exists(context, "features", [])
+        context.features.append(filename)
+
+
+@given(u'an empty file named "{filename}"')
+def step_an_empty_file_named_filename(context, filename):
+    """
+    Creates an empty file.
+    """
+    assert not os.path.isabs(filename)
+    command_util.ensure_workdir_exists(context)
+    filename2 = os.path.join(context.workdir, filename)
+    pathutil.create_textfile_with_contents(filename2, "")
+
+
+# -----------------------------------------------------------------------------
+# STEPS: Run commands
+# -----------------------------------------------------------------------------
+@when(u'I run "{command}"')
+@when(u'I run `{command}`')
+def step_i_run_command(context, command):
+    """
+    Run a command as subprocess, collect its output and returncode.
+    """
+    command_util.ensure_workdir_exists(context)
+    context.command_result = command_shell.run(command, cwd=context.workdir)
+    command_util.workdir_save_coverage_files(context.workdir)
+    if False and DEBUG:
+        print(u"run_command: {0}".format(command))
+        print(u"run_command.output {0}".format(context.command_result.output))
+
+@when(u'I successfully run "{command}"')
+@when(u'I successfully run `{command}`')
+def step_i_successfully_run_command(context, command):
+    step_i_run_command(context, command)
+    step_it_should_pass(context)
+
+@then(u'it should fail with result "{result:int}"')
+def step_it_should_fail_with_result(context, result):
+    assert_that(context.command_result.returncode, equal_to(result))
+    assert_that(result, is_not(equal_to(0)))
+
+@then(u'the command should fail with returncode="{result:int}"')
+def step_it_should_fail_with_returncode(context, result):
+    assert_that(context.command_result.returncode, equal_to(result))
+    assert_that(result, is_not(equal_to(0)))
+
+@then(u'the command returncode is "{result:int}"')
+def step_the_command_returncode_is(context, result):
+    assert_that(context.command_result.returncode, equal_to(result))
+
+@then(u'the command returncode is non-zero')
+def step_the_command_returncode_is_nonzero(context):
+    assert_that(context.command_result.returncode, is_not(equal_to(0)))
+
+@then(u'it should pass')
+def step_it_should_pass(context):
+    assert_that(context.command_result.returncode, equal_to(0),
+                context.command_result.output)
+
+@then(u'it should fail')
+def step_it_should_fail(context):
+    assert_that(context.command_result.returncode, is_not(equal_to(0)),
+                context.command_result.output)
+
+@then(u'it should pass with')
+def step_it_should_pass_with(context):
+    '''
+    EXAMPLE:
+        ...
+        when I run "behave ..."
+        then it should pass with:
+            """
+            TEXT
+            """
+    '''
+    assert context.text is not None, "ENSURE: multiline text is provided."
+    step_command_output_should_contain(context)
+    assert_that(context.command_result.returncode, equal_to(0),
+                context.command_result.output)
+
+
+@then(u'it should fail with')
+def step_it_should_fail_with(context):
+    '''
+    EXAMPLE:
+        ...
+        when I run "behave ..."
+        then it should fail with:
+            """
+            TEXT
+            """
+    '''
+    assert context.text is not None, "ENSURE: multiline text is provided."
+    step_command_output_should_contain(context)
+    assert_that(context.command_result.returncode, is_not(equal_to(0)))
+
+
+# -----------------------------------------------------------------------------
+# STEPS FOR: Output Comparison
+# -----------------------------------------------------------------------------
+@then(u'the command output should contain "{text}"')
+def step_command_output_should_contain_text(context, text):
+    '''
+    EXAMPLE:
+        ...
+        Then the command output should contain "TEXT"
+    '''
+    expected_text = text
+    if "{__WORKDIR__}" in expected_text or "{__CWD__}" in expected_text:
+        expected_text = textutil.template_substitute(text,
+             __WORKDIR__ = posixpath_normpath(context.workdir),
+             __CWD__     = posixpath_normpath(os.getcwd())
+        )
+    actual_output = context.command_result.output
+    with on_assert_failed_print_details(actual_output, expected_text):
+        textutil.assert_normtext_should_contain(actual_output, expected_text)
+
+
+@then(u'the command output should not contain "{text}"')
+def step_command_output_should_not_contain_text(context, text):
+    '''
+    EXAMPLE:
+        ...
+        then the command output should not contain "TEXT"
+    '''
+    expected_text = text
+    if "{__WORKDIR__}" in text or "{__CWD__}" in text:
+        expected_text = textutil.template_substitute(text,
+             __WORKDIR__ = posixpath_normpath(context.workdir),
+             __CWD__     = posixpath_normpath(os.getcwd())
+        )
+    actual_output  = context.command_result.output
+    with on_assert_failed_print_details(actual_output, expected_text):
+        textutil.assert_normtext_should_not_contain(actual_output, expected_text)
+
+
+@then(u'the command output should contain "{text}" {count:d} times')
+def step_command_output_should_contain_text_multiple_times(context, text, count):
+    '''
+    EXAMPLE:
+        ...
+        Then the command output should contain "TEXT" 3 times
+    '''
+    assert count >= 0
+    expected_text = text
+    if "{__WORKDIR__}" in expected_text or "{__CWD__}" in expected_text:
+        expected_text = textutil.template_substitute(text,
+             __WORKDIR__ = posixpath_normpath(context.workdir),
+             __CWD__     = posixpath_normpath(os.getcwd())
+        )
+    actual_output = context.command_result.output
+    with on_assert_failed_print_details(actual_output, expected_text):
+        textutil.assert_normtext_should_contain_multiple_times(actual_output,
+                                                               expected_text,
+                                                               count)
+
+@then(u'the command output should contain exactly "{text}"')
+def step_command_output_should_contain_exactly_text(context, text):
+    """
+    Verifies that the command output of the last command contains the
+    expected text.
+
+    .. code-block:: gherkin
+
+        When I run "echo Hello"
+        Then the command output should contain "Hello"
+    """
+    expected_text = text
+    if "{__WORKDIR__}" in text or "{__CWD__}" in text:
+        expected_text = textutil.template_substitute(text,
+             __WORKDIR__ = posixpath_normpath(context.workdir),
+             __CWD__     = posixpath_normpath(os.getcwd())
+        )
+    actual_output  = context.command_result.output
+    textutil.assert_text_should_contain_exactly(actual_output, expected_text)
+
+
+@then(u'the command output should not contain exactly "{text}"')
+def step_command_output_should_not_contain_exactly_text(context, text):
+    expected_text = text
+    if "{__WORKDIR__}" in text or "{__CWD__}" in text:
+        expected_text = textutil.template_substitute(text,
+             __WORKDIR__ = posixpath_normpath(context.workdir),
+             __CWD__     = posixpath_normpath(os.getcwd())
+        )
+    actual_output  = context.command_result.output
+    textutil.assert_text_should_not_contain_exactly(actual_output, expected_text)
+
+
+@then(u'the command output should contain')
+def step_command_output_should_contain(context):
+    '''
+    EXAMPLE:
+        ...
+        when I run "behave ..."
+        then it should pass
+        and  the command output should contain:
+            """
+            TEXT
+            """
+    '''
+    assert context.text is not None, "REQUIRE: multi-line text"
+    step_command_output_should_contain_text(context, context.text)
+
+
+@then(u'the command output should not contain')
+def step_command_output_should_not_contain(context):
+    '''
+    EXAMPLE:
+        ...
+        when I run "behave ..."
+        then it should pass
+        and  the command output should not contain:
+            """
+            TEXT
+            """
+    '''
+    assert context.text is not None, "REQUIRE: multi-line text"
+    step_command_output_should_not_contain_text(context, context.text.strip())
+
+@then(u'the command output should contain {count:d} times')
+def step_command_output_should_contain_multiple_times(context, count):
+    '''
+    EXAMPLE:
+        ...
+        when I run "behave ..."
+        then it should pass
+        and  the command output should contain 2 times:
+            """
+            TEXT
+            """
+    '''
+    assert context.text is not None, "REQUIRE: multi-line text"
+    step_command_output_should_contain_text_multiple_times(context,
+                                                           context.text, count)
+
+@then(u'the command output should contain exactly')
+def step_command_output_should_contain_exactly_with_multiline_text(context):
+    assert context.text is not None, "REQUIRE: multi-line text"
+    step_command_output_should_contain_exactly_text(context, context.text)
+
+
+@then(u'the command output should not contain exactly')
+def step_command_output_should_contain_not_exactly_with_multiline_text(context):
+    assert context.text is not None, "REQUIRE: multi-line text"
+    step_command_output_should_not_contain_exactly_text(context, context.text)
+
+
+# -----------------------------------------------------------------------------
+# STEPS FOR: Directories
+# -----------------------------------------------------------------------------
+@step(u'I remove the directory "{directory}"')
+def step_remove_directory(context, directory):
+    path_ = directory
+    if not os.path.isabs(directory):
+        path_ = os.path.join(context.workdir, os.path.normpath(directory))
+    if os.path.isdir(path_):
+        shutil.rmtree(path_, ignore_errors=True)
+    assert_that(not os.path.isdir(path_))
+
+@given(u'I ensure that the directory "{directory}" does not exist')
+def step_given_the_directory_should_not_exist(context, directory):
+    step_remove_directory(context, directory)
+
+@given(u'a directory named "{path}"')
+def step_directory_named_dirname(context, path):
+    assert context.workdir, "REQUIRE: context.workdir"
+    path_ = os.path.join(context.workdir, os.path.normpath(path))
+    if not os.path.exists(path_):
+        os.makedirs(path_)
+    assert os.path.isdir(path_)
+
+@then(u'the directory "{directory}" should exist')
+def step_the_directory_should_exist(context, directory):
+    path_ = directory
+    if not os.path.isabs(directory):
+        path_ = os.path.join(context.workdir, os.path.normpath(directory))
+    assert_that(os.path.isdir(path_))
+
+@then(u'the directory "{directory}" should not exist')
+def step_the_directory_should_not_exist(context, directory):
+    path_ = directory
+    if not os.path.isabs(directory):
+        path_ = os.path.join(context.workdir, os.path.normpath(directory))
+    assert_that(not os.path.isdir(path_))
+
+@step(u'the directory "{directory}" exists')
+def step_directory_exists(context, directory):
+    """
+    Verifies that a directory exists.
+
+    .. code-block:: gherkin
+
+        Given the directory "abc.txt" exists
+         When the directory "abc.txt" exists
+    """
+    step_the_directory_should_exist(context, directory)
+
+@step(u'the directory "{directory}" does not exist')
+def step_directory_named_does_not_exist(context, directory):
+    """
+    Verifies that a directory does not exist.
+
+    .. code-block:: gherkin
+
+        Given the directory "abc/" does not exist
+         When the directory "abc/" does not exist
+    """
+    step_the_directory_should_not_exist(context, directory)
+
+# -----------------------------------------------------------------------------
+# FILE STEPS:
+# -----------------------------------------------------------------------------
+@step(u'a file named "{filename}" exists')
+def step_file_named_filename_exists(context, filename):
+    """
+    Verifies that a file with this filename exists.
+
+    .. code-block:: gherkin
+
+        Given a file named "abc.txt" exists
+         When a file named "abc.txt" exists
+    """
+    step_file_named_filename_should_exist(context, filename)
+
+@step(u'a file named "{filename}" does not exist')
+def step_file_named_filename_does_not_exist(context, filename):
+    """
+    Verifies that a file with this filename does not exist.
+
+    .. code-block:: gherkin
+
+        Given a file named "abc.txt" does not exist
+         When a file named "abc.txt" does not exist
+    """
+    step_file_named_filename_should_not_exist(context, filename)
+
+@then(u'a file named "{filename}" should exist')
+def step_file_named_filename_should_exist(context, filename):
+    command_util.ensure_workdir_exists(context)
+    filename_ = pathutil.realpath_with_context(filename, context)
+    assert_that(os.path.exists(filename_) and os.path.isfile(filename_))
+
+@then(u'a file named "{filename}" should not exist')
+def step_file_named_filename_should_not_exist(context, filename):
+    command_util.ensure_workdir_exists(context)
+    filename_ = pathutil.realpath_with_context(filename, context)
+    assert_that(not os.path.exists(filename_))
+
+# -----------------------------------------------------------------------------
+# STEPS FOR FILE CONTENTS:
+# -----------------------------------------------------------------------------
+@then(u'the file "{filename}" should contain "{text}"')
+def step_file_should_contain_text(context, filename, text):
+    expected_text = text
+    if "{__WORKDIR__}" in text or "{__CWD__}" in text:
+        expected_text = textutil.template_substitute(text,
+            __WORKDIR__ = posixpath_normpath(context.workdir),
+            __CWD__     = posixpath_normpath(os.getcwd())
+        )
+    file_contents = pathutil.read_file_contents(filename, context=context)
+    file_contents = file_contents.rstrip()
+    if file_contents_normalizer:
+        # -- HACK: Inject TextProcessor as text normalizer
+        file_contents = file_contents_normalizer(file_contents)
+    with on_assert_failed_print_details(file_contents, expected_text):
+        textutil.assert_normtext_should_contain(file_contents, expected_text)
+
+
+@then(u'the file "{filename}" should not contain "{text}"')
+def step_file_should_not_contain_text(context, filename, text):
+    file_contents = pathutil.read_file_contents(filename, context=context)
+    file_contents = file_contents.rstrip()
+    textutil.assert_normtext_should_not_contain(file_contents, text)
+    # XXX assert_that(file_contents, is_not(contains_string(text)))
+
+
+@then(u'the file "{filename}" should contain')
+def step_file_should_contain_multiline_text(context, filename):
+    assert context.text is not None, "REQUIRE: multiline text"
+    step_file_should_contain_text(context, filename, context.text)
+
+
+@then(u'the file "{filename}" should not contain')
+def step_file_should_not_contain_multiline_text(context, filename):
+    assert context.text is not None, "REQUIRE: multiline text"
+    step_file_should_not_contain_text(context, filename, context.text)
+
+
+# -----------------------------------------------------------------------------
+# ENVIRONMENT VARIABLES
+# -----------------------------------------------------------------------------
+@step(u'I set the environment variable "{env_name}" to "{env_value}"')
+def step_I_set_the_environment_variable_to(context, env_name, env_value):
+    if not hasattr(context, "environ"):
+        context.environ = {}
+    context.environ[env_name] = env_value
+    os.environ[env_name] = env_value
+
+@step(u'I remove the environment variable "{env_name}"')
+def step_I_remove_the_environment_variable(context, env_name):
+    if not hasattr(context, "environ"):
+        context.environ = {}
+    context.environ[env_name] = ""
+    os.environ[env_name] = ""
+    del context.environ[env_name]
+    del os.environ[env_name]
+