Premium multi layout Jekyll theme

Gabriel N Voicu — Mon, 13 Dec 2021 07:44:11 +0000

Premium theme using Jekyll version 4.1.2 & Bootstrap 5
Multipurpose (multiple homepage layouts)
Fully ready for production within minutes
Responsive, SEO Friendly, and Mobile optimized
Step by step documentation

USE: ZEESPIREHOLIDAYS code to get 35$ discount

Checkout our demos

Support: office@zeespire.com

Details:

Three homepage designs which you can choose from
Easily create and use your own Bootstrap designs
Includes multiple blog posts and frontpage as sample content
Customizable through config files and properties:
show/hide authors
show/hide dates
show/hide social integrations
show/hide watermark
show/hide selected posts on the front page
change footer color
Has Authors, Posts, Categories features
Supports multiple image sizes for fast loading
Lightbox and Image galleries support
Code snippets highlight
Git helper scripts (.bat) for easy GIT interaction
Jekyll helper scripts (.bat) to easily build or start HTTP server locally
100% Responsive
Many SEO features; Open Graph protocol; schema.org using Microdata; meta tags
No dependency on external resources
Track your visitors with Google Tag Manager or Google Analytics integration
YouTube and other video website support for embedded videos
Pinterest integration
Links and icons to other social platforms like YouTube, Facebook, Instagram, Medium, TikTok, Pinterest (hidden if not needed)
Search feature
Clean code
Favicons for all types of devices
.htaccess redirects with HTTPS support
Minimized HTML CSS and JS code on build for super speed
Sitemap with latest modification date
RSS feed
Great documentation and support in max. 48 hours
Easy to upgrade Jekyll and Bootstrap version
Easy to deploy, customize and extend

Jumpstart Testing with Mockito and JUnit5

Gabriel N Voicu — Thu, 02 Jul 2020 07:07:03 +0000

In this article, we will see JUnit and Mockito in action using 2 Java components, a service class, and a repository class.

We will start by creating the classes and then write tests in different ways to use concepts like, assert, verify, check for thrown exception, ArgumentMatcher and ArgumentCaptor. At last, we will create cleaner tests by extracting the duplicated code and even use Mockito annotations. We will not focus on having 100% code coverage.

Code under test
DataRepository.java

public interface DataRepository {
    int[] retrieveAllData();
    int getStoredSumById(int id);
    void save(Object o);
}

DataService.java

public interface DataService {
    int calculateSum();
    void setDataRepository(DataRepository dataRepository);
    int calculateNewSum(int id);
    void save(Data o);
}

DataServiceImpl.java

public class DataServiceImpl implements DataService {

    private DataRepository dataRepository;

    public void setDataRepository(DataRepository dataRepository) {
        this.dataRepository = dataRepository;
    }

    public int calculateSum(){
        int sum = 0;
        for(int value : dataRepository.retrieveAllData()){
            sum += value;
        }
        return sum;
    }

    public int calculateNewSum(int id){
        int sum = dataRepository.getStoredSumById(id);
        return sum + sum;
    }

    public void save(Data o){
        o = new Data(o.getName().toUpperCase());
        dataRepository.save(o);
    }
}

Data.java

public class Data {
    private String name;
    // constructors, getters and setters
}

Unit tests without Mockito annotations
Test for calculateSum() method from service class, mocking repository. In this test, we are assuming that the retrieveAllData() mocked method from the repository returns an array with data.

@Test
public void calculateSum_Should_ReturnResult_When_DataIsProvided() {
    //create service under test
    DataService ms = new DataServiceImpl();

    //mock repository to test service in isolation
    DataRepository dataRepositoryMock = mock(DataRepository.class);
    when(dataRepositoryMock.retrieveAllData()).thenReturn(new int[]{1, 2, 3});

    //set mock to service
    ms.setDataRepository(dataRepositoryMock);

    //call method under test
    int result = ms.calculateSum();

    //verify if method on the mock is called by service under test
    //it is mostly used when a method that is called on a mock does not have a return
    verify(dataRepositoryMock, times(1)).retrieveAllData();

    //assert result
    assertEquals(6, result);
}

Test for calculateSum() method from service class, mocking repository. We are assuming that the retrieveAllData() mocked method from the repository returns an array without data.

@Test
public void calculateSum_Should_ReturnZero_When_DataIsEmpty() {
    //create service under test
    DataService ms = new DataServiceImpl();

    //mock repository to test service in isolation
    DataRepository dataRepositoryMock = mock(DataRepository.class);
    when(dataRepositoryMock.retrieveAllData()).thenReturn(new int[]{});

    //set mock to service
    ms.setDataRepository(dataRepositoryMock);

    //call method under test
    int result = ms.calculateSum();

    //verify if method on the mock is called by service under test
    verify(dataRepositoryMock, times(1)).retrieveAllData();

    //assert result
    assertEquals(0, result);
}

Test for calculateSum() method from service class, mocking repository. Assuming that retrieveAllData() mocked method from the repository returns null, causing the calculateSum() method from service class to throw a NullPointerException.

@Test
public void calculateSum_Should_ThrowException_When_DataIsNull() {
    assertThrows(NullPointerException.class, () -> {
        //create service under test
        DataService ms = new DataServiceImpl();

        //mock repository to test service in isolation
        DataRepository dataRepositoryMock = mock(DataRepository.class);
        when(dataRepositoryMock.retrieveAllData()).thenReturn(null);

        //set mock to service
        ms.setDataRepository(dataRepositoryMock);

        //call method under test
        ms.calculateSum();
    });
}

Test for calculateNewSum() method from service class, mocking repository using ArgumentMatchers. In this test, we are assuming that getStoredSumById() mocked method from the repository returns 2. The new topic introduced here are ArgumentMatchers like any(), anyInt(), etc. that can be used to replace an actual argument to make tests more generic.

@Test
void calculateNewSum_Should_ReturnResult_When_DataIsProvided() {
    //create service under test
    DataService ms = new DataServiceImpl();

    //mock repository to test service in isolation
    DataRepository dataRepositoryMock = mock(DataRepository.class);

    //return 2 when method is called with any int value
    when(dataRepositoryMock.getStoredSumById(anyInt())).thenReturn(2);

    //set mock to service
    ms.setDataRepository(dataRepositoryMock);

    //call method under test
    int result = ms.calculateNewSum(1);

    //verify if method on the mock is called by service under test with any argument
    verify(dataRepositoryMock, times(1)).getStoredSumById(anyInt());

    //assert result
    assertEquals(4, result);
}

Test for save() method from service class, mocking repository. In this case, the save() method from the service class doesn’t return anything to be asserted. We can use an ArgumentCaptor to check if the save() method from the repository class is called with expected arguments.

@Test
void save_ShouldCallRepository_With_GivenParam() {
    // create service under test
    DataService ms = new DataServiceImpl();

    // mock repository to test service in isolation
    DataRepository dataRepositoryMock = mock(DataRepository.class);

    // set mock to service
    ms.setDataRepository(dataRepositoryMock);

    // call method under test
    Data o = new Data("MockitoObject");
    ms.save(o);

    //create expected object
    Data expected = new Data("MOCKITOOBJECT");

    // because the method does not return anything we can check
    // if mock method was called with an expected parameter
    ArgumentCaptor<Data> captor = ArgumentCaptor.forClass(Data.class);
    verify(dataRepositoryMock, times(1)).save(captor.capture());

    //assert captured argument
    assertEquals(expected, captor.getValue());
}

The entire article was published at https://weinspire.tech

Hexagonal Architecture

Gabriel N Voicu — Wed, 25 Mar 2020 15:58:49 +0000

1. Overview

Hexagonal Architecture is an architectural design pattern that makes the application highly maintainable and fully testable.
It keeps the important parts of the application isolated from outer components.
Components are integrated into the core through ports and adapters.
The core comprises business logic and domain layers.
Also known as Ports and Adapters Pattern it has a lot of benefits visible in the long term.
Above all, testing and changing the application are easy and cost-effective.

The entire article was published at https://weinspire.tech on October 18, 2019.

DEV Community: Gabriel N Voicu

Premium multi layout Jekyll theme

Jumpstart Testing with Mockito and JUnit5

Hexagonal Architecture

1. Overview