a 4j@sfdZddlmZmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZmZmZmZddlmZddlmZe jrddlZnddlZGdd d eeZGd d d eeZGd d d eeZGdddeZGdddeZGdddeeZ GdddeeZ!GdddeZ"GdddeZ#Gddde j$Z%Gddde j$Z&ddZ'dS) z This module provides the model element class that represent a behave model: * :class:`Feature` * :class:`Scenario` * :class:`ScenarioOutline` * :class:`Step` * ... )absolute_importwith_statementN)zip)StatusBasicStatementTagAndStatusStatement TagStatement Replayable)NoMatch)textcseZdZdZdZdfdd ZfddZdd Zd d Zd d Z ddZ e ddZ d ddZ d!ddZddZddZd"ddZddZZS)#Featurea- A `feature`_ parsed from a *feature file*. The attributes are: .. attribute:: keyword This is the keyword as seen in the *feature file*. In English this will be "Feature". .. attribute:: name The name of the feature (the text after "Feature".) .. attribute:: description The description of the feature as seen in the *feature file*. This is stored as a list of text lines. .. attribute:: background The :class:`~behave.model.Background` for this feature, if any. .. attribute:: scenarios A list of :class:`~behave.model.Scenario` making up this feature. .. attribute:: tags A list of @tags (as :class:`~behave.model.Tag` which are basically glorified strings) attached to the feature. See :ref:`controlling things with tags`. .. attribute:: status Read-Only. A summary status of the feature's run. If read before the feature is fully tested it will return "untested" otherwise it will return one of: Status.untested The feature was has not been completely tested yet. Status.skipped One or more steps of this feature was passed over during testing. Status.passed The feature was tested successfully. Status.failed One or more steps of this feature failed. .. versionchanged:: 1.2.6 Use Status enum class (was: string). .. attribute:: hook_failed Indicates if a hook failure occured while running this feature. .. versionadded:: 1.2.6 .. attribute:: duration The time, in seconds, that it took to test this feature. If read before the feature is tested it will return 0.0. .. attribute:: filename The file name (or "") of the *feature file* where the feature was found. .. attribute:: line The line number of the *feature file* where the feature was found. .. attribute:: language Indicates which spoken language (English, French, German, ..) was used for parsing the feature file and its keywords. The I18N language code indicates which language is used. This corresponds to the language tag at the beginning of the feature file. .. versionadded:: 1.2.6 .. _`feature`: gherkin.html#features featureNc sd|pg}tt|||||||p&g|_g|_||_| |_d|_d|_|r`|D]} | | qPdSNF) superr __init__ description scenarios backgroundlanguageparser hook_failed add_scenario) selffilenamelinekeywordnametagsrrrrscenario __class__2E:\soccer\ml_env\Lib\site-packages\behave/model.pyrus zFeature.__init__cs,tt|d|_|jD] }|qdS)z'Reset to clean state before a test run.FN)rr resetrrrrrr!r"r#s z Feature.resetcCsd|jt|jfS)Nz)rlenrrr!r!r"__repr__szFeature.__repr__cCs t|jSNiterrr&r!r!r"__iter__szFeature.__iter__cCs||_|j|_|j|dSr()r rrappendr$r!r!r"rszFeature.add_scenariocCs|jr tjSd}d}|jD]d}|j}|tjkr8tjS|tjkr^|dkrTtjStjS|tjkrld}|tjkr|d7}q|rtjStjSdS)zCompute the status of this feature based on its: * scenarios * scenario outlines * hook failures :return: Computed status (as string-enum). TrFN)rrfailedrstatusuntestedskippedpassed)rr1Z passed_countrscenario_statusr!r!r"compute_statuss&         zFeature.compute_statuscCsd}|jD]}||j7}q |S)Ng)rduration)rZfeature_durationrr!r!r"r5s  zFeature.durationFcCsHg}|jD]8}t|tr8|}|r*||||jq ||q |S)a Provides a flat list of all scenarios of this feature. A ScenarioOutline element adds its scenarios to this list. But the ScenarioOutline element itself is only added when specified. A flat scenario list is useful when all scenarios of a features should be processed. :param with_outlines: If ScenarioOutline items should be added, too. :return: List of all scenarios of this feature. )r isinstanceScenarioOutliner,extend)rZ with_outlinesZ all_scenariosrscenario_outliner!r!r"walk_scenarioss     zFeature.walk_scenarioscCs |j }|r|r||j}|S)a Determines if this Feature (and its scenarios) should run. Implements the run decision logic for a feature. The decision depends on: * if the Feature is marked as skipped * if the config.tags (tag expression) enable/disable this feature :param config: Runner configuration to use (optional). :return: True, if scenario should run. False, otherwise. ) should_skipshould_run_with_tagsrrconfigZanswerr!r!r" should_runs  zFeature.should_runcCs0||j}|s,|D]}||rd}q,q|S)atDetermines if this feature should run when the tag expression is used. A feature should run if: * it should run according to its tags * any of its scenarios should run according to its tags :param tag_expression: Runner/config environment tags to use. :return: True, if feature should run. False, otherwise (skip it). T)checkrr<)rtag_expression run_featurerr!r!r"r<s  zFeature.should_run_with_tagscCs&|jdd|jtjks"|js"JdS)zMarks this feature (and all its scenarios and steps) as skipped. Note this function may be called before the feature is executed. Trequire_not_executedN)skipr/rr1rr&r!r!r" mark_skippeds zFeature.mark_skippedcCsp|rtd}|d|j||d|_||_|jD]}|||q8|js\| t j |j |j vslJdS)a}Skip executing this feature or the remaining parts of it. Note that this feature may be already partly executed when this function is called. :param reason: Optional reason why feature should be skipped (as string). :param require_not_executed: Optional, requires that feature is not executed yet (default: false). behavezSKIP FEATURE %s: %sTN)logging getLoggerwarningr clear_statusr; skip_reasonrrE set_statusrr1r/ final_statusrreasonrDloggerrr!r!r"rEs    z Feature.skipc Cs|d|_|jjdd||j_t|j|j_|j}||j }d}d}|j j s|rd}|jD]}| d|j|qb| d|j||jr|d7}|jp|j}|}|s|j j r|j D]}||q|jr|j D]}||jq|sJ|jD]R}|j jr||j s|q||} | r|d7}|j jsB|jrqJq||jsl|sl|tj|r| d |j||jD]}| d |j|q|jr|d7}|tjz|jWn ty|tjYn0|s|j j r|j D]}|q|dk} | S) NFr Z layer_namerT before_tagZbefore_featurer-Z after_feature after_tag)rKrcontext_pushr setrabortedr?r>dry_runrun_hook show_skipped formattersrrrshould_run_with_name_selectrFrunstoprMrr1r._pop Exceptioneof) rrunnerZskip_feature_untestedrB failed_count hooks_calledtag formatterrr.r!r!r"r^sn                 z Feature.run)NNNNN)F)N)NF)__name__ __module__ __qualname____doc__typerr#r'r+rr4propertyr5r:r?r<rFrEr^ __classcell__r!r!rr"r s&R      r csBeZdZdZdZd fdd ZddZdd Zed d Z Z S) BackgroundaOA `background`_ parsed from a *feature file*. The attributes are: .. attribute:: keyword This is the keyword as seen in the *feature file*. In English this will typically be "Background". .. attribute:: name The name of the background (the text after "Background:".) .. attribute:: steps A list of :class:`~behave.model.Step` making up this background. .. attribute:: duration The time, in seconds, that it took to run this background. If read before the background is run it will return 0.0. .. attribute:: filename The file name (or "") of the *feature file* where the background was found. .. attribute:: line The line number of the *feature file* where the background was found. .. _`background`: gherkin.html#backgrounds rNcs$tt||||||pg|_dSr()rrorsteps)rrrrrrprr!r"rszBackground.__init__cCs d|jS)Nzrr&r!r!r"r'szBackground.__repr__cCs t|jSr()r*rpr&r!r!r"r+szBackground.__iter__cCsd}|jD]}||j7}q |SNr)rpr5)rr5stepr!r!r"r5s  zBackground.duration)N) rhrirjrkrlrr'r+rmr5rnr!r!rr"rods!rocseZdZdZdZdZd#fdd ZfddZed d Z ed d Z d dZ ddZ ddZ eddZeddZd$ddZddZddZddZd%dd Zd!d"ZZS)&ScenarioaA `scenario`_ parsed from a *feature file*. The attributes are: .. attribute:: keyword This is the keyword as seen in the *feature file*. In English this will typically be "Scenario". .. attribute:: name The name of the scenario (the text after "Scenario:".) .. attribute:: description The description of the scenario as seen in the *feature file*. This is stored as a list of text lines. .. attribute:: feature The :class:`~behave.model.Feature` this scenario belongs to. .. attribute:: steps A list of :class:`~behave.model.Step` making up this scenario. .. attribute:: tags A list of @tags (as :class:`~behave.model.Tag` which are basically glorified strings) attached to the scenario. See :ref:`controlling things with tags`. .. attribute:: status Read-Only. A summary status of the scenario's run. If read before the scenario is fully tested it will return "untested" otherwise it will return one of: Status.untested The scenario was has not been completely tested yet. Status.skipped One or more steps of this scenario was passed over during testing. Status.passed The scenario was tested successfully. Status.failed One or more steps of this scenario failed. .. versionchanged:: 1.2.6 Use Status enum class (was: string) .. attribute:: hook_failed Indicates if a hook failure occured while running this scenario. .. versionadded:: 1.2.6 .. attribute:: duration The time, in seconds, that it took to test this scenario. If read before the scenario is tested it will return 0.0. .. attribute:: filename The file name (or "") of the *feature file* where the scenario was found. .. attribute:: line The line number of the *feature file* where the scenario was found. .. _`scenario`: gherkin.html#scenarios rFNcs\|pg}tt|||||||p&g|_|p0g|_d|_d|_d|_d|_d|_ d|_ dSr) rrtrrrprr r_background_steps_row was_dry_run)rrrrrrrprrr!r"rs  zScenario.__init__cs8tt|d|_d|_d|_|jD] }|q&dS)zfReset the internal data to reintroduce new-born state just after the ctor was called. FN)rrtr#rrvrw all_stepsrrsrr!r"r#s  zScenario.resetcCs2|jdur,g}|jr&dd|jjD}||_|jS)a7Provide background steps if feature has a background. Lazy init that copies the background steps. Note that a copy of the background steps is needed to ensure that the background step status is specific to the scenario. :return: List of background steps or empty list NcSsg|]}t|qSr!)copy).0rsr!r!r" z-Scenario.background_steps..)rurrp)rrpr!r!r"background_stepss zScenario.background_stepscCs(|jdurt|j|jSt|jSdS)zAReturns iterator to all steps, including background steps if any.N)r itertoolschainr~rpr*r&r!r!r"rxs zScenario.all_stepscCs d|jS)Nzrqr&r!r!r"r'szScenario.__repr__cCs|jSr()rxr&r!r!r"r+ szScenario.__iter__cCsv|jr tjS|jD]\}|jtjkr>|jr2tjStjSq|jtjkr|jtjtj tjfvsdJ|jSqtjS)zCompute the status of the scenario from its steps (and hook failures). :return: Computed status (as enum value). ) rrr.rxr/ undefinedrwr0r2r1ryr!r!r"r4#s      zScenario.compute_statuscCsd}|jD]}||j7}q |Srr)rxr5)rZscenario_durationrsr!r!r"r5;s  zScenario.durationcCs|j}|jr|jj|j}|S)zt Effective tags for this scenario: * own tags * tags inherited from its feature )rr )rrr!r!r"effective_tagsCszScenario.effective_tagscCs*|j }|r&|r&||jo$||}|S)a Determines if this Scenario (or ScenarioOutline) should run. Implements the run decision logic for a scenario. The decision depends on: * if the Scenario is marked as skipped * if the config.tags (tag expression) enable/disable this scenario * if the scenario is selected by name :param config: Runner configuration to use (optional). :return: True, if scenario should run. False, otherwise. )r;r<rr]r=r!r!r"r?Os  zScenario.should_runcCs ||jS)z Determines if this scenario should run when the tag expression is used. :param tag_expression: Runner/config environment tags to use. :return: True, if scenario should run. False, otherwise (skip it). )r@r)rrAr!r!r"r<bszScenario.should_run_with_tagscCs|j p|j|jS)Determines if this scenario should run when it is selected by name. :param config: Runner/config environment name regexp (if any). :return: True, if scenario should run. False, otherwise (skip it). )rZname_research)rr>r!r!r"r]ksz$Scenario.should_run_with_name_selectcCs2|jdd|jtjks.|js.Jd|jjdS)zMarks this scenario (and all its steps) as skipped. Note that this method can be called before the scenario is executed. TrCzOOPS: scenario.status=%sN)rEr/rr1rrr&r!r!r"rFts  zScenario.mark_skippedcCs|r(|jj}td}|d||j||d|_||_|j D]6}|j t j t j fv}|rft j |_ qB|rBJd|j qB|j o|j }|r|t j |j |jvsJdS)zSkip from executing this scenario or the remaining parts of it. Note that the scenario may be already partly executed when this method is called. :param reason: Optional reason why it should be skipped (as string). rGzSKIP %s %s: %sTz$REQUIRE NOT-EXECUTED, but step is %sN)r rhrHrIrJrrKr;rLrxr/rr0r1rpr~rMrN)rrPrDZ scenario_typerQrsZ not_executedZscenario_without_stepsr!r!r"rE|s$    z Scenario.skipc Cs||jd|_d}|j}||j}|o:|jj }|oF|jj}||_|j j dd||j _ t |j |j _d}|jjs|rd}|jD]}|d|j |q|d|j ||jrd}|jp|j}|}|o|jj }|s|jjr|jD]} | |q||s|jjr>|D]} |jD]} | | q(q|s4|jD]} |r| |s|jor| jtjk}d}|j dd|tjn |jr0d}n|s|r(tj| _|rtj| _|j | } | stj!| _|j"#| n:|r0| jtjksJ|jD]} | $| | %| q ntj| _qJ||sV|j&sV|tj|r|d|j ||jD]}|d |j |qr|jr|tjd}z|j 'Wn$t(y|tjd}Yn0|jj)p|jtjk} | r|j*j|_|+|S) NFrrRTrSZbefore_scenarior.Zafter_scenariorT),rKcapturedr#rrXr?r>rYrwrUrVrrWrrrZr[r\Z setup_capturersrxr^continue_after_failed_stepr/rr._set_root_attributerMr;r1r0 step_registry find_matchrundefined_stepsr,matchresultrpr`raZjunitcapture_controllerZteardown_capture) rrcr.Zskip_scenario_untestedZ run_scenarioZ run_stepsZdry_run_scenariorerfrgrsZfound_step_matchstore_capturedr!r!r"r^s                       z Scenario.run)NNN)N)NF)rhrirjrkrlrrr#rmr~rxr'r+r4r5rr?r<r]rFrEr^rnr!r!rr"rts0K        rtc@sTeZdZdZddZedddZdddZedd d Z edd d Z d dZ dS)ScenarioOutlineBuilderzmHelper class to use a ScenarioOutline as a template and build its scenarios (as template instances). cCs ||_dSr()annotation_schema)rrr!r!r"rszScenarioOutlineBuilder.__init__NcCshd|vrd|vs|Sd}||fD]B}|s*q |D].\}}|rPd|vrPd|vrPq2|d||}q2q |S)aRender a text template with placeholders, ala "Hello ". :param row: As placeholder provider (dict-like). :param params: As additional placeholder provider (as dict). :return: Rendered text, known placeholders are substituted w/ values. <>F<%s>)itemsreplace)r rowparamsZ safe_valuesZ placeholdersrvaluer!r!r"render_templates z&ScenarioOutlineBuilder.render_templatec Cs|dur i}|jpd|d<|d|j|d|j|d|j||j||}||d<||||}Gdddt}|||j}||j|j} |jj||| d S) aBuild a scenario name for an example row of this scenario outline. Placeholders for row data are replaced by values. SCHEMA: "{outline_name} -*- {examples.name}@{row.id}" :param outline_name: ScenarioOutline's name (as template). :param example: Examples object. :param row: Row of this example. :param params: Additional placeholders for example/row. :return: Computed name for the scenario representing example/row. N examples.nameexamples.index row.indexrow.idc@seZdZddZdS)z7ScenarioOutlineBuilder.make_scenario_name..DatacSs||_||_||_dSr()rindexidrrrr!r!r"rCsz@ScenarioOutlineBuilder.make_scenario_name..Data.__init__N)rhrirjrr!r!r!r"DataBsr)rexamplesr)r setdefaultrrrobjectrformat) rZ outline_nameexamplerrZ examples_name scenario_namerZ example_dataZrow_datar!r!r"make_scenario_name*s  z)ScenarioOutlineBuilder.make_scenario_namecCsb|sgSg}|D]L}d|vr2d|vr2||||}d|vsd|vrDqtj|dd}||q|S)NrrT)unescape)rTag make_namer,)clsZ outline_tagsrrrrfZnew_tagr!r!r" make_row_tagsMs z$ScenarioOutlineBuilder.make_row_tagsc Cst|}||j|||_|jr2||j||_|jr|D]>\}}|jD].}t|jD]\}}| d|||j|<q\qNq@|S)Nr) rzdeepcopyrrr tabler enumeratecellsr) r outline_steprrnew_steprricellr!r!r"make_step_for_row]s  z(ScenarioOutlineBuilder.make_step_for_rowc Cs(ddddd}g}t|jD]\}}|d|_|j|d<t|j|d<t|jD]\}}|d|_d|j|jf|_|j|d<t|j|d<||j|||}||j ||} | |j g} |j D]} | | ||} | | q|j} t|j| |j|| | }|j|_|j|_||_| |qRq|S) z8Build scenarios for a ScenarioOutline from its examples.N)rrrrr-rrz%d.%drr)rrrr_textrrrrrr8rprr,rrtrrr rrv)rr9rrZ example_indexrZ row_indexrrZrow_tagsZ new_stepsrrZ scenario_linerr!r!r"build_scenariosksD       z&ScenarioOutlineBuilder.build_scenarios)NN)N)N)N) rhrirjrkr staticmethodrr classmethodrrrr!r!r!r"r s  #  rcseZdZdZdZdZdfdd ZfddZed d Z d d Z d dZ ddZ eddZ ddZddZddZdddZddZZS) r7aA `scenario outline`_ parsed from a *feature file*. A scenario outline extends the existing :class:`~behave.model.Scenario` class with the addition of the :class:`~behave.model.Examples` tables of data from the *feature file*. The attributes are: .. attribute:: keyword This is the keyword as seen in the *feature file*. In English this will typically be "Scenario Outline". .. attribute:: name The name of the scenario (the text after "Scenario Outline:".) .. attribute:: description The description of the `scenario outline`_ as seen in the *feature file*. This is stored as a list of text lines. .. attribute:: feature The :class:`~behave.model.Feature` this scenario outline belongs to. .. attribute:: steps A list of :class:`~behave.model.Step` making up this scenario outline. .. attribute:: examples A list of :class:`~behave.model.Examples` used by this scenario outline. .. attribute:: tags A list of @tags (as :class:`~behave.model.Tag` which are basically glorified strings) attached to the scenario. See :ref:`controlling things with tags`. .. attribute:: status Read-Only. A summary status of the scenario outlines's run. If read before the scenario is fully tested it will return "untested" otherwise it will return one of: Status.untested The scenario was has not been completely tested yet. Status.skipped One or more scenarios of this outline was passed over during testing. Status.passed The scenario was tested successfully. Status.failed One or more scenarios of this outline failed. .. versionchanged:: 1.2.6 Use Status enum class (was: string) .. attribute:: duration The time, in seconds, that it took to test the scenarios of this outline. If read before the scenarios are tested it will return 0.0. .. attribute:: filename The file name (or "") of the *feature file* where the scenario was found. .. attribute:: line The line number of the *feature file* where the scenario was found. .. _`scenario outline`: gherkin.html#scenario-outlines r9z#{name} -- @{row.id} {examples.name}Nc s0tt|||||||||p"g|_g|_dSr()rr7rr _scenarios) rrrrrrrprrrr!r"rs  zScenarioOutline.__init__cs&tt||jD] }|qdS)z4Reset runtime temporary data like before a test run.N)rr7r#rr$rr!r"r#s zScenarioOutline.resetcCs(|jr |jSt|j}|||_|jS)zbReturn the scenarios with the steps altered to take the values from the examples. )rrrr)rbuilderr!r!r"rs   zScenarioOutline.scenarioscCs d|jS)Nzrqr&r!r!r"r'szScenarioOutline.__repr__cCs t|jSr(r)r&r!r!r"r+szScenarioOutline.__iter__cCsbd}|jD]4}|j}|tjtjfvr,|S|tjkr |d7}q |dkr\|t|jkr\tjStjS)Nrr-)rr/rr.r0r1r%r2)rZ skipped_countrr3r!r!r"r4s   zScenarioOutline.compute_statuscCsd}|jD]}||j7}q |Srr)rr5)rZoutline_durationrr!r!r"r5s  zScenarioOutline.durationcCs0||jrdS|jD]}||rdSqdS)a Determines if this scenario outline (or one of its scenarios) should run when the tag expression is used. :param tag_expression: Runner/config environment tags to use. :return: True, if scenario should run. False, otherwise (skip it). TF)r@rrr<)rrArr!r!r"r<s    z$ScenarioOutline.should_run_with_tagscCs*|js dS|jD]}||rdSqdS)rTF)rrr])rr>rr!r!r"r]'s   z+ScenarioOutline.should_run_with_name_selectcCs |jdd|jtjksJdS)zMarks this scenario outline (and all its scenarios/steps) as skipped. Note that this method may be called before the scenario outline is executed. TrCN)rEr/rr1r&r!r!r"rF7s zScenarioOutline.mark_skippedFcCsj|rtd}|d|j||d|_|jD]}|||q2|jsV|t j |j |j vsfJdS)aSkip from executing this scenario outline or its remaining parts. Note that the scenario outline may be already partly executed when this method is called. :param reason: Optional reason why it should be skipped (as string). rGzSKIP ScenarioOutline %s: %sTN) rHrIrJrrKr;rrErMrr1r/rNrOr!r!r"rE?s   zScenarioOutline.skipcCsf|d}|jD]<}|jd|j||}|r|d7}|jjsJ|jrqPq|jdd|dkS)NrZactive_outliner-) rKrrUrrvr^r>r_rX)rrcrdrr.r!r!r"r^Ss  zScenarioOutline.run)NNNN)NF)rhrirjrkrlrrr#rmrr'r+r4r5r<r]rFrEr^rnr!r!rr"r7s&J    r7cs&eZdZdZdZdfdd ZZS)ExamplesaA table parsed from a `scenario outline`_ in a *feature file*. The attributes are: .. attribute:: keyword This is the keyword as seen in the *feature file*. In English this will typically be "Example". .. attribute:: name The name of the example (the text after "Example:".) .. attribute:: table An instance of :class:`~behave.model.Table` that came with the example in the *feature file*. .. attribute:: filename The file name (or "") of the *feature file* where the example was found. .. attribute:: line The line number of the *feature file* where the example was found. .. _`examples`: gherkin.html#examples rNcs(tt||||||||_d|_dSr()rrrrr)rrrrrrrrr!r"rszExamples.__init__)NN)rhrirjrkrlrrnr!r!rr"rcsrcs\eZdZdZdZdfdd ZfddZdd Zd d Zd d Z ddZ dddZ Z S)StepajA single `step`_ parsed from a *feature file*. The attributes are: .. attribute:: keyword This is the keyword as seen in the *feature file*. In English this will typically be "Given", "When", "Then" or a number of other words. .. attribute:: name The name of the step (the text after "Given" etc.) .. attribute:: step_type The type of step as determined by the keyword. If the keyword is "and" then the previous keyword in the *feature file* will determine this step's step_type. .. attribute:: text An instance of :class:`~behave.model.Text` that came with the step in the *feature file*. .. attribute:: table An instance of :class:`~behave.model.Table` that came with the step in the *feature file*. .. attribute:: status Read-Only. A summary status of the step's run. If read before the step is tested it will return "untested" otherwise it will return one of: Status.untested This step was not run (yet). Status.skipped This step was skipped during testing. Status.passed The step was tested successfully. Status.failed The step failed. Status.undefined The step has no matching step implementation. .. versionchanged:: Use Status enum class (was: string). .. attribute:: hook_failed Indicates if a hook failure occured while running this step. .. versionadded:: 1.2.6 .. attribute:: duration The time, in seconds, that it took to test this step. If read before the step is tested it will return 0.0. .. attribute:: error_message If the step failed then this will hold any error information, as a single string. It will otherwise be None. .. versionchanged:: 1.2.6 (moved to base class) .. attribute:: filename The file name (or "") of the *feature file* where the step was found. .. attribute:: line The line number of the *feature file* where the step was found. .. _`step`: gherkin.html#steps rsNcs@tt|||||||_||_||_tj|_d|_ d|_ dS)NFr) rrr step_typer rrr0r/rr5)rrrrrrr rrr!r"rsz Step.__init__cs&tt|tj|_d|_d|_dS)z8Reset temporary runtime data to reach clean state again.FrN)rrr#rr0r/rr5r&rr!r"r#sz Step.resetcCsd|j|jfS)Nz <%s "%s">rrr&r!r!r"r'sz Step.__repr__cCs|j|jf|j|jfkSr(rrotherr!r!r"__eq__sz Step.__eq__cCst|jt|jSr()hashrrr&r!r!r"__hash__sz Step.__hash__cCs(ddl}|jdtdd|}t||S)aKClone a new step from this one, used for ScenarioOutline. Replace ScenarioOutline placeholders w/ values. :param table_row: Placeholder data for example row. :return: Cloned, adapted step object. .. note:: Deprecating Use 'ScenarioOutlineBuilder.make_step_for_row()' instead. rNz1Use 'ScenarioOutline.make_step_for_row()' instead) stacklevel)warningswarnPendingDeprecationWarningrr)rZ table_rowrrr!r!r" set_valuess zStep.set_valuesFTc Cs||j|}|durj|j||sD|jD]}|tq2tj |_ |sf|jD]}| |qVdSd}d}|s|jD]}||q||r| d}| d|j||jrd}t} |sz8|j|j_|j|j_||j|j tjkrtj|_ Wnty>} z(d|_d}tj|_ || WYd} ~ nd} ~ 0ty} zDtj|_ || | jrzt| } d| }n tt}WYd} ~ nLd} ~ 0ty} z*tj|_ tt}|| WYd} ~ n d} ~ 00t| |_ | d|j||jr tj|_ |r|!d} |j tjkp.| } |j tjkrt"|t#j$sPJ|r||j%j&|_&|j&'}|r||d|7}||_(d}n| r|r|j%j&|_&|s|jD]}| |q|S) NFTrZ before_stepz%ABORTED: By user (KeyboardInterrupt).zAssertion Failed: Z after_step ))r#rrrr,r\rr rrr/rZ start_capturerZrUrtimer rr^r0r2KeyboardInterruptrXr.Zstore_exception_contextAssertionErrorargsr traceback format_excrar5Z stop_capturer6six text_typerrZ make_report error_message)rrcquietcapturerrgZ keep_goingerrorZskip_step_untestedstartemessageZstore_captured_alwaysrZerror2r!r!r"r^s                       zStep.run)NN)FT) rhrirjrkrlrr#r'rrrr^rnr!r!rr"rsN rc@seZdZdZdZd%ddZd&ddZd'd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$ZdS)(Tablea>A `table`_ extracted from a *feature file*. Table instance data is accessible using a number of methods: **iteration** Iterating over the Table will yield the :class:`~behave.model.Row` instances from the .rows attribute. **indexed access** Individual rows may be accessed directly by index on the Table instance; table[0] gives the first non-heading row and table[-1] gives the last row. The attributes are: .. attribute:: headings The headings of the table as a list of strings. .. attribute:: rows An list of instances of :class:`~behave.model.Row` that make up the body of the table in the *feature file*. Tables are also comparable, for what that's worth. Headings and row data are compared. .. _`table`: gherkin.html#table rNcCs:t|||_||_g|_|r6|D]}|||q$dSr()r rheadingsrrowsadd_row)rrrrrr!r!r"rs zTable.__init__cCs|jt|j||dSr()rr,Rowr)rrrr!r!r"rsz Table.add_rowrc Cs||rJ|dur(|gt|j}nt|ts:t|}t|t|jkrrt|jt|}|g|}||t|j}|j|t|j|D]&\}}t|j |ksJ|j |q|S)aAdds a new column to this table. Uses :param:`default_value` for new cells (if :param:`values` are not provided). param:`values` are extended with :param:`default_value` if values list is smaller than the number of table rows. :param column_name: Name of new column (as string). :param values: Optional list of cell values in new column. :param default_value: Default value for cell (if values not provided). :returns: Index of new column (as number). N) has_columnr%rr6listr8rr,rr) r column_namevalues default_valueZ more_sizeZ more_valuesZnew_column_indexrrr!r!r" add_columns      zTable.add_columncCst|ts8z||}Wnty6td|Yn0t|tsFJ|t|jksXJ|j|=|jD]}|t|jks|J|j|=qfdS)Nzcolumn=%s is unknown) r6intget_column_index ValueErrorKeyErrorr%rrr)rr column_indexrr!r!r" remove_columns   zTable.remove_columncCs|D]}||qdSr()rrZ column_namesrr!r!r"remove_columnsszTable.remove_columnscCs ||jvSr()rrrr!r!r"rszTable.has_columncCs |j|Sr()rrrr!r!r"rszTable.get_column_indexcCs4||s*d|j}d||f}t|||S)zRequire that a column exists in the table. Raise an AssertionError if the column does not exist. :param column_name: Name of new column (as string). :return: Index of column (as number) if it exists. z, z REQUIRE COLUMN: %s (columns: %s))rjoinrrr)rrcolumnsmsgr!r!r"require_columns    zTable.require_columncCs|D]}||qdSr()rrr!r!r"require_columnsszTable.require_columnscCs"||r||S||SdS)zEnsures that a column with the given name exists. If the column does not exist, the column is added. :param column_name: Name of column (as string). :return: Index of column (as number). N)rrrrr!r!r"ensure_column_existss  zTable.ensure_column_existscCsdt|jt|jfS)Nz)r%rrr&r!r!r"r'szTable.__repr__cCsnt|trB|j|jkrdSt|j|jD]\}}||kr(dSq(n(|}t|j|D]\}}||krRdSqRdS)NFT)r6rrrr)rrZmy_rowZ their_rowZ other_rowsr!r!r"rs   z Table.__eq__cCs || Sr(rrr!r!r"__ne__sz Table.__ne__cCs t|jSr()r*rr&r!r!r"r+szTable.__iter__cCs |j|Sr()r)rrr!r!r" __getitem__szTable.__getitem__cCs||ks JtdS)a@Assert that this table's cells are the same as the supplied "data". The data passed in must be a list of lists giving: [ [row 1], [row 2], [row 3], ] If the cells do not match then a useful AssertionError will be raised. N)NotImplementedError)rdatar!r!r" assert_equalss zTable.assert_equals)NN)N)Nr)rhrirjrkrlrrrrrrrrrrr'rrr+rrr!r!r!r"rhs$    rc@sdeZdZdZdddZddZddZd d Zd d Zd dZ ddZ ddZ dddZ ddZ dS)raSOne row of a `table`_ parsed from a *feature file*. Row data is accessible using a number of methods: **iteration** Iterating over the Row will yield the individual cells as strings. **named access** Individual cells may be accessed by heading name; row["name"] would give the cell value for the column with heading "name". **indexed access** Individual cells may be accessed directly by index on the Row instance; row[0] gives the first cell and row[-1] gives the last cell. The attributes are: .. attribute:: cells The list of strings that form the cells of this row. .. attribute:: headings The headings of the table as a list of strings. Rows are also comparable, for what that's worth. Only the cells are compared. .. _`table`: gherkin.html#table NcCs6||_||_|D]}t|tjsJq||_||_dSr()rcommentsr6rrrr)rrrrrcr!r!r"r1s z Row.__init__cCsJz|j|}Wn.ty>t|tr.|}n td|Yn0|j|S)Nz"%s" is not a row heading)rrrr6rrrrr!r!r"r9s  zRow.__getitem__cCs d|jfS)Nzrr&r!r!r"r'Csz Row.__repr__cCs |j|jkSr(rrr!r!r"rFsz Row.__eq__cCs || Sr(rrr!r!r"rIsz Row.__ne__cCs t|jSr()r%rr&r!r!r"__len__Lsz Row.__len__cCs t|jSr()r*rr&r!r!r"r+Osz Row.__iter__cCst|j|jSr()rrrr&r!r!r"rRsz Row.itemscCs&z ||WSty |YS0dSr()r)rkeydefaultr!r!r"getUs  zRow.getcCsddlm}||S)zConverts the row and its cell data into a dictionary. :return: Row data as dictionary (without comments, line info). r) OrderedDict)Zbehave.compat.collectionsrr)rrr!r!r"as_dict[s z Row.as_dict)NN)N)rhrirjrkrrr'rrrr+rrrr!r!r!r"rs   rc@s.eZdZdZdZdZddZed dd ZdS) raTags appear may be associated with Features or Scenarios. They're a subclass of regular strings (unicode pre-Python 3) with an additional ``line`` number attribute (where the tag was seen in the source feature file. See :ref:`controlling things with tags`. z._-=:)'"rrcCstj||}||_|Sr()rr__new__r)rrror!r!r"rosz Tag.__new__FNcCst|tjsJ|dur|j}|r6|dddd}g}|D]B}|sV|rb||vrb||q>|rv|dq>||jvr>q>d |S)aWTranslate text into a "valid tag" without whitespace, etc. Translation rules are: * alnum chars => same, kept * space chars => "_" * other chars => deleted Preserve following characters (in addition to alnums, like: A-z, 0-9): * dots => "." (support: dotted-names, active-tag name schema) * minus => "-" (support: dashed-names) * underscore => "_" * equal => "=" (support: active-tag name schema) * colon => ":" (support: active-tag name schema or similar) :param text: Unicode text as input for name. :param unescape: Optional flag to unescape some chars (default: false) :param allowed_chars: Optional string with additional preserved chars. :return: Unicode name that can be used as tag. Nz\t z\nr_r) r6rr allowed_charsrisalnumr,isspace quoting_charsr)rr rr charscharr!r!r"rts   z Tag.make_name)FN) rhrirjrkr rrrrr!r!r!r"rcs rcs<eZdZdZd ddZddZdfd d Zd d ZZS)TextzStore multiline text from a Step definition. The attributes are: .. attribute:: value The actual text parsed from the *feature file*. .. attribute:: content_type Currently only "text/plain". text/plainrcCs>t|tjsJt|tjs Jtj||}||_||_|Sr()r6rrr content_typer)rrrrr r!r!r"rs z Text.__new__cCs t|}|j|j|dfS)Nr-)r% splitlinesr)r line_countr!r!r" line_ranges zText.line_rangecs ttt|||||j|jSr()rrrrr)roldnewcountrr!r"rsz Text.replacecCsX||kr dSg}t||D]}||q$dg|dd}td|dS)zAssert that my text is identical to the "expected" text. A nice context diff will be displayed if they do not match. TzText does not match:Nr)difflibZ unified_diffrr,rr)rexpecteddiffrr!r!r"rs  zText.assert_equals)rr)r) rhrirjrkrrrrrnr!r!rr"rs  rcCs|D] }|qdS)zReset the test run information stored in model elements. :param model_elements: List of model elements (Feature, Scenario, ...) N)r#)Zmodel_elementsZ model_elementr!r!r" reset_modelsr )(rk __future__rrrzrrHrrrZ six.movesrZbehave.model_corerrrrr Zbehave.matchersr Zbehave.textutilr rPY2Z traceback2rr rortrrr7rrrrrrrr r!r!r!r"sD     F6uP&`+Q;0