📝 Topics Covered
- 1. Software Testing
- Definition, Verification & Validation
- 2. Types of Software Testing
- 2.1 Manual Testing
- 2.2 Automation Testing
- 3. Levels of Software Testing
- 3.1 Unit, 3.2 Integration, 3.3 System, and 3.4 Regression Testing
- Testing environments (Alpha, Beta, Acceptance)
- Non-functional testing (Load, Stress, Security)
- 4. Test Case Design Approaches
- 4.1 White Box, 4.2 Black Box, and 4.3 Gray Box Testing
- 5. Test-Driven Development (TDD)
- 5.1 Shift Left vs. Shift Right testing paradigms
1. Software Testing
Software testing is the systematic process of verifying and validating whether a software application is bug-free, meets its specified technical design requirements, and delivers a high-quality user experience.
The process of software testing is not just about finding bugs in existing software; it also focuses on finding key areas to improve software efficiency, accuracy, and usability.
💡 Verification vs. Validation:
- Verification: “Are we building the product right?” (Ensures the software conforms to specifications via reviews, inspections, and static code analysis).
- Validation: “Are we building the right product?” (Ensures the final software meets customer expectations via dynamic testing and execution).
2. Types of Software Testing (Manual vs. Automation)
Modern software testing is divided into two primary execution models:
2.1 Manual Testing
Manual testing is the process where Quality Analysts manually execute test cases on the software without using any automation tools or scripts. The tester acts as an end-user, checking for usability issues, broken interfaces, and general functional bugs.
2.2 Automation Testing
Automation testing refers to running pre-written test scripts automatically with the help of specialized testing frameworks (e.g., Selenium, Playwright, Jest).
👍 Benefits of Automation: Testers write scripts once, and they run repeatedly without human intervention, instantly outputting pass/fail metrics. This is highly recommended for stable features and continuous regression cycles.
- Learn more in the Shopify Automation Testing Guide .
3. Levels of Software Testing
Software applications are tested at different granular levels to catch bugs at various stages of development.
3.1 Unit Testing
Software is divided into standalone, individual units (methods, classes, or modules). Testing each unit in isolation is known as Unit Testing.
- Phase: Conducted during the active development phase.
- Tester: Performed directly by the development team.
- Focus: Functional correctness of isolated logic.
- Approach:
White-Box Testing(requires direct code visibility).
3.2 Integration Testing
Testing the interfaces and data exchanges between multiple integrated units or modules to ensure they are fully compatible.
- Phase: Conducted during the active development phase.
- Tester: Performed by the development team.
- Focus: Compatibility and data flow between integrated components.
- Approach: Primarily
White-Box Testing(with some Black-Box integration tests).
3.3 System Testing
Once the entire application is fully integrated and compiled, the system as a whole is tested against the merchant or business requirements.
- Phase: Conducted after the development phase is complete.
- Tester: Performed by a dedicated QA / Testing team.
- Focus: End-to-end user workflows, functional correctness, and performance benchmarks.
- Approach:
Black-Box Testing(no code visibility required).
.
👥 Testing by Stakeholder Role:
- Alpha Testing: Conducted in-house by the internal QA team or developers in a sandboxed staging environment.
- Beta Testing: Distributed to a small, friendly group of external users (or pilot customers) to gather real-world usage data and feedback before the official release.
- Acceptance Testing (UAT): Conducted by the end client or business stakeholders to confirm that the completed product matches their expectations and is ready for production.
📈 Non-Functional & Performance Testing:
- Volume Testing: Verifies how the application behaves under massive database loads or heavy file inputs.
- Load Testing: Simulates real-world concurrent user traffic to measure page load times and response latency.
- Stress Testing: Pushes the system beyond its intended operational limits to find its breaking point and analyze recovery procedures.
- Security & Recovery: Evaluates authorization security rules and tests database backup recovery routines.
3.4 Regression Testing
A regression test verifies that existing features and system behaviors continue to work correctly after a new upgrade, feature addition, or bug fix is deployed.
- Phase: Conducted during product maintenance or pre-release cycles.
- Focus: Protecting codebase integrity and avoiding regressions.
4. Test Case Design Approaches (Testing Techniques)
Test cases are designed and executed based on three different visibility models:
4.1 White Box Testing
White Box testing is performed with full visibility of the internal code structure.
- Executor: Performed by developers.
- Goal: Verifies internal logic paths, branch coverage, loop limits, and security vulnerabilities.
4.2 Black Box Testing
Black Box testing is performed without any knowledge of the underlying source code.
- Executor: Performed by QA Test Engineers.
- Goal: Focuses strictly on inputs and expected outputs according to customer specifications.
4.3 Gray Box Testing
Gray Box testing is a hybrid approach where the tester has partial knowledge of the internal logic and database schemas, but tests the application from the user perspective.
- Executor: Performed by QA Engineers who write automated scripts and debug database entries.
5. Test-Driven Development (TDD)
Test-Driven Development (TDD) is an advanced software engineering paradigm where you write automated test cases before writing the actual production code.
🔄 The TDD Workflow:
- Red: Write a failing unit test for the feature.
- Green: Write the minimum amount of production code required to make the test pass.
- Refactor: Clean up and optimize the code while keeping all tests green.
Key Advantages of TDD:
- Confidence to Refactor: Clean up legacy systems safely knowing your test suite will instantly catch broken logic.
- Early Bug Notification: Discover bugs the exact second they are introduced into your local workspace.
- Modular Design: Forces developers to build clean, decoupled, and highly testable code architectures.
5.1 Shift Left vs. Shift Right in Software Testing
To optimize software quality, modern agile teams balance two testing methodologies:
Shift Left testing
Shift Left testing means moving testing activities earlier in the lifecycle. Instead of waiting until system testing, you execute tests at the earliest stages of development.
- Goal: Detect bugs early to reduce fixing costs and prevent compound errors.
- Examples: Unit tests, integration tests, static code analysis, and TDD.
Shift Right testing
Shift Right testing means extending testing activities into the very end of the cycle, including testing directly in production environments.
- Goal: Catch real-world edge cases, unexpected user behaviors, and third-party API issues that staging sandboxes cannot replicate.
- Examples: Real-time logging, canary releases, A/B testing, and production system testing.
