DEV Community: Balaji Srinivasan

Running Spring Boot Test via docker

Balaji Srinivasan — Sat, 27 Mar 2021 12:29:53 +0000

Spring boot becoming a common defacto for writing micro-services in the Java ecosystem. We have a lot of frameworks and options to write unit and integration tests are available. Below are the few resources, that I have looked upon in the past to improve my unit testing skills

Test Containers - By Siva
Testing Spring Boot- By Baeldung

We are not going to discuss in detail writing unit-testing. But setting up the necessary things that enable us to independently write end-to-end tests for our spring boot applications.

Assumption

Our application is going to be a simple backend service connected with a database. In our case, let's assume it is Postgres. Based on your application architecture the same template can be changed. Below the types of tests we have

Controller Level Tests
Service Level Tests
Core Business Logic

Most of the time we might miss validating our repository/data layer via tests under the assumption all will be fine. But if we do it, it is always good to ensure we don't end up with weird data issues in production. As I mentioned above TestContainers are a good way to write tests including embedded databases. Cored database schema migrations are integrated into the application bootup. We can use tools like flyway or liquibase to do this.

Settings

For our application, we should have the below properties src/test/java/resource/application.properties for effective testing

We have passed our values to be env variables. You can refer here

Base Image

Create a base image for your projects and push it to some registry. Either docker hub or anything which can be accessed. Please keep this base image minimal without any confidential details of your project. Let's assume we have a base image named orgname/base-springboot

We would need a docker-compose.yml file to have this setup working end to end. Below is a docker-compose that can be used for reference

How to Run the tests?

Below is the simple command that can be used to run the tests

docker-compose up --abort-on-container-exit --exit-code-from application_under_test

What the above command does is spins the DB, application and runs the tests. If a test failed it gets exit. The same command can be used in CI/CD pipelines also. To fasten the process the base image should be built with all common dependencies.

Environment Variables In Spring Boot Application

Balaji Srinivasan — Tue, 15 Dec 2020 15:33:43 +0000

Spring Boot lets you externalize configurations for our application. Lets take a simple application which connects to database and perform some operations on it. Standard configuration for this kind of app would be the database related details. Below is one sample properties file

spring.datasource.url=${JDBC_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

Like this we might have more properties specific to our application also which we want to have it as dynamic configurations that can be passed when application startup. In order to have these have different across different environments like dev,staging,production. Spring boot provides us with option to have environment specific files with different values for different environments.

Below are few common practices developers follow which has its own pros and cons

Commit secrets in these files as part of the code base
Commit only local configuration in the code base and as part of deployment pipeline copy environment specific files from different repository and build the package

If we are having separate profile files then we might need to have separate start-up scripts for each to ensure right profile details are passed. If we are copying files at the time of the build for any change in secrets or configurations we might need to build the package again to take effect.

According to 12factor apps its good practice to store configurations in environments.

How can we achieve this?

We can avoid multiple property files and have only one file as below

spring.datasource.url=${JDBC_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

The above helps in multiple ways

No need to rebuild the package again if there is any change in configuration.
One common properties file versioned as part of code base.
Build pipelines would be generic. Same builds can be used across all environments

When running as containers

If we are running our application as containers we need to pass the environment variables while starting the application. This can be taken care by a deployment pipeline.If there is a change in value just a restart of the container is enough

When running as fat jars

If we are running our application as normal jars then best practice would be to set the environment variables as part of the host machine and start the application.

What about local development/tests

For tests I would recommend to have dedicated properties file. For local development we can do it two ways.

Have one .env file in local and source them before starting the application
We can give default values to properties if not present in environment as spring.datasource.username=${DB_USERNAME:username}

The key thing to note here is the deployment process. I will cover a detailed blog on how the deployment pipeline can be done for such a setup of spring boot application.

Simple State Machines In Java

Balaji Srinivasan — Sun, 06 Dec 2020 15:34:27 +0000

What is a State Machine ?

Wikipedia defines a finite-state machine (FSM) as:

an abstract machine that can be in exactly one of a finite number of states at any given time.
The FSM can change from one state to another in response to some external inputs; the change from one state to another is called a transition.
An FSM is defined by a list of its states, its initial state, and the conditions for each transition.

It is way to program a model so that it is at one particular state at any moment.

The world is filled with state machines which we can see anywhere in our daily usage. Below are few

Road Traffic Signale Red -> Yellow -> Green
Coffee Vending Machine
E-commerce Portal Ordering
Online Trip Booking
Many Cron Jobs

Implementing State Machines In Java

There are many ways which we can implement state machines. In Java world itself we have many libraries using which we can model these states

We can also implement them using a standard State Design pattern [example] https://www.journaldev.com/1751/state-design-pattern-java)

What if we don't want to add any external dependencies?
What if we want to have simple state machine and control it via our own logic?

State Machines Using Enums in Java

Many of us would have used Uber or Ola at-least once. Lets try implementing the trip booking state machine using Java Enums

What are the ideal states in trip booking?

Trip Booked
Driver Assigned
Driver Reached
Trip Started
Trip Ended

Simple Implementation


public enum TripStates {
    TRIPCREATED,
    DRIVERASSSIGNED,
    DRIVERREACHED,
    TRIPSTARTED,
    TRIPENDED;

}

The above enum can be used across our application for maintaining the state of the trip. Even in database this can be used by using the string value of the enum. Example TripStates.TRIPCREATED.name()

Now we have implemented the state machine but how to ensure proper state transition happens. One simple way is to include a function within the enum and check it across whenever we are trying to change the state of a trip

public boolean canChangeTripState(TripStates fromState, TripStates toState){
        return fromState.ordinal()<toState.ordinal();
}

The above function needs to be called wherever state changes needs to happen. This helps in moving states in forward manner.
But there is problem with this. We will be able to move a trip from trip created to trip started. The above implementation might not solve the real constraint we would like to introduce like a trip cannot be marked as started without marking as reached.

How can we achieve this with just enum?

Java Enums can have additional fields to it. We can leverage that to solve this.

public enum TripStates {
    TRIPCREATED(Arrays.asList(new TripStates[]{})),
    DRIVERASSSIGNED(Arrays.asList(new TripStates[]{TripStates.TRIPCREATED})),
    DRIVERREACHED(Arrays.asList(new TripStates[]{TripStates.DRIVERASSSIGNED})),
    TRIPSTARTED(Arrays.asList(new TripStates[]{TripStates.DRIVERREACHED})),
    TRIPENDED(Arrays.asList(new TripStates[]{TripStates.TRIPSTARTED}));


    private List<TripStates> validFromStates = new LinkedList<TripStates>();


    TripStates(List<TripStates> validFromStates) {
        this.validFromStates = validFromStates;
    }

    public boolean canChangeTripState(TripStates fromState, TripStates toState) {
        return toState.validFromStates.contains(fromState);
    }
}

If you look we are maintaining validFromStates in order easily expand this to other cases where a trip can ended even from different states. Example: CustomerNotReachable etc..

The above is a simple implementation that can be used. But if we wanted to have more logic within this state transitions we can still leverage but we need to hook the above model with other design patterns.

Managing multiple git account

Balaji Srinivasan — Sun, 24 May 2020 06:46:05 +0000

Lot of companies requests developers to create dedicated git accounts to access work related git projects. It is good from security and access control perspective but it is a pain from developers who wish to work on personal projects in their private accounts. Lot of times commits goes in the name of work accounts or the otherway. I have also gone through this that is why have setup my work laptop as below such that there is clear segregation of usage of git accounts

Prerequisite

You should be using ssh based git access which most of the devs would be using. I still find still few are using http based and giving creds each time 🤦‍♂️
You should be used to segregate your office work space (code folders) from your private workspace

Folder Structure

I usually go with the below folder structures. This has helped me in maintaining a clean structure and managing multiple git accounts

├── personal
│   └── workspace
│       ├── repo1
│       └── repo2
└── work
    └── workspace
        ├── workrepo1
        └── workrepo2

SSH Keys

Ensure you create two different ssh keys for each of your git accounts. Please refer this link.
Once you have the keys ensure to follow this ensure to configure the corresponding Github account with corresponding keys. Follow this link.
Since you have generated two keys two private key files would be present.

SSH Configuration

Since we have two different ssh keys we need to configure it to use it. Below are the ssh configs

Host github.com
   HostName github.com
   User git
   IdentityFile ~/.ssh/<private key filename of private account>

Host <githubwork.com>    
   HostName github.com
   User git
   IdentityFile ~/.ssh/<private key filename of work account>

Git Configuration

Here I will be setting the default git config as my private account and configure work git account specific to work associated directories. But we can do the other way based on how we are structuring our workspace.
Below is configuration in default git config in /.gitconfig

[user]
    name = Personal Git Account Name
    email = personalemailassociatedwithpersonalgit@somedomain

The above will ensure all the git operations uses the above config across your machine.

Work Related Git Configuration

In the same ~/.gitconfig add these lines.

[includeIf "gitdir:~/work/"]
    path = ~/work/.gitconfig

What we have done is used the includeif.Conditional Includes was introduced from git 2.13. Ensure you have this version of git to use this feature. It actually includes gitconfig dynamically based on the conditions. In this case if the git working directory is ~/work it uses the .gitconfig from the ~/work/.gitconfig.
Below are the contents of this config file inside ~/work/.gitconfig

[user]
    name = Work Git Account Name
    email = workacountemail@domain

How to Work on repositories from Both Account

To clone a repo from work account you need to follow this since you have configured the ssh - git clone git@githubwork.com:<repopath>.git
To clone a repo from private account you need to follow this since you have configured the ssh - git clone git@github.com:<repopath>.git

All the git operations on corresponding repos ensure to follow the corresponding configs. You can customize more configurations in this custom git configs.