Delve into designing a test automation framework using Java and Selenium. Learn about Selenium basics, TestNG, build management, logging, and reporting to automate web applications effectively.

ui-test.tar.gz

Java

TestNG

Bash

ui-test

ui-test-1

ui-test-frmk

ui-frmk

Testing the user interface for any application is generally time-consuming when done for each new release. UI test automation is the most common and effective way to simulate the actual user journey and business use-cases for any application.
In this course, you will learn how to design a test automation framework from scratch for automating any web-based application using Java, Selenium, and TestNG. You’ll start by learning the basics of Selenium and TestNG and then move on to learn about build management, logging, and reporting, which are key learnings for any QA engineer or developer. By the end of this course, you will have successfully created a UI test automation framework.

Design a Test Automation Framework with Selenium and Java

# What is AspectJ?

AspectJ is a seamless aspect-oriented extension to the Java programming language that enables clean modularization of crosscutting concerns, such as error checking and handling, synchronization, context-sensitive behavior, performance optimizations, monitoring and logging, debugging support, and multi-object protocols.

# How can we use AspectJ for automatic logging?
We can use `AspectJ` for automatically logging whenever we are performing assertions using `org.testng.Assert`(stops further execution of the test on failure) or `org.testng.asserts.SoftAssert`(continues test execution, irrespective of whether the assertions are passing or failing. At the completion of the test execution, TestNG will show all the occurred failures, if any).

This strategy can be applied to various other operations as well.

To know more about `AspectJ`, please follow the [link](https://www.eclipse.org/aspectj/doc/released/progguide/starting.html).

# Dependency

Apart from adding the dependency, we need to attach the dependency to javaagent also.

## Maven

```xml
<properties>
   <aspectj.version>1.9.5</aspectj.version>
</properties>


<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>${aspectj.version}</version>
</dependency>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
            <configuration>
                <testFailureIgnore>false</testFailureIgnore>
                <argLine>
                    -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
                </argLine>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>org.aspectj</groupId>
                    <artifactId>aspectjweaver</artifactId>
                    <version>${aspectj.version}</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

```

## Gradle

```
configurations {
    agent
}

dependencies {
    agent group: 'org.aspectj', name: 'aspectjweaver', version: '1.9.5'

}

test.doFirst {
    jvmArgs "-javaagent:${configurations.agent.singleFile}"
}
```

# Creating `@Aspect`

If we don't use `AspectJ`, we may have to explicitly log all the assertions and their arguments for debugging. 

The below `LoggerAspect` class shows how to automatically log all the assertions along with their arguments using `AspectJ`. 

You can think of `AspectJ` as an interceptor to help log certain methods (as given in the `@Pointcut` expression) automatically.

```java
package com.example;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;

@Aspect
public class LoggerAspect {

	private static final Logger LOG = LoggerFactory.getLogger(LoggerAspect.class);

	@Pointcut("execution(* org.testng.Assert.assert*(..))")
	public void assertMethod() {
	}

	@Pointcut("execution(* org.testng.asserts.SoftAssert.assert*(..))")
	public void softAssertMethod() {
	}

	@Around("assertMethod() || softAssertMethod()")
	public Object logAsserts(final ProceedingJoinPoint joinPoint) throws Throwable {
		final MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
		LOG.debug("assertions ::: calling {} with arguments {}", methodSignature.getMethod().getName(),
				java.util.Arrays.deepToString(joinPoint.getArgs()));
		return joinPoint.proceed();
	}
}
```

# Creating `aop-ajc.xml`

`aop-ajc.xml` is the configuration file that contains all the `@Aspect` classes to be used by the `AspectJ` library. Make sure `aop-ajc.xml` is present under `src/main/resources/META-INF` path.

```xml
<aspectj>
	<aspects>
		<aspect name="com.example.LoggerAspect" />
	</aspects>
</aspectj>
```

---

Now you are familiar with logging to console and file using Logback and automatically logging using AspectJ. In the next section, you’ll learn about reporting.

In this lesson, we will see how to use AspectJ for logging all assertions done using TestNG Assert and SoftAssert.

Introduction to UI Test Automation

Selenium WebDriver Basics

TestNG Framework

Build Management

Configuration Management

Logging

Reporting

Designing the UI Test Automation Framework

Sample UI Test Framework

Automatic Logging using Aspects

What is AspectJ? #