Exemplo n.º 1
0
def test_parse_feature_after_parser_error():
    parser = Parser()
    with assert_raises(ParserError):
        parser.parse(TokenScanner('# a comment\n' +
                                  'Feature: Foo\n' +
                                  '  Scenario: Bar\n' +
                                  '    Given x\n' +
                                  '      ```\n' +
                                  '      unclosed docstring\n'))
    feature = parser.parse(TokenScanner('Feature: Foo\n' +
                                        '  Scenario: Bar\n' +
                                        '    Given x\n'
                                        '      """\n'
                                        '      closed docstring\n'
                                        '      """\n'))
    expected = [{
        'name': u'Bar',
        'keyword': u'Scenario',
        'tags': [],
        'steps': [{
            'text': u'x',
            'type': 'Step',
            'location': {'column': 5, 'line': 3},
            'keyword': u'Given ',
            'argument': {
                'content': u'closed docstring',
                'type': 'DocString',
                'contentType': u'',
                'location': {'column': 7, 'line': 4}}}],
        'location': {'column': 3, 'line': 2},
        'type': 'Scenario'}]

    assert_equals(expected, feature['scenarioDefinitions'])
Exemplo n.º 2
0
def test_parse_feature_after_parser_error():
    parser = Parser()
    with assert_raises(ParserError):
        parser.parse(TokenScanner('# a comment\n' +
                                  'Feature: Foo\n' +
                                  '  Scenario: Bar\n' +
                                  '    Given x\n' +
                                  '      ```\n' +
                                  '      unclosed docstring\n'))
    feature = parser.parse(TokenScanner('Feature: Foo\n' +
                                        '  Scenario: Bar\n' +
                                        '    Given x\n'
                                        '      """\n'
                                        '      closed docstring\n'
                                        '      """\n'))
    expected = [{
        'name': u'Bar',
        'keyword': u'Scenario',
        'tags': [],
        'steps': [{
            'text': u'x',
            'type': 'Step',
            'location': {'column': 5, 'line': 3},
            'keyword': u'Given ',
            'argument': {
                'content': u'closed docstring',
                'type': 'DocString',
                'location': {'column': 7, 'line': 4}}}],
        'location': {'column': 3, 'line': 2},
        'type': 'Scenario'}]

    assert_equals(expected, feature['scenarioDefinitions'])
Exemplo n.º 3
0
def process_gherkin(gherkin_filename, basedir, output):
    print(f"Processing gherkin: {gherkin_filename}")
    if verbose:
        print(f"Basedir: {basedir}")
        print(f"Output: {output}")

    with open(gherkin_filename, 'r') as f:
        content = f.read()
    parser = Parser()
    feature = parser.parse(content)
    global settings_lines, test_cases_lines, keywords_lines, seen_steps
    settings_lines = []
    test_cases_lines = []
    keywords_lines = []
    seen_steps = {}

    process_feature(feature)

    feature_base = os.path.dirname(gherkin_filename)
    feature_sub = None
    if feature_base.startswith(basedir):
        feature_sub = feature_base[len(basedir) + 1:]
    else:
        feature_sub = feature_base

    generate_robot_script(os.path.join(output, feature_sub), feature['name'])
Exemplo n.º 4
0
    def parse(cls, string=None, filename=None, language=None):
        """
        Parse either a string or a file.
        """

        parser = Parser()
        # pylint:disable=redefined-variable-type
        # https://bitbucket.org/logilab/pylint/issues/710
        if language:
            if language == 'pt-br':
                language = 'pt'
            token_matcher = LanguageTokenMatcher(language)
        else:
            token_matcher = TokenMatcher()
        # pylint:enable=redefined-variable-type

        if string:
            token_scanner = TokenScanner(string=string)
        else:
            token_scanner = TokenScanner(filename=filename)

        try:
            return cls(
                parser.parse(token_scanner, token_matcher=token_matcher),
                filename=filename,
            )
        except ParserError as ex:
            raise AloeSyntaxError(filename, str(ex))
def dump_gherkin(gherkin_filename):
    with open(gherkin_filename, 'r') as f:
        str = f.read()
    parser = Parser()
    feature = parser.parse(str)

    print yaml.dump(feature)
def dump_gherkin(gherkin_filename):
    with open(gherkin_filename, 'r') as f:
        content = f.read()
    parser = Parser()
    feature = parser.parse(content)

    print(yaml.dump(feature))
Exemplo n.º 7
0
class Reader:
    def __init__(self):
        self.parser = Parser()

    def strip_comments(self, step):
        comment = step.find(GHERKIN_COMMENT)
        if comment != -1:
            return step[:comment].rstrip()
        return step

    def filter_definitions(self, defs):
        f = lambda prev, curr: prev + list(
            map(self.strip_comments, pluck(curr['steps'], 'text')))
        return reduce(f, defs, [])

    def read_steps(self, filename):
        try:
            feature = self.parser.parse(TokenScanner(filename))
            defs = []
            if GHERKIN_SCENARIOS in feature: defs += feature[GHERKIN_SCENARIOS]
            if GHERKIN_BACKGROUND in feature:
                defs.append(feature[GHERKIN_BACKGROUND])
            steps = self.filter_definitions(defs)
            cache.set(filename, steps)
        except CompositeParserException as e:
            steps = []
            print(e)

        return steps

    def get_steps(self, filename):
        if cache.has(filename):
            return cache.get(filename)

        return self.read_steps(filename)
Exemplo n.º 8
0
def test_parse_multiple_features():
    parser = Parser()
    f1 = parser.parse(TokenScanner("Feature: 1"))
    f2 = parser.parse(TokenScanner("Feature: 2"))

    assert_equals("1", f1['name'])
    assert_equals("2", f2['name'])
Exemplo n.º 9
0
class Reader:

    def __init__(self):
        self.parser = Parser()

    def strip_comments(self, step):
        comment = step.find(GHERKIN_COMMENT)
        if comment != -1:
            return step[:comment].rstrip()
        return step

    def filter_definitions(self, defs):
        f = lambda prev, curr: prev + list(map(self.strip_comments, pluck(curr['steps'], 'text')))
        return reduce(f, defs, [])

    def read_steps(self, filename):
        try:
            feature = self.parser.parse(TokenScanner(filename))
            defs = []
            if GHERKIN_SCENARIOS in feature: defs += feature[GHERKIN_SCENARIOS]
            if GHERKIN_BACKGROUND in feature: defs.append(feature[GHERKIN_BACKGROUND])
            steps = self.filter_definitions(defs)
            cache.set(filename, steps)
        except CompositeParserException as e:
            steps = []
            print(e)

        return steps

    def get_steps(self, filename):
        if cache.has(filename):
            return cache.get(filename)

        return self.read_steps(filename)
Exemplo n.º 10
0
def test_parse_multiple_features():
    parser = Parser()
    f1 = parser.parse(TokenScanner("Feature: 1"))
    f2 = parser.parse(TokenScanner("Feature: 2"))

    assert_equals("1", f1['name'])
    assert_equals("2", f2['name'])
Exemplo n.º 11
0
def gherkin_pieces_grouped_by_featurename(features_dir):
    """ For a list of BDD feature files, discover the parts
    that are tagged with FM feature names (features and scenarios) and group them by the FM feature names.
    """

    gherkin_parser = Parser()

    pieces_grouped_by_tag = {}
    for feature_file in listdir(features_dir):
        feature_file = open(path.join(features_dir, feature_file), "r")
        feature_parsed = gherkin_parser.parse(feature_file.read())

        for tag in feature_parsed['tags']:
            tag_name = tag['name'][1:]  # remove @
            if tag_name not in pieces_grouped_by_tag:
                pieces_grouped_by_tag[tag_name] = []
            pieces_grouped_by_tag[tag_name].append(feature_parsed['name'])

        for scenario in feature_parsed['scenarioDefinitions']:
            for tag in scenario['tags']:
                tag_name = tag['name'][1:]  # remove @
                if tag_name not in pieces_grouped_by_tag:
                    pieces_grouped_by_tag[tag_name] = []
                pieces_grouped_by_tag[tag_name].append(scenario['name'])

    return pieces_grouped_by_tag
Exemplo n.º 12
0
def test_parser():
    parser = Parser()
    feature = parser.parse(TokenScanner("Feature: Foo"))
    expected = {'comments': [],
     'keyword': u'Feature',
     'language': 'en',
     'location': {'column': 1, 'line': 1},
     'name': u'Foo',
     'scenarioDefinitions': [],
     'tags': [],
     'type': 'Feature'}

    assert_equals(expected, feature)
Exemplo n.º 13
0
def test_parser():
    parser = Parser()
    feature = parser.parse(TokenScanner("Feature: Foo"))
    expected = {'comments': [],
     'keyword': u'Feature',
     'language': 'en',
     'location': {'column': 1, 'line': 1},
     'name': u'Foo',
     'scenarioDefinitions': [],
     'tags': [],
     'type': 'Feature'}

    assert_equals(expected, feature)
Exemplo n.º 14
0
def test_change_the_default_language():
    parser = Parser()
    matcher = TokenMatcher('no')
    feature = parser.parse(TokenScanner("Egenskap: i18n support"), matcher)
    expected = {'comments': [],
     'keyword': u'Egenskap',
     'language': 'no',
     'location': {'column': 1, 'line': 1},
     'name': u'i18n support',
     'scenarioDefinitions': [],
     'tags': [],
     'type': 'Feature'}

    assert_equals(expected, feature)
Exemplo n.º 15
0
def test_change_the_default_language():
    parser = Parser()
    matcher = TokenMatcher('no')
    feature = parser.parse(TokenScanner("Egenskap: i18n support"), matcher)
    expected = {'comments': [],
     'keyword': u'Egenskap',
     'language': 'no',
     'location': {'column': 1, 'line': 1},
     'name': u'i18n support',
     'scenarioDefinitions': [],
     'tags': [],
     'type': 'Feature'}

    assert_equals(expected, feature)
def process_gherkin(gherkin_filename, basedir, output):
    with open(gherkin_filename, 'r') as f:
        content = f.read()
    parser = Parser()
    feature = parser.parse(content)
    global settings_lines, test_cases_lines, keywords_lines, seen_steps
    settings_lines = []
    test_cases_lines = []
    keywords_lines = []
    seen_steps = set([])

    process_feature(feature)

    feature_base = os.path.dirname(gherkin_filename)
    feature_sub = feature_base[len(basedir)+1:]
    generate_robot_script(os.path.join(output, feature_sub), feature['name'])
Exemplo n.º 17
0
    def parse(cls, string=None, filename=None, language=None):
        """
        Parse either a string or a file.
        """

        parser = Parser()
        if language:
            if language == 'pt-br':
                language = 'pt'
            token_matcher = LanguageTokenMatcher(language)
        else:
            token_matcher = TokenMatcher()

        if string:
            token_scanner = TokenScanner(string=string)
        else:
            token_scanner = TokenScanner(filename=filename)

        return cls(
            parser.parse(token_scanner, token_matcher=token_matcher),
            filename=filename,
        )
Exemplo n.º 18
0
arg_parser = argparse.ArgumentParser(description='Draw dot file from FeatureIDE model.xml')
arg_parser.add_argument('model_xml_file', help="Location of the model XML file")
arg_parser.add_argument('features_dir', help="Location of the feature files")
arg_parser.add_argument('reports_dir', help="Location of the test results files for products")
arg_parser.add_argument('output_dir', help="Location where the output file should be rendered")
arg_parser.add_argument('--output_filename', default="feature_model", help="Name to use for the output file")
arg_parser.add_argument('--productconfig', default="all", help="")

args = arg_parser.parse_args()

gherkin_parser = Parser()
tags = {}

for feature_file in listdir(args.features_dir):
    feature_file = open(path.join(args.features_dir, feature_file), "r")
    feature_parsed = gherkin_parser.parse(feature_file.read())

    for tag in feature_parsed['tags']:
        tag_name = tag['name'][1:] # remove @
        if tag_name not in tags:
            tags[tag_name] = []
        tags[tag_name].append("F: " + feature_parsed['name'])

    for scenario in feature_parsed['scenarioDefinitions']:
        for tag in scenario['tags']:
            tag_name = tag['name'][1:] # remove @
            if tag_name not in tags:
                tags[tag_name] = []
            tags[tag_name].append("S: " + scenario['name'])

def parseFeature(feature, parent, graph, test_results, product_features):