Escape quote in generation (#327)

* Escape single quotes in generated test names

* Escape single, double, triple-single and triple-double quoted (doc)strings in generated code

Author: Mark90

pytest_bdd/generation.py

@@ -6,7 +6,7 @@
 from mako.lookup import TemplateLookup
 import py
 
-from .scenario import find_argumented_step_fixture_name, make_python_name
+from .scenario import find_argumented_step_fixture_name, make_python_docstring, make_python_name, make_string_literal
 from .steps import get_step_fixture_name
 from .feature import get_features
 from .types import STEP_TYPES
@@ -47,7 +47,12 @@ def generate_code(features, scenarios, steps):
     grouped_steps = group_steps(steps)
     template = template_lookup.get_template("test.py.mak")
     return template.render(
-        features=features, scenarios=scenarios, steps=grouped_steps, make_python_name=make_python_name
+        features=features,
+        scenarios=scenarios,
+        steps=grouped_steps,
+        make_python_name=make_python_name,
+        make_python_docstring=make_python_docstring,
+        make_string_literal=make_string_literal,
     )
 
 

pytest_bdd/scenario.py

@@ -292,6 +292,16 @@ def make_python_name(string):
     return re.sub(ALPHA_REGEX, "", string).lower()
 
 
+def make_python_docstring(string):
+    """Make a python docstring literal out of a given string."""
+    return u'"""{}."""'.format(string.replace(u'"""', u'\\"\\"\\"'))
+
+
+def make_string_literal(string):
+    """Make python string literal out of a given string."""
+    return u"'{}'".format(string.replace(u"'", u"\\'"))
+
+
 def get_python_name_generator(name):
     """Generate a sequence of suitable python names out of given arbitrary string name."""
     python_name = make_python_name(name)

pytest_bdd/scripts.py

@@ -5,6 +5,7 @@
 import re
 
 import glob2
+import six
 
 from .generation import generate_code, parse_feature_files
 
@@ -48,7 +49,10 @@ def print_generated_code(args):
     """Print generated test code for the given filenames."""
     features, scenarios, steps = parse_feature_files(args.files)
     code = generate_code(features, scenarios, steps)
-    print (code)
+    if six.PY2:
+        print (code.encode("utf-8"))
+    else:
+        print (code)
 
 
 def main():

pytest_bdd/templates/test.py.mak

@@ -12,16 +12,16 @@ from pytest_bdd import (
 
 % endif
 % for scenario in sorted(scenarios, key=lambda scenario: scenario.name):
-@scenario('${scenario.feature.rel_filename}', '${scenario.name}')
+@scenario('${scenario.feature.rel_filename}', ${ make_string_literal(scenario.name)})
 def test_${ make_python_name(scenario.name)}():
-    """${scenario.name}."""
+    ${make_python_docstring(scenario.name)}
 
 
 % endfor
 % for step in steps:
-@${step.type}('${step.name}')
+@${step.type}(${ make_string_literal(step.name)})
 def ${ make_python_name(step.name)}():
-    """${step.name}."""
+    ${make_python_docstring(step.name)}
     raise NotImplementedError
 % if not loop.last:
 

tests/scripts/test_generate.py

@@ -1,8 +1,11 @@
+# coding=utf-8
 """Test code generation command."""
 import os
 import sys
 import textwrap
 
+import six
+
 from pytest_bdd.scripts import main
 
 PATH = os.path.dirname(__file__)
@@ -60,3 +63,144 @@ def my_list_should_be_1():
             u"'", u"'"
         )
     )
+
+
+def test_generate_with_quotes(testdir):
+    """Test that code generation escapes quote characters properly."""
+    testdir.makefile(
+        ".feature",
+        generate_with_quotes=textwrap.dedent(
+            '''\
+        Feature: Handling quotes in code generation
+
+            Scenario: A step definition with quotes should be escaped as needed
+                Given I have a fixture with 'single' quotes
+                And I have a fixture with "double" quotes
+                And I have a fixture with single-quote \'\'\'triple\'\'\' quotes
+                And I have a fixture with double-quote """triple""" quotes
+        
+                When I generate the code
+        
+                Then The generated string should be written
+        '''
+        ),
+    )
+
+    result = testdir.run("pytest-bdd", "generate", "generate_with_quotes.feature")
+    assert result.stdout.str() == textwrap.dedent(
+        '''\
+    # coding=utf-8
+    """Handling quotes in code generation feature tests."""
+
+    from pytest_bdd import (
+        given,
+        scenario,
+        then,
+        when,
+    )
+
+
+    @scenario('generate_with_quotes.feature', 'A step definition with quotes should be escaped as needed')
+    def test_a_step_definition_with_quotes_should_be_escaped_as_needed():
+        """A step definition with quotes should be escaped as needed."""
+
+
+    @given('I have a fixture with "double" quotes')
+    def i_have_a_fixture_with_double_quotes():
+        """I have a fixture with "double" quotes."""
+        raise NotImplementedError
+
+
+    @given('I have a fixture with \\'single\\' quotes')
+    def i_have_a_fixture_with_single_quotes():
+        """I have a fixture with 'single' quotes."""
+        raise NotImplementedError
+
+
+    @given('I have a fixture with double-quote """triple""" quotes')
+    def i_have_a_fixture_with_doublequote_triple_quotes():
+        """I have a fixture with double-quote \\"\\"\\"triple\\"\\"\\" quotes."""
+        raise NotImplementedError
+
+
+    @given('I have a fixture with single-quote \\'\\'\\'triple\\'\\'\\' quotes')
+    def i_have_a_fixture_with_singlequote_triple_quotes():
+        """I have a fixture with single-quote \'\'\'triple\'\'\' quotes."""
+        raise NotImplementedError
+
+
+    @when('I generate the code')
+    def i_generate_the_code():
+        """I generate the code."""
+        raise NotImplementedError
+
+
+    @then('The generated string should be written')
+    def the_generated_string_should_be_written():
+        """The generated string should be written."""
+        raise NotImplementedError
+    '''
+    )
+
+
+def test_unicode_characters(testdir):
+    """Test generating code with unicode characters.
+
+    Primary purpose is to ensure compatibility with Python2.
+    """
+
+    testdir.makefile(
+        ".feature",
+        unicode_characters=textwrap.dedent(
+            """\
+        # coding=utf-8
+        Feature: Generating unicode characters
+
+            Scenario: Calculating the circumference of a circle
+                Given We have a circle
+                When We want to know its circumference
+                Then We calculate 2 * ℼ * 𝑟
+        """
+        ),
+    )
+
+    result = testdir.run("pytest-bdd", "generate", "unicode_characters.feature")
+    expected_output = textwrap.dedent(
+        u'''\
+            # coding=utf-8
+            """Generating unicode characters feature tests."""
+
+            from pytest_bdd import (
+                given,
+                scenario,
+                then,
+                when,
+            )
+
+
+            @scenario('unicode_characters.feature', 'Calculating the circumference of a circle')
+            def test_calculating_the_circumference_of_a_circle():
+                """Calculating the circumference of a circle."""
+
+
+            @given('We have a circle')
+            def we_have_a_circle():
+                """We have a circle."""
+                raise NotImplementedError
+
+
+            @when('We want to know its circumference')
+            def we_want_to_know_its_circumference():
+                """We want to know its circumference."""
+                raise NotImplementedError
+
+
+            @then('We calculate 2 * ℼ * 𝑟')
+            def {function_with_unicode_chars}():
+                """We calculate 2 * ℼ * 𝑟."""
+                raise NotImplementedError
+            '''.format(
+            function_with_unicode_chars=u"we_calculate_2__ℼ__𝑟" if not six.PY2 else u"we_calculate_2____"
+        )
+    )
+    assert result.stdout.str() == expected_output