DEV Community: Dhivya.R

What is manual Testing?What are the benefits and drawbacks of manual testing?Give some Examples in support of your answer?

Dhivya.R — Mon, 15 Jul 2024 16:58:59 +0000

Manual Testing :
Manual Testing is the process of manually executing test cases without the use of automated tools. In this type of testing, a tester plays the role of an end user and verifies that all features of the application are working correctly. Testers use test plans, test cases, or test scenarios to perform these tests.

Benefits of Manual Testing

Flexibility:
Testers can easily adjust test cases and approaches based on real-time results.
Allows for ad-hoc testing, which can identify defects not anticipated in the test cases.

Cost-Effective for Small Projects:
Initial setup costs are lower compared to automated testing.
Suitable for projects with a small number of test cases or short duration.

Usability Testing:
Manual testing is essential for evaluating the user-friendliness and user experience of an application.
Human testers can provide valuable feedback on the application’s look and feel.

Drawbacks of Manual Testing

Time-Consuming:
Executing tests manually can be very time-consuming, especially for large and complex applications.
Repetitive testing (regression tests) can be tedious and error-prone.

Not Suitable for Repetitive Tasks:
Manual testing is not ideal for tasks that require repeated execution, as it increases the risk of human error and oversight.

Limited Scope:
Manual testing might not cover all possible test scenarios, especially for complex applications.
Some defects may be missed due to human limitations.

Inconsistent Results:
Results may vary depending on the tester’s skill, experience, and understanding of the application.
Lack of consistency can lead to unreliable test outcomes.

Examples Supporting Manual Testing

Example : Exploratory Testing
Scenario: A tester is exploring a newly developed e-commerce website.
Process:
The tester navigates through various product categories.
Adds items to the cart.
Proceeds to checkout.
Tries to apply different discount codes.
Completes the purchase.
Outcome:
During this process, the tester might discover usability issues like unclear navigation, slow page load times, or issues with the payment gateway that were not anticipated in the initial test cases.

Example : Usability Testing
Scenario: A team is testing the user interface of a new mobile banking app.
Process:
Testers interact with the app to evaluate its ease of use.
They assess the intuitiveness of navigation, clarity of instructions, and the overall user experience.
Feedback is collected on visual design, button sizes, and the flow of tasks (e.g., transferring money, checking account balance).
Outcome:
The testers might find that the login process is too complicated or that certain features are hard to locate, which would not be as easily identified through automated testing.

Example : Ad-hoc Testing
Scenario: A tester is performing ad-hoc testing on a social media platform's new feature release.
Process:
Without a predefined plan, the tester randomly interacts with the new feature.
For example, posting a status update, tagging friends, uploading photos, and checking notifications.
Outcome:
This spontaneous testing can reveal unexpected issues such as failure to upload images under certain conditions or incorrect notifications, providing quick insights into potential defects.

Example : Regression Testing
Scenario: After fixing a reported bug in a financial software application, regression testing is performed.
Process:
The tester re-tests the specific functionality where the bug was found.
They also test related functionalities to ensure the bug fix did not introduce new issues.
For example, after fixing a bug in the tax calculation module, the tester checks other related modules like expense tracking and invoice generation.
Outcome:
The tester ensures that the original issue is resolved and verifies that no new bugs were introduced, ensuring the overall stability of the application.

Example : Compatibility Testing
Scenario: Testing a web application across different browsers and devices.
Process:
A tester manually accesses the web application on multiple browsers (Chrome, Firefox, Safari, Edge).
The tester also checks the application on various devices (desktops, tablets, smartphones) with different operating systems (Windows, macOS, Android, iOS).
Outcome:
The tester identifies compatibility issues, such as layout discrepancies, functionality problems, or performance issues, which might be missed by automated tests that simulate environments.

Testing Techniques with proper examples: 1)Boundary Value Analysis 2)Decision Table Testing 3)use case testing 4)LCSAJ testing

Dhivya.R — Mon, 15 Jul 2024 16:25:20 +0000

Boundary Value Analysis:
• Boundary value analysis is based on testing the boundary values of valid and invalid partitions.
• Every partition has its maximum and minimum values and these maximum and minimum values
are the boundary values of a partition.
Example: If we want to enter an amount between 100 to 1000.
Here we check based on boundaries for 100, we take 98, 99, 101, 102 and for 1000, we take 998, 999,
1001, 1002

Decision Table Technique:
• In Decision table technique, we deal with combinations of inputs.
• To identify the test cases with decision table, we consider conditions and actions.
• We take conditions as inputs and actions as outputs.
Example: Login validation - Allow user to login only when both the username and password is correct.
• Conditions 1: Enter valid username and valid password and Click Login.
o Actions 1: Display home page and Execute.
• Conditions 2: Enter invalid username and valid password and Click Login.
o Actions 2: Display Error message as invalid username

Use Case Testing:
Definition: Use case testing focuses on validating the behavior of a system based on its use cases, which are descriptions of interactions between users (actors) and the system.
Purpose: It ensures that the system meets the functional requirements specified in each use case. Use cases typically describe end-to-end scenarios or processes within the system.
Example: In an online shopping application, a use case might detail how a user adds items to the cart, applies discounts, and completes a purchase. Test cases would be derived from these use cases to validate that each step and condition within the scenario works correctly.

TC1: Add Items to Cart
Steps: Add multiple items to the cart.
Expected Outcome: Cart displays correct items with quantities.

TC2: Apply Valid Discount Code
Steps: Apply a valid discount code during checkout.
Expected Outcome: Total amount reflects the discounted price.

TC3: Apply Invalid Discount Code
Steps: Attempt to apply an invalid discount code.
Expected Outcome: System displays an error message indicating the discount code is invalid.

TC4: Complete Purchase - Payment Success
Steps: Complete the purchase process with a valid payment method.
Expected Outcome: Order is successfully placed, and confirmation is received.

TC5: Complete Purchase - Payment Failure Handling
Steps: Simulate a payment failure during checkout.
Expected Outcome: User receives appropriate error message and guidance on next steps

LCSAJ testing:
verifies that all linear sequences of code (straight-line execution paths) and jump statements (such as if, else, for, while conditions) in a program are executed at least once during testing. This ensures comprehensive coverage of the code's execution paths, helping to identify potential errors and ensuring that all parts of the program are tested.

** Example:**
in a function that calculates discounts based on a customer's membership status and the price of an item, LCSAJ testing would involve creating test cases that cover different scenarios:

Checking if the discount calculation branch (if price > 100) is executed correctly.
Verifying that both branches of the membership status condition (if is_member) are tested.

What is software testing ? what we need to know about software testing? What is the relevance of software testing ?

Dhivya.R — Mon, 15 Jul 2024 15:11:27 +0000

what is software testing?
Software testing is the process of identifying bugs in software and examining its behavior through verification and validation to ensure it meets the specified requirements and functions correctly. This process is essential for confirming that the software is of high quality and ready for use.

Verification and Validation:

Verification:
Confirms that the software is developed as per design and requirements, ensuring "Are we building the product right?"

Validation:
Confirms that the software meets the user's needs and expectations, ensuring "Are we building the right product?"

Understanding software testing requires familiarity with several key concepts and practices:

Requirement Analysis: Before testing begins, the requirements for software testing must be thoroughly analyzed and documented. This ensures that the testing process is aligned with the expected outcomes and objectives.
Types of Testing

Black Box Testing: Also known as functional testing, this method tests the software's functionality without looking at the internal code structure. Testers focus on inputs and outputs to validate the software's behavior.

White Box Testing: Conducted during the coding phase by developers, this testing method examines the internal structure and logic of the code to ensure it meets the required specifications.

Grey Box Testing:
A combination of black box and white box testing, grey box testing evaluates the software by partially understanding its internal workings and functionality.

Levels of Testing

Unit Testing: Performed by developers, unit testing focuses on individual components or units of the software to ensure they work correctly.

Integration Testing: Assesses the interaction between integrated components to detect interface defects.

System Testing: Tests the complete and integrated software system to verify it meets the specified requirements.

Acceptance Testing: Validates the software against user requirements to determine its readiness for deployment.
Testing Techniques

Smoke Testing: A preliminary test to check the basic functionality of the application.

Sanity Testing: Ensures that specific functions work correctly after minor changes or bug fixes.

Regression Testing: Verifies that new code changes do not adversely affect existing functionalities.

**Performance Testing: **Evaluates the software's performance under various conditions, such as load and stress.

User Acceptance Testing (UAT): Involves end-users testing the software to ensure it meets their needs and expectations.

Relevance of Software Testing

Software testing is crucial for several key reasons:

Quality Assurance: Ensures the software is of high quality and meets standards, leading to a reliable and efficient product.

Risk Mitigation: Identifies and fixes defects early to prevent potential failures and reduce deployment risks.

Customer Satisfaction: Delivers a well-tested product that meets user expectations, resulting in higher customer satisfaction.

Continuous Improvement: Regular testing maintains software reliability and performance, especially after code changes or updates.

Python selenium architecture & Python virtual environment?

Dhivya.R — Sun, 12 May 2024 10:46:51 +0000

Python Selenium architecture

The Python Selenium architecture is composed of several components that work together to automate web browser interactions.

Python:
Python serves as the primary programming language for writing Selenium scripts. It provides a simple and readable syntax, making it accessible for both beginners and experienced developers.

Selenium WebDriver:
Selenium WebDriver is the core component of Selenium. It provides APIs for interacting with web browsers programmatically. WebDriver communicates with the browser using a browser-specific driver. For example, ChromeDriver for Google Chrome, GeckoDriver for Mozilla Firefox, etc.
Web Browser:
Selenium supports various web browsers such as Chrome, Firefox, Safari, Edge, etc. It allows users to automate interactions with these browsers, including navigation, form filling, clicking buttons, etc.
Browser Drivers:
Browser drivers act as intermediaries between Selenium WebDriver and the web browsers. They translate Selenium commands into browser-specific actions. Each browser requires its own driver. Selenium provides separate driver executables for different browsers.
Remote WebDriver:
Selenium also supports running tests on remote machines or Selenium Grids. Remote WebDriver allows you to execute Selenium tests on a different machine than where your code is running. This is useful for distributing tests across multiple environments or running tests in parallel.
Testing Frameworks:
While not strictly a part of Selenium's architecture, testing frameworks like pytest, unit test, or Behave are often used alongside Selenium for organizing and executing tests efficiently.

Python Virtual Environment:
A Python virtual environment is a self-contained directory that contains a Python installation for a particular version of Python, as well as additional packages. It helps isolate project dependencies and avoids conflicts between different projects.

Here are some examples of its significance:
1.Dependency Management:
Virtual environments allow you to manage project dependencies separately. You can install specific versions of packages for each project without affecting the system-wide Python installation or other projects.
2.Reproducibility:
By encapsulating dependencies within a virtual environment, you ensure that other developers can replicate your project's environment easily. This enhances collaboration and reproducibility of results.
3.Version Control:
Including the virtual environment directory in version control (e.g., using a requirements.txt file) ensures that everyone working on the project uses the same set of dependencies. It simplifies deployment and avoids unexpected issues due to dependency discrepancies.
4.Isolation:
Virtual environments provide a sandboxed environment where you can experiment with different packages or versions without worrying about affecting other projects or the system-wide Python installation.

what is selenium? why do we use selenium in automation?

Dhivya.R — Sun, 12 May 2024 10:08:08 +0000

Selenium:
Selenium is a popular open-source automation testing framework primarily used for web applications. It provides a suite of tools and libraries for automating web browsers across different platforms.

Originally developed by Jason Huggins in 2004, Selenium has evolved into a robust and versatile tool for automating web interactions and testing web applications interactions with web applications, perform functional testing, regression testing, and cross-browser testing.

Components of Selenium:

Selenium WebDriver:
WebDriver is the core component of Selenium that provides a programming interface to interact with web browsers. It enables testers to automate browser actions such as opening URLs, clicking buttons, filling forms, and navigating through web pages.
WebDriver communicates with the browser natively using the browser's built-in support for automation, such as ChromeDriver for Chrome, GeckoDriver for Firefox, etc.
WebDriver supports multiple programming languages, including Java, Python, C#, Ruby, and JavaScript, making it flexible and accessible to a wide range of users.

Selenium IDE (Integrated Development Environment):
Selenium IDE is a browser extension used for recording and playback of user interactions with web applications. It allows testers to create automation scripts by simply recording their actions in the browser and replaying them later.
Selenium IDE is primarily used for quick prototyping, exploratory testing, and generating basic automation scripts. It provides a user-friendly interface for creating and editing test cases without the need for extensive programming knowledge.

Selenium Grid:
Selenium Grid is a distributed testing tool used for running automation tests in parallel across multiple browsers, devices, and operating systems simultaneously.
Selenium Grid consists of a hub and multiple nodes. The hub acts as a central point that receives test requests, while nodes are instances of WebDriver running on different machines or virtual environments. By distributing test execution across multiple nodes, Selenium Grid allows for faster test execution and broader test coverage.

Selenium is a popular tool for automation for several reasons:

1.Cross-Browser Testing:

Selenium allows you to test web applications across different browsers like Chrome, Firefox, Safari, etc. This is crucial because web applications may behave differently in various browsers due to differences in rendering engines.

2. Platform Independence:

Selenium supports multiple operating systems like Windows, macOS, and Linux, making it a versatile choice for automation testing.

3.Multiple Programming Language Support:

Selenium supports various programming languages such as Java, Python, C#, etc., enabling developers and testers to use their preferred language for automation.

4.Integration with Testing Frameworks:

Selenium can be integrated with popular testing frameworks like JUnit, TestNG, NUnit, etc., which provides additional features for test management and reporting.

5.Large Community and Resources:

Selenium has a vast
community of developers and testers contributing to its ecosystem. This means there are plenty of resources, tutorials, and support available for users.

6.Open Source:

Selenium is an open-source tool, which means it's freely available for anyone to use and modify. This makes it cost-effective for organizations and allows for continuous improvement through community contributions.

Testing technique: 1)Boundary value analysis 2)Decision Table Testing 3)use case Testing

Dhivya.R — Tue, 27 Feb 2024 07:19:31 +0000

Testing technique:
1)Boundary value analysis
2)Decision Table Testing
3)use case Testing

Boundary Value Analysis:
• Boundary value analysis is based on testing the boundary values of valid and invalid partitions.
• Every partition has its maximum and minimum values and these maximum and minimum values
are the boundary values of a partition.
Example: If we want to enter an amount between 100 to 1000.
Here we check based on boundaries for 100, we take 98, 99, 101, 102, and for 1000, we take 998, 999,
1001, 1002

Decision Table Technique:
• In the Decision table technique, we deal with combinations of inputs.
• To identify the test cases with a decision table, we consider conditions and actions.
• We take conditions as inputs and actions as outputs.
Example: Login validation - Allow user to log in only when both the username and password is correct.
• Conditions 1: Enter a valid username and valid password and Click Login.
o Actions 1: Display the home page and Execute.
• Conditions 2: Enter an invalid username and valid password and Click Login.
o Actions 2: Display Error message as invalid username

use case testing
Use case testing involves examining how software behaves in response to specific user interactions or scenarios. It's like putting the system through its paces to ensure it does what it's supposed to do in real-life situations.
• Take, for instance, an online shopping site. We could have a use case where a user searches for a product, adds it to their cart, goes through the checkout process, and completes the purchase.
• During use case testing, we'd meticulously go through each step of this scenario. We'd check if the search results are accurate if the items get added to the cart properly, if the checkout process is seamless, and if the payment goes through without a hitch.
• In essence, use case testing helps us catch any glitches or hiccups in the system, making sure it meets user expectations. It's all about ensuring the software performs as intended from the user's standpoint, boosting its overall quality and reliability.

what is software testing ?

Dhivya.R — Sun, 25 Feb 2024 10:40:00 +0000

software testing:
software testing is a process of checking a program or application to make sure it works properly, doesn't have any errors or bugs, and ensures that it functions as expected. Testing is essential to ensure the quality, reliability, and performance of software products before they are released to users.

Software testing is crucial for ensuring that programs function correctly.
It helps identify and fix errors or bugs in the software.
Testing ensures that the software meets user expectations and requirements.
Without testing, the software may have undetected issues that could impact its performance.
Thorough testing enhances the reliability and quality of software products.
It is essential to conduct testing before releasing software to users to prevent problems.
Different types of testing, such as functional and performance testing, address various aspects of software quality.
Automated tools help streamline the testing process.
Regular testing throughout the development lifecycle helps catch issues early on, reducing costs and time.
Continuous improvement in testing practices leads to more robust and dependable software systems.

what is manual testing? what are the Benefits and drawbacks of manual testing?

Dhivya.R — Sat, 24 Feb 2024 16:22:30 +0000

Manual testing :
Manual testing is a type of software testing.
where testers manually execute test cases without the use of automation tools.
In manual testing testers carefully execute test cases to identify defects, bugs, or other issues in the software being tested.

Benefits of manual testing :

The human eye captures more defects.
Everything cannot be automated like Captcha, Image, Animation, Video, etc.
Reports prepared by the manual testers will be always detailed because manual testers are strong in Domain knowledge.
Manual testers can adapt quickly to changes in project requirements, making them valuable assets in agile development environments.
Manual testers to apply real-world scenarios and user interactions more accurately, ensuring extensive testing.

Drawback of Manual Testing:

Time-consuming nature due to the manual execution of test cases.
increased chance of humans making mistakes.
Hard to handle big projects or lots of tests happening often.
Can't check all possible scenarios thoroughly.
Higher resource requirements in terms of manpower and time.

Functional Testing vs Non-functional Testing

Dhivya.R — Sat, 24 Feb 2024 15:19:21 +0000

Functional Testing
Non-Functional Testing

Functional Testing: ✓ Checking the functionalities of the application.

• Manual Testing (Testing the functionalities by manual)
• Automation Testing (Testing the functionalities by using tools/scripts)
• Webservices Testing (Validating request and response) - API Testing
Automation Tools:
• Selenium - Web Based Applications
• Appium - Mobile Applications
• QTP (Quick Test Professional)/UFT (Unified Functional Testing) - Desktop Related
Applications [Ex: MS Office Applications, Web Browsers, etc.]
• Test Complete - Both Web Based and Desktop Based Applications

2. Non-Functional Testing:

✓Checking the non-functional aspects of the application.

Types of Non-Functional Testing:

Performance Testing:

• They add the virtual number of users accessing the application simultaneously and at the same time

To check the performance of the application.

Tools Used:

• J-Meter Open-Source Tool

• Load Runner Paid Version

Load/Stress Testing:

• Process of adding load and making the application stress is called Load/Stress Testing.

Usability Testing:

• To check how good the application is user friendly.

Accessibility Testing:

• To check how well the application is accessible to different users.

• This testing mainly focuses on physically challenged peoples

• Tools Used: JAWS and NVDA