From 0842e0e38fb723260a1729f86637f6af423a5cab Mon Sep 17 00:00:00 2001 From: rschneider <97682836+rainer-exxcellent@users.noreply.github.com> Date: Mon, 27 Nov 2023 08:29:23 +0100 Subject: [PATCH] feat(pool): #556 write test for pool validation in golden record process --- .../TaskStepFetchAndReserveServiceTest.kt | 402 +++++++++++++++++- 1 file changed, 400 insertions(+), 2 deletions(-) diff --git a/bpdm-pool/src/test/kotlin/org/eclipse/tractusx/bpdm/pool/service/TaskStepFetchAndReserveServiceTest.kt b/bpdm-pool/src/test/kotlin/org/eclipse/tractusx/bpdm/pool/service/TaskStepFetchAndReserveServiceTest.kt index e8b894585..e362975a5 100644 --- a/bpdm-pool/src/test/kotlin/org/eclipse/tractusx/bpdm/pool/service/TaskStepFetchAndReserveServiceTest.kt +++ b/bpdm-pool/src/test/kotlin/org/eclipse/tractusx/bpdm/pool/service/TaskStepFetchAndReserveServiceTest.kt @@ -16,12 +16,13 @@ import org.eclipse.tractusx.bpdm.pool.api.client.PoolClientImpl import org.eclipse.tractusx.bpdm.pool.api.model.response.SitePoolVerboseDto import org.eclipse.tractusx.bpdm.pool.repository.BpnRequestIdentifierRepository import org.eclipse.tractusx.bpdm.pool.service.TaskStepBuildService.CleaningError +import org.eclipse.tractusx.bpdm.pool.util.BusinessPartnerNonVerboseValues.addressIdentifierTypeDto1 +import org.eclipse.tractusx.bpdm.pool.util.BusinessPartnerNonVerboseValues.addressIdentifierTypeDto2 import org.eclipse.tractusx.bpdm.pool.util.BusinessPartnerVerboseValues import org.eclipse.tractusx.bpdm.pool.util.PostgreSQLContextInitializer import org.eclipse.tractusx.bpdm.pool.util.TestHelpers -import org.eclipse.tractusx.bpdm.pool.util.BusinessPartnerNonVerboseValues.addressIdentifierTypeDto1 -import org.eclipse.tractusx.bpdm.pool.util.BusinessPartnerNonVerboseValues.addressIdentifierTypeDto2 import org.eclipse.tractusx.orchestrator.api.model.* +import org.eclipse.tractusx.orchestrator.api.model.BpnReferenceType.Bpn import org.eclipse.tractusx.orchestrator.api.model.BpnReferenceType.BpnRequestIdentifier import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @@ -126,6 +127,203 @@ class TaskStepFetchAndReserveServiceTest @Autowired constructor( compareLegalEntity(createdLegalEntity, resultSteps[0].businessPartner?.legalEntity) } + + @Test + fun `create legal entity with additional address`() { + + val leRefValue = "123" + val leAddressRefValue = "222" + val additionalAddressRefValue = "333" + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = BpnReferenceDto(referenceValue = leRefValue, referenceType = BpnRequestIdentifier), + bpnAReference = BpnReferenceDto(referenceValue = leAddressRefValue, referenceType = BpnRequestIdentifier) + ), + address = minLogisticAddress(BpnReferenceDto(referenceValue = additionalAddressRefValue, referenceType = BpnRequestIdentifier)) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors.size).isEqualTo(0) + + val bpnMappings = bpnRequestIdentifierRepository.findDistinctByRequestIdentifierIn(listOf(leRefValue, leAddressRefValue, additionalAddressRefValue)) + assertThat(bpnMappings.size).isEqualTo(3) + + val createdLegalEntity = poolClient.legalEntities.getLegalEntity(resultSteps[0].businessPartner?.legalEntity?.bpnLReference?.referenceValue!!) + assertThat(createdLegalEntity.legalAddress.bpnLegalEntity).isEqualTo(createdLegalEntity.legalEntity.bpnl) + assertThat(createdLegalEntity.legalAddress.isLegalAddress).isTrue() + assertThat(createdLegalEntity.legalAddress.isMainAddress).isFalse() + assertThat(resultSteps[0].businessPartner?.generic?.legalEntityBpn).isEqualTo(createdLegalEntity.legalEntity.bpnl) + compareLegalEntity(createdLegalEntity, resultSteps[0].businessPartner?.legalEntity) + val createdAdditionalAddress = poolClient.addresses.getAddress(resultSteps[0].businessPartner?.address?.bpnAReference?.referenceValue!!) + assertThat(createdAdditionalAddress.bpnLegalEntity).isEqualTo(createdLegalEntity.legalEntity.bpnl) + assertThat(createdAdditionalAddress.isLegalAddress).isFalse() + assertThat(createdAdditionalAddress.isMainAddress).isFalse() + } + + @Test + fun `create legal entity with invalid identifiers`() { + + val leRef = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef, + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + ).copy( + identifiers = listOf( + legalEntityIdentifierDto(leRef.referenceValue, 1L, BusinessPartnerVerboseValues.identifierType1), + legalEntityIdentifierDto(leRef.referenceValue, 2L, TypeKeyNameVerboseDto("Invalid", "Invalid")) + ) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps[0].errors[0].description).isEqualTo("Legal Entity Identifier Type 'Invalid' does not exist") + } + + @Test + fun `create legal entity with invalid legal form`() { + + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier), + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + ).copy( + legalForm = "Invalid Form" + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps[0].errors[0].description).isEqualTo("Legal Form 'Invalid Form' does not exist") + } + + @Test + fun `create legal entity with invalid duplicate identifier`() { + + val leRef = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef, + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + ).copy( + identifiers = listOf( + legalEntityIdentifierDto(leRef.referenceValue, 1L, BusinessPartnerVerboseValues.identifierType1), + legalEntityIdentifierDto(leRef.referenceValue, 1L, BusinessPartnerVerboseValues.identifierType1) + ), + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps[0].errors[0].description).isEqualTo("Duplicate Legal Entity Identifier: Value 'value_123_1' of type 'VAT_DE'") + } + + @Test + fun `create 2 legal entities with invalid duplicate identifier`() { + + val leRef1 = BpnReferenceDto(referenceValue = "111", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef1, + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + ).copy( + identifiers = listOf( + legalEntityIdentifierDto(leRef1.referenceValue, 1L, BusinessPartnerVerboseValues.identifierType1), + legalEntityIdentifierDto(leRef1.referenceValue, 2L, BusinessPartnerVerboseValues.identifierType2) + ), + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors.size).isEqualTo(0) + + val leRef2 = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity2 = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef2, + bpnAReference = BpnReferenceDto(referenceValue = "333", referenceType = BpnRequestIdentifier) + ).copy( + identifiers = listOf( + legalEntityIdentifierDto(leRef1.referenceValue, 1L, BusinessPartnerVerboseValues.identifierType1), + ), + ) + ) + val resultSteps2 = cleanStep(taskId = "TASK_2", businessPartner = fullBpWithLegalEntity2) + assertThat(resultSteps2[0].taskId).isEqualTo("TASK_2") + assertThat(resultSteps2[0].errors.size).isEqualTo(1) + assertThat(resultSteps2[0].errors[0].description).isEqualTo("Duplicate Legal Entity Identifier: Value 'value_111_1' of type 'VAT_DE'") + } + + @Test + fun `create legal entity with invalid address administrativeAreaLevel1`() { + + val bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier), + bpnAReference = bpnAReference + ).copy( + legalAddress = minLogisticAddress(bpnAReference).copy( + physicalPostalAddress = minPhysicalPostalAddressDto(bpnAReference).copy( + administrativeAreaLevel1 = "Invalid" + ) + ) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps[0].errors[0].description).isEqualTo("Address administrative area level1 'Invalid' does not exist") + } + + @Test + fun `create legal entity with invalid address identifier`() { + + val bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier), + bpnAReference = bpnAReference + ).copy( + legalAddress = minLogisticAddress(bpnAReference).copy( + identifiers = listOf( + addressIdentifierDto(bpnAReference.referenceValue, 1L, TypeKeyNameVerboseDto(addressIdentifierTypeDto1.technicalKey, "")), + addressIdentifierDto(bpnAReference.referenceValue, 2L, TypeKeyNameVerboseDto("Invalid Ident", "")) + ), + ) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps[0].errors[0].description).isEqualTo("Address Identifier Type 'Invalid Ident' does not exist") + } + + @Test + fun `create legal entity with invalid duplicated address identifier`() { + + val bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier), + bpnAReference = bpnAReference + ).copy( + legalAddress = minLogisticAddress(bpnAReference).copy( + identifiers = listOf( + addressIdentifierDto(bpnAReference.referenceValue, 1L, TypeKeyNameVerboseDto(addressIdentifierTypeDto1.technicalKey, "")), + addressIdentifierDto(bpnAReference.referenceValue, 1L, TypeKeyNameVerboseDto(addressIdentifierTypeDto1.technicalKey, "")) + ), + ) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps[0].errors[0].description).isEqualTo("Duplicate Address Identifier: Value 'value_222_1' of type 'ADDR_KEY_ONE'") + } + + @Test fun `check that requests with same referenceValue don't create a new legal entity`() { @@ -185,6 +383,206 @@ class TaskStepFetchAndReserveServiceTest @Autowired constructor( assertThat(resultSteps2[0].businessPartner?.generic?.legalEntityBpn).isEqualTo(createdLegalEntity2.legalEntity.bpnl) } + @Test + fun `update legal entity with all fields`() { + + val leRefValue = "123" + val leAddressRefValue = "222" + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = fullValidLegalEntity( + bpnLReference = BpnReferenceDto(referenceValue = leRefValue, referenceType = BpnRequestIdentifier), + bpnAReference = BpnReferenceDto(referenceValue = leAddressRefValue, referenceType = BpnRequestIdentifier) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].taskId).isEqualTo("TASK_1") + assertThat(resultSteps[0].errors.size).isEqualTo(0) + + val updatedFullBpLegalEntity = resultSteps[0].businessPartner?.copy( + legalEntity = resultSteps[0].businessPartner?.legalEntity?.copy( + hasChanged = true, + legalName = "Changed Legal Entity", + legalAddress = resultSteps[0].businessPartner?.legalEntity?.legalAddress?.copy( + hasChanged = true, + name = "Changed Address Name" + ) + ) + ) + val resultSteps2 = cleanStep(taskId = "TASK_2", businessPartner = updatedFullBpLegalEntity!!) + assertThat(resultSteps2[0].taskId).isEqualTo("TASK_2") + assertThat(resultSteps2[0].errors.size).isEqualTo(0) + + val updatedLegalEntity = poolClient.legalEntities.getLegalEntity(resultSteps2[0].businessPartner?.legalEntity?.bpnLReference?.referenceValue!!) + assertThat(updatedLegalEntity.legalName).isEqualTo("Changed Legal Entity") + compareLegalEntity(updatedLegalEntity, resultSteps2[0].businessPartner?.legalEntity) + } + + @Test + fun `update legal entity invalid identifier type `() { + + val leRef = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef, + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].errors.size).isEqualTo(0) + + val updatedFullBpLegalEntity = resultSteps[0].businessPartner?.copy( + legalEntity = resultSteps[0].businessPartner?.legalEntity?.copy( + hasChanged = true, + legalName = "Changed Legal Entity", + identifiers = listOf( + legalEntityIdentifierDto(leRef.referenceValue, 1L, BusinessPartnerVerboseValues.identifierType1), + legalEntityIdentifierDto(leRef.referenceValue, 2L, TypeKeyNameVerboseDto("Invalid", "Invalid")) + ), + legalAddress = resultSteps[0].businessPartner?.legalEntity?.legalAddress?.copy( + hasChanged = true, + name = "Changed Address Name" + ) + ) + ) + val resultSteps2 = cleanStep(taskId = "TASK_2", businessPartner = updatedFullBpLegalEntity!!) + assertThat(resultSteps2[0].taskId).isEqualTo("TASK_2") + assertThat(resultSteps2[0].errors.size).isEqualTo(1) + assertThat(resultSteps2[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps2[0].errors[0].description).isEqualTo("Legal Entity Identifier Type 'Invalid' does not exist") + } + + @Test + fun `update legal entity invalid legal form `() { + + val leRef = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef, + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].errors.size).isEqualTo(0) + + val updatedFullBpLegalEntity = resultSteps[0].businessPartner?.copy( + legalEntity = resultSteps[0].businessPartner?.legalEntity?.copy( + hasChanged = true, + legalName = "Changed Legal Entity", + legalForm = "Invalid Form", + legalAddress = resultSteps[0].businessPartner?.legalEntity?.legalAddress?.copy( + hasChanged = true, + name = "Changed Address Name" + ) + ) + ) + val resultSteps2 = cleanStep(taskId = "TASK_2", businessPartner = updatedFullBpLegalEntity!!) + assertThat(resultSteps2[0].taskId).isEqualTo("TASK_2") + assertThat(resultSteps2[0].errors.size).isEqualTo(1) + assertThat(resultSteps2[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps2[0].errors[0].description).isEqualTo("Legal Form 'Invalid Form' does not exist") + } + + @Test + fun `update legal entity not existing bpn `() { + + val leRef = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef, + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].errors.size).isEqualTo(0) + + val updatedFullBpLegalEntity = resultSteps[0].businessPartner?.copy( + legalEntity = resultSteps[0].businessPartner?.legalEntity?.copy( + bpnLReference= BpnReferenceDto(referenceValue = "InvalidBPN", referenceType = Bpn), + hasChanged = true, + legalName = "Changed Legal Entity", + legalAddress = resultSteps[0].businessPartner?.legalEntity?.legalAddress?.copy( + hasChanged = true, + name = "Changed Address Name" + ) + ) + ) + val resultSteps2 = cleanStep(taskId = "TASK_2", businessPartner = updatedFullBpLegalEntity!!) + assertThat(resultSteps2[0].taskId).isEqualTo("TASK_2") + assertThat(resultSteps2[0].errors.size).isEqualTo(1) + assertThat(resultSteps2[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps2[0].errors[0].description).isEqualTo("Business Partner with BPN 'InvalidBPN' can't be updated as it doesn't exist") + } + + @Test + fun `update legal entity with changed identifiers `() { + + val leRef = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef, + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier), + ).copy( + identifiers = listOf( + legalEntityIdentifierDto(leRef.referenceValue, 1L, BusinessPartnerVerboseValues.identifierType1), + legalEntityIdentifierDto(leRef.referenceValue, 2L, BusinessPartnerVerboseValues.identifierType2) + ) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].errors.size).isEqualTo(0) + + val updatedFullBpLegalEntity = resultSteps[0].businessPartner?.copy( + legalEntity = resultSteps[0].businessPartner?.legalEntity?.copy( + identifiers = listOf( + legalEntityIdentifierDto(leRef.referenceValue, 3L, BusinessPartnerVerboseValues.identifierType3), + legalEntityIdentifierDto(leRef.referenceValue, 2L, BusinessPartnerVerboseValues.identifierType2) + ), + hasChanged = true, + legalName = "Changed Legal Entity", + legalAddress = resultSteps[0].businessPartner?.legalEntity?.legalAddress?.copy( + hasChanged = true, + name = "Changed Address Name" + ) + ) + ) + val resultSteps2 = cleanStep(taskId = "TASK_2", businessPartner = updatedFullBpLegalEntity!!) + assertThat(resultSteps2[0].taskId).isEqualTo("TASK_2") + assertThat(resultSteps2[0].errors.size).isEqualTo(0) + } + + @Test + fun `update legal entity by reference value invalid identifier type `() { + + val leRef = BpnReferenceDto(referenceValue = "123", referenceType = BpnRequestIdentifier) + val fullBpWithLegalEntity = minFullBusinessPartner().copy( + legalEntity = minValidLegalEntity( + bpnLReference = leRef, + bpnAReference = BpnReferenceDto(referenceValue = "222", referenceType = BpnRequestIdentifier) + ) + ) + val resultSteps = cleanStep(taskId = "TASK_1", businessPartner = fullBpWithLegalEntity) + assertThat(resultSteps[0].errors.size).isEqualTo(0) + + val updatedFullBpLegalEntity = fullBpWithLegalEntity.copy( + legalEntity = fullBpWithLegalEntity.legalEntity?.copy( + hasChanged = true, + legalName = "Changed Legal Entity", + identifiers = listOf( + legalEntityIdentifierDto(leRef.referenceValue, 1L, BusinessPartnerVerboseValues.identifierType1), + legalEntityIdentifierDto(leRef.referenceValue, 2L, TypeKeyNameVerboseDto("Invalid", "Invalid")) + ), + legalAddress = fullBpWithLegalEntity.legalEntity?.legalAddress?.copy( + hasChanged = true, + name = "Changed Address Name" + ) + ) + ) + val resultSteps2 = cleanStep(taskId = "TASK_2", businessPartner = updatedFullBpLegalEntity) + assertThat(resultSteps2[0].taskId).isEqualTo("TASK_2") + assertThat(resultSteps2[0].errors.size).isEqualTo(1) + assertThat(resultSteps2[0].errors[0].type).isEqualTo(TaskErrorType.Unspecified) + assertThat(resultSteps2[0].errors[0].description).isEqualTo("Legal Entity Identifier Type 'Invalid' does not exist") + } @Test fun `create Site with minimal fields`() {