Software Testing • Test Design • Test Execution • Defect Management • QA Documentation
A practical end-to-end Manual Testing project demonstrating the complete Software Testing Life Cycle (STLC).
This repository contains my Manual Software Testing practice and project work, covering the complete testing process from requirement analysis to test sign-off.
The repository includes practical testing artifacts such as:
- Functional Requirement understanding
- Test Plans
- Test Scenarios
- Detailed Test Cases
- Requirement Traceability Matrix (RTM)
- Test Execution
- Bug / Defect Reports
- Smoke Testing
- Sanity Testing
- Re-testing
- Regression Testing
- Test Sign-off
- Test Case Design Techniques
- Reusable testing templates
The project primarily focuses on web-based e-commerce applications, including:
- 🛒 Demo Web Shop
- 🛍️ OpenCart
Application: Demo Web Shop by Tricentis
🔗 https://demowebshop.tricentis.com/
The Demo Web Shop application was used to practice end-to-end functional testing, including requirement analysis, scenario identification, test case design, execution, and defect identification.
- User Registration
- Login / Logout
- User Account
- Product Categories
- Product Search
- Product Details
- Shopping Cart
- Wishlist
- Checkout
- Address Management
- Order Processing
- Order History
- Navigation
- Validation Messages
- Error Handling
OpenCart was used for additional practical testing activities involving:
- Test Scenario Design
- Test Case Design
- Test Execution
- Bug Reporting
- Defect Tracking
- Result Documentation
The main objectives of this project are to:
- Understand software testing fundamentals.
- Understand SDLC and STLC.
- Analyze application requirements.
- Explore the Application Under Test (AUT).
- Identify test scenarios.
- Write detailed test cases.
- Apply Black Box Test Design Techniques.
- Prepare a Test Plan.
- Create an RTM.
- Execute test cases.
- Identify and report defects.
- Classify defects using Severity and Priority.
- Perform Smoke Testing.
- Perform Sanity Testing.
- Perform Re-testing.
- Perform Regression Testing.
- Document test results.
- Understand the complete testing life cycle.
- Perform Test Closure and Test Sign-off.
The project follows the major phases of the Software Testing Life Cycle (STLC):
┌──────────────────────────────┐
│ Requirement Analysis │
└──────────────┬───────────────┘
↓
┌──────────────────────────────┐
│ Test Planning │
└──────────────┬───────────────┘
↓
┌──────────────────────────────┐
│ Test Design / Development │
│ Scenarios + Test Cases │
└──────────────┬───────────────┘
↓
┌──────────────────────────────┐
│ Test Environment Setup │
└──────────────┬───────────────┘
↓
┌──────────────────────────────┐
│ Test Execution │
└──────────────┬───────────────┘
↓
┌──────────────────────────────┐
│ Defect Reporting & Tracking│
└──────────────┬───────────────┘
↓
┌──────────────────────────────┐
│ Re-testing & Regression │
└──────────────┬───────────────┘
↓
┌──────────────────────────────┐
│ Test Closure │
└──────────────┬───────────────┘
↓
┌──────────────────────────────┐
│ Test Sign-off │
└──────────────────────────────┘
- What is Software?
- Types of Software
- What is Software Testing?
- What is Software Quality?
- Project vs Product
- Why do we need Software Testing?
- Error, Bug & Failure
- Why Software Has Bugs
- Software Development Life Cycle — SDLC
- Waterfall Model
- Spiral Model
- V-Model
- Static Testing
- Dynamic Testing
- Verification
- Validation
- White Box Testing
- Black Box Testing
- Static Testing
- Dynamic Testing
- Review
- Walkthrough
- Inspection
- Quality Assurance — QA
- Quality Control — QC
- Quality Engineering — QE
- Levels of Software Testing
- Unit Testing
- Integration Testing
- System Testing
- User Acceptance Testing — UAT
- System Testing
- GUI Testing
- GUI Checklist
- Usability Testing
- Functional Testing
- Object Properties Testing
- Database Testing
- Error Handling Testing
- Calculation & Manipulation Testing
- Link Existence Testing
- Link Execution Testing
- Cookies & Sessions Testing
- Performance Testing
- Security Testing
- Recovery Testing
- Compatibility Testing
- Installation Testing
- Sanitation / Garbage Testing
- Functional vs Non-Functional Testing
- Regression Testing
- Re-testing
- Regression vs Re-testing
- Smoke Testing
- Sanity Testing
- Exploratory Testing
- Ad-hoc Testing
- Monkey Testing
- Exploratory vs Ad-hoc vs Monkey Testing
- Positive Testing
- Negative Testing
- Positive vs Negative Test Cases
- End-to-End Testing
- Localization Testing
- Globalization / Internationalization Testing
Dividing input data into valid and invalid classes to reduce redundant test cases while maintaining effective test coverage.
Testing values at the boundaries and immediately around the boundaries of input conditions.
Example:
Valid Range: 18 – 60
Test Values:
17 → Invalid
18 → Valid Boundary
19 → Valid
59 → Valid
60 → Valid Boundary
61 → Invalid
Used to test combinations of conditions and their corresponding actions.
Used to validate system behavior when the application moves from one state to another based on events or conditions.
Creating test cases based on tester experience and common areas where defects are likely to occur.
The project covers the following testing activities:
- Test Planning
- Test Design / Development
- Test Execution
- Defect Reporting
- Defect Tracking
- Re-testing
- Regression Testing
- Test Closure
A Test Plan defines:
- Test Objectives
- Scope
- Testing Approach
- Testing Types
- Resources
- Test Environment
- Schedule
- Entry Criteria
- Exit Criteria
- Risks
- Assumptions
| Document | Description |
|---|---|
| Use Case | Describes how a user interacts with the system |
| Test Scenario | High-level functionality or condition to be tested |
| Test Case | Detailed steps used to verify a specific functionality |
RTM is used to ensure that requirements are mapped to appropriate testing activities.
Requirement
↓
Test Scenario
↓
Test Case
↓
Test Execution
↓
Test Result
↓
Defect
RTM helps ensure:
- Requirement coverage
- Test coverage
- Traceability
- Identification of missing test cases
- Better test management
The project covers the complete defect management process.
A defect report can include:
- Defect ID
- Defect Title
- Module
- Description
- Preconditions
- Steps to Reproduce
- Test Data
- Expected Result
- Actual Result
- Severity
- Priority
- Environment
- Screenshot / Evidence
- Reported By
- Assigned To
- Status
| Severity | Meaning |
|---|---|
| Critical | Application or major functionality is unusable |
| High | Major functionality is significantly affected |
| Medium | Functionality is affected but workaround may exist |
| Low | Minor issue with limited impact |
| Priority | Meaning |
|---|---|
| P0 | Immediate attention required |
| P1 | High priority |
| P2 | Medium priority |
| P3 | Low priority |
A spelling mistake on the homepage may have:
Severity: Low
Priority: Medium
A payment failure may have:
Severity: Critical
Priority: High
┌───────┐
│ New │
└───┬───┘
↓
┌──────────┐
│ Assigned │
└────┬─────┘
↓
┌──────┐
│ Open │
└───┬──┘
↓
┌───────┐
│ Fixed │
└───┬───┘
↓
┌────────┐
│ Retest │
└───┬────┘
↓
┌──────────┐
│ Verified │
└────┬─────┘
↓
┌────────┐
│ Closed │
└────────┘
Possible alternate flow:
Fixed → Retest → Reopened → Assigned → Fixed
Other defect statuses may include:
- Duplicate
- Rejected
- Deferred
- Cannot Reproduce
- Not a Bug
| Testing | Purpose |
|---|---|
| Smoke Testing | Checks whether the build is stable enough for detailed testing |
| Sanity Testing | Checks specific functionality after a minor change/fix |
| Re-testing | Verifies that a previously failed test case now passes after the defect is fixed |
| Regression Testing | Ensures existing functionality has not been broken by changes |
Build Received
↓
Smoke Testing
↓
Detailed Testing
↓
Defect Found
↓
Bug Fixed
↓
Re-testing
↓
Regression Testing
↓
Final Test Results
↓
Test Sign-off
This repository contains practical testing documents and Excel-based testing artifacts.
Contains 20 testing scenarios, with multiple detailed test cases under each scenario.
➡️ Open Demo Web Shop Test Scenarios & Test Cases
A reusable template for documenting high-level testing scenarios.
➡️ Open Test Scenario Template
A reusable template for writing structured test cases.
A reusable template for documenting software defects.
The repository also contains a separate set of practical testing documents for an OpenCart e-commerce application.
Contains identified high-level test scenarios for OpenCart.
➡️ Open OpenCart Test Scenarios
Contains detailed test cases designed from the identified scenarios.
Contains test execution results showing the outcome of executed test cases.
➡️ Open OpenCart Test Execution Results
Contains documented defects identified during testing.
The repository also contains learning/reference material covering Manual Testing concepts.
➡️ View Manual Testing Introduction
➡️ View Live Project Manual Testing Notes
Manual-Testing-Project---1-By-DevPutta
│
├── 📄 README.md
│
├── 📊 Demo_Web_Shop_20_Scenarios_5_to_20_Test_Cases (1).xlsx
│
├── 🐞 Bug_Report_Template.xlsx
│
├── 🧪 Test_Case_Template.xlsx
│
├── 📋 Test_Scenario_Template.xlsx
│
├── 🛒 OpenCart-Test Scenarios.xlsx
│
├── 🧪 OpenCart-TestCases.xlsx
│
├── ▶️ OpenCart-TestExecution Results.xlsx
│
├── 🐞 OpenCart - Bug Report.xlsx
│
├── 📘 Manual Testing Intro.txt
│
└── 📘 LIVE PROJECT (MANUAL TESTING).txt
| Field | Details |
|---|---|
| Test Case ID | TC_LOGIN_001 |
| Module | Login |
| Test Scenario | Verify login using valid credentials |
| Precondition | User must have a registered account |
| Test Data | Valid username and password |
| Steps | Enter username → Enter password → Click Login |
| Expected Result | User should successfully log in |
| Actual Result | As observed during execution |
| Status | Pass / Fail |
Negative testing was used to validate application behavior with invalid or unexpected inputs.
Examples:
- Login with invalid username
- Login with invalid password
- Login with blank username
- Login with blank password
- Submit forms with mandatory fields empty
- Enter invalid email format
- Enter invalid numeric values
- Enter special characters
- Use invalid search input
- Attempt invalid navigation
Possible test cases:
TC_CART_001 → Add product to cart
TC_CART_002 → Add multiple products
TC_CART_003 → Update product quantity
TC_CART_004 → Remove product from cart
TC_CART_005 → Verify cart total
TC_CART_006 → Verify product price
TC_CART_007 → Verify empty cart
TC_CART_008 → Continue shopping
TC_CART_009 → Proceed to checkout
TC_CART_010 → Verify cart persistence
The project also covers common software testing metrics such as:
- Total Test Cases
- Executed Test Cases
- Passed Test Cases
- Failed Test Cases
- Blocked Test Cases
- Not Executed
- Defect Count
- Defect Density
- Pass Percentage
- Fail Percentage
- Test Coverage
- Requirement Coverage
Pass Percentage =
Passed Test Cases
----------------------- × 100
Executed Test Cases
The following fundamental testing principles were studied:
Testing can demonstrate that defects exist, but cannot prove that software is completely defect-free.
Testing every possible combination of inputs and conditions is generally impractical.
Testing activities should begin as early as possible in the development life cycle.
A small number of modules often contain a large number of defects.
Repeatedly executing the same test cases may eventually stop finding new defects.
Testing approaches depend on the application, business domain, risks and requirements.
Finding and fixing defects does not automatically mean that the product meets user needs or business requirements.
- Manual Testing
- Microsoft Excel
- Google Chrome
- Git
- GitHub
- Test Documentation
- Defect Reporting
- Test Execution
Through this project, I developed practical experience in:
- Manual Testing
- Functional Testing
- Non-Functional Testing
- System Testing
- GUI Testing
- Usability Testing
- End-to-End Testing
- Smoke Testing
- Sanity Testing
- Re-testing
- Regression Testing
- Exploratory Testing
- Ad-hoc Testing
- Positive Testing
- Negative Testing
- Equivalence Class Partitioning
- Boundary Value Analysis
- Decision Table Testing
- State Transition Testing
- Error Guessing
- Requirement Analysis
- Test Planning
- Test Scenario Design
- Test Case Design
- Test Execution
- Defect Reporting
- Defect Tracking
- Severity & Priority
- RTM
- Test Closure
- Test Sign-off
| Area | Details |
|---|---|
| 🧪 Testing Type | Manual Testing |
| 🌐 Application | Demo Web Shop |
| 🛍️ Additional Application | OpenCart |
| 📋 Test Documentation | Test Scenarios, Test Cases, RTM, Test Plan |
| 🐞 Defect Management | Bug Reporting & Tracking |
| 🔄 Retesting | Covered |
| ♻️ Regression | Covered |
| 🚦 Smoke Testing | Covered |
| 🧪 Sanity Testing | Covered |
| 📊 Test Execution | Covered |
| 📁 Artifacts | Excel & Text Documentation |
| 🎯 Approach | End-to-End STLC |
This project provided hands-on understanding of how a QA/Manual Tester works through the complete testing lifecycle.
I gained practical experience in:
Requirements
↓
Analysis
↓
Planning
↓
Scenario Design
↓
Test Case Design
↓
RTM
↓
Execution
↓
Defect Reporting
↓
Re-testing
↓
Regression
↓
Test Closure
↓
Sign-off
The project helped bridge the gap between Manual Testing theory and practical project execution.
Software Engineer | Manual Testing & Data Enthusiast
🔗 GitHub Repository
https://github.com/Devputta/Manual-Testing-Project---1-By-DevPutta
If you find this project useful for learning Manual Testing, feel free to ⭐ star the repository.
End-to-End Manual Testing Project