diff --git a/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/actions/PatchEnvAction.kt b/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/actions/PatchEnvAction.kt index cbcafaef55..b89669212f 100644 --- a/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/actions/PatchEnvAction.kt +++ b/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/actions/PatchEnvAction.kt @@ -7,13 +7,15 @@ import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageErrorCode import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageException import fr.gouv.cacem.monitorenv.domain.mappers.PatchEntity import fr.gouv.cacem.monitorenv.domain.repositories.IEnvActionRepository +import fr.gouv.cacem.monitorenv.domain.validators.mission.EnvActionValidator import org.slf4j.LoggerFactory -import java.util.* +import java.util.UUID @UseCase class PatchEnvAction( private val envActionRepository: IEnvActionRepository, private val patchEnvAction: PatchEntity, + private val envActionValidator: EnvActionValidator, ) { private val logger = LoggerFactory.getLogger(PatchEnvAction::class.java) @@ -24,6 +26,7 @@ class PatchEnvAction( logger.info("Attempt to PATCH envaction $id") envActionRepository.findById(id)?.let { patchEnvAction.execute(it, patchableEnvActionEntity) + envActionValidator.validate(it) val patchedEnvAction = envActionRepository.save(it) logger.info("envaction $id patched") return patchedEnvAction diff --git a/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/missions/PatchMission.kt b/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/missions/PatchMission.kt index 5f4636e4e6..a31c0568da 100644 --- a/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/missions/PatchMission.kt +++ b/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/missions/PatchMission.kt @@ -8,12 +8,14 @@ import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageException import fr.gouv.cacem.monitorenv.domain.mappers.PatchEntity import fr.gouv.cacem.monitorenv.domain.repositories.IMissionRepository import fr.gouv.cacem.monitorenv.domain.use_cases.missions.dtos.MissionDetailsDTO +import fr.gouv.cacem.monitorenv.domain.validators.mission.MissionWithEnvActionsValidator import org.slf4j.LoggerFactory @UseCase class PatchMission( private val missionRepository: IMissionRepository, private val patchEntity: PatchEntity, + private val missionWithEnvActionsValidator: MissionWithEnvActionsValidator, ) { private val logger = LoggerFactory.getLogger(GetFullMissionWithFishAndRapportNavActions::class.java) @@ -24,6 +26,7 @@ class PatchMission( logger.info("Attempt to PATCH mission $id") missionRepository.findById(id)?.let { patchEntity.execute(it, patchableMissionEntity) + missionWithEnvActionsValidator.validate(it) val patchedMission = missionRepository.save(it) logger.info("Mission $id patched") return patchedMission diff --git a/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/EnvActionValidator.kt b/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/EnvActionValidator.kt new file mode 100644 index 0000000000..494f1806af --- /dev/null +++ b/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/EnvActionValidator.kt @@ -0,0 +1,88 @@ +package fr.gouv.cacem.monitorenv.domain.validators.mission + +import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.EnvActionEntity +import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.envActionControl.EnvActionControlEntity +import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.envActionControl.infraction.InfractionTypeEnum +import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.envActionSurveillance.EnvActionSurveillanceEntity +import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageErrorCode +import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageException +import fr.gouv.cacem.monitorenv.domain.validators.Validator +import org.springframework.stereotype.Component + +private const val NB_CHAR_MAX = 3 + +@Component +class EnvActionValidator : Validator { + override fun validate(envAction: EnvActionEntity) { + validateEnvAction(envAction) + } + + private fun validateEnvAction(envAction: EnvActionEntity) { + if (envAction is EnvActionControlEntity) { + validateCommonProperties(envAction) + validateInfractions(envAction) + } + if (envAction is EnvActionSurveillanceEntity) { + validateCommonProperties(envAction) + validateSurveillance(envAction) + } + } +} + +private fun validateInfractions(control: EnvActionControlEntity) { + val sumOfNbTarget = control.infractions?.sumOf { infraction -> infraction.nbTarget } + if (sumOfNbTarget != 0 && + sumOfNbTarget != null && + ( + control.actionNumberOfControls != null && + sumOfNbTarget > control.actionNumberOfControls + ) + ) { + throw BackendUsageException( + code = BackendUsageErrorCode.UNVALID_PROPERTY, + data = "Le nombre de cibles excède le nombre total de contrôles", + ) + } + + control.infractions?.forEach { infraction -> + if (infraction.infractionType !== InfractionTypeEnum.WAITING && + infraction.natinf?.isEmpty() == true + ) { + throw BackendUsageException( + code = BackendUsageErrorCode.UNVALID_PROPERTY, + data = + "Une infraction doit avoir une natinf si le type d'infraction n'est pas \"En attente\"", + ) + } + if (infraction.nbTarget < 1) { + throw BackendUsageException( + code = BackendUsageErrorCode.UNVALID_PROPERTY, + data = "le nombre minimum de cible est 1", + ) + } + } +} + +private fun validateSurveillance(surveillance: EnvActionSurveillanceEntity) { + if (surveillance.geom === null) { + throw BackendUsageException( + code = BackendUsageErrorCode.UNVALID_PROPERTY, + data = "La géométrie de la surveillance est obligatoire", + ) + } + if (surveillance.completedBy !== null && surveillance.completedBy.length != NB_CHAR_MAX) { + throw BackendUsageException( + code = BackendUsageErrorCode.UNVALID_PROPERTY, + data = "Le trigramme \"complété par\" doit avoir 3 lettres", + ) + } +} + +private fun validateCommonProperties(envAction: EnvActionEntity) { + if (envAction.openBy?.length != NB_CHAR_MAX) { + throw BackendUsageException( + code = BackendUsageErrorCode.UNVALID_PROPERTY, + data = "Le trigramme \"ouvert par\" doit avoir 3 lettres", + ) + } +} diff --git a/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/MissionWithEnvActionsValidator.kt b/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/MissionWithEnvActionsValidator.kt index 880320b58b..3bfc352301 100644 --- a/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/MissionWithEnvActionsValidator.kt +++ b/backend/src/main/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/MissionWithEnvActionsValidator.kt @@ -4,7 +4,6 @@ import fr.gouv.cacem.monitorenv.domain.entities.mission.MissionEntity import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.ActionTypeEnum import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.EnvActionEntity import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.envActionControl.EnvActionControlEntity -import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.envActionControl.infraction.InfractionTypeEnum import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.envActionSurveillance.EnvActionSurveillanceEntity import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageErrorCode import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageException @@ -17,6 +16,7 @@ private const val NB_CHAR_MAX = 3 @Component class MissionWithEnvActionsValidator( private val missionValidator: MissionValidator, + private val envActionValidator: EnvActionValidator, ) : Validator { private val logger = LoggerFactory.getLogger(MissionWithEnvActionsValidator::class.java) @@ -28,77 +28,21 @@ class MissionWithEnvActionsValidator( private fun validateEnvActions(mission: MissionEntity) { mission.envActions?.forEach { envAction -> + envActionValidator.validate(envAction) if (envAction is EnvActionControlEntity) { - validateControl(envAction, mission) + validateCommonDates(envAction, mission) } - if (envAction is EnvActionSurveillanceEntity) { - validateSurveillance(envAction, mission) - } - } - } - - private fun validateControl( - control: EnvActionControlEntity, - mission: MissionEntity, - ) { - validateEnvAction(control, mission) - - validateInfractions(control) - } - - private fun validateInfractions(control: EnvActionControlEntity) { - val sumOfNbTarget = control.infractions?.sumOf { infraction -> infraction.nbTarget } - if (sumOfNbTarget != 0 && - sumOfNbTarget != null && - ( - control.actionNumberOfControls != null && - sumOfNbTarget > control.actionNumberOfControls - ) - ) { - throw BackendUsageException( - code = BackendUsageErrorCode.UNVALID_PROPERTY, - data = "Le nombre de cibles excède le nombre total de contrôles", - ) - } - - control.infractions?.forEach { infraction -> - if (infraction.infractionType !== InfractionTypeEnum.WAITING && - infraction.natinf?.isEmpty() == true - ) { - throw BackendUsageException( - code = BackendUsageErrorCode.UNVALID_PROPERTY, - data = - "Une infraction doit avoir une natinf si le type d'infraction n'est pas \"En attente\"", - ) - } - if (infraction.nbTarget < 1) { - throw BackendUsageException( - code = BackendUsageErrorCode.UNVALID_PROPERTY, - data = "le nombre minimum de cible est 1", - ) + validateCommonDates(envAction, mission) + validateSurveillanceDates(envAction, mission) } } } - private fun validateSurveillance( + private fun validateSurveillanceDates( surveillance: EnvActionSurveillanceEntity, mission: MissionEntity, ) { - validateEnvAction(surveillance, mission) - - if (surveillance.geom === null) { - throw BackendUsageException( - code = BackendUsageErrorCode.UNVALID_PROPERTY, - data = "La géométrie de la surveillance est obligatoire", - ) - } - if (surveillance.completedBy !== null && surveillance.completedBy.length != NB_CHAR_MAX) { - throw BackendUsageException( - code = BackendUsageErrorCode.UNVALID_PROPERTY, - data = "Le trigramme \"complété par\" doit avoir 3 lettres", - ) - } if (surveillance.actionEndDateTimeUtc?.isAfter(mission.endDateTimeUtc) == true) { logger.info("Validating mission surveillance: ${surveillance.actionEndDateTimeUtc}") logger.info("Validating mission: ${mission.endDateTimeUtc}") @@ -117,7 +61,7 @@ class MissionWithEnvActionsValidator( } } - private fun validateEnvAction( + private fun validateCommonDates( envAction: EnvActionEntity, mission: MissionEntity, ) { @@ -141,11 +85,5 @@ class MissionWithEnvActionsValidator( "La date de début $actionType doit être antérieure à celle de fin de mission", ) } - if (envAction.openBy?.length != NB_CHAR_MAX) { - throw BackendUsageException( - code = BackendUsageErrorCode.UNVALID_PROPERTY, - data = "Le trigramme \"ouvert par\" doit avoir 3 lettres", - ) - } } } diff --git a/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/actions/PatchEnvActionUTest.kt b/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/actions/PatchEnvActionUTest.kt index def622d90b..71cb39b0a0 100644 --- a/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/actions/PatchEnvActionUTest.kt +++ b/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/actions/PatchEnvActionUTest.kt @@ -1,17 +1,18 @@ package fr.gouv.cacem.monitorenv.domain.use_cases.actions import com.nhaarman.mockitokotlin2.given -import com.nhaarman.mockitokotlin2.verify import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.EnvActionEntity import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.PatchableEnvActionEntity import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageException import fr.gouv.cacem.monitorenv.domain.mappers.PatchEntity import fr.gouv.cacem.monitorenv.domain.repositories.IEnvActionRepository import fr.gouv.cacem.monitorenv.domain.use_cases.actions.fixtures.EnvActionFixture.Companion.anEnvAction +import fr.gouv.cacem.monitorenv.domain.validators.mission.EnvActionValidator import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows import org.junit.jupiter.api.extension.ExtendWith +import org.mockito.Mockito import org.mockito.Mockito.mock import org.springframework.boot.test.system.CapturedOutput import org.springframework.boot.test.system.OutputCaptureExtension @@ -23,13 +24,16 @@ import java.util.UUID @ExtendWith(OutputCaptureExtension::class) class PatchEnvActionUTest { private val envActionRepository: IEnvActionRepository = mock() + private val envActionValidator: EnvActionValidator = mock() private val patchEntity: PatchEntity = PatchEntity() - private val patchEnvAction: PatchEnvAction = PatchEnvAction(envActionRepository, patchEntity) + private val patchEnvAction: PatchEnvAction = PatchEnvAction(envActionRepository, patchEntity, envActionValidator) private val jsonMapper: JsonMapper = JsonMapper() @Test fun `execute() should return the patched entity`(log: CapturedOutput) { // Given + val inOrder = Mockito.inOrder(envActionValidator, envActionRepository) + val id = UUID.randomUUID() val today = ZonedDateTime.now() val tomorrow = ZonedDateTime.now().plusDays(1) @@ -86,7 +90,8 @@ class PatchEnvActionUTest { assertThat(savedEnvAction.observationsByUnit).isEqualTo(envActionPatched.observationsByUnit) assertThat(savedEnvAction.hasDivingDuringOperation).isEqualTo(envActionPatched.hasDivingDuringOperation) assertThat(savedEnvAction.incidentDuringOperation).isEqualTo(envActionPatched.incidentDuringOperation) - verify(envActionRepository).save(envActionPatched) + inOrder.verify(envActionValidator).validate(envActionPatched) + inOrder.verify(envActionRepository).save(envActionPatched) assertThat(log.out).contains("Attempt to PATCH envaction $id") assertThat(log.out).contains("envaction $id patched") } diff --git a/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/missions/PatchMissionUTest.kt b/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/missions/PatchMissionUTest.kt index 6f32f3e89f..48e5ffbe3a 100644 --- a/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/missions/PatchMissionUTest.kt +++ b/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/use_cases/missions/PatchMissionUTest.kt @@ -1,7 +1,6 @@ package fr.gouv.cacem.monitorenv.domain.use_cases.missions import com.nhaarman.mockitokotlin2.given -import com.nhaarman.mockitokotlin2.verify import fr.gouv.cacem.monitorenv.domain.entities.controlUnit.ControlUnitResourceType import fr.gouv.cacem.monitorenv.domain.entities.controlUnit.LegacyControlUnitEntity import fr.gouv.cacem.monitorenv.domain.entities.controlUnit.LegacyControlUnitResourceEntity @@ -13,10 +12,12 @@ import fr.gouv.cacem.monitorenv.domain.mappers.PatchEntity import fr.gouv.cacem.monitorenv.domain.repositories.IMissionRepository import fr.gouv.cacem.monitorenv.domain.use_cases.missions.dtos.MissionDetailsDTO import fr.gouv.cacem.monitorenv.domain.use_cases.missions.fixtures.MissionFixture.Companion.aMissionEntity +import fr.gouv.cacem.monitorenv.domain.validators.mission.MissionWithEnvActionsValidator import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows import org.junit.jupiter.api.extension.ExtendWith +import org.mockito.Mockito import org.mockito.Mockito.mock import org.springframework.boot.test.system.CapturedOutput import org.springframework.boot.test.system.OutputCaptureExtension @@ -27,12 +28,15 @@ import kotlin.random.Random @ExtendWith(OutputCaptureExtension::class) class PatchMissionUTest { private val missionRepository: IMissionRepository = mock() + private val missionWithEnvActionsValidator: MissionWithEnvActionsValidator = mock() private val patchEntity: PatchEntity = PatchEntity() - private val patchMission: PatchMission = PatchMission(missionRepository, patchEntity) + private val patchMission: PatchMission = + PatchMission(missionRepository, patchEntity, missionWithEnvActionsValidator) @Test - fun `execute() should return the patched entity`(log: CapturedOutput) { + fun `execute() should validate then return the patched entity`(log: CapturedOutput) { // Given + val inOrder = Mockito.inOrder(missionWithEnvActionsValidator, missionRepository) val id = Random.nextInt() val today = ZonedDateTime.now() val tomorrow = ZonedDateTime.now().plusDays(1) @@ -91,7 +95,8 @@ class PatchMissionUTest { assertThat(savedMission.mission.isUnderJdp).isEqualTo(missionPatched.isUnderJdp) assertThat(savedMission.mission.controlUnits).isEqualTo(missionPatched.controlUnits) assertThat(savedMission.mission.missionTypes).isEqualTo(missionPatched.missionTypes) - verify(missionRepository).save(missionPatched) + inOrder.verify(missionWithEnvActionsValidator).validate(missionPatched) + inOrder.verify(missionRepository).save(missionPatched) assertThat(log.out).contains("Attempt to PATCH mission $id") assertThat(log.out).contains("Mission $id patched") } diff --git a/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/EnvActionValidatorUTest.kt b/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/EnvActionValidatorUTest.kt new file mode 100644 index 0000000000..1dba828b47 --- /dev/null +++ b/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/EnvActionValidatorUTest.kt @@ -0,0 +1,107 @@ +package fr.gouv.cacem.monitorenv.domain.validators.mission + +import fr.gouv.cacem.monitorenv.domain.entities.mission.envAction.envActionControl.infraction.InfractionTypeEnum +import fr.gouv.cacem.monitorenv.domain.exceptions.BackendUsageException +import fr.gouv.cacem.monitorenv.domain.use_cases.actions.fixtures.EnvActionFixture.Companion.anEnvActionControl +import fr.gouv.cacem.monitorenv.domain.use_cases.actions.fixtures.EnvActionFixture.Companion.anEnvActionSurveillance +import fr.gouv.cacem.monitorenv.domain.use_cases.actions.fixtures.EnvActionFixture.Companion.anInfraction +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Assertions.assertThrows +import org.junit.jupiter.api.Test +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.EnumSource +import org.junit.jupiter.params.provider.ValueSource +import org.mockito.Mock + +class EnvActionValidatorUTest { + @Mock + private val envActionsValidator = EnvActionValidator() + + @ParameterizedTest + @EnumSource(value = InfractionTypeEnum::class, names = ["WAITING"], mode = EnumSource.Mode.EXCLUDE) + fun `validate should throw an exception if there is a control with infractionType other than WAITING that doesnt have a NATINF`( + infractionType: InfractionTypeEnum, + ) { + val anEnvActionControl = + anEnvActionControl(infractions = listOf(anInfraction(infractionType = infractionType, natinf = listOf()))) + + val assertThrows = + assertThrows(BackendUsageException::class.java) { envActionsValidator.validate(anEnvActionControl) } + assertThat( + assertThrows.data, + ).isEqualTo("Une infraction doit avoir une natinf si le type d'infraction n'est pas \"En attente\"") + } + + @Test + fun `validate should throw an exception if there is a control with infraction and nbTarget is less than 1`() { + val anEnvActionControl = anEnvActionControl(infractions = listOf(anInfraction(nbTarget = 0))) + + val assertThrows = + assertThrows(BackendUsageException::class.java) { envActionsValidator.validate(anEnvActionControl) } + assertThat(assertThrows.data).isEqualTo("le nombre minimum de cible est 1") + } + + @Test + fun `validate should throw an exception if there is a control with infractions that got more nbTarget than the mission actionNumberOfControls `() { + val anEnvActionControl = + anEnvActionControl( + actionNumberOfControls = 10, + infractions = listOf(anInfraction(nbTarget = 10), anInfraction(nbTarget = 5)), + ) + + val assertThrows = + assertThrows(BackendUsageException::class.java) { envActionsValidator.validate(anEnvActionControl) } + assertThat(assertThrows.data).isEqualTo("Le nombre de cibles excède le nombre total de contrôles") + } + + @Test + fun `validate should pass if there is a control with infractions that got less nbTarget than the mission actionNumberOfControls `() { + val anEnvActionControl = + anEnvActionControl( + actionNumberOfControls = 2, + infractions = listOf(anInfraction(nbTarget = 1)), + ) + + envActionsValidator.validate(anEnvActionControl) + } + + @Test + fun `validate should pass if there is a control with infractionType = WAITING that doesnt have a NATINF`() { + val anEnvActionControl = + anEnvActionControl(infractions = listOf(anInfraction(infractionType = InfractionTypeEnum.WAITING))) + + envActionsValidator.validate(anEnvActionControl) + } + + @ParameterizedTest + @ValueSource(strings = ["A", "AA", "AAAA"]) + fun `validate should throw an exception if there is a control with openBy is not a trigram`(openBy: String) { + val anEnvActionControl = anEnvActionControl(openBy = openBy) + + val assertThrows = + assertThrows(BackendUsageException::class.java) { envActionsValidator.validate(anEnvActionControl) } + assertThat(assertThrows.data).isEqualTo("Le trigramme \"ouvert par\" doit avoir 3 lettres") + } + + @Test + fun `validate should pass if there is a surveillance without geometry`() { + val anEnvActionSurveillance = anEnvActionSurveillance(geom = null) + val assertThrows = + assertThrows(BackendUsageException::class.java) { envActionsValidator.validate(anEnvActionSurveillance) } + assertThat(assertThrows.data).isEqualTo("La géométrie de la surveillance est obligatoire") + } + + @Test + fun `validate should pass for a valid surveillance`() { + val envAction = anEnvActionSurveillance() + + envActionsValidator.validate(envAction) + } + + @Test + fun `validate should pass for a valid control`() { + val envAction = anEnvActionControl() + + envActionsValidator.validate(envAction) + } +} diff --git a/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/MissionValidatorWithEnvActionsUTest.kt b/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/MissionValidatorWithEnvActionsUTest.kt index f235e8aa6c..bbb7ccfe69 100644 --- a/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/MissionValidatorWithEnvActionsUTest.kt +++ b/backend/src/test/kotlin/fr/gouv/cacem/monitorenv/domain/validators/mission/MissionValidatorWithEnvActionsUTest.kt @@ -10,9 +10,6 @@ import fr.gouv.cacem.monitorenv.domain.use_cases.missions.fixtures.MissionFixtur import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Assertions.assertThrows import org.junit.jupiter.api.Test -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.EnumSource -import org.junit.jupiter.params.provider.ValueSource import org.mockito.Mock import org.mockito.Mockito.mock import java.time.ZonedDateTime @@ -20,14 +17,18 @@ import java.time.ZonedDateTime class MissionValidatorWithEnvActionsUTest { @Mock private val missionValidator: MissionValidator = mock() - private val missionWithEnvActionsValidator = MissionWithEnvActionsValidator(missionValidator) + private val envActionValidator: EnvActionValidator = mock() + private val missionWithEnvActionsValidator = MissionWithEnvActionsValidator(missionValidator, envActionValidator) @Test - fun `validate call mission validator`() { + fun `validate call mission validator and envAction validators`() { val mission = aMissionEntity() missionWithEnvActionsValidator.validate(mission) verify(missionValidator).validate(mission) + mission.envActions?.forEach { + verify(envActionValidator).validate(it) + } } @Test @@ -58,46 +59,6 @@ class MissionValidatorWithEnvActionsUTest { missionWithEnvActionsValidator.validate(mission) } - @ParameterizedTest - @EnumSource(value = InfractionTypeEnum::class, names = ["WAITING"], mode = EnumSource.Mode.EXCLUDE) - fun `validate should throw an exception if there is a control with infractionType other than WAITING that doesnt have a NATINF`( - infractionType: InfractionTypeEnum, - ) { - val anEnvActionControl = - anEnvActionControl(infractions = listOf(anInfraction(infractionType = infractionType, natinf = listOf()))) - val mission = aMissionEntity(envActions = listOf(anEnvActionControl)) - - val assertThrows = - assertThrows(BackendUsageException::class.java) { missionWithEnvActionsValidator.validate(mission) } - assertThat( - assertThrows.data, - ).isEqualTo("Une infraction doit avoir une natinf si le type d'infraction n'est pas \"En attente\"") - } - - @Test - fun `validate should throw an exception if there is a control with infraction and nbTarget is less than 1`() { - val anEnvActionControl = anEnvActionControl(infractions = listOf(anInfraction(nbTarget = 0))) - val mission = aMissionEntity(envActions = listOf(anEnvActionControl)) - - val assertThrows = - assertThrows(BackendUsageException::class.java) { missionWithEnvActionsValidator.validate(mission) } - assertThat(assertThrows.data).isEqualTo("le nombre minimum de cible est 1") - } - - @Test - fun `validate should throw an exception if there is a control with infractions that got more nbTarget than the mission actionNumberOfControls `() { - val anEnvActionControl = - anEnvActionControl( - actionNumberOfControls = 10, - infractions = listOf(anInfraction(nbTarget = 10), anInfraction(nbTarget = 5)), - ) - val mission = aMissionEntity(envActions = listOf(anEnvActionControl)) - - val assertThrows = - assertThrows(BackendUsageException::class.java) { missionWithEnvActionsValidator.validate(mission) } - assertThat(assertThrows.data).isEqualTo("Le nombre de cibles excède le nombre total de contrôles") - } - @Test fun `validate should pass if there is a control with infractions that got less nbTarget than the mission actionNumberOfControls `() { val anEnvActionControl = @@ -119,17 +80,6 @@ class MissionValidatorWithEnvActionsUTest { missionWithEnvActionsValidator.validate(mission) } - @ParameterizedTest - @ValueSource(strings = ["A", "AA", "AAAA"]) - fun `validate should throw an exception if there is a control with openBy is not a trigram`(openBy: String) { - val anEnvActionControl = anEnvActionControl(openBy = openBy) - val mission = aMissionEntity(envActions = listOf(anEnvActionControl)) - - val assertThrows = - assertThrows(BackendUsageException::class.java) { missionWithEnvActionsValidator.validate(mission) } - assertThat(assertThrows.data).isEqualTo("Le trigramme \"ouvert par\" doit avoir 3 lettres") - } - @Test fun `validate should throw an exception if there is a surveillance with a start date before mission starting date`() { val startDateTimeUtc = ZonedDateTime.parse("2020-03-04T00:00:00.000Z") @@ -216,21 +166,6 @@ class MissionValidatorWithEnvActionsUTest { missionWithEnvActionsValidator.validate(mission) } - @Test - fun `validate should pass if there is a surveillance without geometry`() { - val endDateTimeUtc = ZonedDateTime.now().minusSeconds(1) - val anEnvActionSurveillance = anEnvActionSurveillance(geom = null) - val mission = - aMissionEntity( - endDateTimeUtc = endDateTimeUtc, - envActions = listOf(anEnvActionSurveillance), - ) - - val assertThrows = - assertThrows(BackendUsageException::class.java) { missionWithEnvActionsValidator.validate(mission) } - assertThat(assertThrows.data).isEqualTo("La géométrie de la surveillance est obligatoire") - } - @Test fun `validate should pass for a valid MissionEntity`() { val mission = aMissionEntity()