Test path
In software development, a test path is a code execution scenario from which a certain behavior is expected and tested.
Happy Path
A Happy Path , Happy Day Scenario or Golden Path (meaning: happy path ) is the simplest scenario in which a section of code should work without exceptions or error states occurring. Since this is the basic functionality of the code section, the happy path is the least that should be tested.
However, the happy path alone is not sufficient to test the functionality in code with branching. For example, if you want to test a function for checking credit card numbers, it is not enough to use the Happy Path to test whether valid credit card numbers lead to a positive result, but further tests must also be carried out to determine whether invalid numbers lead to a negative result.
Scary Path
A Scary Path (analogously: frightening path ) is a scenario which causes the code to a malfunction or an error status. In particular, those that also cause other parts of the program or other programs to malfunction or fail.
The scary path is to be tested above all if there is a high risk for the stakeholders due to the misconduct or the error status .
Angry Path
A Angry Path (analogously: angry path ) is a scenario in which the tested code to an exception handling of leads, but remains in a valid and functioning state. This particularly applies to exceptional behavior due to input validation.
Delinquent Path
A delinquent path (meaning: criminal path ) tests whether authentication, authorization, authorization, digital signing, encryption or other security measures are observed.
Embarrassing Path
An Embarrassing Path (mutatis mutandis: painful path ) is a behavior which, if not met, would result in damage to reputation of the developer or company. For example, if the user receives a wrong or inappropriate message.
Desolate Path
A desolate path (meaning: lonely path ) is a scenario in which the function is not supplied with sufficient data. For example, if at least one of the values passed or dependencies on null, 0, 1, -1, NaN, is set a default value or the like.
Forgetful Path
A Forgetful Path (mutatis mutandis: forgetful path ) is a test scenario in which the code for execution are insufficient resources and data loss is possible. For example, limited memory, a limited thread pool, a file or database that is to be written to but does not exist, etc.
Indecisive Path
The Indecisive Path (analogously: undecided path ) simulates a user who sets a series of actions and wants to undo them. In particular, deselect selected menu items, press a back or undo button, and delete data or changes that have already been saved.
Greedy Path
In Greedy Path (mutatis mutandis: greedy path ) the greatest possible number of options is selected or performed a variety of actions within no time.
Stressful Path
In Stressful Path (mutatis mutandis: stressful path ) will be charged an exemplary path until the correct functioning can not be guaranteed.
For example, a web application in which the number of HTTP requests continues to increase until the web application no longer reacts, for example due to an exhausted connection pool. This allows predictions to be made about the volume from which the application will fail.