Introduction to Junit5

 JUnit5 is the next generation of JUnit. The goal is to create an up-to-date foundation for developer-side testing on the JVM. This includes focusing on Java 8 and above, as well as enabling many different styles of testing.

JUnit 5 is split into three sub-projects: Jupiter, Vintage, and Platform.

They communicate via published APIs, which allows tools and libraries to inject customized behavior. Then, each sub-project is split into several artifacts to separate concerns and guarantee maintainability.

JUnit Vintage:

Implements an engine that allows to run tests written in JUnit 3 and 4 with JUnit 5.

JUnit Jupiter is the combination of the new programming model and extension model for writing tests and extensions in JUnit 5. 

Required Dependencies:

The junit-jupiter-api (version 5.4.2):This dependency provides the public API for writing tests and extensions.

The junit-jupiter-engine (version 5.4.2):This dependency contains the implementation of the JUnit Jupiter test engine that runs our unit tests.

Configuring the Maven Surefire Plugin:

build>

    <plugins>

        <plugin>

            <groupId>org.apache.maven.plugins</groupId>

            <artifactId>maven-surefire-plugin</artifactId>

            <version>2.22.1</version>

        </plugin>

    </plugins>

</build>            

Note: First, if we want to use the native JUnit 5 support of the Maven Surefire Plugin, we must ensure that at least one test engine implementation is found from the classpath. 

That’s why we added the junit-jupiter-engine dependency to the test scope.

Mockito

 Mockito is a mocking framework. It is a Java-based library used to create simple and basic test APIs for performing unit testing of Java applications. It can also be used with other frameworks such as JUnit and TestNG.

The framework allows the creation of test double objects (mock objects) in automated unit tests for the purpose of test-driven development (TDD) or behavior-driven development (BDD).

Mockito allows developers to verify the behavior of the system under test (SUT) without establishing expectations beforehand.One of the criticisms of mock objects is that there is a tight coupling of the test code to the system under test.

Benefits of Mockito:

• No Handwriting − No need to write mock objects on your own.
• Refactoring Safe − Renaming interface method names or reordering parameters will not break the test code as Mocks are created at runtime.
• Return value support − Supports return values.
• Exception support − Supports exceptions.
• Order check support − Supports check on order of method calls.
• Annotation support − Supports creating mocks using annotation.

Following are the mock() methods with different parameters:

mock() method with Class: It is used to create mock objects of a concrete class or an interface. It takes a class or an interface name as a parameter.

Syntax: <T> mock(Class<T> classToMock)

mock() method with Answer: It is used to create mock objects of a class or interface with a specific procedure. It is an advanced mock method, which can be used when working with legacy systems. It takes Answer as a parameter along with the class or interface name. The Answer is an enumeration of pre-configured mock answers.

Syntax: <T> mock(Class<T> classToMock, Answer defaultAnswer)

mock() method with MockSettings: It is used to create mock objects with some non-standard settings. It takes MockSettings as an additional setting parameter along with the class or interface name. MockSettings allows the creation of mock objects with additional settings.

Syntax: <T> mock(Class<T> classToMock, MockSettings mockSettings)

mock() method with ReturnValues: It allows the creation of mock objects of a given class or interface. Now, it is deprecated, as ReturnValues are replaced with Answer.

Syntax: <T> mock(Class<T> classToMock, ReturnValues returnValues)

mock() method with String: It is used to create mock objects by specifying the mock names. In debugging, naming mock objects can be helpful whereas, it is a bad choice using with large and complex code.

Syntax: <T> mock(Class<T> classToMock, String name)

Stored Procedures in Sql

Stored Procedures are created to perform one or more DML operations on Database.

 It is nothing but the group of SQL statements that accepts some input in the form of parameters and performs some task and may or may not returns a value.

Syntax :

CREATE or REPLACE PROCEDURE name(parameters)

IS

variables;

BEGIN

//statements;

END;

The most important part is parameters. Parameters are used to pass values to the Procedure. 

There are 3 different types of parameters, they are as follows:

IN:

This is the Default Parameter for the procedure. It always recieves the values from calling program.

OUT:

This parameter always sends the values to the calling program.

IN OUT:

This parameter performs both the operations. It Receives value from as well as sends the values to the calling program.

CREATE or REPLACE PROCEDURE INC_SAL(eno IN NUMBER, up_sal OUT NUMBER)

IS

BEGIN

UPDATE emp_table SET salary = salary+1000 WHERE emp_no = eno;

COMMIT;

SELECT sal INTO up_sal FROM emp_table WHERE emp_no = eno;

END; 

Steps to execute the procedure:

>Declare a Variable to Store the value comming out from Procedure :

VARIABLE v NUMBER;

>Execution of the Procedure:

EXECUTE INC_SAL(1002, :v);

>To check the updated salary use SELECT statement:

 SELECT * FROM emp_table WHERE emp_no = 1002;

or Use print statement :

PRINT :v

Example For Stored Procedures with Multiple Parameters:

CREATE PROCEDURE SelectAllCustomers @City nvarchar(30), @PostalCode nvarchar(10)

AS

SELECT * FROM Customers WHERE City = @City AND PostalCode = @PostalCode

GO;

Execution of Stored Procedures in SQL 

EXEC SelectAllCustomers City = "London", PostalCode = "WA1 1DP";

Example For Stored Procedure with One Parameter:

Example of SQL Stored Procedure with one parameter- 

CREATE PROCEDURE SelectAllCustomers @City nvarchar(30)

AS

SELECT * FROM Customers WHERE City = @City

GO;

Execution of Stored Procedures in SQL –

EXEC SelectAllCustomers City = "London";

Aws Copilot

 It is a tool for developers to develop, release, and operate production-ready containerized applications on Amazon ECS. From getting started, pushing to staging and releasing to production, Copilot can help manage the entire lifecycle of your application development.

AWS Copilot is a tool in the Container Tools category of a tech stack.

Copilot creates modern application deployments by default, based on production-ready patterns that include best practices designed by ECS engineers and customers over the years.

The AWS Copilot command line interface (CLI) provides application-first, high-level commands to simplify modeling, creating, releasing, and managing production-ready containerized applications on Amazon ECS from a local development environment.

We can use Homebrew to install the cli.Installing the AWS Copilot CLI using Homebrew.

The following command is used to install the AWS Copilot CLI on your macOS or Linux system using Homebrew. 

Prior to installation, you should have Homebrew installed. 

brew install aws/tap/copilot-cli

or

sudo curl -Lo /usr/local/bin/copilot https://github.com/aws/copilot-cli/releases/download/v0.3.0/copilot-linux-v0.3.0  \  && sudo chmod +x /usr/local/bin/copilot \   && copilot --help

Below is the Architecture:

Copilot has three main concepts:

Application : An application is a grouping mechanism for the pieces of your system. Following Conway’s Law you would split up your components into Copilot applications that correspond to the different teams in your organization. 

For example, if you still have a small organization with a unified development team that works on a bit of everything then you can probably organize things as a single application made up out of one or more services. But if you have multiple teams, each responsible for a single group of components, and very little cross team work, then each team should have their own Copilot application.

Environment : An environment is one stage of deployment of an application. For example, you might deploy an application to a “QA” environment. 

Service: A service is a single long running code process inside a container. An application consists of one or more services. If you are using a monolithic architecture, then it’s likely each application will have just a single service. A more distributed architecture will utilize multiple services for each application. 

For example, you might have a “website” service with an internet facing load balancer, an internal “API” service that is only accessible via service discovery, and a “background worker” service that works on jobs off a queue. Together these services make up the components of a single application.

Jdbc Connection Pool

 A JDBC connection pool is a group of reusable connections for a particular database. 

Because creating each new physical connection is time consuming, the server maintains a pool of available connections to increase performance.

 When an application requests a connection, it obtains one from the pool. When an application closes a connection, the connection is returned to the pool.

When creating a connection pool , you are actually defining the aspects of a connection to a specific database. Before creating the pool, you must first install and integrate the JDBC driver. 

The properties of connection pools can vary with different database vendors.

1. Some common properties are the database’s name (URL), user name, and password.
2. Certain data specific to the JDBC driver and the database vendor must be entered. Before proceeding, gather the following information:
3. Database vendor name
4. Resource type, such as javax.sql.DataSource (local transactions only) javax.sql.XADataSource (global transactions)
5. Data source class name: If the JDBC driver has a Datasource class for the resource type and database, then the value of the Datasource Classname field is required.
6. Required properties, such as the database name (URL), user name, and password

A JDBC connection pool is a group of reusable connections for a particular database. When creating the pool with the Administration Console, the Administrator is actually defining the aspects of a connection to a specific database.

Before creating the pool, you must first install and integrate the JDBC driver. When building the Create Connection Pool pages, certain data specific to the JDBC driver and the database vendor must be entered. 

Before proceeding, gather the following information:

1. Database vendor name
2. Resource type, such as javax.sql.DataSource (local transactions only) javax.sql.XADataSource (global transactions)
3. Data source class name
4. Required properties, such as the database name (URL), user name, and password

Connection Pool Libraries considered for analysis:

1) Apache Commons DBCP2:

• Easy to configure. Very detailed configuration page.
• Supports prepared statement caching
• Does not validate connections on borrow
• Does not reset transaction isolation when returns to the pool
• Does not reset the read-only status of the connection
• Does not reset the auto-commit status of the connection
• Does not clear SQL warnings
• DBCP2 compiles and runs under Java 7 only (JDBC 4.1), not sure if it runs on Java 8
• More than 60 classes in the library
• Does not validate connections on borrow
• The code is hosted on GitHub https://github.com/apache/commons-dbcp. The repository has 21 contributors and only 2 contributions in the year 2017. A lot of broken links on the home page, java doc links are broken.
• I logged into Apache Bugtracker (JIRA) to check for the number of bugs, there are 11 open and reopened bugs.
• Licensed under Apache 2.0

2)C3P0:

C3P0 is one of the oldest and best-known libraries. It is very well documented. However, according to some reports, it’s easy to misconfigure the pool and can result in poor performance and deadlocks.

• It comes in a package with hibernate.
• Works well in the heavy concurrent environment.
• Supports prepared statement pooling
• Resets auto commit status when returning to the pool
• Resets read the only status when returning to the pool
• Resets isolation level when returning to the pool
• Does not test connections at getConnection()
• Around 200 classes in the library. Huge code base compared to others.
• The code is hosted on Github -> Repository, the library has 5 contributors with 5 contributions to the code this year, 4th May had the last check-in.
• Issues are tracked on Github tracker and have 41 issues listed.
• The library is licensed under LGPL v.2.1 and EPL v.1.0

3)Tomcat JDBC:

• Supports highly concurrent environments and multi-core/CPU systems.
• It is very well documented here.
• Async connection retrieval. Can queue connection requests and return Future back.
• Ability to configure custom interceptors to enhance functionality.
• It provides multiple ways to configure the pool. One is inside the Apache container, JMX and standalone by using DataSource bean.
• It does not by default reset auto-commit and transaction levels for connections in the pool, users must configure custom interceptors to do this.
• Does not by default test connections on getConnection()
• It does not close abandoned open statements.
• Pool prepared statement properties are not used.
• The code is hosted on GitHub. It has 13 active contributors.
• This is a very active community, one can see looking at the commits and bug list.
• licensed under Apache 2.0

4) HikariCP:

• Very light library, around 130 kb.
• Tests connections at getConnection()
• Tracks and closes abandoned connections.
• Clears connections before returning the connection to the client.
• Resets auto-commit, transaction isolation, read-only status
• The library has 58 active contributors and has a very detailed configuration page with performance benchmarks.
• The library has 33 issues listed on GitHub
• Licensed under Apache 2.0

Introduction to Quartz Scheduler

Quartz is a job scheduling library that can be integrated into a wide variety of Java applications.

Quartz is generally used for enterprise class applications to support process workflow, system management actions and to provide timely services within the applications.

You can create complex schedules for executing any job. Examples are e.g. tasks that run daily, every other Monday 8:30 p.m. or only on the last day of every month. 

You can download Quartz from http://quartz-scheduler.org/downloads

Components:

============

Quartz job:

Quartz job is used for the logic or code which you want to execute. It implements org.quartz.Job interface.

Quartz trigger:

Quartz trigger is used to define the moment when the quartz scheduler will execute quartz’s job.

Types of quartz trigger:

1. SimpleTrigger – SimpleTrigger setting start time, end time, repeat count and repeat interval for quartz’s job.

2.CronTrigger – CronTrigger uses cron expressions to specify the moment when to execute quartz’s job.

 A cron expression is made up of seven sub expressions:

Seconds

Minutes

Hours

Day-of-Month

Month

Day-of-Week

Year (optional field)

3. Scheduler class – Scheduler class is used to connect the quartz job and quartz trigger together and execute the job.

4.JobListener:

JobListener provides the facility to track the status of running jobs. To write a JobListener we have to implements the JobListener interface.

Quartz API:

===========

The key interfaces of the API are:

Scheduler – the primary API for interacting with the scheduler of the framework

Job – an interface to be implemented by components that we wish to have executed

JobDetail – used to define instances of Jobs

Trigger – a component that determines the schedule upon which a given Job will be performed

JobBuilder – used to build JobDetail instances, which define instances of Jobs

TriggerBuilder – used to build Trigger instances