DEV Community: Seshanth Rakesh

Automation Testing..

Seshanth Rakesh — Wed, 11 Oct 2023 12:08:38 +0000

Q1.Explain difference between selenium IDE, Selenium WebDriver and Selenium Grid?
ANS: Selenium IDE allows us to record, playback the recording, edit, and debug our test. Selenium WebDriver is an API that executes our test by driving a browser for
automating an Application Under Test (AUT). Selenium Grid executes our test across multiple browsers, operating systems, and machines.

Q2.Write a selenium scripts in java to open Google and selenium browser Driver

package com.Task15.Answers;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class Q2Launch_browser {

public static void main(String[] args) {
    WebDriver driver =new ChromeDriver();
    driver.get("https://www.google.com/");
    WebElement Q= driver.findElement(By.id("APjFqb"));
            Q.sendKeys("Selenium Browser Driver");
            Q.sendKeys(Keys.ENTER);


}

}

Q3.what is selenium, how it is helpful in Automation Testing ?
Ans:
Selenium is an open-source, automated testing tool used to test web applications across various browsers. Selenium can only test web applications, unfortunately,
so desktop and mobile application can't be tested. However, other tools like Appium and HP's QTP can be used to test software and mobile applications.

Q4.What all Browser driver are used in Selenium?
Ans:
It supports a number of browsers (Google Chrome 12+, Internet Explorer 7,8,9,10, Safari 5.1+, Opera 11.5, Firefox 3+) and operating systems (Windows, Mac, Linux/Unix). Selenium also provides compatibility with different programming languages – C#, Java, JavaScript, Ruby,
Python, PHP.

Q5.What are steps to create Simple Webdriver script? Explain with code

Ans:
Basic Steps in a Selenium WebDriver Script:

Step 1 Create a WebDriver instance.
Step 2: Navigate to a webpage.
Step 3: Locate a web element on the webpage via locators in selenium.
Step 4: Perform one or more user actions on the element.
Step 5: Preload the expected output/browser response to the action.
Step 6 : Run test.
Step 7: Record results and compare results from them to the expected output.

Code:
public class Q2Launch_browser {

public static void main(String[] args) {
    WebDriver driver =new ChromeDriver();              //Create a WebDriver instance.
    driver.get("https://www.google.com/");              // Navigate to a webpage.
    WebElement Q= driver.findElement(By.id("APjFqb"));// Locate a web element on the webpage via locators in selenium.
            Q.sendKeys("Selenium Browser Driver");
            Q.sendKeys(Keys.ENTER);                 //Perform one or more user actions on the element.


}

}

Automation Testing

Seshanth Rakesh — Thu, 05 Oct 2023 11:34:11 +0000

Q1.What is difference between Automation and manual testing in the software development?
Answer:
1. Automated Testing:

Automated testing involves the use of testing tools, scripts, and software to execute test cases and compare the actual results with expected outcomes.
It is typically used for repetitive, time-consuming, or complex test scenarios.
Automation can be scripted using programming languages like Python, Java, or specialized testing frameworks.
Automated tests are efficient for regression testing, where previously tested functionalities are checked after code changes.
They are less prone to human error and can be executed repeatedly with consistency.

Manual Testing:
- Manual testing relies on human testers who perform test cases without the aid of automated tools or scripts.
- Testers follow test plans and execute test cases step by step, often documenting defects and providing feedback.
- It is suitable for exploratory testing, usability testing, and scenarios where human judgment is required.
- Manual testing can be time-consuming and may have limitations in terms of repeatability and coverage.
- It is often used in the early stages of software development, such as during initial feature testing.

Q2.Explore some of the automation testing tool Available in the market?
Answer:
There are numerous automation testing tools available in the market, each with its own set of features and capabilities.

Selenium: Selenium is an open-source automation framework for web applications. It supports multiple programming languages and browsers, making it
one of the most widely used tools for web automation.
Appium: Appium is an open-source tool for automating mobile applications on Android and iOS platforms. It allows you to write tests using
various programming languages.
TestNG: TestNG is a testing framework inspired by JUnit and NUnit but designed for test configuration and parallel execution. It's often used with Selenium
for Java-based test automation.
JUnit: JUnit is a popular testing framework for Java applications. While it's primarily used for unit testing, it can also be used for automation testing
when combined with other tools.
Cucumber: Cucumber is a behavior-driven development (BDD) tool that allows you to write test cases in plain language. It's commonly used for acceptance testing
and is often integrated with Selenium.
Jenkins: Jenkins is an open-source automation server that is used for continuous integration and continuous delivery (CI/CD) pipelines. While it's not a testing
tool itself, it plays a crucial role in automating build and test processes.
Robot Framework: Robot Framework is an open-source automation framework that uses a keyword-driven approach. It supports both web and mobile application testing
and has a rich ecosystem of libraries.
TestComplete: TestComplete is a commercial automation tool for web, mobile, and desktop application testing. It offers a user-friendly interface and supports multiple scripting languages.
Postman: Postman is primarily an API testing tool, but it can also be used for automation. It allows you to create and run tests for RESTful APIs.
SoapUI: SoapUI is another tool for API testing, with a focus on testing SOAP and RESTful web services. It has a free open-source version (SoapUI Open Source)
and a commercial version (SoapUI Pro).
Katalon Studio: Katalon Studio is a comprehensive test automation solution that supports web, mobile, and API testing. It offers a range of built-in features
for test case management and reporting.
TestCafe: TestCafe is an open-source end-to-end web testing framework that doesn't require browser plugins. It supports various browsers and platforms.

Q3.What is crossing Testing?
Answer:
Cross-browser testing is a crucial aspect of web application testing that involves verifying that a web application or website functions correctly and
consistently across different web browsers and browser versions. Since various web browsers (e.g., Google Chrome, Mozilla Firefox, Microsoft Edge, Safari)
have different rendering engines and interpret web code differently, a web application that works perfectly in one browser might encounter issues in another.

Compatibility Testing: It ensures that a web application appears and functions correctly on various browsers and browser versions. This includes checking for
consistent layouts, styling, and functionality.
Functional Testing: Cross-browser testing verifies that all interactive elements, forms, buttons, and features on a website work as intended across
different browsers.
Performance Testing: It assesses the speed and performance of a website in various browsers to identify potential bottlenecks or slow-loading issues specific
to certain browsers.
Responsive Design Testing: Ensures that the website is responsive and adapts well to different screen sizes and resolutions, including mobile devices and tablets.
CSS and HTML Validation: Verifies that the website's Cascading Style Sheets (CSS) and HTML code comply with web standards and do not cause rendering issues or
errors in specific browsers.
JavaScript Compatibility: Checks that JavaScript functions and scripts used on the website are compatible with different browser engines and versions.
Cross-Browser Automation: Automation tools like Selenium or TestComplete can be used to automate cross-browser testing, allowing for efficient testing across
multiple browsers and versions.

The goal of cross-browser testing is to deliver a consistent and user-friendly experience to website visitors, regardless of the browser they choose to use.
It helps identify and address browser-specific issues, ensuring that your web application is accessible and functional for a wide range of users.

Q4,Write a Blog on TDD and BDD.
Ans:
Title: Understanding TDD (Test-Driven Development) and BDD (Behavior-Driven Development) in Software Testing
Introduction

In the world of software development, ensuring that your application functions correctly and meets the desired requirements is of utmost importance.
Two popular methodologies that aid in achieving this goal are Test-Driven Development (TDD) and Behavior-Driven Development (BDD). In this blog post,
we will explore both TDD and BDD, their principles, differences, and how they contribute to creating robust and well-tested software.

Test-Driven Development (TDD)

Test-Driven Development, often abbreviated as TDD, is a software development approach that emphasizes writing tests before writing the actual code.
The TDD process typically follows these steps:

Write a Test: Initially, developers create a test case that defines the expected behavior of a small piece of code (usually a unit of functionality).
Run the Test: At this stage, the newly created test case fails because there's no code to make it pass.
Write Code: Developers then write the minimum code necessary to make the test pass successfully.
Run the Test Again: The test is executed again. If it passes, it means the new code meets the expected behavior.
Refactor Code: With the test passing, developers can now refactor and optimize the code without fear of breaking the expected behavior, as long as the tests
continue to pass.

TDD Benefits:

Ensures code correctness by design.
Promotes a clear understanding of requirements.
Encourages incremental development.
Provides a suite of automated tests for regression testing.
Enhances code maintainability and scalability.

Behavior-Driven Development (BDD)

Behavior-Driven Development, or BDD, is an extension of TDD that focuses on the behavior of the software from the user's perspective. BDD encourages collaboration
between developers, testers, and non-technical stakeholders (e.g., product owners, business analysts). The key components of BDD include:

User Stories: BDD starts with defining user stories that describe the desired behavior of the software in plain language, often using the "Given-When-Then" format.
Scenarios: Based on user stories, scenarios are created to outline specific examples of how the software should behave in different situations.
Automation: Tests are automated using BDD frameworks like Cucumber, Behave, or SpecFlow. These tests are written in a way that closely mirrors the language used
in user stories and scenarios.
Collaboration: BDD promotes collaboration between team members, including developers, testers, and non-technical stakeholders, to ensure a shared understanding
of requirements and behavior.

BDD Benefits:

Fosters collaboration and communication within the team.
Shifts the focus towards user-centric behavior.
Encourages the creation of executable specifications.
Provides living documentation that stays up-to-date.
Helps identify and address misunderstandings early in development.

Key Differences between TDD and BDD

Focus: TDD primarily focuses on the technical aspects of code correctness, while BDD emphasizes the behavior and functionality of the software from a
user's perspective.
Language: TDD test cases are often written in a programming language understood by developers, whereas BDD tests are written in natural language that is
accessible to non-technical stakeholders.
Stakeholder Involvement: BDD encourages collaboration with non-technical stakeholders, whereas TDD typically involves only developers and testers.
Test Granularity: TDD often deals with smaller units of code (unit tests), while BDD typically deals with higher-level behavior (acceptance tests).

Conclusion

Test-Driven Development (TDD) and Behavior-Driven Development (BDD) are two valuable approaches in software development that help ensure code correctness and
user-focused behavior, respectively. While TDD is more focused on technical correctness and developer-driven testing, BDD extends this approach to include
non-technical stakeholders and emphasizes user-centric behavior. Both methodologies contribute to creating robust, well-tested, and maintainable software, and
choosing between them often depends on project requirements and team dynamics. Ultimately, the goal is to produce software that meets user expectations and
performs reliably.

STLC&QA Testing

Seshanth Rakesh — Mon, 18 Sep 2023 11:37:52 +0000

Task3:

1.list down all the models of SDLC:
waterfall model
agile model
v-Model
spiral model
iterative model
bigbang models
incremental model
RAD model
2.what is STLC and explain all stages of STLc
Answer: STLC:(Software Test Lifecycle): STLC is a systematic approach to testing a software application to ensure the it meets the requirements and is free of defects.It is a process of that follows a series of steps or phases and each has specific objectives and deliverables.The STLC is used to ensure that the software is of high quality,reliable and meets the needs of the end-user.
Stages of STLC:
1.Reqirement Analysis
2.Test Planning
3.Test Case development
4.Test Enviroment Setup
5.Test Execution
6.Test cycle closure

Requirement Analysis:
- In this phase, testers and stakeholders analyze and understand the project's requirements.
- Identify testable features, scope, objectives, and constraints.
- Create a Requirement Traceability Matrix (RTM) to link requirements to test cases.
Test Planning:
- Develop a comprehensive test plan that outlines the testing strategy, resources, schedule, and deliverables.
- Define test objectives, entry and exit criteria, and risks.
- Determine the testing types (e.g., functional, non-functional) and testing levels (e.g., unit, integration, system).
Test Case Development:
- Design and create test cases based on the requirements and test plan.
- Each test case should include input data, expected results, and execution steps.
- Ensure good coverage, including positive and negative scenarios.
Test Environment Setup:
- Prepare the test environment, which includes hardware, software, and network configurations.
- Ensure that the test environment mimics the production environment as closely as possible.
- Verify that all necessary tools and resources are available for testing.
Test Execution:
- Execute the test cases on the prepared test environment.
- Record test results, including pass/fail status and any defects found.
- Monitor and manage test execution progress, reporting issues promptly. 6.Test Cycle Closure:*
- Evaluate the test cycle's objectives against the exit criteria defined in the test plan.
- Prepare test summary reports, highlighting the test results, defect metrics, and lessons learned.
- Review the entire testing process and gather feedback for process improvement.
As a test lead for a web-based application, your manager has asked you to identify and explain the different risk factors that should be included in the test plan. Can you provide a list of the potential risks and their explanations that you would include in the test plan?
Answer: 1. Security Risks:
- Explanation: Security vulnerabilities, such as data breaches or unauthorized access, can compromise user data and the application's integrity. Testing should identify and mitigate these risks.
Performance Risks:
- Explanation: Poor performance, slow load times, or server crashes can lead to a bad user experience. Performance testing assesses the application's responsiveness and scalability under different loads.
Compatibility Risks:
- Explanation: Web applications need to work seamlessly on various browsers, devices, and operating systems. Compatibility testing ensures the app functions correctly across different environments.
Functional Risks:
- Explanation: Functional testing verifies that the application's features and functions work as intended. Missing or incorrect functionalities can hinder user satisfaction.
Usability Risks:
- Explanation: Poor user interface design or confusing navigation can result in user frustration. Usability testing evaluates the application's user-friendliness.
Data Integrity Risks:
- Explanation: Errors in data storage, retrieval, or manipulation can lead to data corruption or loss. Data integrity testing confirms that data remains accurate and consistent.
Integration Risks:
- Explanation: If the web application integrates with external services or APIs, testing should ensure smooth data exchange and communication with third-party systems.
Scalability Risks:
- Explanation: As user traffic grows, the application may struggle to handle increased loads. Scalability testing assesses the application's ability to scale up effectively.
Accessibility Risks:
- Explanation: The application should be accessible to users with disabilities. Accessibility testing checks for compliance with accessibility standards, such as WCAG.
Regulatory and Compliance Risks:
- Explanation: Failure to adhere to industry-specific regulations or compliance standards can result in legal issues. Testing should ensure compliance with relevant regulations.
Dependency Risks:
- Explanation: If the application relies on third-party libraries or services, disruptions or changes in those dependencies can affect functionality. Dependency testing verifies their reliability.
Load Risks:
- Explanation: Unexpected spikes in user traffic can stress the application and cause performance issues. Load testing simulates high loads to assess the application's resilience.
Update and Maintenance Risks:
- Explanation: Updates, patches, or maintenance activities can introduce new bugs or disrupt existing functionality. Regression testing should validate changes without causing regressions.
Data Privacy Risks:
- Explanation: Mishandling of user data or non-compliance with data protection laws can lead to legal and reputational issues. Data privacy testing ensures data is handled securely.
Network Risks:
- Explanation: Unstable or slow network connections can impact the application's performance. Network testing simulates different network conditions to assess resilience.
User Load Risks:
- Explanation: Excessive concurrent users can strain the application's resources. Stress testing identifies performance bottlenecks under heavy user loads.
Backup and Recovery Risks:
- Explanation: In case of system failures or data loss, the application should have robust backup and recovery mechanisms. Testing ensures these processes are effective.

Including these risk factors and their explanations in your test plan will help ensure comprehensive testing and risk mitigation for your web-based application.

4.Quality Assurance (QA) focuses on processes and activities that ensure quality is built into the product or service from the beginning. It's proactive and preventive in nature. QA involves defining quality standards, implementing best practices, and creating processes to prevent defects.

Answer: Quality Control (QC), on the other hand, is concerned with inspecting and testing the actual products or services to identify defects. It's a reactive approach aimed at finding and fixing issues after they have occurred. QC activities include product inspections, testing, and verification against established standards.

In summary, QA is about preventing defects through process improvement, while QC is about detecting and addressing defects in the final product. Both are important for delivering a high-quality end result.

5.what is difference between Manual Testing and Automation Testing?
Answer: The difference between Manual testing and automation testing is that in manual Testing, you perform the tests step by step without the help of the tools, where as in automated Testing, tests are executed automatically using automation tools and Framework.

Test case design Techniques

Seshanth Rakesh — Mon, 18 Sep 2023 11:36:28 +0000

Q1. You are testing a form that allows users to schedule appointment with a doctor. The form has the following field: first name , last name ,email, phone number and appointment time /date. Some more inputs:

1 If any field is blank, we should display “ All fields are required”

ANS: Decision table

2 If the email is invalid, we should display “Please enter a valid email”

ANS: State transition

3 if the phone number is invalid, we should display “please enter valid phone number”

ANS: State transition , Boundary value analysis (BVA)

4 If the appointment date/time is not available, it should display “Please choose another date/time”

ANS: State transition

5 If all fields are correct and the appointment is available, we should schedule the appointment successfully.

ANS: State transition

For there requirements write down the correct list of conditions in form of decision table.

Q2. Suppose you are software testing and you are assigned to test a new mobile app that has just been developed. The app has three different user roles: basic user, premium user, and admin user. You have been given the following three test scenarios to execute.

· Basic users can only access limited features of the app, while premium users can access all features. Admin users have access to advanced setting and can perform all actions.

ANS: Application is loaded and network is connected

Basic user , Premium user and Admin is able to logging

Basic user ,check access the limited features -> TEST PASS

Basic user, check access the all features -> TEST FAIL

Basic user, check access the all advance setting -> TEST FAIL

Premium user, check access the all features -> TEST PASS

Premium user, check access the all advance setting -> TEST FAIL

Admin user, check access the all features-> TEST PASS

Admin user, check access the all advance setting-> TEST PASS

· Users should be able to create and delete their accounts successfully. Passwords must meet the required complexity standards and users should receive a confirmation email upon successful account creation.

Ans: Check with the creation of account -> TEST PASS

Check the successful message for the account creation-> TEST PASS

Check the password with complexity standers-> TEST PASS

Check with simple password-> TEST FAIL

· User should be able to navigate through the app seamlessly without any crashes or performance issues. The app should also display appropriate error messages when a user attempts to perform an action they are not authorized to perform.

Ans: Check with user can navigate to the permitted access area ->TEST PASS

Check with can user navigate to all access area ->ERROR MASSEGE

For each of the test scenarios, describe the steps you would take to test them and the expected results.

Agile Methodologies

Seshanth Rakesh — Sun, 03 Sep 2023 10:43:50 +0000

1a.what ia difference between smoke testing & sanitry Testing?
Smoke testing is done to assure that the acute functionalities of program is working fine. Sanity testing is done to check the bugs have been fixed after the build. Smoke testing is also called subset of acceptance testing. Sanity testing is also called subset of regression testing.

1b.what is difference between verification and validation?
Verification is a process of determining if the software is designed and developed as per the specified requirements. Validation is the process of checking if the software (end product) has met the client's true needs and expectations.

The Agile methodology is a project management approach that involves breaking the project into phases and emphasizes continuous collaboration and improvement. Teams follow a cycle of planning, executing, and evaluating.

Explain about Agile methodologies? Agile methodology is a project management approach that involves breaking the project into phases and emphasizes continuous collaboration and improvement. Teams follow a cycle of planning, executing, and evaluating.

3.Explain about Epic and User Stories?
Stories, also called “user stories,” are short requirements or requests written from the perspective of an end user. Epics are large bodies of work that can be broken down into a number of smaller tasks (called stories). Initiatives are collections of epics that drive toward a common goal.

Testing Methodologies & SDLC

Seshanth Rakesh — Sun, 03 Sep 2023 09:50:56 +0000

1.what is different types of Testing:
1.Smoke Testing.
2.Integration Testing.
3.System Testing.
4.Unit Testing.
5.Regression Testing.
6.performance Testing.
7.User Acceptance Testing
8.Security Testing.
9.Acceptance Testing.
10.Functional Testing.

2.what are the different STLC phases?
Phases of STLC:
Requirement Analysis.
Test Planning.
Test case Development.
Test Environment Setup.
Test Execution.
Test Closure.

3.As an manual tester, what qualities to you possess ?provide examples to illustrate your points
positive Attitude
Good communication.
Multi-Tasking Abilities
Quick Leaner.
Passion for Testing
Team Player
Think and Act As and End-User.
Analytical Abilities

4.What is the difference between Waterfall and agile Methodologies in
The main difference is that waterfall is a linear system of working that requires the team to complete each project phases before moving on to next one while Agile encourages the team to work simultaneously on the different phases of the project.