Use Case Testing is a functional black box testing technique. It helps testers to identify test scenarios to exercise the whole system on each transaction basis from start to finish (“End to end testing“). It makes sure that the user performs its function successfully, without any interruption or error. Use case testing is not performed to determine the quality of the software.
Important Properties :
- It provides the interactions between “actors” and the “system”.
- “Actors” serve as users and their interactions of each user takes part into the system.
- We can also refer “Use Case Testing” as Scenarios.
- It identifies gaps in the system which would not be found by testing individual components in isolation.
- Very effective in defining the scope of acceptance tests.
Documentation elements in a use case can be :
- Actor: It is a user entity that is involved in use case actions.
- Brief description: It is a description that explains the use case in brief.
- Precondition: It is a condition that needs to be satisfied before the use case starts.
- Basic Flow: It is a flow of transaction that is done by the user while interacting with the system or software. As it is a normal workflow, there will be no chances of getting an error from the system. The actor or user will get the expected result from the system.
- Alternate Flow: A system can also have alternate flow. This is a less common interaction done by the user towards the system.
- Exception Flow: It is a flow that prevents and user to achieve its goal and throw some error.
- Post Condition: It is a condition that needs to be checked after the use case.
use case Diagram elements :
- System
It is shown by using a rectangle shape.
- Use Case
It is shown by using an oval shape. Any action or activity which is carried is shown by using the use case.
- Actor (without smiling face and happy rising hands – hands are on the sides- 🙂
The actor is an entity that is used to represent the user.
- Indicator of Relationship
Relationship is used to show the flow of the action. It is represented by using an arrow.
Exmple test case :
- Consider the first step of an end to end scenario for a login functionality for our web application where the Actor enters email and password. This is a very clasic senario on any softwares / apps these days.
- In the next step, the system will validate the password
- Next, if the password is correct, the access will be granted
- There can be an extension of this use case. In case password is not valid system will display a message and ask for re-try four times
- If Password, not valid four times system will ban the IP address.
- Here we will test the success scenario and one case of each extension.
Exmple test Diagram :
Related Glossary (Source: ISTQB Glossary "glossary.istqb.org") -> # Transactional analysis : The analysis of transactions between people and within people's minds; a transaction is defined as a stimulus plus a response. Transactions take place between people and between the ego states (personality segments) within one person's mind. # Black-box test technique : A test technique based on an analysis of the specification of a component or system. Synonyms: specification-based test technique, black-box test design technique # Acceptance testing : A test level that focuses on determining whether to accept the system. # End to end testing : A type of testing in which business processes are tested from start to finish under production-like circumstances. Synonyms: E2E testing
Use Case software testing in detail, providing examples and incorporating diagrams to illustrate key concepts. Use Case Testing is a black-box testing technique that focuses on validating whether a system behaves as expected from an end-user perspective. It’s based on use cases, which describe how users interact with the system to achieve specific goals.
Components of a Use Case
A typical use case consists of:
- Actor: The user or external system interacting with the system under test
- Preconditions: Conditions that must be true before the use case can begin
- Main flow: The normal sequence of steps
- Alternate flows: Optional paths or exceptions
- Postconditions: The system state after the use case completes
Here’s a simple diagram illustrating these components:
+-------------------+
| Use Case |
+-------------------+
| Actor |
| Preconditions |
| Main Flow |
| Alternate Flows |
| Postconditions |
+-------------------+
Example: Online Shopping Use Case
Let’s consider a use case for purchasing an item on an e-commerce website:
textUse Case: Purchase Item
Actor: Customer
Preconditions:
- User is logged in
- Item is in stock
Main Flow:
1. User searches for an item
2. User selects the item
3. User adds item to cart
4. User proceeds to checkout
5. User enters shipping information
6. User enters payment information
7. User confirms order
8. System processes payment
9. System confirms order
Alternate Flows:
4a. Item out of stock
1. System notifies user
2. Use case ends
6a. Payment declined
1. System notifies user
2. User enters new payment information or cancels order
Postconditions:
- Order is placed in the system
- Inventory is updated
- User receives order confirmation
Use Case Diagram
A Use Case Diagram visually represents the interactions between actors and the system. Here’s a simple diagram for our online shopping example:
+---------------------+
| Online Shop |
| |
| +---------------+ |
| | Search Item | |
| +---------------+ |
| | Add to Cart | |
| +---------------+ |
| | Checkout | |
| +---------------+ |
| | Place Order | |
| +---------------+ |
| |
+---------------------+
^
|
|
+--------+
|Customer|
+--------+
Use Case Testing Process
- Identify use cases
- Review and refine use cases
- Determine test scenarios
- Create test cases
- Execute tests
- Report and fix defects
Test Case Example
Based on our online shopping use case, here’s an example of a test case:
textTest Case ID: TC001
Test Case Name: Successful Item Purchase
Objective: Verify that a user can successfully purchase an item
Steps:
1. Log in to the system
2. Search for "smartphone"
3. Select the first item in search results
4. Click "Add to Cart"
5. Click "Proceed to Checkout"
6. Enter shipping information
7. Enter valid payment information
8. Click "Confirm Order"
Expected Results:
- Order confirmation page is displayed
- Order number is generated
- Confirmation email is sent to the user
- Item quantity in inventory is reduced by 1
Benefits of Use Case Testing
- User-centric approach ensures testing aligns with real-world usage
- Helps identify missing requirements or unclear specifications
- Provides a clear structure for creating test cases
- Facilitates communication between stakeholders, developers, and testers
- Helps in prioritizing testing efforts based on critical user scenarios
Challenges in Use Case Testing
- Can be time-consuming to create detailed use cases
- May miss technical details not visible to end-users
- Requires regular updates as system requirements change
- Can lead to redundant testing if not properly managed
By following this approach, testers can ensure that the software meets user requirements and functions as expected in real-world scenarios. Use Case Testing is particularly valuable for validating complex systems with multiple user interactions and workflows.
