Resources

The final project you can find on my GitLab. If you prefer video tutorial text, you can watch it on my YouTube channel.

Detector script

Let’s have a look on the following detector script. The script is a typical MonoBehaviour script and it requires Collider component be able to detect if any other object interacts with the collider. In that case that the script detects any interaction it broadcasts particular events trough UnityEvents system.

using UnityEngine;
using UnityEngine.Events;

namespace Commons
{
    [RequireComponent(typeof(Collider))]
    public class Detector : MonoBehaviour
    {
        public UnityEvent<Collider> onTriggerEnter;
        public UnityEvent<Collider> onTriggerStay;
        public UnityEvent<Collider> onTriggerExit;

        private void OnTriggerEnter(Collider other)
        {
            onTriggerEnter?.Invoke(other);
        }

        private void OnTriggerStay(Collider other)
        {
            onTriggerStay?.Invoke(other);
        }

        private void OnTriggerExit(Collider other)
        {
            onTriggerExit?.Invoke(other);
        }
    }
}

Receiver script

Now it’s time to implement a MonoBehavior with ability to handle the events emitted by Detector. The only requirement is that the receiver MonoBehaviour has to have implemented a public method with the same parameters as emitted events have.

using UnityEngine;

namespace Commons
{
    public class DummyReceiver : MonoBehaviour
    {
        public void ListenOnTriggerEnter(Collider other)
        {
            Debug.Log("ListenOnTriggerEnter");
        }

        public void ListenOnTriggerStay(Collider other)
        {
            Debug.Log("ListenOnTriggerStay");
        }

        public void ListenOnTriggerExit(Collider other)
        {
            Debug.Log("ListenOnTriggerEnter");
        }
    }
}

Putting it together – UnityEvent system

It’s time to put everything together. Create a sphere and add Rigidbody component to it. Then create two empty game objects – one for Detector and one for Receiver. Add some collider (for example BoxCollider) and the cerated Detector script to the Detector GameObject. Please consider to set IsTrigger=ture flag of the crated collider.

Then add DummyReceiver script to the Receiver GameObejct. It allows you to handle events generated by Detector.

And now the most interesting part, which is event listeners configuration using UnityEvent system. It’s sounds complicated but it’s actually very simple. Just select Detector GameObject and add event listeners by clicking “+” icon. Drag DummyReceiver GameObejct into the property inspector field (1) and choose DummyReceiver’s event handlers as it is shown below (2,3,4).

If you have done everything correctly the created detector should work. Run the simulation and test the behaviour of the detector by moving the Sphere in and out of the detector’s collider.

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.

TL;DR

You can find a ready to use solution here and on my GitLab. However, I encourage you to read the whole article, because when coming up with the solution, I add many interesting digressions from the field of SpringBoot and the H2 database itself.

Why clean the database at all during testing?

Resetting the database state before running each test can be very useful when dealing with integration tests and Spring. Very often, in the case of integration tests, we use the in-memory H2 database, which allows us to test the JPA layer with a real database. The problem is that this instance of the database is run together with the Spring context being raised and it stores its state until the application is turned off. This causes problems with determining the state of the database before starting a given test and whether the state state does not affect the test result. Therefore, it would be much more convenient to clean the database before running each test case, to make sure that it executes under the same conditions every time. In the following, I will introduce two methods of resetting the database state and discuss the pros and cons of each.

Sample test case

To better illustrate the described problem, I have prepared the following test. Notice that we have two test methods in it. Each of them adds a book to the book repository and checks that there is exactly one book in the repository after each test case.

package com.bettercoding.h2databasecleanup;

import com.bettercoding.h2databasecleanup.db.Book;
import com.bettercoding.h2databasecleanup.helper.BookRepositoryHelper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.UUID;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
class H2DatabaseCleanupTests {

    @Autowired
    private BookRepositoryHelper bookRepositoryHelper;


    @Test
    void firstTest() {
        //given
        Book book = new Book(UUID.randomUUID().toString(), "A Passage to India", "E.M. Foster");
        //when
        bookRepositoryHelper.addBook(book);
        // then
        assertEquals(1, bookRepositoryHelper.findAllBooks().size());
    }

    @Test
    void secondTest() {
        //given
        Book book = new Book(UUID.randomUUID().toString(), "A Revenue Stamp", "Amrita Pritam");
        //when
        bookRepositoryHelper.addBook(book);
        // then
        assertEquals(1, bookRepositoryHelper.findAllBooks().size());
    }


}

package com.bettercoding.h2databasecleanup.helper;

import com.bettercoding.h2databasecleanup.db.Book;
import com.bettercoding.h2databasecleanup.db.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.transaction.Transactional;
import java.util.List;

@Component
public class BookRepositoryHelper {
    @Autowired
    BookRepository bookRepository;

    @Transactional
    public void addBook(Book book) {
        bookRepository.save(book);
    }

    @Transactional
    public List<Book> findAllBooks() {
        return bookRepository.findAll();
    }
}

package com.bettercoding.h2databasecleanup.db;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.annotation.processing.Generated;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;

@Getter
@Setter
@NoArgsConstructor
@Entity
@AllArgsConstructor
public class Book {
    @Id
    private String id;

    @Column
    private String title;

    @Column
    private String author;
}

package com.bettercoding.h2databasecleanup.db;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface BookRepository extends JpaRepository<Book, String> {
}

After running the test, it turns out that the second test case fails, because in the repository, apart from the newly added book, there is another one – added in the first test case. Of course, we can write this test in such a way that it is resistant to the already existing data, but in the case of more complex tests, it is more convenient to start with a clean application and create exactly the conditions we want.

1st Method: @DirtiestContext

SpringBoot has implemented a mechanism of reusing contexts for testing purposes. I will not deep into its detailed description here because out of the scope of this article. It is important to know that if a test class does not differ significantly from another (e.g. it does not have additional beans or other configuration elements), SpringBoot can very quickly deliver a clean copy of the context from a special cache instead of restarting the entire application. In our example, we are dealing with exactly this situation, so SpringBoot will start the context when running the first test case, add it to the cache and then execute the first test case. When the second test case runs, SpringBoot will provide us with a clean copy of the context from the cache – which is a very quick operation – instead of restarting the entire application. Unfortunately, the H2 database is not being re-created.

We can force SpringBoot not to use this context caching mechanism by adding the @DirtiestContext annotation to the test class. It is also important to force a new context to be started for each test case by adding @DirtiesContext (classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD).

package com.bettercoding.h2databasecleanup;

import com.bettercoding.h2databasecleanup.db.Book;
import com.bettercoding.h2databasecleanup.helper.BookRepositoryHelper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.DirtiesContext;

import java.util.UUID;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_EACH_TEST_METHOD)
class H2DatabaseCleanupTests1 {

    @Autowired
    private BookRepositoryHelper bookRepositoryHelper;


    @Test
    void firstTest() {
        //given
        Book book = new Book(UUID.randomUUID().toString(), "A Passage to India", "E.M. Foster");
        //when
        bookRepositoryHelper.addBook(book);
        // then
        assertEquals(1, bookRepositoryHelper.findAllBooks().size());
    }

    @Test
    void secondTest() {
        //given
        Book book = new Book(UUID.randomUUID().toString(), "A Revenue Stamp", "Amrita Pritam");
        //when
        bookRepositoryHelper.addBook(book);
        // then
        assertEquals(1, bookRepositoryHelper.findAllBooks().size());
    }


}

This solution is very easy to implement. Unfortunately, for each test case, the application is restarted, which, depending on the complexity of the application, may take from seconds to several dozen seconds. This may result in extending the test execution time to minutes or even hours. Please pay attention to the execution times of both test cases, which we will compare with the second discussed method.

2nd Method: TestExecutionListener that cleans database on every test case

Let’s consider another way to reset the database state before running each test case, so as not to sacrifice the benefits of context caching. Here, the TestExecutionListener interface and the @TestExecutionListeners annotation come in handy, which allows you to connect to the JUnit test execution cycle and run your own code, e.g. before running a test case.

In the following, you will see the source code for the two CleanupH2DatabaseTestListener and CleanupH2DbService classes. The first one is responsible for joining the test execution cycle in such a way as to call the code responsible for cleaning the database, which was implemented in the CleanupH2DbService component. The discussed solution can be presented as follows:

There is one important problem in the process of deleting data in a relational database. Namely, we cannot delete the parent row as long as there are rows that refer to it. In practice, this means cleaning tables in the right order (in the case of a foreign key to the same table, it is even necessary to delete the rows in the right order).

Fortunately, we can use a trick to disable Constraint checking for a moment, so we will be able to delete the data in any order. After deletion is complete, turn on Constraint checking again. An additional step worth taking is resetting all sequences.

The last thing that remains for us to do is add the newly-implemented CleanupH2DatabaseTestListener to our test using the @TestExecutionListeners annotation. There is also a small catch here – we have to add DependencyInjectionTestExecutionListener to the list of custom listers. In other case Dependency Injection doesn’t work anymore in test. So let’s see the final solution that can also be found on my GitLab.

package com.bettercoding.h2databasecleanup.listener;

import lombok.extern.slf4j.Slf4j;
import org.springframework.core.Ordered;
import org.springframework.test.context.TestContext;
import org.springframework.test.context.TestExecutionListener;

@Slf4j
public class CleanupH2DatabaseTestListener implements TestExecutionListener, Ordered {

    private static final String H2_SCHEMA_NAME = "PUBLIC";

    @Override
    public void beforeTestMethod(TestContext testContext) throws Exception {
        TestExecutionListener.super.beforeTestMethod(testContext);
        cleanupDatabase(testContext);
    }

    private void cleanupDatabase(TestContext testContext) {
        log.info("Cleaning up database begin");
        CleanupH2DbService cleanupH2DbService = testContext.getApplicationContext().getBean(CleanupH2DbService.class);
        cleanupH2DbService.cleanup(H2_SCHEMA_NAME);
        log.info("Cleaning up database end");
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

package com.bettercoding.h2databasecleanup.listener;

import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import javax.transaction.Transactional;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.HashSet;
import java.util.Set;

@Component
@Slf4j
@RequiredArgsConstructor
public class CleanupH2DbService {
    public static final String H2_DB_PRODUCT_NAME = "H2";
    private final DataSource dataSource;

    @SneakyThrows
    @Transactional(Transactional.TxType.REQUIRES_NEW)
    public void cleanup(String schemaName) {
        try (Connection connection = dataSource.getConnection();
             Statement statement = connection.createStatement()) {
            if (isH2Database(connection)) {
                disableConstraints(statement);
                truncateTables(statement, schemaName);
                resetSequences(statement, schemaName);
                enableConstraints(statement);
            } else {
                log.warn("Skipping cleaning up database, because it's not H2 database");
            }
        }
    }

    private void resetSequences(Statement statement, String schemaName) {
        getSchemaSequences(statement, schemaName).forEach(sequenceName ->
                executeStatement(statement, String.format("ALTER SEQUENCE %s RESTART WITH 1", sequenceName)));
    }

    private void truncateTables(Statement statement, String schemaName) {
        getSchemaTables(statement, schemaName)
                .forEach(tableName -> executeStatement(statement, "TRUNCATE TABLE " + tableName));
    }

    private void enableConstraints(Statement statement) {
        executeStatement(statement, "SET REFERENTIAL_INTEGRITY TRUE");
    }

    private void disableConstraints(Statement statement) {
        executeStatement(statement, "SET REFERENTIAL_INTEGRITY FALSE");
    }

    @SneakyThrows
    private boolean isH2Database(Connection connection) {
        return H2_DB_PRODUCT_NAME.equals(connection.getMetaData().getDatabaseProductName());
    }

    @SneakyThrows
    private void executeStatement(Statement statement, String sql) {
        statement.executeUpdate(sql);
    }

    @SneakyThrows
    private Set<String> getSchemaTables(Statement statement, String schemaName) {
        String sql = String.format("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES  where TABLE_SCHEMA='%s'", schemaName);
        return queryForList(statement, sql);
    }

    @SneakyThrows
    private Set<String> getSchemaSequences(Statement statement, String schemaName) {
        String sql = String.format("SELECT SEQUENCE_NAME FROM INFORMATION_SCHEMA.SEQUENCES WHERE SEQUENCE_SCHEMA='%s'", schemaName);
        return queryForList(statement, sql);
    }

    @SneakyThrows
    private Set<String> queryForList(Statement statement, String sql) {
        Set<String> tables = new HashSet<>();
        try (ResultSet rs = statement.executeQuery(sql)) {
            while (rs.next()) {
                tables.add(rs.getString(1));
            }
        }
        return tables;
    }
}

package com.bettercoding.h2databasecleanup;

import com.bettercoding.h2databasecleanup.db.Book;
import com.bettercoding.h2databasecleanup.helper.BookRepositoryHelper;
import com.bettercoding.h2databasecleanup.listener.CleanupH2DatabaseTestListener;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;

import java.util.UUID;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
@TestExecutionListeners(listeners = {DependencyInjectionTestExecutionListener.class, CleanupH2DatabaseTestListener.class})
class H2DatabaseCleanupTests2 {

    @Autowired
    private BookRepositoryHelper bookRepositoryHelper;


    @Test
    void firstTest() {
        //given
        Book book = new Book(UUID.randomUUID().toString(), "A Passage to India", "E.M. Foster");
        //when
        bookRepositoryHelper.addBook(book);
        // then
        assertEquals(1, bookRepositoryHelper.findAllBooks().size());
    }

    @Test
    void secondTest() {
        //given
        Book book = new Book(UUID.randomUUID().toString(), "A Revenue Stamp", "Amrita Pritam");
        //when
        bookRepositoryHelper.addBook(book);
        // then
        assertEquals(1, bookRepositoryHelper.findAllBooks().size());
    }


}

All that remains is to run the tests and check if the result matches the expected result. Please note how much faster the tests were performed compared to the previous method. Cleaning the database in this case took less than 4ms, which is a great result compared to the previous method which took around 130ms. However, it should be remembered that the first method is the overhead associated with the start of the application and depends on the number and time of loading beans, and the second method depends only on the number of tables and the amount of data. By this I mean that as the application becomes more complex, the first method will slow down significantly, while the second – regardless of conditions – will remain just as fast.

To już wszystko co dla Ciebie przygotowałem w tym poradniku. Udostępnij proszę ten post aby pomóc mi dotrzeć do większego grona odbiorców. Dzięki i do zobaczenia w kolejnym poradniku.

Resources

Ready to use project you can find in my GitLab. If you prefer video you can find the tutorial on my YouTube channel.

Prepare the scene

Let’s start with preparing some nice texture that we want to scroll on sprite. In my case it is a night sky image with a size of 2048x2048px. After copying the texture to the Assets folder, it’s time to prepare the Canvas and Image objects. On Canvas Object I selected UI scale mode = Scale with screen size option and the resolution of 800x600px.

Then I adjust the Image to cover the entire visible area by centering the Image and setting the size to 1024x1024px. I assign the prepared texture of the night sky to the Image object.

Writing ScrollingTexture MonoBehaviour

Now that we have a prepared test scene, it’s time to go trough to the implementation of the script responsible for scrolling the texture. Below I have presented one of its variants. I suggest that you read it before we dive into its detailed description, because there is a little hitch lurking there that is not obvious. I would like to add that apart from copying the script, the texture parameters must also be adjusted, which will be described in the next section.

using UnityEngine;
using UnityEngine.UI;

[RequireComponent(typeof(Image))]
public class ScrollTexture : MonoBehaviour
{
    private Image _image;
    [SerializeField] private Vector2 speed;

    void Start()
    {
        _image = GetComponent<Image>();
        _image.material = new Material(_image.material); //Clone the original material
    }

    void Update()
    {
        _image.material.mainTextureOffset += speed * Time.deltaTime;
    }
}

We start the script analysis with the parameters displayed to the editor. In our case it is speed, which is a 2D vector and denotes the speed of scrolling in one second. The value of 1 means that the entire texture is scrolled in one second.

Let’s jump to the Update method for a moment. This is the heart of the script, and in it a fairly simple operation that updates the offset of the main texture by the product of speed and time – that is, the distance.

However, the most important part, is what happens in the Awake method, i.e. cloning the material assigned to our Image. Sprite 2D textures share one material instance. So if we update, for example, the mainTextureOffset property (as in our case), the effect of scrolling the texture will be applied to all Sprites that use it. In order for the texture scrolling effect to apply only to the object with the ScrollTexture component, it is necessary to create a copy of the material and assign it to the object. And this is what happens in the Awake method.

Adding ScrollTexture script to the scene

We add the script like any other component – by dragging it onto the selected GameObject. Set the value of speed property to some low value – let’s say – 0.1 texture per second.

Texture adjusting

If you have already run the simulation at this stage, you have probably noticed that the texture, after scrolling to the end, stretches the last pixels – drawing specific lines – instead of repeating itself.

This specific effect is due to the default setting of the Wrap Mode = Clamp property on the texture. To achieve the repeating effect just change the Wrap Mode = Repeat on the texture of the sky. After sunning the simulation you should see nice texture scrolling effect.

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.

1. Missing Cinemachine package

At first, ensure that you have installed Cinemachine package in your unity project. Open Window -> Package Manager and choose Packages in project from the top menu. If you have not installed Cinamechine just switch to Unity Registry from the top menu, search for Cinemachine and install it.

2. Missing assembly reference

If you have an assembly definition file in your project ensure that you have linked com.unity.cinemachine assembly to it. In the following case I created a Main.afmdef file in on of the directory of my project. Try to locate the assembly definition file in your project going up from the directory contains the problematic script. Select the assembly definition file and add Assembly Definition Reference to the list as it is shown below.

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.

1. Prepare basic client and server C# projects. In the following step I show you how to set dependency between mentioned projects, to force right build order and then to perform copy result artefacts to the game resources directory.
2. Create simple working FiveM plug-ins. From this part of the tutorial you will learn how to create very basic pair of plug-ins – client and server side.
3. Passing data from the game client to the FiveM server. In the following step you will register a client command, that displays chat message on the screen. After that you enrich it with ability to emit event to the server. At the end, you will display the received message to the sever console.
4. In the final step of our journey, you will start from creating MySQL connection to the real database. After that you will use it to call insert statement that allows you to store data in the database.

Here you can find the video version of the tutorial

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.

Watch the tutorial on YouTube

Here you can find the video version of the tutorial.

How to implement a custom page transition in Ionic with Angular

Lets suppose that you want to add fade out effect to all page transitions in your Ionic application. The best place to customize animation for this purpose is ion-router-outlet. According to the Ionic documentation you can pass a custom function as the “animation” property of ion-router-outlet.

Edit app.component.html file and set “myCustomPageTransition” value as the animation property of ion-router-outlet.

<ion-app>
  <ion-router-outlet [animation]="myCustomPageTransition"></ion-router-outlet>
</ion-app>

Then edit app.component.ts file and create myCustomPageTransition property as is shown below. Please not that you can use both enteringEl and leavingEl in your animation.

import { Component } from '@angular/core';

import { AnimationController, Platform } from '@ionic/angular';
import { SplashScreen } from '@ionic-native/splash-screen/ngx';
import { StatusBar } from '@ionic-native/status-bar/ngx';

@Component({
  selector: 'app-root',
  templateUrl: 'app.component.html',
  styleUrls: ['app.component.scss']
})
export class AppComponent {
myCustomPageTransition = ((baseEl: any, opts?: any) => { 
    console.log("opts.enteringEl:"  + opts.enteringEl); //Entering Element - New Page
    console.log("opts.leavingEl:"  + opts.leavingEl);   //Leaving Element - Current Page
    var anim1 = this.animationCtrl.create()
      .addElement(opts.leavingEl)
      .duration(2000)
      .iterations(1)
      .easing('ease-out')
      .fromTo('opacity', '1', '0.0')
    var anim2 = this.animationCtrl.create()
      .addElement(opts.enteringEl)
      .duration(2000)
      .iterations(1)
      .easing('ease-out')
      .fromTo('opacity', '0.0', '1')
     var anim2 = this.animationCtrl.create()
      .duration(2000)
      .iterations(1)
      .addAnimation([anim1, anim2]);
    return anim2;
});

  constructor(
    private platform: Platform,
    private splashScreen: SplashScreen,
    private statusBar: StatusBar,
    private animationCtrl: AnimationController
  ) {
    this.initializeApp();
  }

  initializeApp() {
    this.platform.ready().then(() => {
      this.statusBar.styleDefault();
      this.splashScreen.hide();
    });
  }
}

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.

Resources

GitLab: java-singletons

Java thread safe singleton implementation without lazy loading

The easiest and thread safe singleton implementation in Java is to use enum class. It might be not intuitive but it works perfect if you don’t need lazy loading. Enum instances are guaranteed to be created exactly once that you don’t have to worry about thread safe initialization. So let’s see how the implementation looks like in the following example:

public enum DummySingleton {
    INSTANCE;

    public static DummySingleton getInstance() {
        return INSTANCE;
    }

    //This is dummy singleton's field
    private String dummyField = "Hello World!";

    //This is dummy singleton's method
    public void dummyMethod(String stringParam) {
        this.dummyField = stringParam;
    }

    //This is dummy singleton's method
    public String getDummyField() {
        return this.dummyField;
    }
}

Java thread safe singleton with lazy loading

In case, you need a thread safe singleton with lazy loading you can use the following pattern. As you can see, it consists of a double check of the singleton instance, to check if it is null. The first one is not synchronized so it’s fast and each thread can access it without additional synchronization cost. When the singleton instance returns to null then the synchronized initialization of the singleton starts to happens in order to ensure that exactly one instance of the class has been created.

public final class DummySingletonWithLazyLoading {
    private static DummySingletonWithLazyLoading instance = null;

    public static DummySingletonWithLazyLoading getInstance() {
        if (instance  == null ) {
            synchronized (DummySingletonWithLazyLoading.class) {
                if (instance  == null ) {
                    instance = initializeSingletonInstance();
                }
            }
        }
        return instance;
    }

    private DummySingletonWithLazyLoading() {
    }

    private static DummySingletonWithLazyLoading initializeSingletonInstance() {
        return new DummySingletonWithLazyLoading();
    }

    //This is dummy singleton's field
    private String dummyField = "Hello World!";

    //This is dummy singleton's method
    public void dummyMethod(String stringParam) {
        this.dummyField = stringParam;
    }

    //This is dummy singleton's method
    public String getDummyField() {
        return this.dummyField;
    }
}

Non thread safe single null check singleton implementation

In the last part I would like to explain to you why one of the most common singleton implementation is not threqd safe. Let’s have look at the following example. I intentionally modified the initialization time of the first singleton instance to emphasize what may happened in that scenario in multithreading environment. So let’s suppose that two threads run almost in the same time. From perspective of the first thread it run line 8 and because the instance is equal to null it run line 9. Then it have to wait some time for constructing the object (I my case it is 2000ms) then the reference of the object is assigned to instance. If the second thread runs line 8 during the first thread is waiting for the object construction the condition in the line 8 returns true, so the second thread starts to execute line 9. In that way two instances of the singleton were created instead of one.

import java.util.concurrent.atomic.AtomicInteger;

public class NonThreadSafeDummySingleton {
    public static final AtomicInteger TOTAL_INSTANCES = new AtomicInteger();
    private static NonThreadSafeDummySingleton instance;

    public static NonThreadSafeDummySingleton getInstance() {
        if (instance == null) {
            instance = new NonThreadSafeDummySingleton();
        }
        return instance;
    }

    public NonThreadSafeDummySingleton() {
        final int currentInstance = TOTAL_INSTANCES.incrementAndGet();
        System.out.println("Creating NonThreadSafeDummySingleton instance number: " + currentInstance);
        if (currentInstance == 1) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("NonThreadSafeDummySingleton instance number: " + currentInstance + " created");
    }
}

import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.concurrent.CompletableFuture;

import static org.junit.jupiter.api.Assertions.*;

class NonThreadSafeDummySingletonTest {
    @Test
    void doubleInstanceCreatedTest() {
        //given
        CompletableFuture<Void> c1 = CompletableFuture.supplyAsync(() -> {
            NonThreadSafeDummySingleton.getInstance();
            return null;
        });

        CompletableFuture<Void> c2 = CompletableFuture.supplyAsync(() -> {
            NonThreadSafeDummySingleton.getInstance();
            return null;
        });

        List<CompletableFuture> all = List.of(c1, c2);
        //when
        all.forEach(CompletableFuture::join);
        //then
        assertEquals(2, NonThreadSafeDummySingleton.TOTAL_INSTANCES.get());
    }
}

You can run the above test to ensure the wrong behaviour of the singleton implementation.

Creating NonThreadSafeDummySingleton instance number: 2
Creating NonThreadSafeDummySingleton instance number: 1
NonThreadSafeDummySingleton instance number: 2 created
NonThreadSafeDummySingleton instance number: 1 created

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.

Resources

• GitLab: time-traveling-demo
• Video tutorial on YouTube

Overview

Let’s think for a moment how we can test the behaviour of our application in different points of time.

The most obvious way is just to wait for time to pass by. But it’s not optimal solution and I think that I don’t have to explain it to you why.

Another solution is targeted to applications that you don’t have control over. It requires to modify bytecode using AspectJ in the way that all of getting time invocations return custom point in time, but it’s not covered in this tutorial.

The last way is targeted to applications that you have full control over. It’s to replace all of the getting time invocations (like LocalDateTime.now(), new Date() … etc) by invoking a custom DateTime provider. It’s very simple solution but it’s easy to implement and it works perfect.

Sample application

For the tutorial purposes I prepared simple SpringBoot application consists of TimeController exposed on the localhost:8080/time REST endpoint. It returns current time from BigBen bean which is responsible for returning current time in the application. 

package com.bettercoding.timetraveling.timetravelingdemo;

import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.ZonedDateTime;

@RestController
@RequestMapping("/time")
@RequiredArgsConstructor
public class TimeController {
    private final BigBen bigBen;

    @GetMapping("/")
    public ZonedDateTime getCurrentTime() {
        return bigBen.getApplicationTime();
    }
}

package com.bettercoding.timetraveling.timetravelingdemo;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

import java.time.ZonedDateTime;

@Component
@RequiredArgsConstructor
public class BigBen {
    public ZonedDateTime getApplicationTime() {
        return ZonedDateTime.now();
    }
}

package com.bettercoding.timetraveling.timetravelingdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TimeTravelingDemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(TimeTravelingDemoApplication.class, args);
	}

}

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.6.6</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.bettercoding.timetraveling</groupId>
	<artifactId>time-traveling-demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>time-traveling-demo</name>
	<description>Demo project of time traveling Spring Boot application</description>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

DateTimeProvider implementation

I decided to implement the following DateTImeProvider as a thread-safe Singleton. The easiest way to achieve it it to use enum class. DateTimeProvider consists of the internal clock, and following methods: 

• timeNow() – returns current time, based on internal clock
• setTime() – sets the internal clock as fix time or custom clock passed as parameter
• resetTime() – resets the internal clock to the default one.

package com.bettercoding.timetraveling.timetravelingdemo;

import java.time.Clock;
import java.time.ZonedDateTime;

public enum DateTimeProvider {
    INSTANCE;

    public static DateTimeProvider getInstance() {
        return INSTANCE;
    }

    private final Clock defaultClock = Clock.systemDefaultZone();
    private Clock clock = defaultClock;

    public ZonedDateTime timeNow() {
        return ZonedDateTime.now(clock);
    }

    public void setTime(ZonedDateTime zonedDateTime) {
        var customClock = Clock.fixed(zonedDateTime.toInstant(), zonedDateTime.getZone());
        this.setTime(customClock);
    }

    public void setTime(Clock clock) {
        this.clock = clock;
    }

    public void resetTime() {
        this.clock = this.defaultClock;
    }

}

What we have to do now is to replace all of getting time invocations(LocalDateTime, new Date(), etc…) by invoking DateTimeProvider.getInstance().timeNow(). So let’s modify BigBen class to use the implemented DateTimeProvider.

package com.bettercoding.timetraveling.timetravelingdemo;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

import java.time.ZonedDateTime;

@Component
@RequiredArgsConstructor
public class BigBen {

    public ZonedDateTime getApplicationTime() {
        return DateTimeProvider.getInstance().timeNow();
    }
}

Changing time in Unit Tests

Managing the time in UnitTest is very simple, the only thing you have to do is just to invoke DateTimeProvider.getInstance().setTime() before unit test. It’s very important to resetTime() after execution of unit tests because modified time may affect on the other unit tests. Please remember that you cannot run time traveling tests in parallel, because time set in one thread may be overridden by another thread.

package com.bettercoding.timetraveling.timetravelingdemo;


import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class BigBenTimeTravelingUnitTest {

    @BeforeAll
    static void setup() {
        ZonedDateTime customAppTime = ZonedDateTime.parse("1990-01-02T11:00:56+02:00", DateTimeFormatter.ISO_ZONED_DATE_TIME);
        DateTimeProvider.getInstance().setTime(customAppTime);
    }

    @AfterAll
    static void cleanup() {
        DateTimeProvider.getInstance().resetTime();
    }

    @Test
    void timeTravelingTest() {
        //given
        ZonedDateTime expectedTime = ZonedDateTime.parse("1990-01-02T11:00:56+02:00", DateTimeFormatter.ISO_ZONED_DATE_TIME);
        BigBen bigBen = new BigBen();
        //when
        var applicationTime = bigBen.getApplicationTime();
        //then
        Assertions.assertEquals(expectedTime, applicationTime);
    }
}

Managing the time in Integration Tests

Let’s modify BigBen class to use DateTimeProvider bean instead of invoking DateTimeProvider.getInstance().timeNow() directly. This step is not necessary, but I would like to show you, that you can do it too. 

package com.bettercoding.timetraveling.timetravelingdemo;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

import java.time.ZonedDateTime;

@Component
@RequiredArgsConstructor
public class BigBen {
    private final DateTimeProvider dateTimeProvider;

    public ZonedDateTime getApplicationTime() {
        return dateTimeProvider.timeNow();
    }
}

Before you you run the application you have to provide DateTimeProvider bean configuration. Please, don’t mark DateTimeProvider as a component. It’s very important to create a custom bean configuration that you return DateTimeProvider.getInstance() instead creating new instance.

package com.bettercoding.timetraveling.timetravelingdemo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TimeConfiguration {
    @Bean
    DateTimeProvider dateTimeProvider() {
        return DateTimeProvider.getInstance();
    }
}

If you made all of the previous steps you can modify the time in the similar way as you made it in the unit tests case.

package com.bettercoding.timetraveling.timetravelingdemo;

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

@SpringBootTest
class TimeTravelingDemoApplicationTests {
	@Autowired
	private BigBen bigBen;

	@BeforeAll
	static void setup() {
		ZonedDateTime customAppTime = ZonedDateTime.parse("1990-01-02T11:00:56+02:00", DateTimeFormatter.ISO_ZONED_DATE_TIME);
		DateTimeProvider.getInstance().setTime(customAppTime);
	}

	@AfterAll
	static void cleanup() {
		DateTimeProvider.getInstance().resetTime();
	}

	@Test
	void contextLoads() {
	}

	@Test
	void timeTravelTest() {
		//given
		ZonedDateTime expectedTime = ZonedDateTime.parse("1990-01-02T11:00:56+02:00", DateTimeFormatter.ISO_ZONED_DATE_TIME);
		//when
		ZonedDateTime applicationTime = bigBen.getApplicationTime();
		//then
		Assertions.assertEquals(expectedTime, applicationTime);
	}

}

Managing time in End2End testing

End2End testing is usually performed in some test environment that our application exists in and it is managed by some external application (for example TestNg and Selenium based application). Let’s call it End2EndTestPlayer. The application is responsible for playing a test scenario across tested applications. 

The easiest way to test our application in such environment is to expose some REST endpoint that you can set and reset previously implemented DateDimeProvider externally. The following TimeManagementController exposes POST method on /time-management/ resource that allows you to set the time in the application and it also exposes DELETE method for resetting the time. 

It’s not a good idea to always expose the TimeManagementController (for example in production environment) so you can add @ConditionalOnPropoerty annotation and use time-management.enable property to manage environments where the changing time feature should be enabled.

package com.bettercoding.timetraveling.timetravelingdemo;

import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.web.bind.annotation.*;

import java.time.ZonedDateTime;

@RestController
@RequestMapping("/time-management")
@ConditionalOnProperty(prefix = "time-management", name = "enabled", havingValue = "true")
@RequiredArgsConstructor
public class TimeManagementController {
    private final DateTimeProvider dateTimeProvider;

    @PostMapping("/")
    public void changeApplicationTime(@RequestBody ChangeApplicationTimeRequest changeApplicationTimeRequest) {
        this.dateTimeProvider.setTime(changeApplicationTimeRequest.getZonedDateTime());
    }

    @DeleteMapping
    public void resetApplicationTime() {
        this.dateTimeProvider.resetTime();
    }

    @Data
    private static class ChangeApplicationTimeRequest {
        ZonedDateTime zonedDateTime;
    }
}

time-management:
  enabled: true

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.

Resources

GitLab: springboot-prototype-scope-inside-singleton

The Problem

Let’s suppose that we have CoffeeMachine and DisposableCup components like below. We would like to achieve the effect that the CoffeeMachine always uses a new cup when brewing coffee, so that’s why we changed the default singleton to prototype scope on DisposableCup component.

package com.bettercoding.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CoffeeMachine {
    @Autowired
    public final DisposableCup disposableCup;

    public DisposableCup brewCoffee() {
        System.out.printf("Brewing coffee in [%s]\n", disposableCup.getName());
        return disposableCup;
    }
}

package com.bettercoding.demo;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import java.util.concurrent.atomic.AtomicInteger;

@Component
@Scope(scopeName = "prototype")
public class DisposableCup {
    private static final AtomicInteger TOTAL_CUPS = new AtomicInteger();
    private final String name;

    public DisposableCup() {
        this.name = "Disposable cup number " + TOTAL_CUPS.incrementAndGet();
    }

    public String getName() {
        return name;
    }
}

package com.bettercoding.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ScopesDemoApp implements CommandLineRunner {


    @Autowired
    private CoffeeMachine coffeeMachine;

    public static void main(String[] args) {
        SpringApplication.run(ScopesDemoApp.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        coffeeMachine.brewCoffee();
        coffeeMachine.brewCoffee();
        coffeeMachine.brewCoffee();
    }
}

But… When we run the application we got the result like below:

Brewing coffee in [Disposable cup number 1]
Brewing coffee in [Disposable cup number 1]
Brewing coffee in [Disposable cup number 1]

As you can see CoffeeMachine uses the same cup instance for each brewing coffee. So what’s wrong with the code? The problem is understanding how Spring inject’s dependencies. It does it only once – during bean creation process. It means that once injected reference doesn’t change through the whole bean’s life even if the reference’s life scope is shorter than the bean’s life scope it is injected to. There is no difference if you use @Autowierd on a class field or you inject dependencies via class constructor.

The solution

In order for the CoffeeMachine to always use a new cup when brewing coffee you need to inject ObjectFactory<DisposableCup> and then just get necessary component instance from the factory. So let’s modify the CoffeMachine componet

package com.bettercoding.demo;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class CoffeeMachine {
    @Autowired
    public ObjectFactory<DisposableCup> disposableCupObjectFactory;

    public DisposableCup brewCoffee() {
        DisposableCup aCup = disposableCupObjectFactory.getObject();
        System.out.printf("Brewing coffee in [%s]\n", aCup.getName());
        return aCup;
    }
}

The last thing to do is to run the application again to ensure that everything works like we expect.

Brewing coffee in [Disposable cup number 1]
Brewing coffee in [Disposable cup number 2]
Brewing coffee in [Disposable cup number 3]

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.

The problem

Let’s suppose that we have ShipmentService with delivery metod like below and we would like to test it. As you may see the delivery method calls OrderService to get delivery metod selected for the specific order and then it calls orderService.setDeliveryStatus with different deliveryStatus depends on the deliveryMethod.

public class ShipmentService {
    private final OrderService orderService;

    public ShipmentService(OrderService orderService) {
        this.orderService = orderService;
    }

    public void deliver(String orderId) {
        String deliveryMethod = orderService.getDeliveryMethod(orderId);
        if (deliveryMethod.equals("CAR")) {
            orderService.setDeliveryStatus("Delivered by CAR");
        } else {
            orderService.setDeliveryStatus("Unsupported delivery method");
        }
    }
}

public interface OrderService {
    String getDeliveryMethod(String orderId);

    void setDeliveryStatus(String deliveryMethod);
}

Let’s try to create Spock test. When you run the following test you got NullPointerException in ShipmentService.java:10, because mocked orderService.getDeliveryMethod(orderId) returns null.

import spock.lang.Specification

class ShipmentServiceTest extends Specification {
  def "delivery should set 'Delivered by CAR' status when order's delivery method is CAR"() {
    given:
      OrderService orderService = Mock()
      ShipmentService shipmentService = new ShipmentService(orderService)
    when:
      shipmentService.deliver("1")
    then:
      1 * orderService.getDeliveryMethod("1")
      1 * orderService.setDeliveryStatus("Delivered by CAR")
  }
}

Watch the solution on YouTube

Here you can find the video version of the tutorial

Wrong solution

The first thought to deal with it may be to use Stub instead of Mock, but it’s a dead end. Why? Let’s run the code below to find out.

import spock.lang.Specification

class ShipmentServiceTest extends Specification {
  def "delivery should set 'Delivered by CAR' status when order's delivery method is CAR"() {
    given:
      OrderService orderService = Stub()
      orderService.getDeliveryMethod("1") >> "CAR"
      ShipmentService shipmentService = new ShipmentService(orderService)
    when:
      shipmentService.deliver("1")
    then:
      1 * orderService.getDeliveryMethod("1")
      1 * orderService.setDeliveryStatus("Delivered by CAR")
  }
}

Of course we got InvalidSpecException like below, because we cannot use Stub for testing interaction.

org.spockframework.runtime.InvalidSpecException: Stub 'orderService' matches the following required interaction:

1 * orderService.getDeliveryMethod("1")   (0 invocations)

Remove the cardinality (e.g. '1 *'), or turn the stub into a mock.

Proper solution

The right solution of the problem is to add return value “CAR” to place when we test the first interaction. It means that we expect exactly once invocation of orderService.getDeliveryMethod with argument “1” which should return mocked value “CAR” instead if null. More you can find in the official Spock documentation.

import spock.lang.Specification

class ShipmentServiceTest extends Specification {
  def "delivery should set 'Delivered by CAR' status when order's delivery method is CAR"() {
    given:
      OrderService orderService = Mock()
      ShipmentService shipmentService = new ShipmentService(orderService)
    when:
      shipmentService.deliver("1")
    then:
      1 * orderService.getDeliveryMethod("1") >> "CAR"
      1 * orderService.setDeliveryStatus("Delivered by CAR")
  }
}

Bonus: How to parametrize the test to cover all of the conditions

In our case we can introduce orderDeliveryMethod and expectedDeliveryStatus parameters to paramtertize test input data and the expectation.

import spock.lang.Specification

class ShipmentServiceTest extends Specification {
  def "delivery should set '#expectedDeliveryStatus' status when order's delivery method is '#orderDeliveryMethod'"() {
    given:
      OrderService orderService = Mock()
      ShipmentService shipmentService = new ShipmentService(orderService)
    when:
      shipmentService.deliver("1")
    then:
      1 * orderService.getDeliveryMethod("1") >> orderDeliveryMethod
      1 * orderService.setDeliveryStatus(expectedDeliveryStatus)
    where:
      orderDeliveryMethod || expectedDeliveryStatus
      "CAR"               || "Delivered by CAR"
      "SHIP"              || "Unsupported delivery method"
  }
}

That’s all what I’ve prepared for you in this tutorial, if I helped you, please consider sharing this post to help me gain a wider audience.
Thanks and I hope to see you in my next tutorial.