rahulshettyacademy - Tumblr blog

rahulshettyacademy · 2 years

Text

Manual Testing Tutorial - Rahul Shetty Academy

A Learning Path is a selection of courses tied together for learners to progress through, mastering a particular subject or program. It allows you to enroll multiple users in multiple courses at once saving you valuable time.

SDET Automation Engineer – JAVA

If your language of interest is Java, then this is the path you can start from scratch to learn and excel in your QA Automation Career.

For 2-4 Year’s Experience QA Folk’s-

Core Java Basics with detailed understanding on OOPS Concepts.

Start with Selenium- Java UI Automation and understand how to automate Web applications.

Understand the API Core concepts with real use cases.

API Manual testing with various tools like Postman, Soap UI etc.

Basics of SQL.

For 3- 7 Years Experience -

After solid understanding on Selenium and API Testing, (Above 1- 5 points) Focus on Developing Test Automation Frameworks for Selenium and API Testing with Java using TestNG/Junit, Maven, Cucumber (You should work hard in this area for expertise)

Understand Mobile Automation Testing with Appium and ability to design Framework for Android and IOS Applications

At Rahul Shetty Academy You have a special learning Package which will make you java Automation expert on all above Skills from Scratch with real time use cases/Projects.

Below are the Courses included in Package

Free Software Testing Tutorial for Beginners

Core Java Tutorial

Selenium WebDriver with Java – Basics to Advanced + Frameworks

API Automation Testing with Rest Assured + Frameworks

Mobile Automation Testing with Appium + Frameworks

Java SDET Automation Interview Kit (Top 200+ Questions with explanations)

Purchase this Package as 1 Bundle and start Your preparation for Powerful JAVA -SDET Automation Engineer roles.

Software Quality Assurance Engineer

This Path should be chosen by the people who want to master all the core concepts of Software testing (Manual) with real time Projects.

Below are the Skills one should aware if they want to get into any QA Entry Roles or Switch their domain to QA Testing field

Experience – Freshers / 0 – 3 Year’s Experience :

What is Software Testing and its Principles?

How Testing happens in real time Projects. And day to day activities of the Tester

Complete Understanding on Manual Testing Concepts.

How Testing activities are Performed in Agile and Waterfall models.

Agile Scrum Terminologies and the Process followed.

Knowledge on Manual Test Management tools like Jira, Bugzilla, Quality Centre (ALM) etc.,

What are Webservices and understand the core concepts of WebServices and Rest API testing?

SQL Basics and thorough knowledge on SQL Syntaxes to interact with databases.

Identify Security flaws in applications with Security testing skills.

At Rahul Shetty Academy We have a special learning Package which will make you expert on all above Skills from Scratch with real time use cases/Projects.

Below are the Courses included in Package

Master Software Testing from Scratch with real time Examples

Understand the Jira and Agile Scrum

Learn SQL from Scratch

Web Security Testing essentials

WebServices/API Testing with SoapUI + Real time Projects

Purchase this Package as 1 Bundle and start Your preparation to emerge as QA Engineer with Strong foundation.

#Manual Testing Tutorial - Rahul Shetty Academy

0 notes

rahulshettyacademy · 2 years

Photo

Selenium WebDriver Courses Online

#Selenium WebDriver Courses Online Testing Certification Training Course Selenium Python Tutorial For Beginners

0 notes

rahulshettyacademy · 2 years

Text

Selenium Design Patterns/Best Practices for Framework Design

Nothing is Impossible. It all depends on how we are Trained on it!

Teaching is my Passion. And it's my Profession. The only Business I know is Spreading the Knowledge

"Every software Professional have a desire to learn latest IT courses which are trending in the Market but somehow 90% of them are giving up their thoughts

It's not due to the lack of courses available in the market, but it's about finding the right Mentor who can guide, teach and understand student's pulse with their background education"

So to full fill all these Gaps, I have established a "Testing school" a few years ago, And after successful completion of more than 300 offline Training batches. I am finally here at Rahul Shetty Academy.com to share all my 13 Years of IT Experience Knowledge to QA Colleagues and Students

And you know?? Already 1,00,000 Happy Students are taking advantage of my courses on various platforms with overwhelmed responses

Below is the course I teach here on this platform and many more on the way!

For Web Automation Testing : 1. Selenium Tutorial - In Java and Python 2. Protractor Tutorial - Java Script Automation for Angular 3. Selenium- Frameworks 4. Cucumber Framework Tutorial

For Mobile Automation Testing 3. Appium Mobile Testing Tutorial

For API Automation Testing : 4. SoapUI API Automation 5. Rest API Automation

For Performance Testing: 6. Jmeter Tutorial

For complete QA Process: Software Testing comprehensive Tutorial

For Security and DataBase Testing : Web Security Testing tutorial SQL-Data Base Testing Tutorial

For Core Java- Complete Java for Automation Tutorial

Please note that All RAHUL SHETTY courses offer lifetime query support and we have a dedicated discussion board where you can post your questions. I will answer all of them in less than 24 hours.

#Selenium Certification Course Online

0 notes

rahulshettyacademy · 2 years

Photo

Welcome to Rahul Shetty Academy. We provide many services Best Cypressio Courses & Certification, Postman Tutorial for Beginners, Postman is one of the most popular software testing tools which is used for API testing. With the help of this tool, developers can easily create, test, share, and document APIs. For more information call us 3237446780.

#Cypressio Courses & Certification #Postman Tutorial for Beginners

0 notes

rahulshettyacademy · 2 years

Text

Selenium 4 Key features, What’s New!

Selenium is the most used automation tool in the market. The Selenium is constantly improving and changing as per market standards. Selenium 4 released with many useful features created hope in selenium testers. Those who were thinking that selenium has no future, the selenium 4 answered this by updating selenium with rich features, adopting functionality for modern web development testing.

There are many useful features in Selenium 4, we will look into that one by one.

Selenium 4 adopted the W3C standard protocol

Enhanced support for Selenium Grid

Selenium 4 IDE for record and playback

Relative Locators

Access to Chrome Developer Tool / Chrome DevTools Protocol (CDP)

Network Interception

Updated New Window/Tab Management options

Rich Actions class

Better Screenshot options

Improved Documentation

Selenium 4 W3C Protocol

The Protocol is very important to communicate between Webdriver and Browser, earlier this communication was made possible through JSON wire protocol, Selenium started implementing W3C protocol before Selenium 4 but with Selenium 4 the selenium fully supports W3C protocol standards. W3C Protocol makes cross-browser testing more efficient and stable. All the modern browsers support the W3C protocol. Though this is the major change with selenium 4, for users impact is less it made his job easier. Selenium provided detailed documentation on upgrading Selenium 4

Selenium IDE:- Selenium IDE existed earlier as well, but later it was removed due to Firefox add-on standardization. Selenium 4 re-introducing Selenium IDE. The Selenium IDE makes beginners' jobs easier, with Selenium IDE you can record the test and playback, No coding knowledge is required for this. The selenium IDE is provided as a browser add-on, it is available for all major browsers like Chrome, Firefox, etc.

Some of the Notable Features of Selenium 4 IDE are

The Selenium 4 has a complete revamp of the User Interface.

Multiple locator strategy, the Selenium 4 IDE records multiple locators so if one locator fails, it tries with another locator. Multiple locator strategy makes test scripts stable.

The test case can be reused, just like how you do re-use of common code in utility the same way you can re-use in Selenium IDE.

Control Flow supported. Using the if, while, and times command you can make tests more stable and stronger.

Extendable, Selenium 4 IDE commands can be extended. You can define your command. It helps you to get the most out of it.

Debugging Support, The Selenium 4 IDE comes with debugging support, you can set a breakpoint on IDE and run the tests, as soon as it hits the breakpoint, the execution stops and you can step over the command.

Control Execution Speed, Selenium 4 IDE allows you to control the execution speed, you can set execution speed fast, slow, medium, etc.

Logs are shown in the Log section which helps to understand and analyze the problem.

The project can be saved as .side extension and reuse for later.

Enhanced Support for Selenium Grid

Selenium Grid is used for scaling and distributing tests on different browsers and operating system combinations. Earlier, the Selenium Grid setup was complicated and it was time-consuming. Now, Selenium has extended its support for Docker containers, so rather than using a Virtual machine you can just set up docker and run your tests. Selenium Grid 4 is a fresh implementation.

Selenium Grid 4 comes with 3 advanced features

Observability: The Selenium Grid 4 observability features mainly focus on logs, metrics, traces. This helps to understand the internals of the system and debugging as well.

Grid End Points: The Grid endpoint feature mainly focuses on the Grid itself like availability, status, sessions, and slots.

GraphQL Query Support: GraphQL Query helps you to query with existing data. This makes API queries more powerful, users can ask and get what they want.

The Selenium Grid 4 helps to utilize the DevOps concept fully.

The relative locators make the test more stable and provide alternative options to locate the element. These relative locators work according to Visual Location of other elements, that means how elements appear visually on the browser considering other DOM elements.

Support for Chrome Debugging Tool:- The most awaited functionality is Chrome DevTools Tool Protocol. The Selenium 4 supports Chrome DevTools protocol, this functionality helps to access the Chrome Developer Tools and use them in your tests programmatically, with the Chrome DevTools Protocol one can control the browser itself as it provides the feature like device emulation, capturing logs, etc. Selenium has built the wrapper class called DevTools to support all the chrome devtools protocol functionalities. Selenium 4 also allows you to access the Chrome DevTools Protocol directly using method executeCdpCommand()

What is the difference between send() and executeCdpCommand ()?

The Selenium 4 introduced two major commands: send() and executeCdpCommand(). Both are used for interacting with Dev Tools.

send(): The selenium has written a wrapper to chrome devtools protocol, internally it makes the call to chrome devtools protocol commands, org.openqa.selenium.devtools package provides this option. Selenium has done this considering the future of this feature. Selenium might consider this for other browsers as well in the future. So the wrapper send() should be your first choice when you interact with dev tools.

executeCdpCommand(): The executeCdpCommand() method is available directly from ChromiumDriver, It doesn’t use any selenium wrapper.Only if you want to bypass selenium implementation of CDP commands then you should consider this. Since you are calling The executeCdpCommand() method it requires more work while sending parameters.

Enhanced Window/Tab Management in Selenium 4:- We must admit this, the modern automation framework is still struggling to provide features like automating New Window/ Tab scenarios, The Selenium has gone one step advanced, and providing new window API makes it simpler. Selenium 4 provides a new API called NewWindow which creates a new tab, new window, and Once it's created, Selenium automatically switches to New Tab/Window.

Improved Documents:- Though Selenium was popular, most of us relied on external documents and tutorials to learn and implement Selenium Tests. Selenium has improved documentation, the APIs, Commands are documented with their syntax, for example on all Selenium-supported languages.

The official website of selenium provides complete documentation of Selenium 4. The new website helps everyone, it eliminates a lot of confusion that pops up while writing test automation scripts.

Rich Actions Class:- The keyboard and mouse actions are performed using the Actions class. Complicated scenarios like drag and drop, click and hold, click on an element with Key combinations are some examples of Actions class usage. Selenium 4 has made some changes to the Actions class. In earlier versions, we were performing MoveToElement action before click, clickAndWait, etc. but with Selenium 4 you can simply use Click() method of the action class and it will MoveToElement and Click.

Full-Page Screenshot:- This functionality in Selenium 4 enables one to take a full-page screenshot. The getScreenshotAs() method is used with the driver instance to take a full-page screenshot.

Print Page Option:- The Print Page Option is available in Headless Chrome, Selenium framework provides PrintPage options, this prints the current page into PDF.

Network Interception:- Since Selenium 4 has enabled support for CDP, users can take advantage of this to capture performance metrics, limit the network bandwidth, block the URLs, etc. All modern automation testing frameworks provide this feature, The selenium is introduced now with Selenium 4. The Network Interception is an advanced feature, you can get control over all the requests. For example, if you want to block all the CSS files you can do so.

The Selenium is a long-lived automation framework, it has evolved a lot. Many players in the market entered and disappeared, the Selenium 4 release is a clear message to all of its users it’s not going to disappear any time soon. The selenium team also manages to add all the major features which are very much required for Modern web development. The selenium 4 release stopped some users from switching to modern frameworks.

The Rahul Shetty Academy provides world-class training cost-effectively, The training is planned considering beginners to advanced users. The Rahul Shetty Academy helps people to get updated with the latest technology and trends. The complete learning guide for testing courses even with many advanced tools are available in Rahul Shetty Academy.

#Selenium WebDriver Courses Online #Selenium Online Training Certification Course #Selenium Training Course #Selenium Certification Course Online #Selenium Online Training #Selenium Online Training Courses

0 notes

rahulshettyacademy · 2 years

Link

World class Tutorials on Selenium, Rest Assured, Protractor, SoapUI, Appium, Cypress, Jmeter, Cucumber, Jira and many more!

https://courses.rahulshettyacademy.com/courses

#Selenium WebDriver Courses Online

0 notes

rahulshettyacademy · 2 years

Text

Robotic Process Automation(RPA) using UIPATH

Robotic Process Automation is a game-changing technology that is designed to automate high-volume of repeatable Digital Computer tasks that take up a large percentage of a workers’ time

https://courses.rahulshettyacademy.com/p/robotic-process-automation-rpa-using-uipath-live-projects

#Selenium WebDriver Courses Online

0 notes

rahulshettyacademy · 2 years

Text

Software Testing: Test Design Techniques

In the last post, we discussed about the software testing, why testing is important, the testing principles, software testing levels and their types, the software testing life cycle, software development life cycle, the bug life cycle, and the static techniques. In the static techniques, we saw how we can perform testing by looking into the documents, and code but not executing the code. In this section, we will be looking into the testing done by executing the tests on the code running in the software.

The Test Development Process

Before executing the tests, we should know what we are testing, the inputs, the expected outputs and do we get ready for and run the tests. Test conditions are documented in test design specification and test cases are documented in a test case specification. Similarly, test procedures are documented in a test procedure specification (also known as test script or manual test script).

The formality of test documentation

Testing can vary from very formal to very informal. Very formal testing includes extensive documentation which is well-controlled and the document involves every detail of the tests including the set of inputs and the expected outputs. Very informal testing may not be documented, but the testers have to keep in mind the ideas, what they will test, and what possible outcome they are expecting.

The level of formality differs based on the organization, the people working over there, the culture, how mature the development process is, how mature the testing process is, etc.

Test analysis

Test analysis is the process of looking at something that can be used to derive the test information. This basis for the tests is called the test basis. Test basis can be system requirements, a technical specification, the code itself, or a business process. The tests, sometimes, can be based on an experienced user’s knowledge of the system, which may not be documented.

Test basis: All documents from which the requirements of a component or system can be inferred. The documentation on which the test cases are based.

If a document can be amended only by way of formal amendment procedure, then the test basis is called a frozen test basis.

Test basis is basically a documentation on which the test cases are based. It is the information to start the test analysis and creating our own test cases. Test basis documents can be used to understand what the system will do once built.

From a testing perspective, we look at the test basis to see what needs to be tested, the conditions are called test conditions.

Test condition: An item or event of the component or system that could be verified by one or more test cases, e.g. a function, transaction, feature, quality attribute or structural element.

A test condition is something that we could test. If we are looking to measure coverage of code decisions(branches), then the test basis would be the code itself, and the list of test conditions would be the decision outcomes (true or false). If we have a requirements specification, the table of contents can be our initial list of test conditions.

A good way to understand requirements better is to try to define tests to meet those requirements.

Since exhaustive testing (testing everything) is an impractical goal, we have to select a possible subset of all possible tests. Practically, the smallest subset may contain the highest number of defects. For guiding our selection of subsets, we need an intelligent thought process called test techniques.

A testing technique helps us to select a good set of tests from the total number of all possible sets for a given system. Different techniques offer different ways of looking at the software under test. Each technique provides a set of rules or guidelines for a tester to identify the test conditions and the test cases.

The test conditions we choose will depend upon the test strategy. Once we have identified the test conditions, prioritizing them is important, so that the most prior test conditions can be identified.

Test conditions should be able to link back to their sources on a test basis – this is called traceability.

Traceability can be either horizontal or vertical. It can be vertical through all the layers of development documentation, e.g., from requirements to components and horizontal through all the test documentation for a given test level, e.g., system testing, from test conditions through test cases to test scripts.

Why is traceability important?

Let’s look into some examples that will help us understand why we are focusing on traceability.

A set of tests that have run OK in the past has now started creating serious problems. What functionality do these tests actually exercise? Traceability between the tests and the requirement being tested enables the functions or features affected to be identified more easily.

Before delivering a new release, we want to know whether or not we have tested all of the specified requirements in the requirements specification. We have the list of the tests that have passed – was every requirement tested?

The requirements for a given function or feature have changed. Some of the fields now have different ranges that can be entered. Which tests were looking at those boundaries? They now need to be changed. How many tests will actually be affected by this change in the requirements? These questions can be answered easily if the requirements can easily be traced to the tests.

Now that we have prioritized our test conditions, we don’t want to spend time implementing the poor tests and we will be focusing more on the priority conditions.

Test design: Specifying test cases

Test design is basically an act of creating and writing test suites for testing software. Test analysis and identifying test conditions give us a general idea for testing, covering quite a range of possibilities.

When we need to make a test case, we need to be very specific. We need exact input specifications and not descriptions. Test conditions can be rather vague, covers quite a range of possibilities. A test case covers multiple conditions for specific detail.

A test case needs to have input values but just having some input values to a system is not a test. If we don’t know what the system is supposed to do with the inputs, we can’t tell whether our test has passed or failed.

Test cases can be formally documented as per the IEEE 829 standard for test documentation.

One of the most important aspects is that it checks that the system performs the same way it is supposed to perform. In order to know what the system should do, we need to have a source of information about the correct behavior of the system called an ‘oracle’ or a ‘test oracle’.

Once a given input value has been chosen, the tester needs to determine what the expected result would be and document them in the test case. Expected results include information according to an input but it also includes changes to data and/or states, and any other consequences of the test.

If we haven’t decided on the expected result before running the test, we can still look at what the system produces and would probably notice if something goes wrong.

Ideally, expected results should be run before the test is run and then the assessment whether the software passed or failed will be more objective.

For a few applications, it may not be possible to predict the expected results before running the software, in that case, we can only do a ‘reasonable check’. We have a ‘partial oracle’- we know something is wrong but would probably have to accept something that looked reasonable.

In addition to expected results, the test case also specifies the environment and other things that must be in place before the test can be run (the pre-conditions) and any things that should apply after the test completes (the post-conditions).

The test case should also say why it exists – i.e., the objective of the test or the traceability. Test cases need to be prioritized from high priority to low priority so that the execution is done accordingly.

Test cases need to be detailed so that we can accurately check the results and know that we have exactly the right response from the system.

Test implementation

The next step is to group the test cases in a sensible way for execution and order them in sequence in order to run the test. Some test cases may need to run in a sequence, else they won’t test what they are meant to test.

The document that describes the steps to be taken in running a set of tests and specifies the executable order of the tests is called a test procedure in IEEE 829 and is also known as a test script. When test Procedure Specification is prepared then it is implemented and is called Test implementation.

Test script is also used to describe the instructions to a test execution tool. An automation script is written in a programming language that the tool can understand. The tests that are intended to be run manually rather than using a test execution tool can be called as manual test script.

The test procedures, or test scripts, are then formed into a test execution schedule that specifies which procedures are to be run first – a kind of superscript.

The test schedule is when the given test should be run and by whom. The schedule could vary depending on newly perceived risks affecting the priority of a script that addresses that risk.

Categories of Test Design Technique

A test design technique basically helps us to select a good number of tests from the possible number of test cases for a system. There are mainly two types of testing techniques: static testing and dynamic testing. We have already learned in our previous article about static testing.

In this section, we are going to focus more on dynamic testing. Dynamic testing has three types:

Specification-based (black box test techniques or behavioral techniques)

Structure-based (white-box or structural techniques)

Experienced-based techniques.

Static testing techniques

These techniques do not execute code being examined and are used before any tests are executed on the software. Most static test techniques can be used to ‘test’ any form of document including source code, design documents, models, functional specifications and requirement specifications.

Static testing techniques have two types: Reviews and Static analysis. We have already seen these techniques in our last section which talked about Static Testing entirely.

Dynamic testing techniques

The testing is performed by executing the code and it has three types:

Specification-based (black-box) testing techniques

Black-box (specification-based) testing technique is a procedure to derive and/or select test cases based on an analysis of the specification, either functional or non-functional of a component or system without reference to its internal structure.

These are known as black-box or input/output driven testing technique because they view the software without any knowledge of how the system or component is structured. The tester concentrates on what the software does and not how the software does it. It focuses both on functional and non-functional testing.

Functional testing, as we know, is concerned with what the system does, its features and functions. On the other hand, non-functional testing is majorly concerned with how well the system performs.

Structure-based (white-box) testing techniques

Structure-based (white-box) test design technique is a procedure to derive and/or select test cases based on an analysis of the internal structure of a component or system.

These are called white-box or glass-box techniques as they require the knowledge of how the software is implemented, i.e., how it works. Structure-based testing techniques use the internal structure of the software to derive the test cases.

Experience-based testing techniques

Experience-based test design technique is a procedure to derive and/or select test cases based on the tester’s experience, knowledge and intuition.

In this technique, people’s knowledge, skills and background are important to the test conditions and test cases. The experience of both technical and business people is important as they bring a different perspective to the test analysis and design process.

An advantage of this technique could be the insights from the previous experiences with similar tests that what could go wrong, which is useful for the testing.

Where to apply the different testing techniques?

Black-box test techniques are applicable at all levels of testing wherever a specification exists. While performing system/ acceptance testing, the requirement specification or the functional specification may form the test basis. When it comes to component or integration testing, a design document or a low-level specification forms the basis of the tests.

White-box test techniques are also applicable at all levels of the testing. Developers use these techniques in the component and the component-integration testing levels, where there is good tool support for code coverage. These techniques are also used in system and acceptance testing levels, but the structures are different.

Experience-based test techniques are used to complement white-box and black-box test techniques and are also used when there is no specification, or if the specification is inadequate or out-of-date.

This is the only type of testing used for low risks systems, but this approach is useful under extreme time pressure.

Visit us: https://rahulshettyacademy.com/blog/index.php/2021/07/17/software-testing-test-design-techniques/

0 notes