2595 - add active field into series model, add tests for new field

src/main/kotlin/com/epam/brn/dto/SeriesDto.kt

@@ -13,5 +13,6 @@ data class SeriesDto(
     val name: String,
     val level: Int,
     val description: String? = "",
+    val active: Boolean = true,
     val subGroups: List<Long> = emptyList(),
 )

src/main/kotlin/com/epam/brn/model/Series.kt

@@ -25,6 +25,8 @@ class Series(
     @Column
     var level: Int,
     var description: String? = "",
+    @Column
+    var active: Boolean = true,
     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "exercise_group_id")
     var exerciseGroup: ExerciseGroup,

src/main/kotlin/com/epam/brn/repo/SeriesRepository.kt

@@ -22,8 +22,9 @@ interface SeriesRepository : CrudRepository<Series, Long> {
 
     fun findByNameIn(names: List<String>): List<Series>
 
-    @Query("select distinct s from Series s where s.exerciseGroup.id=?1")
-    fun findByExerciseGroupLike(groupId: Long): List<Series>
+    fun findDistinctByExerciseGroupIdAndActiveTrue(groupId: Long): List<Series>
+
+    fun findByIdAndActiveTrue(seriesId: Long): Series?
 
 //    @Query("select distinct s from Series s left JOIN FETCH s.exercises where s.id=?1")
 //    fun findSeriesWithExercisesById(groupId: Long): Optional<Series>

src/main/kotlin/com/epam/brn/service/SeriesService.kt

@@ -15,18 +15,18 @@ class SeriesService(
 
     @Cacheable("series")
     fun findSeriesForGroup(groupId: Long): List<SeriesDto> {
-        log.debug("try to find series for groupId=$groupId")
-        val series = seriesRepository.findByExerciseGroupLike(groupId)
-        return series.map { seriesEntry -> seriesEntry.toDto() }
+        log.debug("try to find active series for groupId=$groupId")
+        return seriesRepository
+            .findDistinctByExerciseGroupIdAndActiveTrue(groupId)
+            .map { it.toDto() }
     }
 
     @Cacheable("seriesDto")
     fun findSeriesDtoForId(seriesId: Long): SeriesDto {
-        log.debug("try to find series for seriesId=$seriesId")
-        val series =
-            seriesRepository
-                .findById(seriesId)
-                .orElseThrow { EntityNotFoundException("no series was found for id=$seriesId") }
-        return series.toDto()
+        log.debug("try to find active series for seriesId=$seriesId")
+        return seriesRepository
+            .findByIdAndActiveTrue(seriesId)
+            ?.toDto()
+            ?: throw EntityNotFoundException("no active series was found for id=$seriesId")
     }
 }

src/main/resources/db/migration/V220250909_2592.sql

@@ -0,0 +1,2 @@
+ALTER TABLE series
+ADD COLUMN active BOOLEAN DEFAULT TRUE;

src/test/kotlin/com/epam/brn/integration/SeriesControllerIT.kt

@@ -74,6 +74,33 @@ class SeriesControllerIT : BaseIT() {
         Assertions.assertEquals(series2.toDto(), resultSeries[1])
     }
 
+    @Test
+    fun `test get inactive series for group`() {
+        // GIVEN
+        val group = insertGroup()
+        insertInactiveSeries(group, series1Name)
+        val series2 = insertSeries(group, series2Name)
+        // WHEN
+        val resultAction =
+            mockMvc.perform(
+                MockMvcRequestBuilders
+                    .get(baseUrl)
+                    .param("groupId", group.id.toString())
+                    .contentType(MediaType.APPLICATION_JSON),
+            )
+        // THEN
+        resultAction
+            .andExpect(status().isOk)
+            .andExpect(MockMvcResultMatchers.content().contentType(MediaType.APPLICATION_JSON))
+        val responseJson = resultAction.andReturn().response.getContentAsString(StandardCharsets.UTF_8)
+        val baseResponseDto = objectMapper.readValue(responseJson, BrnResponse::class.java)
+        val seriesJson = gson.toJson(baseResponseDto.data)
+        val resultSeries: List<SeriesDto> =
+            objectMapper.readValue(seriesJson, object : TypeReference<List<SeriesDto>>() {})
+        Assertions.assertEquals(1, resultSeries.size)
+        Assertions.assertEquals(series2.toDto(), resultSeries[0])
+    }
+
     @Test
     fun `test get series for seriesId`() {
         // GIVEN
@@ -96,6 +123,31 @@ class SeriesControllerIT : BaseIT() {
         Assertions.assertEquals(series.toDto(), resultSeries)
     }
 
+    @Test
+    fun `test get inactive series for seriesId`() {
+        // GIVEN
+        val group = insertGroup()
+        val series = insertInactiveSeries(group, "series")
+        // WHEN
+        val resultAction =
+            mockMvc.perform(
+                MockMvcRequestBuilders
+                    .get("/series/${series.id}")
+                    .contentType(MediaType.APPLICATION_JSON),
+            )
+        // THEN
+        resultAction
+            .andExpect(status().isNotFound)
+            .andExpect(MockMvcResultMatchers.content().contentType(MediaType.APPLICATION_JSON))
+            .andExpect(
+                MockMvcResultMatchers
+                    .jsonPath("$.errors[0]")
+                    .value(
+                        "no active series was found for id=${series.id}",
+                    ),
+            )
+    }
+
     @Test
     fun `test get file format for seriesId`() {
         val group = insertGroup()
@@ -132,4 +184,20 @@ class SeriesControllerIT : BaseIT() {
             )
         return seriesRepository.save(series)
     }
+
+    private fun insertInactiveSeries(
+        group: ExerciseGroup,
+        name: String,
+    ): Series {
+        val series =
+            Series(
+                name = name,
+                description = "description",
+                exerciseGroup = group,
+                active = false,
+                level = 1,
+                type = ExerciseType.SINGLE_SIMPLE_WORDS.name,
+            )
+        return seriesRepository.save(series)
+    }
 }

src/test/kotlin/com/epam/brn/service/SeriesServiceTest.kt

@@ -14,7 +14,6 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertThrows
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
-import java.util.Optional
 
 @ExtendWith(MockKExtension::class)
 internal class SeriesServiceTest {
@@ -32,43 +31,73 @@ internal class SeriesServiceTest {
         val seriesDto = mockk<SeriesDto>()
         val listSeries = listOf(series)
         val expectedResult = listOf(seriesDto)
-        every { seriesRepository.findByExerciseGroupLike(groupId) } returns listSeries
+        every { series.active } returns true
+        every { seriesRepository.findDistinctByExerciseGroupIdAndActiveTrue(groupId) } returns listSeries
         every { series.toDto() } returns seriesDto
 
         // WHEN
         val actualResult = seriesService.findSeriesForGroup(groupId)
 
         // THEN
-        verify(exactly = 1) { seriesRepository.findByExerciseGroupLike(groupId) }
+        verify(exactly = 1) { seriesRepository.findDistinctByExerciseGroupIdAndActiveTrue(groupId) }
         assertEquals(expectedResult, actualResult)
     }
 
+    @Test
+    fun `should not get inactive series for group`() {
+        // GIVEN
+        val groupId: Long = 1
+        val listSeries = emptyList<Series>()
+        every { seriesRepository.findDistinctByExerciseGroupIdAndActiveTrue(groupId) } returns listSeries
+
+        // WHEN
+        val actualResult = seriesService.findSeriesForGroup(groupId)
+
+        // THEN
+        verify(exactly = 1) { seriesRepository.findDistinctByExerciseGroupIdAndActiveTrue(groupId) }
+        assertEquals(emptyList<SeriesDto>(), actualResult)
+    }
+
     @Test
     fun `should get series for id`() {
         // GIVEN
         val seriesId: Long = 1
         val series = mockk<Series>()
         val seriesDto = mockk<SeriesDto>()
-        every { seriesRepository.findById(seriesId) } returns Optional.of(series)
+        every { series.active } returns true
+        every { seriesRepository.findByIdAndActiveTrue(seriesId) } returns series
         every { series.toDto() } returns seriesDto
 
         // WHEN
         seriesService.findSeriesDtoForId(seriesId)
 
         // THEN
-        verify(exactly = 1) { seriesRepository.findById(seriesId) }
+        verify(exactly = 1) { seriesRepository.findByIdAndActiveTrue(seriesId) }
+    }
+
+    @Test
+    fun `should not get inactive series for id`() {
+        // GIVEN
+        val seriesId: Long = 1
+        every { seriesRepository.findByIdAndActiveTrue(seriesId) } returns null
+
+        // WHEN
+        assertThrows(EntityNotFoundException::class.java) { seriesService.findSeriesDtoForId(seriesId) }
+
+        // THEN
+        verify(exactly = 1) { seriesRepository.findByIdAndActiveTrue(seriesId) }
     }
 
     @Test
     fun `should not get series for id`() {
         // GIVEN
         val seriesId: Long = 1
-        every { seriesRepository.findById(seriesId) } returns Optional.empty()
+        every { seriesRepository.findByIdAndActiveTrue(seriesId) } returns null
 
         // WHEN
         assertThrows(EntityNotFoundException::class.java) { seriesService.findSeriesDtoForId(seriesId) }
 
         // THEN
-        verify(exactly = 1) { seriesRepository.findById(seriesId) }
+        verify(exactly = 1) { seriesRepository.findByIdAndActiveTrue(seriesId) }
     }
 }