def test_detect_scenario_loop(self):
"""
Test detecting ScenarioLoop on a given line
"""
line = "Scenario Loop 10: Some fancy scenario loop"
with NamedTemporaryFile("w+") as featurefile:
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
result = parser._detect_scenario_loop(line)
result.should.be.a(tuple)
result[0].should.be.equal("Some fancy scenario loop")
result[1].should.be.equal(10)
parser._detect_scenario_loop.when.called_with(
"").should.return_value(None)
parser._detect_scenario_loop.when.called_with(
"Scenario: Some fancy scenario").should.return_value(None)
parser._detect_scenario_loop.when.called_with(
"Scenario Outline: Some fancy scenario").should.return_value(
None)
parser._detect_scenario_loop.when.called_with(
"Scenario Loop: Some fancy scenario").should.return_value(None)
parser._detect_scenario_loop.when.called_with(
"Scenario Loop 5.5: Some fancy scenario").should.return_value(
None)
def test_parse_feature_with_multiple_tags(self):
"""
Test parsing feature with tags
"""
feature = """
@some_feature
@has_scenario_loop
@add_numbers
Feature: some feature
Scenario Loop 10: some fancy scenario
Given I have the number 1
When I add 2 to my number
Then I expect my number to be 3
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.tags.should.have.length_of(3)
parser.feature.tags[0].name.should.be.equal("some_feature")
parser.feature.tags[1].name.should.be.equal("has_scenario_loop")
parser.feature.tags[2].name.should.be.equal("add_numbers")
def test_parse_feature_with_multiple_tags(self):
"""
Test parsing feature with tags
"""
feature = """
@some_feature
@has_scenario_loop
@add_numbers
Feature: some feature
Scenario Loop 10: some fancy scenario
Given I have the number 1
When I add 2 to my number
Then I expect my number to be 3
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.tags.should.have.length_of(3)
parser.feature.tags[0].name.should.be.equal("some_feature")
parser.feature.tags[1].name.should.be.equal("has_scenario_loop")
parser.feature.tags[2].name.should.be.equal("add_numbers")
def test_parse_empty_feature_with_description(self):
"""
Test parsing of an empty feature with desription
"""
feature = """Feature: some empty feature
In order to support cool software
I do fancy BDD testing with radish"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.sentence.should.be.equal("some empty feature")
parser.feature.id.should.be.equal(1)
parser.feature.path.should.be.equal(featurefile.name)
parser.feature.line.should.be.equal(1)
parser.feature.scenarios.should.be.empty
parser.feature.description.should.have.length_of(2)
parser.feature.description[0].should.be.equal(
"In order to support cool software")
parser.feature.description[1].should.be.equal(
"I do fancy BDD testing with radish")
def test_parse_feature_with_ignored_tag(self):
"""
Test parsing a feature which is not part of the feature tag expression
"""
feature = """
@some_feature
Feature: some feature
Scenario: foo
When I have a normal scenario
Then I expect nothing special
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(
core,
featurefile.name,
1,
feature_tag_expr=tagexpressions.parse('not some_feature'))
feature = parser.parse()
feature.should.be.none
def test_parse_feature_with_scenario_loop(self):
"""
Test parsing of a feature file with a scenario loop
"""
feature = """Feature: some feature
Scenario Loop 10: some fancy scenario
Given I have the number 1
When I add 2 to my number
Then I expect my number to be 3
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
scenario = parser.feature.scenarios[0]
scenario.should.be.a(ScenarioLoop)
scenario.id.should.be.equal(1)
scenario.sentence.should.be.equal("some fancy scenario")
scenario.steps.should.have.length_of(3)
scenario.steps[0].id.should.be.equal(1)
scenario.steps[0].sentence.should.be.equal(
"Given I have the number 1")
scenario.steps[0].path.should.be.equal(featurefile.name)
scenario.steps[0].line.should.be.equal(3)
scenario.steps[1].id.should.be.equal(2)
scenario.steps[1].sentence.should.be.equal(
"When I add 2 to my number")
scenario.steps[1].path.should.be.equal(featurefile.name)
scenario.steps[1].line.should.be.equal(4)
scenario.steps[2].id.should.be.equal(3)
scenario.steps[2].sentence.should.be.equal(
"Then I expect my number to be 3")
scenario.steps[2].path.should.be.equal(featurefile.name)
scenario.steps[2].line.should.be.equal(5)
scenario.scenarios.should.have.length_of(10)
for i in range(10):
scenario.scenarios[i].id.should.be.equal(i + 2)
scenario.scenarios[i].steps.should.have.length_of(3)
scenario.scenarios[i].steps[0].id.should.be.equal(1)
scenario.scenarios[i].steps[0].sentence.should.be.equal(
"Given I have the number 1")
scenario.scenarios[i].steps[1].id.should.be.equal(2)
scenario.scenarios[i].steps[1].sentence.should.be.equal(
"When I add 2 to my number")
scenario.scenarios[i].steps[2].id.should.be.equal(3)
scenario.scenarios[i].steps[2].sentence.should.be.equal(
"Then I expect my number to be 3")
def test_parse_feature_with_multiple_scenarios(self):
"""
Test parsing of a feature with multiple scenarios and steps
"""
feature = """Feature: some feature
Scenario: some fancy scenario
Given I have the number 5
When I add 2 to my number
Then I expect my number to be 7
Scenario: some other fancy scenario
Given I have the number 50
When I add 20 to my number
Then I expect my number to be 70"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(2)
parser.feature.scenarios[0].id.should.be.equal(1)
parser.feature.scenarios[0].sentence.should.be.equal("some fancy scenario")
parser.feature.scenarios[0].steps.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].id.should.be.equal(1)
parser.feature.scenarios[0].steps[0].sentence.should.be.equal("Given I have the number 5")
parser.feature.scenarios[0].steps[0].path.should.be.equal(featurefile.name)
parser.feature.scenarios[0].steps[0].line.should.be.equal(3)
parser.feature.scenarios[0].steps[1].id.should.be.equal(2)
parser.feature.scenarios[0].steps[1].sentence.should.be.equal("When I add 2 to my number")
parser.feature.scenarios[0].steps[1].path.should.be.equal(featurefile.name)
parser.feature.scenarios[0].steps[1].line.should.be.equal(4)
parser.feature.scenarios[0].steps[2].id.should.be.equal(3)
parser.feature.scenarios[0].steps[2].sentence.should.be.equal("Then I expect my number to be 7")
parser.feature.scenarios[0].steps[2].path.should.be.equal(featurefile.name)
parser.feature.scenarios[0].steps[2].line.should.be.equal(5)
parser.feature.scenarios[1].id.should.be.equal(2)
parser.feature.scenarios[1].sentence.should.be.equal("some other fancy scenario")
parser.feature.scenarios[1].steps.should.have.length_of(3)
parser.feature.scenarios[1].steps[0].id.should.be.equal(1)
parser.feature.scenarios[1].steps[0].sentence.should.be.equal("Given I have the number 50")
parser.feature.scenarios[1].steps[0].path.should.be.equal(featurefile.name)
parser.feature.scenarios[1].steps[0].line.should.be.equal(8)
parser.feature.scenarios[1].steps[1].id.should.be.equal(2)
parser.feature.scenarios[1].steps[1].sentence.should.be.equal("When I add 20 to my number")
parser.feature.scenarios[1].steps[1].path.should.be.equal(featurefile.name)
parser.feature.scenarios[1].steps[1].line.should.be.equal(9)
parser.feature.scenarios[1].steps[2].id.should.be.equal(3)
parser.feature.scenarios[1].steps[2].sentence.should.be.equal("Then I expect my number to be 70")
parser.feature.scenarios[1].steps[2].path.should.be.equal(featurefile.name)
parser.feature.scenarios[1].steps[2].line.should.be.equal(10)
def test_feature_with_comments(self):
"""
Test parsing a feature with comments
"""
feature = """Feature: some feature
# this is a comment
Scenario: some fancy scenario
Given I have the number 5
When I add 2 to my number
# this is another comment
Then I expect my number to be 7
Scenario: some other fancy scenario
Given I have the number 50
# foobar comment
When I add 20 to my number
Then I expect my number to be 70
# another stupid comment"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(2)
parser.feature.scenarios[0].sentence.should.be.equal("some fancy scenario")
parser.feature.scenarios[0].line.should.be.equal(3)
parser.feature.scenarios[0].steps.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].sentence.should.be.equal("Given I have the number 5")
parser.feature.scenarios[0].steps[0].path.should.be.equal(featurefile.name)
parser.feature.scenarios[0].steps[0].line.should.be.equal(4)
parser.feature.scenarios[0].steps[1].sentence.should.be.equal("When I add 2 to my number")
parser.feature.scenarios[0].steps[1].path.should.be.equal(featurefile.name)
parser.feature.scenarios[0].steps[1].line.should.be.equal(5)
parser.feature.scenarios[0].steps[2].sentence.should.be.equal("Then I expect my number to be 7")
parser.feature.scenarios[0].steps[2].path.should.be.equal(featurefile.name)
parser.feature.scenarios[0].steps[2].line.should.be.equal(7)
parser.feature.scenarios[1].sentence.should.be.equal("some other fancy scenario")
parser.feature.scenarios[1].line.should.be.equal(9)
parser.feature.scenarios[1].steps.should.have.length_of(3)
parser.feature.scenarios[1].steps[0].sentence.should.be.equal("Given I have the number 50")
parser.feature.scenarios[1].steps[0].path.should.be.equal(featurefile.name)
parser.feature.scenarios[1].steps[0].line.should.be.equal(10)
parser.feature.scenarios[1].steps[1].sentence.should.be.equal("When I add 20 to my number")
parser.feature.scenarios[1].steps[1].path.should.be.equal(featurefile.name)
parser.feature.scenarios[1].steps[1].line.should.be.equal(12)
parser.feature.scenarios[1].steps[2].sentence.should.be.equal("Then I expect my number to be 70")
parser.feature.scenarios[1].steps[2].path.should.be.equal(featurefile.name)
parser.feature.scenarios[1].steps[2].line.should.be.equal(13)
def test_parse_feature_with_scenario_loop(self):
"""
Test parsing of a feature file with a scenario loop
"""
feature = """Feature: some feature
Scenario Loop 10: some fancy scenario
Given I have the number 1
When I add 2 to my number
Then I expect my number to be 3
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
scenario = parser.feature.scenarios[0]
scenario.should.be.a(ScenarioLoop)
scenario.id.should.be.equal(1)
scenario.sentence.should.be.equal("some fancy scenario")
scenario.steps.should.have.length_of(3)
scenario.steps[0].id.should.be.equal(1)
scenario.steps[0].sentence.should.be.equal("Given I have the number 1")
scenario.steps[0].path.should.be.equal(featurefile.name)
scenario.steps[0].line.should.be.equal(3)
scenario.steps[1].id.should.be.equal(2)
scenario.steps[1].sentence.should.be.equal("When I add 2 to my number")
scenario.steps[1].path.should.be.equal(featurefile.name)
scenario.steps[1].line.should.be.equal(4)
scenario.steps[2].id.should.be.equal(3)
scenario.steps[2].sentence.should.be.equal("Then I expect my number to be 3")
scenario.steps[2].path.should.be.equal(featurefile.name)
scenario.steps[2].line.should.be.equal(5)
scenario.scenarios.should.have.length_of(10)
for i in range(10):
scenario.scenarios[i].id.should.be.equal(i + 2)
scenario.scenarios[i].steps.should.have.length_of(3)
scenario.scenarios[i].steps[0].id.should.be.equal(1)
scenario.scenarios[i].steps[0].sentence.should.be.equal("Given I have the number 1")
scenario.scenarios[i].steps[1].id.should.be.equal(2)
scenario.scenarios[i].steps[1].sentence.should.be.equal("When I add 2 to my number")
scenario.scenarios[i].steps[2].id.should.be.equal(3)
scenario.scenarios[i].steps[2].sentence.should.be.equal("Then I expect my number to be 3")
def parse_feature(self, featurefile, featureid=0):
"""
Parses the given feature file
If the feature is alreay parsed then it will just return it
:returns: the parsed feature
:rtype: Feature
"""
featureparser = FeatureParser(self, featurefile, featureid)
featureparser.parse()
self.features.append(featureparser.feature)
return featureparser.feature
def test_parse_feature_with_scenario_with_tags(self):
"""
Test parsing feature with scenario and multiple tags
"""
feature = """
@some_feature
Feature: some feature
@some_scenario_loop
Scenario Loop 10: some fancy scenario
Given I have the number 1
When I add 2 to my number
Then I expect my number to be 3
Scenario: foo
When I have a normal scenario
Then I expect nothing special
@error_case
@bad_case
Scenario: bad case
Given I have the number 1
When I add 3 to my number
Then I expect my number not to be 4
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.tags.should.have.length_of(1)
parser.feature.tags[0].name.should.be.equal("some_feature")
parser.feature.scenarios.should.have.length_of(3)
parser.feature.scenarios[0].tags.should.have.length_of(1)
parser.feature.scenarios[0].tags[0].name.should.be.equal(
"some_scenario_loop")
parser.feature.scenarios[1].tags.should.be.empty
parser.feature.scenarios[2].tags.should.have.length_of(2)
parser.feature.scenarios[2].tags[0].name.should.be.equal(
"error_case")
parser.feature.scenarios[2].tags[1].name.should.be.equal(
"bad_case")
def test_parse_feature_with_scenario_and_examples(self):
"""
Test parsing of a feature with a scenario which has examples
"""
feature = """Feature: some feature
Scenario: some fancy scenario
Given I have the number <number>
When I add <delta> to my number
Then I expect my number to be <result>
Examples:
| number | delta | result |
| 5 | 2 | 7 |
| 10 | 3 | 13 |
| 15 | 6 | 21 |
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse.when.called_with().should.throw(
RadishError,
"Scenario does not support Examples. Use 'Scenario Outline'")
def test_parse_feature_with_scenario_with_tags(self):
"""
Test parsing feature with scenario and multiple tags
"""
feature = """
@some_feature
Feature: some feature
@some_scenario_loop
Scenario Loop 10: some fancy scenario
Given I have the number 1
When I add 2 to my number
Then I expect my number to be 3
Scenario: foo
When I have a normal scenario
Then I expect nothing special
@error_case
@bad_case
Scenario: bad case
Given I have the number 1
When I add 3 to my number
Then I expect my number not to be 4
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.tags.should.have.length_of(1)
parser.feature.tags[0].name.should.be.equal("some_feature")
parser.feature.scenarios.should.have.length_of(3)
parser.feature.scenarios[0].tags.should.have.length_of(1)
parser.feature.scenarios[0].tags[0].name.should.be.equal("some_scenario_loop")
parser.feature.scenarios[1].tags.should.be.empty
parser.feature.scenarios[2].tags.should.have.length_of(2)
parser.feature.scenarios[2].tags[0].name.should.be.equal("error_case")
parser.feature.scenarios[2].tags[1].name.should.be.equal("bad_case")
def test_parse_steps_with_table(self):
"""
Test parsing of a feature with a scenario and steps with a table
"""
feature = """Feature: some feature
Scenario: some normal scenario
Given I have the user
| Bruce | Wayne | Batman |
| Chuck | Norris | PureAwesome |
| Peter | Parker | Spiderman |
When I register them in the database
Then I expect 3 entries in the database
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
parser.feature.scenarios[0].should.be.a(Scenario)
parser.feature.scenarios[0].sentence.should.be.equal(
"some normal scenario")
parser.feature.scenarios[0].steps.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].sentence.should.be.equal(
"Given I have the user")
parser.feature.scenarios[0].steps[0].table.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].table[0].should.be.equal(
["Bruce", "Wayne", "Batman"])
parser.feature.scenarios[0].steps[0].table[1].should.be.equal(
["Chuck", "Norris", "PureAwesome"])
parser.feature.scenarios[0].steps[0].table[2].should.be.equal(
["Peter", "Parker", "Spiderman"])
parser.feature.scenarios[0].steps[1].sentence.should.be.equal(
"When I register them in the database")
parser.feature.scenarios[0].steps[1].table.should.have.length_of(0)
parser.feature.scenarios[0].steps[2].sentence.should.be.equal(
"Then I expect 3 entries in the database")
parser.feature.scenarios[0].steps[2].table.should.have.length_of(0)
def test_parse_feature_with_one_scenario_and_steps(self):
"""
Test parsing of a feautre with one scenario and multiple steps
"""
feature = """Feature: some feature
Scenario: some fancy scenario
Given I have the number 5
When I add 2 to my number
Then I expect my number to be 7 """
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
parser.feature.scenarios.should.have.length_of(1)
parser.feature.scenarios[0].sentence.should.be.equal(
"some fancy scenario")
parser.feature.scenarios[0].steps.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].id.should.be.equal(1)
parser.feature.scenarios[0].steps[0].sentence.should.be.equal(
"Given I have the number 5")
parser.feature.scenarios[0].steps[0].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[0].steps[0].line.should.be.equal(3)
parser.feature.scenarios[0].steps[1].id.should.be.equal(2)
parser.feature.scenarios[0].steps[1].sentence.should.be.equal(
"When I add 2 to my number")
parser.feature.scenarios[0].steps[1].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[0].steps[1].line.should.be.equal(4)
parser.feature.scenarios[0].steps[2].id.should.be.equal(3)
parser.feature.scenarios[0].steps[2].sentence.should.be.equal(
"Then I expect my number to be 7")
parser.feature.scenarios[0].steps[2].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[0].steps[2].line.should.be.equal(5)
def test_parse_not_existing_featurefile(core):
"""
Test parsing a not existing Feature File
"""
# given & when
with pytest.raises(OSError) as exc:
FeatureParser(core, "does-not-exist.feature", 1)
# then
assert str(exc.value) == "Feature file at 'does-not-exist.feature' does not exist"
def test_parse_empty_feature(self):
"""
Test parsing of an empty feature
"""
feature = """Feature: some empty feature"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.sentence.should.be.equal("some empty feature")
parser.feature.id.should.be.equal(1)
parser.feature.path.should.be.equal(featurefile.name)
parser.feature.line.should.be.equal(1)
parser.feature.scenarios.should.be.empty
def test_creating_parser_with_unsupported_lang_detection(core):
"""
Test creating a Parser with yet unsupported language auto detection
"""
# given & when
with pytest.raises(NotImplementedError) as exc:
FeatureParser(core, '/', 1, language=None)
# then
assert str(exc.value) == 'Auto detect language is not implemented yet'
def test_parse_empty_featurefile(self):
"""
Test parsing of an empty feature file
"""
core = Mock()
with NamedTemporaryFile("w+") as featurefile:
parser = FeatureParser(core, featurefile.name, 1)
parser.parse.when.called_with().should.throw(
RadishError,
"No Feature found in file {0}".format(featurefile.name))
def test_creating_parser_for_not_supported_lang(core):
"""
Test creating a Parser for a not supported language
"""
# given & when
with pytest.raises(errors.LanguageNotSupportedError) as exc:
FeatureParser(core, '/', 1, language='chruesimuesi')
# then
assert str(exc.value) == 'Language chruesimuesi could not be found'
def test_parse_empty_feature(self):
"""
Test parsing of an empty feature
"""
feature = """Feature: some empty feature"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.sentence.should.be.equal("some empty feature")
parser.feature.id.should.be.equal(1)
parser.feature.path.should.be.equal(featurefile.name)
parser.feature.line.should.be.equal(1)
parser.feature.scenarios.should.be.empty
def test_detect_scenario_loop(self):
"""
Test detecting ScenarioLoop on a given line
"""
line = "Scenario Loop 10: Some fancy scenario loop"
with NamedTemporaryFile("w+") as featurefile:
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
result = parser._detect_scenario_loop(line)
result.should.be.a(tuple)
result[0].should.be.equal("Some fancy scenario loop")
result[1].should.be.equal(10)
parser._detect_scenario_loop.when.called_with("").should.return_value(None)
parser._detect_scenario_loop.when.called_with("Scenario: Some fancy scenario").should.return_value(None)
parser._detect_scenario_loop.when.called_with("Scenario Outline: Some fancy scenario").should.return_value(None)
parser._detect_scenario_loop.when.called_with("Scenario Loop: Some fancy scenario").should.return_value(None)
parser._detect_scenario_loop.when.called_with("Scenario Loop 5.5: Some fancy scenario").should.return_value(None)
def test_creating_language_agnostic_parser(language, feature_keyword,
scenario_keyword, core):
"""
Test creating a language agnostic parser
"""
# given & when
parser = FeatureParser(core, '/', 1, language=language)
# then
assert parser.keywords.feature == feature_keyword
assert parser.keywords.scenario == scenario_keyword
def test_language_loading(self):
"""
Test loading of a specific language
"""
core = Mock()
en_feature_parser = FeatureParser(core, "/", 1, language="en")
en_feature_parser.keywords.feature.should.be.equal("Feature")
en_feature_parser.keywords.scenario.should.be.equal("Scenario")
en_feature_parser.keywords.scenario_outline.should.be.equal(
"Scenario Outline")
en_feature_parser.keywords.examples.should.be.equal("Examples")
de_feature_parser = FeatureParser(core, "/", 1, language="de")
de_feature_parser.keywords.scenario.should.be.equal("Szenario")
de_feature_parser.keywords.scenario_outline.should.be.equal(
"Szenario Auslagerung")
de_feature_parser.keywords.examples.should.be.equal("Beispiele")
FeatureParser.when.called_with(
core, "/", 1,
language="foo").should.throw(LanguageNotSupportedError)
def test_parse_steps_with_table(self):
"""
Test parsing of a feature with a scenario and steps with a table
"""
feature = """Feature: some feature
Scenario: some normal scenario
Given I have the user
| Bruce | Wayne | Batman |
| Chuck | Norris | PureAwesome |
| Peter | Parker | Spiderman |
When I register them in the database
Then I expect 3 entries in the database
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
parser.feature.scenarios[0].should.be.a(Scenario)
parser.feature.scenarios[0].sentence.should.be.equal("some normal scenario")
parser.feature.scenarios[0].steps.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].sentence.should.be.equal("Given I have the user")
parser.feature.scenarios[0].steps[0].table.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].table[0].should.be.equal(["Bruce", "Wayne", "Batman"])
parser.feature.scenarios[0].steps[0].table[1].should.be.equal(["Chuck", "Norris", "PureAwesome"])
parser.feature.scenarios[0].steps[0].table[2].should.be.equal(["Peter", "Parker", "Spiderman"])
parser.feature.scenarios[0].steps[1].sentence.should.be.equal("When I register them in the database")
parser.feature.scenarios[0].steps[1].table.should.have.length_of(0)
parser.feature.scenarios[0].steps[2].sentence.should.be.equal("Then I expect 3 entries in the database")
parser.feature.scenarios[0].steps[2].table.should.have.length_of(0)
def test_parse_feature_with_empty_scenario(self):
"""
Test parsing of a feature with one empty scenario
"""
feature = """Feature: some feature
Scenario: some empty scenario"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
parser.feature.scenarios[0].id.should.be.equal(1)
parser.feature.scenarios[0].sentence.should.be.equal("some empty scenario")
parser.feature.scenarios[0].path.should.be.equal(featurefile.name)
parser.feature.scenarios[0].line.should.be.equal(2)
parser.feature.scenarios[0].steps.should.be.empty
def test_parse_feature_with_ignored_scenario(self):
"""
Test parsing a feature which has an ignored scenario by a given tag expression
"""
feature = """
Feature: some feature
@good_case
Scenario: foo
When I have a normal scenario
Then I expect nothing special
@bad_case
Scenario: bad case
Given I have the number 1
When I add 3 to my number
Then I expect my number not to be 4
@good_case
Scenario: foo second it
When I have a normal scenario
Then I expect nothing special
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(
core,
featurefile.name,
1,
scenario_tag_expr=tagexpressions.parse('not bad_case'))
feature = parser.parse()
feature.scenarios.should.have.length_of(2)
def test_parse_empty_feature_with_description(self):
"""
Test parsing of an empty feature with desription
"""
feature = """Feature: some empty feature
In order to support cool software
I do fancy BDD testing with radish"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.sentence.should.be.equal("some empty feature")
parser.feature.id.should.be.equal(1)
parser.feature.path.should.be.equal(featurefile.name)
parser.feature.line.should.be.equal(1)
parser.feature.scenarios.should.be.empty
parser.feature.description.should.have.length_of(2)
parser.feature.description[0].should.be.equal("In order to support cool software")
parser.feature.description[1].should.be.equal("I do fancy BDD testing with radish")
def test_parse_feature_with_empty_scenario(self):
"""
Test parsing of a feature with one empty scenario
"""
feature = """Feature: some feature
Scenario: some empty scenario"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
parser.feature.scenarios[0].id.should.be.equal(1)
parser.feature.scenarios[0].sentence.should.be.equal(
"some empty scenario")
parser.feature.scenarios[0].path.should.be.equal(featurefile.name)
parser.feature.scenarios[0].line.should.be.equal(2)
parser.feature.scenarios[0].steps.should.be.empty
def test_parse_featurefile_with_multiple_features(self):
"""
Test parsing a feature file with multiple features
"""
feature = """Feature: some empty feature
Feature: another empty feature"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse.when.called_with().should.throw(
RadishError,
"radish supports only one Feature per feature file")
def test_parse_feature_with_syntax_error(self):
"""
Test parsing a feature which has syntax errors
"""
feature = """
Bllllla: fooo
@good_case
Scenario: foo
When I have a normal scenario
Then I expect nothing special"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse.when.called.should.throw(FeatureFileSyntaxError)
def parser(request, core):
"""
Fixture to create a Feature Parser ready to parse the given Feature File
"""
featurename = request.param[0]
# get parser positional arguments
try:
parser_args = request.param[1]
except IndexError:
parser_args = []
# get parser keyword arguments
try:
parser_kwargs = request.param[2]
except IndexError:
parser_kwargs = {}
# create the Feature Parser instance
return FeatureParser(core, os.path.join(__FEATURE_FILES_DIR__, featurename + '.feature'),
1, *parser_args, **parser_kwargs)
def test_detect_tag(self):
"""
Test detecting a tag
"""
feature = """Feature: some feature"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser._detect_tag.when.called_with(
"@some_tag").should.return_value(("some_tag", None))
parser._detect_tag.when.called_with(
"@some_tag sdfg").should.return_value(("some_tag", None))
parser._detect_tag.when.called_with(
"@some_tag_with_arg(args)").should.return_value(
("some_tag_with_arg", "args"))
parser._detect_tag.when.called_with(
"some_tag").should.return_value(None)
parser._detect_tag.when.called_with(
"some_tag sdfg").should.return_value(None)
def test_parse_feature_with_scenario_and_scenario_outline(self):
"""
Test parsing of a feature file with a scenario and a scenario outline
"""
feature = """Feature: some feature
Scenario: some normal scenario
Given I do some stuff
When I modify it
Then I expect something else
Scenario Outline: some fancy scenario
Given I have the number <number>
When I add <delta> to my number
Then I expect my number to be <result>
Examples:
| number | delta | result |
| 5 | 2 | 7 |
| 10 | 3 | 13 |
| 15 | 6 | 21 |
Scenario: some other normal scenario
Given I do some other stuff
When I modify it
Then I expect something else
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(3)
parser.feature.scenarios[0].should.be.a(Scenario)
parser.feature.scenarios[0].id.should.be.equal(1)
parser.feature.scenarios[0].sentence.should.be.equal("some normal scenario")
parser.feature.scenarios[0].steps.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].sentence.should.be.equal("Given I do some stuff")
parser.feature.scenarios[0].steps[1].sentence.should.be.equal("When I modify it")
parser.feature.scenarios[0].steps[2].sentence.should.be.equal("Then I expect something else")
parser.feature.scenarios[1].should.be.a(ScenarioOutline)
parser.feature.scenarios[1].id.should.be.equal(2)
parser.feature.scenarios[1].sentence.should.be.equal("some fancy scenario")
parser.feature.scenarios[1].steps.should.have.length_of(3)
parser.feature.scenarios[1].steps[0].sentence.should.be.equal("Given I have the number <number>")
parser.feature.scenarios[1].steps[1].sentence.should.be.equal("When I add <delta> to my number")
parser.feature.scenarios[1].steps[2].sentence.should.be.equal("Then I expect my number to be <result>")
parser.feature.scenarios[1].examples_header.should.be.equal(["number", "delta", "result"])
parser.feature.scenarios[1].examples.should.have.length_of(3)
parser.feature.scenarios[1].examples[0].data.should.be.equal(["5", "2", "7"])
parser.feature.scenarios[1].examples[1].data.should.be.equal(["10", "3", "13"])
parser.feature.scenarios[1].examples[2].data.should.be.equal(["15", "6", "21"])
parser.feature.scenarios[2].should.be.a(Scenario)
parser.feature.scenarios[2].id.should.be.equal(6)
parser.feature.scenarios[2].sentence.should.be.equal("some other normal scenario")
parser.feature.scenarios[2].steps.should.have.length_of(3)
parser.feature.scenarios[2].steps[0].sentence.should.be.equal("Given I do some other stuff")
parser.feature.scenarios[2].steps[1].sentence.should.be.equal("When I modify it")
parser.feature.scenarios[2].steps[2].sentence.should.be.equal("Then I expect something else")
def test_feature_with_comments(self):
"""
Test parsing a feature with comments
"""
feature = """Feature: some feature
# this is a comment
Scenario: some fancy scenario
Given I have the number 5
When I add 2 to my number
# this is another comment
Then I expect my number to be 7
Scenario: some other fancy scenario
Given I have the number 50
# foobar comment
When I add 20 to my number
Then I expect my number to be 70
# another stupid comment"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(2)
parser.feature.scenarios[0].sentence.should.be.equal(
"some fancy scenario")
parser.feature.scenarios[0].line.should.be.equal(3)
parser.feature.scenarios[0].steps.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].sentence.should.be.equal(
"Given I have the number 5")
parser.feature.scenarios[0].steps[0].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[0].steps[0].line.should.be.equal(4)
parser.feature.scenarios[0].steps[1].sentence.should.be.equal(
"When I add 2 to my number")
parser.feature.scenarios[0].steps[1].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[0].steps[1].line.should.be.equal(5)
parser.feature.scenarios[0].steps[2].sentence.should.be.equal(
"Then I expect my number to be 7")
parser.feature.scenarios[0].steps[2].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[0].steps[2].line.should.be.equal(7)
parser.feature.scenarios[1].sentence.should.be.equal(
"some other fancy scenario")
parser.feature.scenarios[1].line.should.be.equal(9)
parser.feature.scenarios[1].steps.should.have.length_of(3)
parser.feature.scenarios[1].steps[0].sentence.should.be.equal(
"Given I have the number 50")
parser.feature.scenarios[1].steps[0].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[1].steps[0].line.should.be.equal(10)
parser.feature.scenarios[1].steps[1].sentence.should.be.equal(
"When I add 20 to my number")
parser.feature.scenarios[1].steps[1].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[1].steps[1].line.should.be.equal(12)
parser.feature.scenarios[1].steps[2].sentence.should.be.equal(
"Then I expect my number to be 70")
parser.feature.scenarios[1].steps[2].path.should.be.equal(
featurefile.name)
parser.feature.scenarios[1].steps[2].line.should.be.equal(13)
def test_parse_feature_with_scenario_outline(self):
"""
Test parsing of a feature file with a scenario outline
"""
feature = """Feature: some feature
Scenario Outline: some fancy scenario
Given I have the number <number>
When I add <delta> to my number
Then I expect my number to be <result>
Examples:
| number | delta | result |
| 5 | 2 | 7 |
| 10 | 3 | 13 |
| 15 | 6 | 21 |
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
scenario = parser.feature.scenarios[0]
scenario.should.be.a(ScenarioOutline)
scenario.id.should.be.equal(1)
scenario.sentence.should.be.equal("some fancy scenario")
scenario.steps.should.have.length_of(3)
scenario.steps[0].id.should.be.equal(1)
scenario.steps[0].sentence.should.be.equal(
"Given I have the number <number>")
scenario.steps[0].path.should.be.equal(featurefile.name)
scenario.steps[0].line.should.be.equal(3)
scenario.steps[1].id.should.be.equal(2)
scenario.steps[1].sentence.should.be.equal(
"When I add <delta> to my number")
scenario.steps[1].path.should.be.equal(featurefile.name)
scenario.steps[1].line.should.be.equal(4)
scenario.steps[2].id.should.be.equal(3)
scenario.steps[2].sentence.should.be.equal(
"Then I expect my number to be <result>")
scenario.steps[2].path.should.be.equal(featurefile.name)
scenario.steps[2].line.should.be.equal(5)
scenario.examples_header.should.be.equal(
["number", "delta", "result"])
scenario.examples.should.have.length_of(3)
scenario.examples[0].data.should.be.equal(["5", "2", "7"])
scenario.examples[1].data.should.be.equal(["10", "3", "13"])
scenario.examples[2].data.should.be.equal(["15", "6", "21"])
scenario.scenarios.should.have.length_of(3)
scenario.scenarios[0].id.should.be.equal(2)
scenario.scenarios[0].steps.should.have.length_of(3)
scenario.scenarios[0].steps[0].id.should.be.equal(1)
scenario.scenarios[0].steps[0].sentence.should.be.equal(
"Given I have the number 5")
scenario.scenarios[0].steps[1].id.should.be.equal(2)
scenario.scenarios[0].steps[1].sentence.should.be.equal(
"When I add 2 to my number")
scenario.scenarios[0].steps[2].id.should.be.equal(3)
scenario.scenarios[0].steps[2].sentence.should.be.equal(
"Then I expect my number to be 7")
scenario.scenarios[1].id.should.be.equal(3)
scenario.scenarios[1].steps.should.have.length_of(3)
scenario.scenarios[0].steps[0].id.should.be.equal(1)
scenario.scenarios[1].steps[0].sentence.should.be.equal(
"Given I have the number 10")
scenario.scenarios[1].steps[1].id.should.be.equal(2)
scenario.scenarios[1].steps[1].sentence.should.be.equal(
"When I add 3 to my number")
scenario.scenarios[1].steps[2].id.should.be.equal(3)
scenario.scenarios[1].steps[2].sentence.should.be.equal(
"Then I expect my number to be 13")
scenario.scenarios[2].id.should.be.equal(4)
scenario.scenarios[2].steps.should.have.length_of(3)
scenario.scenarios[2].steps[0].id.should.be.equal(1)
scenario.scenarios[2].steps[0].sentence.should.be.equal(
"Given I have the number 15")
scenario.scenarios[2].steps[1].id.should.be.equal(2)
scenario.scenarios[2].steps[1].sentence.should.be.equal(
"When I add 6 to my number")
scenario.scenarios[2].steps[2].id.should.be.equal(3)
scenario.scenarios[2].steps[2].sentence.should.be.equal(
"Then I expect my number to be 21")
def test_parse_feature_with_scenario_and_scenario_outline(self):
"""
Test parsing of a feature file with a scenario and a scenario outline
"""
feature = """Feature: some feature
Scenario: some normal scenario
Given I do some stuff
When I modify it
Then I expect something else
Scenario Outline: some fancy scenario
Given I have the number <number>
When I add <delta> to my number
Then I expect my number to be <result>
Examples:
| number | delta | result |
| 5 | 2 | 7 |
| 10 | 3 | 13 |
| 15 | 6 | 21 |
Scenario: some other normal scenario
Given I do some other stuff
When I modify it
Then I expect something else
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(3)
parser.feature.scenarios[0].should.be.a(Scenario)
parser.feature.scenarios[0].id.should.be.equal(1)
parser.feature.scenarios[0].sentence.should.be.equal(
"some normal scenario")
parser.feature.scenarios[0].steps.should.have.length_of(3)
parser.feature.scenarios[0].steps[0].sentence.should.be.equal(
"Given I do some stuff")
parser.feature.scenarios[0].steps[1].sentence.should.be.equal(
"When I modify it")
parser.feature.scenarios[0].steps[2].sentence.should.be.equal(
"Then I expect something else")
parser.feature.scenarios[1].should.be.a(ScenarioOutline)
parser.feature.scenarios[1].id.should.be.equal(2)
parser.feature.scenarios[1].sentence.should.be.equal(
"some fancy scenario")
parser.feature.scenarios[1].steps.should.have.length_of(3)
parser.feature.scenarios[1].steps[0].sentence.should.be.equal(
"Given I have the number <number>")
parser.feature.scenarios[1].steps[1].sentence.should.be.equal(
"When I add <delta> to my number")
parser.feature.scenarios[1].steps[2].sentence.should.be.equal(
"Then I expect my number to be <result>")
parser.feature.scenarios[1].examples_header.should.be.equal(
["number", "delta", "result"])
parser.feature.scenarios[1].examples.should.have.length_of(3)
parser.feature.scenarios[1].examples[0].data.should.be.equal(
["5", "2", "7"])
parser.feature.scenarios[1].examples[1].data.should.be.equal(
["10", "3", "13"])
parser.feature.scenarios[1].examples[2].data.should.be.equal(
["15", "6", "21"])
parser.feature.scenarios[2].should.be.a(Scenario)
parser.feature.scenarios[2].id.should.be.equal(6)
parser.feature.scenarios[2].sentence.should.be.equal(
"some other normal scenario")
parser.feature.scenarios[2].steps.should.have.length_of(3)
parser.feature.scenarios[2].steps[0].sentence.should.be.equal(
"Given I do some other stuff")
parser.feature.scenarios[2].steps[1].sentence.should.be.equal(
"When I modify it")
parser.feature.scenarios[2].steps[2].sentence.should.be.equal(
"Then I expect something else")
def test_parse_feature_with_scenario_outline(self):
"""
Test parsing of a feature file with a scenario outline
"""
feature = """Feature: some feature
Scenario Outline: some fancy scenario
Given I have the number <number>
When I add <delta> to my number
Then I expect my number to be <result>
Examples:
| number | delta | result |
| 5 | 2 | 7 |
| 10 | 3 | 13 |
| 15 | 6 | 21 |
"""
with NamedTemporaryFile("w+") as featurefile:
featurefile.write(feature)
featurefile.flush()
core = Mock()
parser = FeatureParser(core, featurefile.name, 1)
parser.parse()
parser.feature.id.should.be.equal(1)
parser.feature.sentence.should.be.equal("some feature")
parser.feature.scenarios.should.have.length_of(1)
scenario = parser.feature.scenarios[0]
scenario.should.be.a(ScenarioOutline)
scenario.id.should.be.equal(1)
scenario.sentence.should.be.equal("some fancy scenario")
scenario.steps.should.have.length_of(3)
scenario.steps[0].id.should.be.equal(1)
scenario.steps[0].sentence.should.be.equal("Given I have the number <number>")
scenario.steps[0].path.should.be.equal(featurefile.name)
scenario.steps[0].line.should.be.equal(3)
scenario.steps[1].id.should.be.equal(2)
scenario.steps[1].sentence.should.be.equal("When I add <delta> to my number")
scenario.steps[1].path.should.be.equal(featurefile.name)
scenario.steps[1].line.should.be.equal(4)
scenario.steps[2].id.should.be.equal(3)
scenario.steps[2].sentence.should.be.equal("Then I expect my number to be <result>")
scenario.steps[2].path.should.be.equal(featurefile.name)
scenario.steps[2].line.should.be.equal(5)
scenario.examples_header.should.be.equal(["number", "delta", "result"])
scenario.examples.should.have.length_of(3)
scenario.examples[0].data.should.be.equal(["5", "2", "7"])
scenario.examples[1].data.should.be.equal(["10", "3", "13"])
scenario.examples[2].data.should.be.equal(["15", "6", "21"])
scenario.scenarios.should.have.length_of(3)
scenario.scenarios[0].id.should.be.equal(2)
scenario.scenarios[0].steps.should.have.length_of(3)
scenario.scenarios[0].steps[0].id.should.be.equal(1)
scenario.scenarios[0].steps[0].sentence.should.be.equal("Given I have the number 5")
scenario.scenarios[0].steps[1].id.should.be.equal(2)
scenario.scenarios[0].steps[1].sentence.should.be.equal("When I add 2 to my number")
scenario.scenarios[0].steps[2].id.should.be.equal(3)
scenario.scenarios[0].steps[2].sentence.should.be.equal("Then I expect my number to be 7")
scenario.scenarios[1].id.should.be.equal(3)
scenario.scenarios[1].steps.should.have.length_of(3)
scenario.scenarios[0].steps[0].id.should.be.equal(1)
scenario.scenarios[1].steps[0].sentence.should.be.equal("Given I have the number 10")
scenario.scenarios[1].steps[1].id.should.be.equal(2)
scenario.scenarios[1].steps[1].sentence.should.be.equal("When I add 3 to my number")
scenario.scenarios[1].steps[2].id.should.be.equal(3)
scenario.scenarios[1].steps[2].sentence.should.be.equal("Then I expect my number to be 13")
scenario.scenarios[2].id.should.be.equal(4)
scenario.scenarios[2].steps.should.have.length_of(3)
scenario.scenarios[2].steps[0].id.should.be.equal(1)
scenario.scenarios[2].steps[0].sentence.should.be.equal("Given I have the number 15")
scenario.scenarios[2].steps[1].id.should.be.equal(2)
scenario.scenarios[2].steps[1].sentence.should.be.equal("When I add 6 to my number")
scenario.scenarios[2].steps[2].id.should.be.equal(3)
scenario.scenarios[2].steps[2].sentence.should.be.equal("Then I expect my number to be 21")
