Manual Testing and required skills Notes By ShariqSP

What is Manual Testing?

Manual testing is a process where test cases are executed manually by testers without using any automated tools or scripts. Testers play the role of an end-user and manually verify that the software functions as intended. This approach allows for thorough exploration of the software’s functionality, user interface, and overall user experience. Manual testing is especially valuable for identifying usability issues, checking new features, and validating unique test scenarios.

Manual testing involves various techniques, including exploratory testing, ad-hoc testing, and structured test cases, to ensure comprehensive coverage. Unlike automation testing, manual testing is flexible and adaptive, allowing testers to respond dynamically to new discoveries and unexpected software behavior.

Skills Required for Manual Testing

To be an effective manual test engineer, certain skills are essential to understand requirements, execute tests accurately, and communicate findings. Key skills include:

1. Strong Analytical and Problem-Solving Skills

Manual testers need strong analytical skills to understand complex requirements and break them down into clear, testable scenarios. Problem-solving skills are essential for identifying the root causes of defects and suggesting potential solutions. A keen eye for detail is necessary to catch subtle issues that could impact the user experience.

2. Attention to Detail

Attention to detail is critical in manual testing to spot even the smallest inconsistencies and unexpected behaviors. Testers should be meticulous when following test steps and recording observations to ensure that no potential defects go unnoticed.

3. Strong Communication Skills

Testers must effectively communicate their findings to developers, project managers, and other stakeholders. This includes writing clear and detailed bug reports, documenting test cases, and summarizing results in a way that others can understand. Good communication is also essential for discussing requirements and clarifying any ambiguities with the development team.

4. Domain Knowledge

Understanding the domain in which the software operates helps testers make informed decisions about test cases and scenarios. For example, knowledge of finance, healthcare, or e-commerce helps testers better understand industry-specific requirements and regulations, which can be crucial for effective testing.

5. Test Planning and Documentation Skills

Manual testers should be able to create detailed test plans, test cases, and documentation. Good documentation skills are essential for creating readable, reproducible, and organized test case documents that help ensure comprehensive test coverage and assist in future testing cycles.

6. Understanding of Software Development Life Cycle (SDLC) and Software Testing Life Cycle (STLC)

A solid understanding of SDLC and STLC helps testers know where testing fits into the overall process. Familiarity with different testing phases—such as requirements analysis, test planning, test case design, test execution, defect tracking, and test closure—is essential to effectively carry out testing activities.

7. Familiarity with Bug Tracking Tools

Manual testers need to be proficient in bug tracking tools like JIRA, Bugzilla, or Mantis. These tools help testers log, track, and manage defects efficiently, allowing the development team to prioritize and address issues effectively.

8. Basic Knowledge of SQL and Database Concepts

Understanding databases and basic SQL can be helpful in validating data stored in databases. This skill allows testers to verify that data flows correctly through the system and ensures data integrity in applications where backend databases are involved.

9. Curiosity and Adaptability

Curiosity helps testers to thoroughly explore the application, while adaptability enables them to adjust to changes in requirements, application functionality, or testing techniques. A good manual tester should be eager to learn, explore different testing approaches, and continuously improve their skills.

These skills collectively enable manual testers to perform thorough and accurate testing, ensuring software quality and improving the end-user experience. By mastering these skills, a manual test engineer can play a critical role in delivering a reliable, user-friendly product.

Types of Software Testing

1. Functional Testing

Functional testing focuses on verifying that each function of the software application operates in conformance with the specified requirements. It involves checking user interface, APIs, databases, security, client/server applications, and functionality of the software. Functional testing is primarily concerned with what the system does.

Types of Functional Testing

• Unit Testing:

  Tests individual components or modules of a software. For instance, testing a login function to ensure it returns a success or failure status correctly. This is typically done by developers during the coding phase.

• Integration Testing:

  Tests the interaction between integrated modules to detect interface defects. For example, testing the data flow between a user module and payment processing module in an ecommerce application.

• System Testing:

  Tests the entire system as a whole to verify it meets the requirements. For instance, testing the entire order processing system in an ecommerce application, including inventory, billing, and shipping modules.

• Sanity Testing:

  A quick, surface-level test to ensure major functionalities work as expected. For example, verifying basic operations like login, data entry, and logout in a new software build.

• Smoke Testing:

  A preliminary test to check the stability of a software build. For example, testing core functions like application launch, basic navigation, and response to basic user inputs before deeper testing.

• Regression Testing:

  Ensures that recent code changes have not adversely affected existing functionalities. For example, retesting the login and checkout processes after a new payment gateway integration.

• User Acceptance Testing (UAT):

  Conducted by the end-users to verify that the software works in real-world scenarios. For instance, testing a business application by actual employees before it goes live.

Example of Functional Testing

Consider a banking application with features like account login, fund transfer, and balance inquiry. Functional testing would involve testing each of these features independently to ensure they perform as expected. For example, logging in with valid credentials should grant access, while incorrect credentials should display an error.

2. Non-Functional Testing

Non-functional testing focuses on the operational aspects of software, such as performance, usability, reliability, and security. It is concerned with "how" the system performs, rather than specific functionalities.

Types of Non-Functional Testing

• Performance Testing:

  Evaluates the speed, responsiveness, and stability of the application under different conditions. For example, testing how an application performs under high user load in an online shopping site.

• Load Testing:

  Checks the system's behavior under expected user load. For instance, testing an online booking system to handle up to 10,000 users simultaneously during peak times.

• Stress Testing:

  Assesses the system's robustness by testing it under extreme conditions, such as excessive load or data input. For example, pushing a server beyond its capacity to understand its breaking point and recovery.

• Usability Testing:

  Focuses on user-friendliness and ease of use. For example, observing users as they navigate a new feature in a mobile app to ensure intuitive design and functionality.

• Security Testing:

  Ensures that the application is secure from vulnerabilities like unauthorized access, data breaches, and malware. For example, testing an e-commerce application to ensure encryption of credit card information during transactions.

• Compatibility Testing:

  Ensures that the software works well across different browsers, devices, operating systems, and networks. For instance, testing a website’s layout and performance on both Android and iOS devices, as well as Chrome, Safari, and Firefox browsers.

• Reliability Testing:

  Checks the application's stability and consistency over time. For instance, running a long-term test on a CRM application to ensure that it consistently processes transactions without error.

• Compliance Testing:

  Ensures the software complies with regulatory requirements and standards. For example, checking a healthcare application to verify that it adheres to HIPAA regulations.

Example of Non-Functional Testing

In a video streaming platform, non-functional testing would evaluate its performance under high traffic, security against unauthorized access, and compatibility across devices. For example, load testing could determine if the platform can handle peak hours, and security testing would ensure encryption during data transmission.

Principles of Manual Testing

Manual testing follows foundational principles that guide testers in effectively identifying defects and improving software quality. These principles ensure a structured and strategic approach to testing, maximizing the effectiveness of each test. Below are the key principles of manual testing and their importance:

1. Avoid Exhaustive Testing: Exhaustive testing, or testing all possible combinations and scenarios, is often impractical due to time and resource constraints. Instead, manual testers focus on testing the most critical and commonly used functions. This approach allows testers to use their resources wisely, concentrating on high-impact areas that provide the most coverage with the least effort.
2. Address the Pesticide Paradox: In testing, repeating the same tests over time tends to reduce their effectiveness, as they no longer catch new bugs. This is known as the "pesticide paradox." To counter this, testers periodically review and revise test cases, incorporating new variations and scenarios to uncover previously hidden defects. This principle encourages continuous improvement in test design.
3. Emphasize Early Testing: Early testing involves beginning testing activities as soon as possible in the software development lifecycle (SDLC). This helps in identifying defects at earlier stages, making them cheaper and easier to fix. Conducting reviews, walkthroughs, and unit testing early can prevent issues from cascading down the line, saving time and resources.
4. Testing to Reveal Defects: The purpose of testing is to find defects—not to prove that the application is defect-free. Testers approach each test case with the mindset of uncovering issues. By focusing on discovering defects rather than verifying functionality, manual testers help improve the application’s overall quality and reliability.
5. Testing is Context-Dependent: Different applications require different testing approaches based on factors such as industry, user base, and application type. For example, testing methods for a financial application will differ from those for a gaming app. Context-dependent testing ensures that testing strategies are aligned with the specific goals and constraints of the application.
6. Error-Free Software Doesn’t Guarantee Quality: Even if an application is free from defects, it may still fail to meet user expectations or business requirements. This principle reminds testers that defect-free software does not necessarily mean that the software is useful, reliable, or complete. Testing should not only focus on finding defects but also on verifying that the software meets all functional and non-functional requirements.
7. Focus on Defect Clustering: Defect clustering refers to the phenomenon where a small number of modules contain the majority of defects. Testers use historical data or knowledge of the application to identify and concentrate testing on these high-risk areas. By focusing on the areas most likely to have issues, testers can maximize the effectiveness of their efforts.

Following these principles helps testers perform efficient and focused manual testing, ultimately improving software quality by strategically finding and addressing defects. These principles serve as the foundation for a reliable and consistent testing process.