def test_feature_max_length_on_scenario_outline_keys(): """ The max length of a feature considering when the table keys of the scenario oulines are longer than the remaining things """ feature1 = Feature.from_string(FEATURE8) feature2 = Feature.from_string(FEATURE9) assert_equals(feature1.max_length, 68) assert_equals(feature2.max_length, 68)
def test_scenario_outlines_within_feature(): """ Solving scenario outlines within a feature """ feature = Feature.from_string(OUTLINED_FEATURE) scenario = feature.scenarios[0] assert_equals(len(scenario.solved_steps), 12) expected_sentences = [ 'Given I have entered 20 into the calculator', 'And I have entered 30 into the calculator', 'When I press add', 'Then the result should be 50 on the screen', 'Given I have entered 2 into the calculator', 'And I have entered 5 into the calculator', 'When I press add', 'Then the result should be 7 on the screen', 'Given I have entered 0 into the calculator', 'And I have entered 40 into the calculator', 'When I press add', 'Then the result should be 40 on the screen', ] for step, expected_sentence in zip(scenario.solved_steps, expected_sentences): assert_equals(type(step), Step) assert_equals(step.sentence, expected_sentence)
def test_feature_first_scenario_tags_extraction(): ("A feature object should be able to find the tags " "belonging to the first scenario") feature = Feature.from_string(FEATURE23) assert that(feature.scenarios[0].tags).deep_equals([ 'onetag', 'another', '$%^&even-weird_chars'])
def test_scenarios_parsed_by_feature_has_feature(): "Scenarios parsed by features has feature" feature = Feature.from_string(FEATURE2) for scenario in feature.scenarios: assert_equals(scenario.feature, feature)
def test_single_scenario_many_scenarios(): "Untagged scenario following a tagged one should have no tags" @step('this scenario has tags') def scenario_has_tags(step): assert step.scenario.tags @step('this scenario has no tags') def scenario_has_no_tags(step): assert not step.scenario.tags @step('it can be inspected from within the object') def inspected_within_object(step): assert step.scenario.tags @step(r'fill my email with [\'"]?([^\'"]+)[\'"]?') def fill_email(step, email): assert that(email).equals('*****@*****.**') feature = Feature.from_string(FEATURE13) first_scenario = feature.scenarios[0] assert that(first_scenario.tags).equals(['runme']) second_scenario = feature.scenarios[1] assert that(second_scenario.tags).equals([]) third_scenario = feature.scenarios[2] assert that(third_scenario.tags).equals(['slow']) last_scenario = feature.scenarios[3] assert that(last_scenario.tags).equals([])
def test_background_parsing_without_mmf(): feature = Feature.from_string(FEATURE17) expect(feature.description).to.be.empty expect(feature).to.have.property('background').being.a(Background) expect(feature.background).to.have.property('steps') expect(feature.background.steps).to.have.length_of(2) step1, step2 = feature.background.steps step1.sentence.should.equal( 'Given I have the following movies in my database:') step1.hashes.should.equal([ { u'Available': u'6', u'Rating': u'4 stars', u'Name': u'Matrix Revolutions', u'New': u'no', }, { u'Available': u'11', u'Rating': u'5 stars', u'Name': u'Iron Man 2', u'New': u'yes', }, ]) step2.sentence.should.equal( 'And the following clients:') step2.hashes.should.equal([ {u'Name': u'John Doe'}, {u'Name': u'Foo Bar'}, ])
def test_feature_first_scenario_tag_extraction(): ("A feature object should be able to find the single tag " "belonging to the first scenario") feature = Feature.from_string(FEATURE22) assert that(feature.scenarios[0].tags).deep_equals([ 'onetag'])
def test_full_featured_feature(): """ Solving scenarios within a full-featured feature """ feature = Feature.from_string(OUTLINED_FEATURE_WITH_MANY) scenario1, scenario2, scenario3, scenario4 = feature.scenarios assert_equals(scenario1.name, 'Do something') assert_equals(scenario2.name, 'Do something else') assert_equals(scenario3.name, 'Worked!') assert_equals(scenario4.name, 'Add two numbers wisely') assert_equals(len(scenario1.solved_steps), 2) expected_sentences = [ 'Given I have entered ok into the fail', 'Given I have entered fail into the ok', ] for step, expected_sentence in zip(scenario1.solved_steps, expected_sentences): assert_equals(step.sentence, expected_sentence) expected_evaluated = ( ( {'button': 'add', 'input_1': '20', 'input_2': '30', 'output': '50'}, [ 'Given I have entered 20 into the calculator', 'And I have entered 30 into the calculator', 'When I press add', 'Then the result should be 50 on the screen', ] ), ( {'button': 'add', 'input_1': '2', 'input_2': '5', 'output': '7'}, [ 'Given I have entered 2 into the calculator', 'And I have entered 5 into the calculator', 'When I press add', 'Then the result should be 7 on the screen', ] ), ( {'button': 'add', 'input_1': '0', 'input_2': '40', 'output': '40'}, [ 'Given I have entered 0 into the calculator', 'And I have entered 40 into the calculator', 'When I press add', 'Then the result should be 40 on the screen', ], ), ( {'button': 'add', 'input_1': '5', 'input_2': '7', 'output': '12'}, [ 'Given I have entered 5 into the calculator', 'And I have entered 7 into the calculator', 'When I press add', 'Then the result should be 12 on the screen', ], ) ) for ((got_examples, got_steps), (expected_examples, expected_steps)) in zip(scenario4.evaluated, expected_evaluated): sentences_of = lambda x: x.sentence assert_equals(got_examples, expected_examples) assert_equals(map(sentences_of, got_steps), expected_steps)
def test_feature_max_length_on_step_with_table_keys(): """ The max length of a feature considering when the table keys of some of the steps are longer than the remaining things """ feature = Feature.from_string(FEATURE7) assert_equals(feature.max_length, 74)
def test_feature_max_length_on_step_sentence(): """ The max length of a feature considering when the some of the step sentences is longer than the remaining things """ feature = Feature.from_string(FEATURE4) assert_equals(feature.max_length, 55)
def test_feature_max_length_on_feature_name(): """ The max length of a feature considering when the name of the feature is longer than the remaining things """ feature = Feature.from_string(FEATURE3) assert_equals(feature.max_length, 78)
def test_feature_max_length_on_feature_description(): """ The max length of a feature considering when one of the description lines of the feature is longer than the remaining things """ feature = Feature.from_string(FEATURE2) assert_equals(feature.max_length, 47)
def test_feature_max_length_on_scenario(): """ The max length of a feature considering when the scenario is longer than the remaining things """ feature = Feature.from_string(FEATURE1) assert_equals(feature.max_length, 76)
def test_feature_max_length_on_scenario_outline(): """ The max length of a feature considering when the table of some of the scenario oulines is longer than the remaining things """ feature = Feature.from_string(FEATURE6) assert_equals(feature.max_length, 79)
def test_description_on_long_named_feature(): "Can parse the description on long named features" feature = Feature.from_string(FEATURE3) assert_equals( feature.description, "In order to describe my features\n" "I want to add description on them", )
def test_single_scenario_single_scenario(): "Features should have at least the first scenario parsed with tags" feature = Feature.from_string(FEATURE11) first_scenario = feature.scenarios[0] assert that(first_scenario.tags).deep_equals([ 'many', 'other', 'basic', 'tags', 'here', ':)'])
def test_comments(): """ It should ignore lines that start with #, despite white spaces """ feature = Feature.from_string(FEATURE10) assert_equals(feature.max_length, 55)
def parse_steps(step): feature = """ Feature: parse a step Scenario: parse a single step """ feature += step return Feature.from_string(feature).scenarios[0].steps
def test_scenarios_with_special_characters(): "Make sure that regex special characters in the scenario names are ignored" feature = Feature.from_string(FEATURE19) assert that(feature.scenarios[0].tags).deep_equals([ 'runme1']) assert that(feature.scenarios[1].tags).deep_equals([ 'runme2'])
def test_description_on_big_sentenced_steps(): "Can parse the description on long sentenced steps" feature = Feature.from_string(FEATURE4) assert_equals( feature.description, "As a clever guy\n" "I want to describe this Feature\n" "So that I can take care of my Scenario", )
def test_scenario_has_name(): """ It should extract the name string from the scenario """ feature = Feature.from_string(FEATURE1) assert isinstance(feature, Feature) expect(feature.name).to.equal("Rent movies")
def test_scenario_post_email(): ("Having a scenario which the body has an email address; " "Then the following scenario should have no " "tags related to the email") feature = Feature.from_string(FEATURE21) scenario1, scenario2 = feature.scenarios scenario1.tags.should.be.empty scenario2.tags.should.equal(['tag'])
def test_scenarios_with_extra_whitespace(): "Make sure that extra leading whitespace is ignored" feature = Feature.from_string(FEATURE14) assert_equals(type(feature.scenarios), list) assert_equals(len(feature.scenarios), 1, "It should have 1 scenario") assert_equals(feature.name, "Extra whitespace feature") scenario = feature.scenarios[0] assert_equals(type(scenario), Scenario) assert_equals(scenario.name, "Extra whitespace scenario")
def test_single_feature_single_tag(): "All scenarios within a feature inherit the feature's tags" feature = Feature.from_string(FEATURE18) assert that(feature.scenarios[0].tags).deep_equals([ 'runme1', 'feature_runme']) assert that(feature.scenarios[1].tags).deep_equals([ 'runme2', 'feature_runme']) assert that(feature.scenarios[2].tags).deep_equals([ 'runme3', 'feature_runme'])
def parse_scenario(scenario, tags=None): feature_str = """ Feature: test scenario """ if tags: feature_str += ' '.join('@%s' % tag for tag in tags) feature_str += scenario feature = Feature.from_string(feature_str) return feature.scenarios[0]
def test_feature_has_scenarios(): """ A feature object should have a list of scenarios """ feature = Feature.from_string(FEATURE1) expect(feature.scenarios).to.be.a(list) expect(feature.scenarios).to.have.length_of(3) expected_scenario_names = [ "Renting a featured movie", "Renting a non-featured movie", "Renting two movies allows client to take one more without charge", ] for scenario, expected_name in zip(feature.scenarios, expected_scenario_names): expect(scenario).to.be.a(Scenario) expect(scenario.name).to.equal(expected_name) expect(feature.scenarios[1].steps[0].keys).to.equal( ('Name', 'Rating', 'New', 'Available')) expect(list(feature.scenarios[1].steps[0].hashes)).to.equal([ { 'Name': 'A night at the museum 2', 'Rating': '3 stars', 'New': 'yes', 'Available': '9', }, { 'Name': 'Matrix Revolutions', 'Rating': '4 stars', 'New': 'no', 'Available': '6', }, ])
def test_background_parsing_with_mmf(): feature = Feature.from_string(FEATURE16) expect(feature.description).to.equal( "As a rental store owner\n" "I want to keep track of my clients\n" "So that I can manage my business better" ) expect(feature).to.have.property('background').being.a(Background) expect(feature.background).to.have.property('steps') expect(feature.background.steps).to.have.length_of(2) step1, step2 = feature.background.steps step1.sentence.should.equal( 'Given I have the following movies in my database:') step1.hashes.should.equal([ { u'Available': u'6', u'Rating': u'4 stars', u'Name': u'Matrix Revolutions', u'New': u'no', }, { u'Available': u'11', u'Rating': u'5 stars', u'Name': u'Iron Man 2', u'New': u'yes', }, ]) step2.sentence.should.equal( 'And the following clients:') step2.hashes.should.equal([ {u'Name': u'John Doe'}, {u'Name': u'Foo Bar'}, ])
def test_scenarios_parsing(): "Tags are parsed correctly" feature = Feature.from_string(FEATURE15) scenarios_and_tags = [(s.name, s.tags) for s in feature.scenarios] scenarios_and_tags.should.equal([ ('Bootstraping Redis role', []), ('Restart scalarizr', []), ('Rebundle server', [u'rebundle']), ('Use new role', [u'rebundle']), ('Restart scalarizr after bundling', [u'rebundle']), ('Bundling data', []), ('Modifying data', []), ('Reboot server', []), ('Backuping data on Master', []), ('Setup replication', []), ('Restart scalarizr in slave', []), ('Slave force termination', []), ('Slave delete EBS', [u'ec2']), ('Setup replication for EBS test', [u'ec2']), ('Writing on Master, reading on Slave', []), ('Slave -> Master promotion', []), ('Restart farm', [u'restart_farm']), ])
def test_can_parse_feature_description(): """ A feature object should have a description """ feature = Feature.from_string(FEATURE2) assert_equals( feature.description, "In order to avoid silly mistakes\n" "Cashiers must be able to calculate a fraction" ) expected_scenario_names = ["Regular numbers"] got_scenario_names = [s.name for s in feature.scenarios] assert_equals(expected_scenario_names, got_scenario_names) assert_equals(len(feature.scenarios[0].steps), 4) step1, step2, step3, step4 = feature.scenarios[0].steps assert_equals(step1.sentence, 'Given I have entered 3 into the calculator') assert_equals(step2.sentence, 'And I have entered 2 into the calculator') assert_equals(step3.sentence, 'When I press divide') assert_equals(step4.sentence, 'Then the result should be 1.5 on the screen')
def test_feature_has_repr(): """ Feature implements __repr__ nicely """ feature = Feature.from_string(FEATURE1) expect(repr(feature)).to.equal('<Feature: "Rent movies">')