Test Automation Architecture

---

A test automation architecture is the organization and abstraction of test scripts, test data, and business logic.
An efficient test automation architecture is one that has all its layers loosely coupled and scalable. In this article, we'll understand the POM design pattern and its implementation.
The page functions and logic are abstracted from test scripts in POM, moreover, it is easy to maintain and scale. It is the application of different tools, methods, and techniques in an efficient way to accomplish varied testing goals.
In POM design pattern, we are treating every page as an object. Every page is an object and these objects are used in the corresponding test class.For every web page we create a java/class file for e.g.
there will be a java file for 'login' page, a separate java file for 'home' page, separate java file for 'about us' page and so on. A typical POM structure can be seen in the below image.
  In the page class, we declare the page elements present on that page as seen in the below image   Also write methods/functions/operations which we want to execute on that page for e.g. java file for login page contains methods/functions related to login functionality like entering username, entering password, clicking submit button, click forgot password link etc.
We just define these functions/operations in loginpage class. The calling of these functions happens in a separate java/class file which is nothing but our test file.
So in the page class we define the function, and in the test file we call those functions. In this way we separate out the test execution from the pages.
As can be seen in the above image, there is a class called loginPaga.java, and another test class called testLoginpage.java. This testLoginpage.java calls the functions defined in loginPaga.java.
Similarly there is homepage.java and its corresponding testHomePage.java and so on.Another important point to remember in POM is that in a page class if suppose clicking a button is redirecting to another page then we need to return object of that page when we perform this operation. For e.g.
if on the home page if clicking 'aboutus' link is redirecting to 'Aboutus' page then we have to return the object of 'Aboutus' page in the method written in homepage for clicking 'aboutus' link. The method written in homepage.java should be like this-public aboutusPage clickonAboutUs(){Webdriver code;return new aboutus;}     This way, the constructor of resulting page gets triggered and page elements and webdriver of subMenuPage gets initialized.
  What does this mean by independent test cases? This means every test case can run independently and there is no dependency on another test case. To achieve this, you need to run preconditions of that particular test case in @BeforeMethod annotation.
A typical structure of a test class is as seen in the below image. There are preconditions defined under @BeforeMethod annotation.
The code under @BeforeMethod annotation will run before the test case execution. This way you can execute preconditions of a test case before the actual execution of the test case.
For e.g. you want to validate "My Account" section of Amazon and under my account to want to validate "your orders" etc.
But before reaching "My account" section you first need to login to your amazon account.So "login" to amazon account will be one of the preconditions of your "My Account" section test case. The below image depicts an example of a product detail page of the Flipkart app where the test case for adding a product to cart is defined under @Test annotation.
But before adding a product to the cart, the product must be first selected from the home page's main category and then final selection from sub menu page's.So category selection from homepage and then product selection from sub menu page are two preconditions before adding a product to the cart.So whenever we run testAddToCart test case, the preconditions will execute before the test case. These preconditions are nothing but previous or predecessor test cases that might have already executed in their respective test classes.
  When we execute our testng.xml file where our test classes are mapped. The testng.xml triggers the respective test class defined in it.
This test class creates an object of its respective page class and call methods or operations defined under the page class. Once the object of a page class is created, its constructor gets called and all the web components and web driver belonging to that page get initialized.
Whenever such an operation is called from the test class which results in navigation to another page, another page's constructor gets called and web components and web driver belonging to the resulting page gets initialized. In this way a typical page object model design pattern works.
Source: Free Articles from ArticlesFactory.com This is Jayesh Jamindar, but I'm more often called as JJ. I'm the owner, author, and developer of techno-geeks.co.in.After completing more than a decade in the software industry, I decided to come up with techno-geeks.co.in with an intent to give quality, classified and organized learning materials to my fellow IT folks.
I've decided to share my learnings and journey over these years to my fellow professionals and students who are about to venture into the industry. The idea is to share my learnings, challenges, roadblocks, and strategy to overcome.In my current professional capacity, I'm overseeing development and testing operations as an SDET.
 .