enhancement: adding test cases

enhancement/adding-test-cases

.github/workflows/maven.yml

@@ -17,5 +17,9 @@ jobs:
         java-version: '21'
         distribution: 'adopt'
         cache: maven
+    - name: Set up Docker
+      uses: docker/setup-buildx-action@v2
     - name: Compile project
       run: mvn compile
+    - name: Execute tests
+      run: mvn test

pom.xml

@@ -80,6 +80,17 @@
 			<artifactId>lombok</artifactId>
 			<optional>true</optional>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.testcontainers</groupId>
+			<artifactId>mysql</artifactId>
+			<version>${testcontainer.version}</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
 
 	<build>

src/test/java/com/behl/cachetropolis/CacheExtension.java

@@ -0,0 +1,38 @@
+package com.behl.cachetropolis;
+
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.springframework.context.annotation.Configuration;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.utility.DockerImageName;
+
+import lombok.extern.slf4j.Slf4j;
+import net.bytebuddy.utility.RandomString;
+
+@Slf4j
+@Configuration
+public class CacheExtension implements BeforeAllCallback {
+
+	private static final int REDIS_PORT = 6379;
+	private static final String REDIS_PASSWORD = RandomString.make(10);
+	private static final DockerImageName REDIS_IMAGE = DockerImageName.parse("redis:7.2.3-alpine");
+
+	private static final GenericContainer<?> redisContainer = new GenericContainer<>(REDIS_IMAGE)
+			.withExposedPorts(REDIS_PORT)
+			.withCommand("redis-server", "--requirepass", REDIS_PASSWORD);
+
+	@Override
+	public void beforeAll(final ExtensionContext context) {
+		log.info("Creating cache container : {}", REDIS_IMAGE);
+		redisContainer.start();
+		addCacheProperties();
+		log.info("Successfully started cache container : {}", REDIS_IMAGE);
+	}
+
+	private void addCacheProperties() {
+		System.setProperty("spring.data.redis.host", redisContainer.getHost());
+		System.setProperty("spring.data.redis.port", String.valueOf(redisContainer.getMappedPort(REDIS_PORT)));
+		System.setProperty("spring.data.redis.password", REDIS_PASSWORD);
+	}
+
+}

src/test/java/com/behl/cachetropolis/DataSourceExtension.java

@@ -0,0 +1,32 @@
+package com.behl.cachetropolis;
+
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.springframework.context.annotation.Configuration;
+import org.testcontainers.containers.MySQLContainer;
+import org.testcontainers.utility.DockerImageName;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Configuration
+public class DataSourceExtension implements BeforeAllCallback {
+
+	private static final DockerImageName MYSQL_IMAGE = DockerImageName.parse("mysql:8");
+	private static final MySQLContainer<?> mySQLContainer = new MySQLContainer<>(MYSQL_IMAGE);
+
+	@Override
+	public void beforeAll(final ExtensionContext context) {
+		log.info("Creating datasource container : {}", MYSQL_IMAGE);
+		mySQLContainer.start();
+		addDataSourceProperties();
+		log.info("Successfully started datasource container : {}", MYSQL_IMAGE);
+	}
+
+	private void addDataSourceProperties() {
+		System.setProperty("spring.datasource.url", mySQLContainer.getJdbcUrl());
+		System.setProperty("spring.datasource.username", mySQLContainer.getUsername());
+		System.setProperty("spring.datasource.password", mySQLContainer.getPassword());
+	}
+
+}

src/test/java/com/behl/cachetropolis/repository/MasterHouseRepositoryTest.java

@@ -0,0 +1,63 @@
+package com.behl.cachetropolis.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import com.behl.cachetropolis.DataSourceExtension;
+import com.behl.cachetropolis.entity.MasterHouse;
+
+import junit.framework.AssertionFailedError;
+
+@DataJpaTest
+@ExtendWith(DataSourceExtension.class)
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+class MasterHouseRepositoryTest {
+
+	@Autowired
+	private MasterHouseRepository masterHouseRepository;
+
+	@Test
+	void shouldFetchRandomHouseRecordFromDataSource() {
+		// Fetch random house record from data source
+		Optional<MasterHouse> masterHouse = masterHouseRepository.fetchRandom();
+
+		// assert fetched record's attributes
+		assertThat(masterHouse).isPresent().get().satisfies(house -> {
+			assertThat(house.getId()).isNotNull();
+			assertThat(house.getName()).isNotNull();
+			assertThat(house.getCreatedAt()).isNotNull();
+			assertThat(house.getUpdatedAt()).isNotNull();
+		});
+	}
+
+	@Test
+	void shouldNotFetchSameHouseRecordForEachInvocation() {
+		// Retrieve IDs of all houses present in the data source
+		final List<UUID> houseIds = masterHouseRepository.findAll().stream().map(MasterHouse::getId).toList();
+		assertThat(houseIds).isNotEmpty().hasSizeGreaterThan(1);
+
+		// invoke method under test multiple times
+		final var batchSize = 100;
+		final List<MasterHouse> masterHouses = new ArrayList<MasterHouse>();
+		for (int i = 0; i < batchSize; i++) {
+			final var masterHouse = masterHouseRepository.fetchRandom().orElseThrow(AssertionFailedError::new);
+			masterHouses.add(masterHouse);
+		}
+
+		// Ensure randomly fetched houses contains all house-ids present in datasource
+		final var totalHouses = houseIds.size();
+		List<UUID> uniqueHouseIds = masterHouses.stream().map(MasterHouse::getId).distinct().toList();
+		assertThat(uniqueHouseIds).hasSize(totalHouses).containsAll(houseIds);
+	}
+
+}

src/test/java/com/behl/cachetropolis/repository/WizardRepositoryTest.java

@@ -0,0 +1,64 @@
+package com.behl.cachetropolis.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import java.util.UUID;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import com.behl.cachetropolis.DataSourceExtension;
+import com.behl.cachetropolis.entity.Wizard;
+
+import junit.framework.AssertionFailedError;
+import net.bytebuddy.utility.RandomString;
+
+@DataJpaTest
+@ExtendWith(DataSourceExtension.class)
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+class WizardRepositoryTest {
+
+	@Autowired
+	private WizardRepository wizardRepository;
+
+	@Autowired
+	private MasterHouseRepository masterHouseRepository;
+
+	@Test
+	void shouldReturnWizardListByHouseId() {
+		// fetch random house record from datasource
+		final var masterHouse = masterHouseRepository.fetchRandom().orElseThrow(AssertionFailedError::new);
+		final var houseId = masterHouse.getId();
+
+		// creare wizard record corresponding to fetched house
+		final var wizard = new Wizard();
+		final var firstName = RandomString.make();
+		wizard.setFirstName(firstName);
+		wizard.setGender("Male");
+		wizard.setHouseId(houseId);
+		wizardRepository.save(wizard);
+
+		// invoke method under test
+		List<Wizard> wizards = wizardRepository.findByHouseId(houseId);
+
+		// assert datasource response contains saved wizard record
+		assertThat(wizards).isNotEmpty().map(Wizard::getFirstName).contains(firstName);
+	}
+
+	@Test
+	void shouldReturnEmptyWizardListForInvalidHouseId() {
+		// generate random house-id
+		final var invalidHouseId = UUID.randomUUID();
+
+		// invoke method under test
+		List<Wizard> wizards = wizardRepository.findByHouseId(invalidHouseId);
+
+		// assert datasource response is empty list
+		assertThat(wizards).isEmpty();
+	}
+
+}

src/test/java/com/behl/cachetropolis/service/MasterHouseServiceTest.java

@@ -0,0 +1,139 @@
+package com.behl.cachetropolis.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.util.List;
+import java.util.UUID;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.SpyBean;
+import org.springframework.cache.CacheManager;
+
+import com.behl.cachetropolis.CacheExtension;
+import com.behl.cachetropolis.DataSourceExtension;
+import com.behl.cachetropolis.dto.HouseDto;
+import com.behl.cachetropolis.dto.WizardDto;
+import com.behl.cachetropolis.entity.Wizard;
+import com.behl.cachetropolis.exception.InvalidHouseIdException;
+import com.behl.cachetropolis.repository.MasterHouseRepository;
+import com.behl.cachetropolis.repository.WizardRepository;
+
+import junit.framework.AssertionFailedError;
+import net.bytebuddy.utility.RandomString;
+
+@SpringBootTest
+@ExtendWith({ DataSourceExtension.class, CacheExtension.class })
+class MasterHouseServiceTest {
+
+	@Autowired
+	private MasterHouseService masterHouseService;
+
+	@SpyBean
+	private WizardRepository wizardRepository;
+
+	@SpyBean
+	private MasterHouseRepository masterHouseRepository;
+
+	@Autowired
+	private CacheManager listCacheManager;
+
+	@Test
+	void shouldRetrieveWizardsAgainstValidHouseId() {
+		// fetch random house record from datasource
+		final var house = masterHouseRepository.fetchRandom().orElseThrow(AssertionFailedError::new);
+
+		// create wizard record
+		final var firstName = RandomString.make();
+		final var lastName = RandomString.make();
+		final var wizard = new Wizard();
+		wizard.setFirstName(firstName);
+		wizard.setLastName(lastName);
+		wizard.setGender("Male");
+		wizard.setHouseId(house.getId());
+		wizardRepository.save(wizard);
+
+		// invoke method under test
+		final List<WizardDto> retrievedWizards = masterHouseService.retrieveWizardsByHouseId(house.getId());
+
+		// assert presence of saved wizard in retrieved records and verify datasource interaction
+		assertThat(retrievedWizards).isNotNull().isNotEmpty();
+		assertThat(retrievedWizards).map(WizardDto::getFirstName).contains(firstName);
+		assertThat(retrievedWizards).map(WizardDto::getLastName).contains(lastName);
+		verify(wizardRepository, times(1)).findByHouseId(house.getId());
+	}
+
+	@Test
+	void shouldRetrieveWizardRecordsByHouseIdFromCacheAfterInitialDatabaseRetrieval() {
+		// fetch random house record from datasource
+		final var house = masterHouseRepository.fetchRandom().orElseThrow(AssertionFailedError::new);
+		final var houseId = house.getId();
+
+		// create wizard record
+		final var firstName = RandomString.make();
+		final var lastName = RandomString.make();
+		final var wizard = new Wizard();
+		wizard.setFirstName(firstName);
+		wizard.setLastName(lastName);
+		wizard.setGender("Male");
+		wizard.setHouseId(houseId);
+		wizardRepository.save(wizard);
+
+		// assert cache does not contain wizard records corresponding to house-id
+		var cachedWizardRecords = listCacheManager.getCache("wizards").get(houseId);
+		assertThat(cachedWizardRecords).isNull();
+
+		// invoke method under test and assert that initial retrieval is done from datasource
+		masterHouseService.retrieveWizardsByHouseId(houseId);
+		verify(wizardRepository, times(1)).findByHouseId(houseId);
+		Mockito.clearInvocations(wizardRepository);
+
+		// invoke method under test multiple times to verify subsequent reads are made from cache and datasource is not queried
+		final var queryTimes = 100;
+		for (int i = 1; i < queryTimes; i++) {
+			masterHouseService.retrieveWizardsByHouseId(houseId);
+		}
+		verify(wizardRepository, times(0)).findByHouseId(houseId);
+	}
+
+	@Test
+	void shouldThrowExceptionForInvalidHouseId() {
+		// prepare invalid house-id
+		final var houseId = UUID.randomUUID();
+
+		// invoke method under test and verify datasource interaction
+		assertThrows(InvalidHouseIdException.class, () -> masterHouseService.retrieveWizardsByHouseId(houseId));
+		verify(wizardRepository, times(1)).findByHouseId(houseId);
+	}
+
+	@Test
+	void shouldReturnNonEmptyHouseListPostFlywayMigrationExecution() {
+		// Retrieve the list of house records saved in the datasource
+        final var retrievedHouses = masterHouseService.retrieve();
+
+        // Verify that the list of countries is not empty and flyway migration script is executed
+        assertThat(retrievedHouses).isNotNull().isNotEmpty().hasSizeGreaterThanOrEqualTo(4);
+        assertThat(retrievedHouses).map(HouseDto::getId).doesNotContainNull();
+        assertThat(retrievedHouses).map(HouseDto::getName).doesNotContainNull();
+	}
+
+	@Test
+	void shouldFetchRandomHouseRecordFromDataSource() {
+		// invoke method under test
+		final var retrievedHouse = masterHouseService.retrieveRandom();
+
+		// assert response attributes
+		assertThat(retrievedHouse).isNotNull().isInstanceOf(HouseDto.class)
+			.satisfies(house -> {
+				assertThat(house.getId()).isNotNull();
+				assertThat(house.getName()).isNotNull();
+		});
+	}
+
+}