In this tutorial, we will discuss the Docker, Docker Desktop and how to install Docker Desktop on the Windows 11.

Table of Contents

What is Docker?

Docker is an open platform for developing, shipping, and running applications using the containers. Docker enables us to separate the applications from the infrastructure so we can deliver software quickly. With Docker, we can manage your infrastructure in the same ways you manage your applications.

Containers are lightweight, portable, and self-sufficient units that package an application and its dependencies, ensuring consistency across different environments.

The current image has no alternative text. The file name is: image-34.png

What is Docker Desktop?

Docker Desktop is a one-click-install application for your Mac, Linux, or Windows environment that lets you build, share, and run containerized applications and microservices.

It provides a straightforward GUI (Graphical User Interface) that lets you manage your containers, applications, and images directly from your machine.

Before installing Docker on Windows 10 or 11, ensure your system meets the following requirements:

Windows 10 64-bit: Build 18362 or higher
Windows 11 64-bit
Hardware Virtualization Technology (VT-x) enabled in BIOS
Microsoft Hyper-V and Containers features enabled

How to verify WSL is installed?

Windows Subsystem for Linux (WSL) 2 is a prerequisite for Docker Desktop on Windows. It provides a lightweight Linux kernel for compatibility and performance improvements.

wsl --version

The output of the above command should display the version of wsl installed on the machine.

Open PowerShell as Administrator and run:

wsl --install

Restart the computer if prompted.

Install Docker Desktop

On the Docker download page, select “Windows” as your operating system.

The download will begin automatically. The duration will depend on your internet speed.

After installation, open Docker Desktop.

After clicking “OK,” the installation will start.

After installation completes, it will show a confirmation screen.

Create an account for Docker Desktop.

Once we will create the account, we will login and see that the Docker Engine is stopped.

Go to the settings and select “Start Docker Desktop when sign in to your computer.”. This is optional.

Go to the bottom tray and right click on the Desktop option.

It will show below mentioned options. Select “Quit Docker Desktop”.

Start Docker Desktop

Docker Desktop does not start automatically after installation. To start Docker Desktop:

Search for Docker, and select Docker Desktop in the search results.

The Docker menu displays the Docker Subscription Service Agreement. Select Accept to continue. Docker Desktop starts after you accept the terms.

Note that Docker Desktop won’t run if you do not agree to the terms. You can choose to accept the terms at a later date by opening Docker Desktop.

How to verify successful docker installation

Open a command prompt or PowerShell window.

Using the following command check the docker version for verifying the installation.

docker --version

Pull a sample image, such as Nginx, using the following command:

 docker pull nginx

If the image pulls successfully, Docker Desktop has been installed correctly

TroubleShooting

The error you’re seeing indicates that Docker is unable to authenticate when trying to pull the NGINX image from Docker Hub

Use the below command to login to docker

 docker login -u my-user-name (using real username)

We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

November 29, 2023 vibssingh

How to split log files based on size in Log4j 2?

HOME

In the previous tutorial, we got an introduction to Log4j 2. In this tutorial, we will see the process of splitting a log file on size in Log4j 2.

Table of Contents

Prerequisite

Java installed
Maven installed
TestNG installed

Dependency List

Java -17
Selenium – 4.15.0
TestNG – 7.8.0
Maven – 3.8.1
Log4j – 3.0.0-alpha1

Implementation Steps

Step 1 – Create a new Maven Project

You can use any IDE or text editor that supports Java.

Step 2- Add the dependencies to the POM.xml

Add the log4j library to your project.

<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>com.example</groupId>
  <artifactId>Log4j2_Demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>Log4j2_Demo</name>
  <url>http://maven.apache.org</url>

  <properties>
    <selenium.version>4.15.0</selenium.version>
    <testng.version>7.8.0</testng.version>
    <log4j.version>3.0.0-alpha1</log4j.version>
    <maven.compiler.version>3.11.0</maven.compiler.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.surefire.failsafe.version>3.1.2</maven.surefire.failsafe.version>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
  </properties>

  <dependencies>

    <!-- TestNG Dependency -->
    <dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>${testng.version}</version>
      <scope>test</scope>
    </dependency>


    <!-- Log4j Dependency -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>${log4j.version}</version>
    </dependency>

    <!-- Selenium Dependency -->
    <dependency>
      <groupId>org.seleniumhq.selenium</groupId>
      <artifactId>selenium-java</artifactId>
      <version>${selenium.version}</version>
    </dependency>

  </dependencies>

  <build>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${maven.surefire.failsafe.version}</version>
        <configuration>
          <skipTests>false</skipTests>
          <skip>false</skip>
          <testFailureIgnore>true</testFailureIgnore>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.version}</version>
        <configuration>
          <source>${maven.compiler.source}</source>
          <target>${maven.compiler.target}</target>
          <fork>true</fork>
        </configuration>
      </plugin>
    </plugins>

  </build>

</project>

Step 3- Create the log4j2.xml configuration file

Create a resource folder in src/java named as resources.

Create the log4j2.xml configuration file in src/java/resources.

The log4j configuration file specifies how log4j should log information.

Here is an example of a simple log4j configuration file:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="LogToConsole" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
        <RollingFile name="LogToRollingFile" fileName="logs/application.log"
                     filePattern="logs/%d{YYYY-MM}/application.%d{dd-MMM}-%i.log.gz">
            <PatternLayout>
                <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
            </PatternLayout>
            <Policies>
                <TimeBasedTriggeringPolicy />
                <SizeBasedTriggeringPolicy size="1 KB"/>
            </Policies>
        </RollingFile>
    </Appenders>
    <Loggers>
        <Logger name="com.example" level="debug" additivity="false">
            <AppenderRef ref="LogToRollingFile"/>
            <AppenderRef ref="LogToConsole"/>
        </Logger>
        <Root level="error">
            <AppenderRef ref="LogToRollingFile"/>
            <AppenderRef ref="LogToConsole"/>
        </Root>
    </Loggers>
</Configuration>

In the given example, the appender is able to refer to the file name pattern and time-based rollover strategy using the filePattern attribute, which includes {dd-MMM}. Size-based rollover will happen at 1 KB. The moment the size of the application.log will be 1KB, it will split the file.

Below is a very basic XML configuration for rollover.

<RollingFile name="LogToRollingFile" fileName="logs/application.log"
                     filePattern="logs/%d{YYYY-MM}/application.%d{dd-MMM}.log.gz">

<Policies>

                <SizeBasedTriggeringPolicy size="1 KB"/>
</Policies>

If we want to roll over log files based on file size and date time, then we need to use SizeBasedTriggeringPolicy and TimeBasedRollingPolicy.

Step 4 – Import log4j in the Selenium script

We need to import the log4j library in the Selenium script so that we can use it in your code. Here is an example of how to import log4j in the Selenium script:

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

Step 5 – Create a Logger instance

We need to create a Logger instance in the Selenium script so that we can use it to log information. Here is an example of how to create a Logger instance:

private static Logger logger = LogManager.getLogger();

Step 6 – Create the Test Code with Log4j

Here is a complete code example that demonstrates how to use log4j in Selenium:

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.concurrent.TimeUnit;

public class Log4j_XML_Example {

    WebDriver driver;

    By userName = By.name("username");
    By passWord = By.name("password");

    By loginBtn = By.xpath("//*[@id='app']/div[1]/div/div[1]/div/div[2]/div[2]/form/div[3]/button");

    By loginTitle = By.xpath("//*[@id='app']/div[1]/div/div[1]/div/div[2]/h5");

    By dashboardPage = By.xpath("//*[@id='app']/div[1]/div[1]/header/div[1]/div[1]/span/h6");

    // Creating a logger
    private static Logger logger = LogManager.getLogger();

    @BeforeMethod
    public void setUp() {

        logger.info("Open a Chrome Web Browser");
        ChromeOptions options=new ChromeOptions();
        
        logger.info("Make the Web Browser full screen");
        options.addArguments("--start-maximized");
        driver=new ChromeDriver(options);
       
        logger.info("Wait for 10 sec");
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://opensource-demo.orangehrmlive.com/");
        logger.info("Open the application");
    }

    @Test(description = "This test validates title of login functionality", priority = 0)
    public void verifyLoginPageTitle() {

        logger.info("Verify the Login page title");
        String expectedTitle = driver.findElement(loginTitle).getText();

        logger.info("Expected Title :" + expectedTitle);
        Assert.assertTrue(expectedTitle.equalsIgnoreCase("Login"));
    }

    @Test(description = "This test validates  successful login to Home page", priority = 1)
    public void verifyloginPage() {

        logger.info("Enter Username");
        driver.findElement(userName).sendKeys("Admin");

        logger.info("Enter Password");
        driver.findElement(passWord).sendKeys("admin123");

        driver.findElement(loginBtn).submit();

        logger.info("New page - Dashboard is opened");
        String newPageText = driver.findElement(dashboardPage).getText();

        logger.info("Heading of new page :" + newPageText);
        Assert.assertTrue(newPageText.contains("Dashboard"));

    }

    @AfterMethod
    public void teardown() {

        logger.info("Close the webpage");
        driver.quit();
    }

}

Step 7 – Execute the test

Right-click on the test and select “Run Log4j_XML_Example”.

The output of the above program is

Step 8 – View the logs

The output log file is created under folder logs that are created at the root level of the project. The file name is application.log.

application.log file created under folder – 2023-11. application.log is the current log. Other logs are older logs, but are run on the same day. They are created after reaching the maximum size.

The application.log file will look like the image shown below.

By default, it will create up to 7 archives on the same day.

We can override the default 7 archives with this DefaultRolloverStrategy

<Policies>
			<TimeBasedTriggeringPolicy/>
			<SizeBasedTriggeringPolicy size="1 KB"/>
		</Policies>
		<DefaultRolloverStrategy max="10"/>
	</RollingFile>

Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

May 1, 2021 vibssingh

Interview Questions

September 26, 2019February 13, 2021 vibssingh

Maven – How to create a Java project using Command Line

HOME

In the previous tutorial, we have discussed about How to install Maven on Windows. In this tutorial, we will see how to use Maven to manage a Java project – Create and update the dependencies.

1) Change current folder to the folder where we want to create the Java project

In my case I have my Eclipse Workspace mentioned at the below mentioned path

cd C:\Users\vibha\eclipse-workspace\Selenium

2) Create a Project from Maven Template

This tells Maven to generate a Java project from a Maven template.

mvn archetype:generate

3) We need to mention the number as displayed on your screen in Command Prompt to proceed further. Like here, Choose a folder or apply has 1394, so I have also mentioned 1394 in command prompt.

4) We need to provide again input in command prompt. This time program wants to know which version we want to use. I prefer to use the latest version. Here, it is 8, so I have selected version 8.

5) We need to provide 2 input here

A) Value of groupId – This serves as the group identifier of your Maven project, it should be in a form similar to Java packages, such as com.Selenium
B) Value of artifactId – This serves as the group-local identifier of my Maven project like MavenProjectFromCMD
C) Value of Version – The initial version of our project. The default is 1.0-SNAPSHOT
D) Value of package – The name of our root package. The default is groupId we have created earlier.
We will notice the INFO message about the properties. If the displayed settings are correct, then just enter Y in :: prompt.

Successful Build – Below screenshot shows that the Maven Project built successfully.

6) Project Folder Creation – We can see a folder with the name of project – MavenProjectFromCMD in our Eclipse Workspace. In my case, it is

C:\Users\vibha\eclipse-workspace\Selenium\MavenProjectFromCMD

7) Contents of Project Folder – Open folder MavenProjectFromCMD to see the contents of the folder. It should have POM file and src

QA Automation Expert

Automation solutions to build Test Framework

QA Automation

How to install Desktop Docker on Windows 11