by admin | Sep 22, 2021 | Automation Testing, Blog, Latest Post |
During the early days, record and play was popular to create automation scripts. However, in the modern era, it goes without saying that you have to be highly skilled in test automation scripting. Some automation testing tools claim that it supports code-less automation. But in reality, there is no substantial fact to prove that code-less automation is a game-changer and that no coding knowledge is required to create test automation scripts. In this blog article, you will learn why coding skills are a key to kick start your test automation career and what are all the coding concepts you should know to begin with.
JavaScript & HTML Basics
Basic knowledge in JavaScript and HTML is a must-have skill for any automation tester. If you have sufficient knowledge about a web element’s HTML tag & attributes, and its associated JavaScript events, you can create a robust automation test script.
Let’s say you want to fill a date using the calendar field, there is no need for you to automate the date selection in the calendar field. Rather, you can fill the date directly using the Selenium JavaScriptExecutor instead of writing complex code snippets.
In addition to that, you should also know what the HTML DOM tree structure is, and how the page components are divided using DIV tags. So it is evident here that basic knowledge in JavaScript and HTML is very crucial when you are at the budding stages of your test automation career.
Object-Oriented Programming
We know for a fact that it is not possible to create an automation test script without a class. So it is mandatory for you to know the below-mentioned object-oriented programming concepts prior to starting your test automation career.
– Constructor
– Object Creation
– Method Overloading & Overriding
– Inheritance
– Getters & Setters
As a leading automation test company, we make sure we provide the best in class programming and tool level training to all our resources before they are inducted into any project. Make sure you pour your heart and soul into the process as it is vital for you to know the real purpose of each concept and how it is implemented in test automation while learning object-oriented programming. One of the best sources to learn OOPS concepts is the multiple GitHub projects which are public. You will be able to learn how OOPS concepts are used in test automation and fly high in your test automation career.
Coding Design Patterns
Page Object Pattern is a fundamental part of programming that every test automation engineer will know about. However, there are a lot of other coding design patterns which you can use in test automation to avoid boilerplate codes.
Singleton Pattern
When it comes to test automation, you can use the Singleton pattern for DB connections. Once a DB connection is established for query execution, there will be no need for you to open a new DB connection to execute another query if you use the Singleton pattern.
Factory Pattern
Factory Pattern allows you to create an object from one of the several possible classes that share a common superclass. By following this pattern, you can hide the instantiation logic and avoid writing complex logic inside the ‘if else’ blocks.
Strategy Pattern
Using the Strategy pattern, you will be able to implement the methods’ logic of multiple classes that share a common interface and objective and call the methods in one place instead of calling all the implemented methods of the classes for different logics in multiple places.
Dependency Injection
There will be a need to create multiple page object classes for test automation. If you want to create objects for the page object classes only once and serve the created objects in all the tests, then you need to know how to set up the Dependency Injection pattern in your Framework.
Though Test Automation Design patterns are advanced concepts, you should at least know the basics of them before starting your test automation career.
Exception Handling
You have to keep in mind the fact that you will never handle exceptions in your automated tests. The reason behind it is that if a script throws an exception, it will be marked as a failure and the exception details will be required for troubleshooting. However, if you get into the framework and other automation library development, you have to catch exceptions because libraries are not tests. So make sure to avoid unwanted exceptions. It would be better if you report them in log files that are related to test automation frameworks.
Assertion Libraries
Assertions are important to report whether an automated test case has passed or not. There are several assertion libraries available in the market and so you should learn how to use assertions in your tests. Apart from that, you should also know that assertion chaining allows you to write complex validations in a single readable line.
Conclusion
As an Automation Testing Services Company, we train our resources in all the aspects of coding in order to create robust test automation scripts and frameworks. As stated earlier, even with the introduction of tools that claim codeless automation, there is just no path to automation without coding. Simply put, you can’t ignore coding and do automation testing as coding will have a huge impact on your test automation career.
by admin | Sep 20, 2021 | Automation Testing, Blog, Latest Post |
Nowadays we cover all the functional tests in automation using Selenium and Appium tools. But the question here is, are we doing the Automated GUI Testing right? We would definitely check whether a button is clicked or not. But we might fail to check whether CSS has been applied as excepted and if the button is displayed to the end-user as per the design.
Let’s say an e-commerce website has an ‘Add to Cart’ button that is blue in color and the font is white in color. But what if the font color is also made blue by mistake? The result would be a button that seems to be empty despite having the text. The more serious underlying issue here is that the end-user will have difficulty in making a purchase as they will not be able to find the ‘Add to Cart’ button. In this case, the automation test script will pass even though the issue is a huge business concern that will lead to financial loss.
Another example is having a button that is too small and inconvenient for touch action on mobile devices. These type of issues can’t be spotted until it is tested manually. So, in this blog article, we will be taking a look at how to get automated GUI testing right.
Layout Testing
The above-discussed roadblocks and topics of concern can be overcome if we had the option to check the layout of the GUI elements.
Galen Framework is a great option that will fulfill this need of ours as it enables us to check both the size and alignment of GUI elements on multiple browsers and devices. .spec is the file format of the Galen script and you can write the scripts using the Galen spec language. Specs files can be triggered for execution from JavaScript and Java as well.
Galen is an open-source project. It even lets us perform Selenium actions in order to perform some functionalities on GUI and view certain page components. Parameterization is a critical feature for any test automation framework, and Galen supports parameterization in data tables. We will be able to tag the data table inside the spec file.
Grouping the tests and running a group test using its tag is a must-have feature. We know for a fact that we will not run all the tests in one go every time. Moreover, if you don’t group the tests, the test output (HTML Report) will list all the executed tests in one group instead of showing a segregated output. So it becomes a cumbersome task for an automation tester to analyze the report. Galen also supports mutation testing.
As an automation software testing company, we have used Galen in many of our automation testing projects and detected many responsive and GUI-related issues that would have been overlooked without Galen.
Visual Testing
Visual testing is another viable option we can opt for to detect many UI issues. But what is visual testing? Storing the baseline screenshots of web pages, and capturing the actual images again to compare them with the baseline images is called Visual Testing. As stated earlier, when a Selenium script is used to click a button, the script does not confirm whether the button is displayed as per the design. However, if you compare the web page screenshots, you will unearth many UI issues and have enough time to solve them.
Menu Touring
Menu touring is a type of visual testing and it is exactly what the name suggests it to be. We will write scripts to navigate all the pages from the main menu and all the other available links as well. Once the page is loaded, we can take a screenshot and compare the screenshot with the baseline image. As one of the leading software test automation companies, we set up a menu touring automated test suites as visual smoke tests for our clients. So with the feedback from both the Automated Function Regression testing and Visual regression testing, your team will be able to deploy the application confidently.
Tools for Visual Testing
It is very much possible to create Visual regression test suites without the aid or usage of any visual testing tool. All you would need to know is how to navigate to different web pages/mobile screens and compare the screenshots. However, there are some tools available in the market which are specifically developed for the purpose of visual testing alone and they can come in handy.
Applitools
One can say that Applitools is a quite sophisticated visual testing tool as it supports over 50+ frameworks and languages. Using it you will be able to write tests for web, mobile, desktop, IoT, AR, and even VR apps.
Percy
Once you have written the tests using the above tool, the other aspect is comparing the screenshots and that is where Percy comes into the picture. It can be used to compare the screenshot against the baseline image. You can even run the tests with different responsive widths and even across different browsers.
Functional testing alone is not sufficient. Visual testing is a must to identity GUI issues that could go overlooked during functional testing. So pick the right visual testing tool which fits well with your existing CI/CD pipeline. If a tool is a good fit for your requirement, go ahead and use it instead of reinventing the wheel. Implementing and managing custom frameworks for visual testing is an overhead that should be avoided. As a tester, you must focus on being able to provide quick and accurate feedback at regular intervals. So leave the visual testing to the tool as your job is to create the scripts.
Conclusion
Automated GUI testing is instrumental in deploying your website/apps with the utmost confidence. GUI issues have the potential to bring down your business’ reputation at first sight even before your product has a chance to win the customer over with its functionality. So make sure to catch the GUI issues before they are reported by end-users.
by admin | Sep 20, 2021 | Automation Testing, Blog, Latest Post |
Programming language for automation testing should never be chosen based on popularity. There are several factors involved in choosing the best programming language for Test Automation. While some may prefer an option based on the testing team’s skillset, some teams go with the programming language which was used to develop the application to be tested. Are these factors alone enough? Let’s find out as we will be exploring the factors to consider when choosing a suitable programming language for your automation testing needs.
What programming language is best fit for test automation?
We, as an automation testing company have faced this question multiple times from our clients during sales calls. But imagine if this same question is asked to a Ruby programmer, the obvious answer will be “Ruby is an excellent programming language that will satisfy all your needs”. We shouldn’t be surprised with this answer as a person who has been using Ruby for a while will seem to feel that way.
But if we take a closer look at the reality, we will understand that the Ruby, Cucumber, and Selenium combination was very popular among automation testers a decade ago. The lack of community support and the emergence of other programming languages have resulted in Ruby losing its popularity. However, if you use Ruby even now, you will still love it as the aspects that made Ruby great are still there. It’s just the popularity that has gone down and that in no way makes a great language bad.
So let’s jump straight to the point and take a look at the factors an automation testing team should consider when choosing a programming language for automation testing:
1. The Automation Tools in use
If the automation testing tool you’re using is the right fit but supports only a few programming languages, then you would be left without much choice as you would have to choose from the languages that are supported.
The Common factor
There could be times where the programming language used during the development stages would also be supported by the test automation tool and have a lot of test automation libraries that you can benefit from. During such scenarios, it is better to opt for that language.
Your Forte
Everybody has their own strengths and weaknesses. So if your company or team has testers with a specific programming background and the tool also has good community support for the language, you can go for that programming language.
Checklist
Performing this action will definitely help you make a more educated choice that fits your needs. You would have to prepare a checklist of the valid reasons that would justify the choice of not just the programming language, but also of the automation tool. So what you would have in your hand is a report of whether you are taking a biased decision or a decision with the mindset that is unwilling to go out of your comfort zone. Be very point-blank with your justifications to get the best results.
Now let’s go over some of the popular programming languages we have used thus far in our automation testing projects. But more importantly, we will also be seeing what made the language popular and thereby help you have a better insight when making that choice for yourself.
Java
When Selenium and Appium emerged in the market, the trend to write automation tests using Java also picked up. If you go to any Selenium tutorial page right now, you will be able to see the examples using Java in the very beginning. Maven and Gradle are two major value-adds for Java as you will be able to develop some unique test automation framework features using Java if you know the design patterns and Maven capabilities. It is also fairly easy to find an automation tester who is knowledgeable in the Java, Selenium, and Appium combinations.
Python
According to a report, in the year 2020, 29% of the tutorials that were searched for was for Python and 19% for Java. Python’s popularity explosion was very quick and the stats are a clear reflection of that fact. But that alone doesn’t make Python one of the best programming languages for test automation. We, as a software testing company, have started recommending Python to our clients as the support for the tool, the libraries for automation testing, and the talents from different regions also grew in tandem with its popularity.
JavaScript
JavaScript was originally introduced for client-side programming. No one even thought about using it for server-side until Node.js came into the picture. To adopt a programming language for automation testing, it should have a package manager which allows to upload & download the test automation libraries and the automation tool should have 100% support for the language. When Node.js and npm were launched, JavaScript got the package manager it needed and gained more popularity.
C#
When Microsoft made the .net framework open-source with (.net core), it enabled the support for Linux & macOS. This is turn resulted in C#’s popularity shooting up drastically. Nowadays C# is used widely for the development of Desktop and Gaming Apps. If your team is using C# for application development, then C# is a great choice for automation testing as well.
Conclusion
You can’t choose a programming language for automation testing by others’ opinion, and that goes for our opinion as well. As a leading QA Automation Services provider, we use Python, C#, Java for multiple automation testing projects. But we do not pick them at random as every project has its own requirement. We never fail to perform the evaluation using the checklist to pick both the automation tool and the programming language.
by admin | Aug 31, 2021 | Automation Testing, Blog, Latest Post |
We live in an era where instant gratification is wanted by each customer that buys a product or service. Knowing this, it is critical that businesses keep up with their customers’ expectations to prevent losing sales and customers to their business rivals. To do this, it is a must that companies administer continuous testing to their software to ensure that it will always be up to par with what customers expect.
However, getting started with continuous testing may not be something that comes naturally to everyone. Plus, even if you do get the ball rolling for your continuous testing for your software development processes, you may still face some significant roadblocks. This blog post will shed some light on what these possible challenges may be and how to deal with them.
Major Roadblocks of Continous Testing: What You Can Do
There are three major roadblocks that may hinder the development of the software that you offer. Overcoming these challenges is the key to ensuring that you keep your clients happy and satisfied in the long run.
1 – Bottlenecks Caused by Time and Resource Restrictions
Many times, the time and resources that are needed to complete sustainable development and test automation are underestimated. This being said, testing may come to a halt if these considerations are not thought of beforehand.
What You Can Do: Before getting started, it is vital to establish a testing agenda that supports reuse and data-driven testing. It is also critical that the testing team keeps individual test results up to date with the improvements being made to the software.
2 – Complexity
It can be extremely easy to get lost in the technical complexity of the test automation process. This task requires a vast amount of technical knowledge to be done correctly.
What You Can Do: To ensure that a team overcomes this roadblock, they need to understand how to automate the testing process and connect the data and results across different technologies. An in-depth understanding of these processes will help weed out critical defects and reduce complexities while undergoing continuous testing.
3 – Addressing the Results
As the continuous testing process goes on, there will come a time where there an immense amount of results will be produced. These results will render an extremely high amount of false positives. Looking into and analyzing these results may become tedious and highly time-consuming for the testing team.
What You Can Do: It may take time, but it pays to look into each result and take each one into consideration when making a release decision about your application or software products.
Conclusion
It is often said that we are now living in the Digital Age. It is getting more and more difficult to please clients. Producing state-of-the-art software that is cutting edge enough to satisfy your clients can only be done when you continually improve your products. Following the tips mentioned above and working with a reliable, tried-and-tested QA team will help you make sure that your software is always at the top of its game.
Should you need help in test automation services for your software, Codoid is an industry leader in QA. We don’t say this just to brag; we say this because it is our passion to help guide and lead the Quality Assurance community. Our brilliant team of engineers love to attend and speak at: software testing meetup groups, forums, Software Quality Assurance events, and Automation testing conferences. Contact us and let us help you test your applications today!
by admin | Aug 30, 2021 | Automation Testing, Blog, Latest Post |
Nowadays Appium is being prominently used for identifying Xpath or locators in both Android and iOS apps. But when it comes to iOS, we would have to spend a lot of time configuring the real device using Xcode for Building the WebDriverAgent. If in case we don’t have the latest iOS Version, iPhone Version, and Xcode version, then we will be facing configuration issues. This is where a cloud testing platform like BrowserStack comes into the picture as an easy solution and alternative to such problems. So if you were looking for the steps to use BrowserStack for inspecting a mobile app’s locators, then you’re in the right place. As a leading automation testing company, we have been using BrowserStack for a long time. So in this BrowserStack Tutorial, we will be showing you how to use BrowserStack as a UI inspector for both Android and iOS apps.
App Live
Make sure to install BrowserStack and keep it ready to do the following steps. If you are still on the fence about purchasing an account, you can still use their trial period to check out how well it fits your needs. So now let’s see how we can test our mobile apps and view the developer logs via DevTools and also identify the mobile elements using the ‘Inspect’ option in DevTools.
Navigate to App Live as shown in the image below,
Let’s a look at the 7 easy steps that have to be followed in this BrowserStack Tutorial now,
i. Click on ‘Test with a Sample app’ as shown in the image.
ii. Upload your App using the given option. If it’s an Android app then upload your apk file here, if it’s iOS, upload your ipa file here.
iii. Select the device you want to test the app in.
iv. Once you have chosen the Real Device that you want to test in, the App will launch.
v. You will get a split-screen view as you see in the below image.
vi. So you will see a pane on the right side that will show the following three options, LOGCAT, INSPECT (BETA), and NETWORK
vii. Now, click on the ‘Inspect’ option, and then click on the ‘Play Button’ that appears to enable Inspector mode.
Inspector Mode
Once we have turned the Inspector mode on by clicking on the Play icon, we will easily be able to identify the locators and objects. All you have to do is hover the mouse over the element that you want to inspect on the mobile screen, and click on it. Once you have clicked, the XML snippet and the element we have selected will be highlighted as shown in the image below.
Right below the code snippers, we will be able to see the ‘Properties Table’ as well.
Highlighted XML code snippet:
>android.widget.ViewGroup
>android.widget.TextView
Properties Table:
The table will show attributes, keys, and values like the Resource-Id, Class name, Package Name, Index, Visible Text, etc…
Example:
Text: Login
Resource-Id: org.package:id/headerLabel
Class: android.widget.TextView
Package: org.package.alpha
Conclusion:
So using BrowserStack as a UI inspector is a very easy process that every tester must know. BrowserStack’s UI inspector has come in handy whenever there was any locator or object issue in the automation suite. We were able to come up with quick fixes and provide the best automation testing services to our clients as we were able to easily identify the locators and objects using BrowserStack. That is why specifically chose to cover that in this BrowserStack Tutorial. If you are looking to learn more about BrowserStack, kindly read our End-to-End guide on it.
by admin | Aug 23, 2021 | Automation Testing, Blog, Latest Post |
Dependency Injection is a design pattern used to create dependent objects outside a class and provide those objects to a class through different ways by implementing Inversion of Control. Using Dependency Injection, we can move the creation and binding of the dependent objects outside of the class that depends on them. JVM-Cucumber supports many different dependency injection frameworks, and one of them is Guice. As a leading QA company, we are always on the watch for new tools and frameworks to improve our testing process and so we tested out Guice as well. So in this blog, we will be showing you how to perform Cucumber Dependency Injection Using Guice.
Cucumber Dependency Injection Using Guice:
If you’re going to work in an automation framework from scratch or use an existing one, there are few aspects that you should keep in your mind. For example, you have to ensure that the framework is maintainable, easy to understand, helpful in avoiding coding duplicates, and quick to adapt to any changes. Though these are very basic aspects of a framework, it does require you to follow a few design principles and techniques in it. First off, let’s see why sharing the state between steps in Cucumber-JVM is a necessity.
Well, a Gherkin scenario is created by steps and each step depends on previous steps. That is why we must be able to share the state between steps. Since the tests are implemented as regular Java methods in regular Java classes. If steps are global, then every step in the same package or subpackage relative to the runner will be found and executed. This allows us to define one step in one class and another step in another class.
If you’re writing your first test, then there are high chances that you have just a few steps that can easily be fit into one class. But the real problem arises when there are a bunch of scenarios as it gets exponentially harder to maintain. So that is why dividing the steps between many classes is a good idea.
How do you share the state between different classes for Cucumber-JVM?
The recommended solution in Java is to use dependency injection. That is, inject a common object in each class with steps, an object that is recreated every time a new scenario is executed.
Note – Object State sharing is only for steps and not for scenarios.
Let’s take a look at an example scenario and find out how to share the state between multiple step definition files with a common object.
Example Scenario:
* David Orders a mobile phone from Amazon.
* He receives a defective product.
* He returns the product and requests a replacement.
* Amazon replaces the defective product.
Now, let’s split this example into the Gherkin format.
Cucumber-Guice\src\test\resources\Demo.feature
Feature: Replace the product
Scenario: Defective product should be replaced if user requests for replacement.
Given David orders the mobile phone from Amazon
When He returns the product for replacement
Then He will get a new product from Amazon
The example scenario we have seen talks about two different actions,
1. Purchasing a product from Amazon.
2. Returning a product.
So when we divide the implementation of the steps into different classes, the only file that gets affected is the steps definition. This is where Dependency Injection comes into play as we can use it to overcome this obstacle. So let’s see how to get it done using Guice.
The first change here would be to add new dependencies in the Maven POM File.
This is the dependency for Cucumber to use Guice:
<dependency>
<groupId>info.cukes</groupId>
<artifactId>cucumber-guice</artifactId>
<version>1.2.5</version>
<scope>test</scope>
</dependency>
This dependency to use Google Guice:
<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>4.1.0</version>
<scope>test</scope>
</dependency>
Maven POM File:
This is how the Maven POM file will look like:
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>Cucumber-Guice</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<java.version>1.8</java.version>
<junit.version>4.12</junit.version>
<cucumber.version>1.2.5</cucumber.version>
<selenium.version>3.7.1</selenium.version>
<maven.compiler.source>1.6</maven.compiler.source>
<maven.compiler.target>1.6</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>22.0</version>
</dependency>
<dependency>
<groupId>info.cukes</groupId>
<artifactId>cucumber-guice</artifactId>
<version>${cucumber.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>4.1.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>info.cukes</groupId>
<artifactId>cucumber-java</artifactId>
<version>${cucumber.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>info.cukes</groupId>
<artifactId>cucumber-core</artifactId>
<version>${cucumber.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>info.cukes</groupId>
<artifactId>cucumber-junit</artifactId>
<version>${cucumber.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>${selenium.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-chrome-driver</artifactId>
<version>${selenium.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
The next step would be to create two classes for the steps. Let’s call them CustomerSteps and ProductSteps.
The idea here is that these classes will share state between steps that depend on the result of an earlier step in the scenario. It is known that sharing state can be done in different ways, and we have used a new class that holds the common data here.
Example:
src\test\java\DemoGuice\Steps\DemoCotainer.java
package DemoGuice.Steps;
import DemoGuice.Pages.ProductPage;
import DemoGuice.Pages.CustomerPage;
import cucumber.runtime.java.guice.ScenarioScoped;
@ScenarioScoped
public class DemoCotainer {
CustomerPage customerPage ;
ProductPage productPage;
}
In the above code, the democontainer class is annotated with @ScenarioScoped. So Guice will be able to acknowledge it as something that should be created and made available in different classes.
If we want to use this common data in each step definition file, we can add a constructor that takes the democontainer as an argument. This is where the injection occurs and so let’s take a look at an example to understand it better.
Example:
src\test\java\DemoGuice\Steps\ProductSteps.java
public class ProductSteps {
private DemoCotainer demoCotainer;
@Inject
public ProductSteps(DemoCotainer demoCotainer) {
this.demoCotainer = demoCotainer;
}
Now we can use the democontainer to access all of the common fields that are needed across the step definition classes. Here, we have annotated the field democontainer with @Inject. It is worth mentioning that you have the choice to annotate a constructor or a field to allow Guice to set the value. This enables the shared democontainer object to be available for all the steps definition classes.
Implementation of ProductSteps class:
src\test\java\DemoGuice\Steps\ProductSteps.java
package DemoGuice.Steps;
import com.google.inject.Inject;
import cucumber.api.java.en.Given;
import cucumber.api.java.en.Then;
import cucumber.api.java.en.When;
public class ProductSteps {
private DemoCotainer demoCotainer;
@Inject
public ProductSteps(DemoCotainer demoCotainer) {
this.demoCotainer = demoCotainer;
}
@Given("^David orders the mobile phone from Amazon$")
public void davidOrdersTheMobilePhoneFromAmazon() {
demoCotainer.productPage.orderMobilePhone();
}
@When("^He returns the product for replacement$")
public void heReturnsTheProductForReplacement() {
demoCotainer.productPage.requestForReturn();
}
}
Implementation of CustomerSteps class:
src\test\java\DemoGuice\Steps\CustomerSteps.java
package DemoGuice.Steps;
import com.google.inject.Inject;
import cucumber.api.java.en.Given;
import cucumber.api.java.en.Then;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
public class CustomerSteps {
@Inject
private DemoCotainer demoCotainer;
@Inject
public CustomerSteps(DemoCotainer demoCotainer) {
this.demoCotainer = demoCotainer;
}
@Then("^He will get new product from Amazon$")
public void heWillGetNewProductFromAmazon() {
demoCotainer.customerPage.receiveNewProduct();
}
}
Conclusion:
We hope you had an enjoyable read while also learning how to use Google Guice for performing cucumber dependency injection. Using Dependency Injection to organize our code better and share state between step definitions has been helpful in streamlining our process to provide the best automation testing services to all our clients. Make sure to stay connected with our blog for more informative blogs.
