diff --git a/src/integrationTest/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/integration/refdata/infrastructure/RefDataMappingRepositoryShould.kt b/src/integrationTest/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/integration/refdata/infrastructure/RefDataMappingRepositoryShould.kt index 6c21dc8..0a49742 100644 --- a/src/integrationTest/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/integration/refdata/infrastructure/RefDataMappingRepositoryShould.kt +++ b/src/integrationTest/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/integration/refdata/infrastructure/RefDataMappingRepositoryShould.kt @@ -27,23 +27,23 @@ class RefDataMappingRepositoryShould : RepositoryTestCase() { fun `return correct mapping, given reference data and data value`() { val refData = "employer_status" val dataValue = "GOLD" - val expectedExtId = 2L + val expectedExtId = 2 val mapping = refDataMappingRepository.findByDataRefDataAndDataValue(refData, dataValue) - assertThat(mapping).hasSize(1) - assertThat(mapping.first().data.externalId).isEqualTo(expectedExtId) + assertThat(mapping).isNotNull + assertThat(mapping!!.data.externalId).isEqualTo(expectedExtId) } @Test fun `return correct mapping, given reference data and data external ID`() { val refData = "employer_sector" - val dataExternalId = 6L + val dataExternalId = 6 val expectedDataValue = "CONSTRUCTION" val mapping = refDataMappingRepository.findByDataRefDataAndDataExternalId(refData, dataExternalId) - assertThat(mapping).hasSize(1) - assertThat(mapping.first().data.value).isEqualTo(expectedDataValue) + assertThat(mapping).isNotNull + assertThat(mapping!!.data.value).isEqualTo(expectedDataValue) } @Nested diff --git a/src/integrationTest/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/integration/shared/infrastructure/RepositoryTestCase.kt b/src/integrationTest/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/integration/shared/infrastructure/RepositoryTestCase.kt index aaefd20..73e233d 100644 --- a/src/integrationTest/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/integration/shared/infrastructure/RepositoryTestCase.kt +++ b/src/integrationTest/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/integration/shared/infrastructure/RepositoryTestCase.kt @@ -79,12 +79,12 @@ abstract class RepositoryTestCase { private val refDataMappingsForTests: List get() = mapOf( "employer_status" to mapOf( - "KEY_PARTNER" to 1L, + "KEY_PARTNER" to 1, "GOLD" to 2, "SILVER" to 3, ), "employer_sector" to mapOf( - "ADMIN_SUPPORT" to 14L, + "ADMIN_SUPPORT" to 14, "AGRICULTURE" to 1, "ARTS_ENTERTAINMENT" to 18, "CONSTRUCTION" to 6, diff --git a/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerRegistrar.kt b/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerRegistrar.kt index a880f66..3d5aa15 100644 --- a/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerRegistrar.kt +++ b/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerRegistrar.kt @@ -1,5 +1,6 @@ package uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.application +import org.slf4j.LoggerFactory import org.springframework.stereotype.Service import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.config.ConditionalOnIntegrationEnabled import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.Employer @@ -9,14 +10,22 @@ import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.Emp class EmployerRegistrar( private val employerService: EmployerService, ) { + companion object { + private val log = LoggerFactory.getLogger(this::class.java) + } + fun registerCreation(employer: Employer) { - try { - val mnEmployer = employerService.run { create(convert(employer)) } - assert(mnEmployer.id != null) { "MN Employer ID is missing! employerId=${employer.id}, employerName=${employer.name}" } - employerService.createIdMapping(mnEmployer.id!!, employer.id) - } catch (ex: Exception) { - "Fail to register employer-creation; employerId=${employer.id}, employerName=${employer.name}".let { message -> - throw Exception(message, ex) + if (employerService.existsIdMappingById(employer.id)) { + log.warn("Employer with id={} already exists (with ID mapping), thus skipping", employer.id) + } else { + try { + val mnEmployer = employerService.run { create(convert(employer)) } + assert(mnEmployer.id != null) { "MN Employer ID is missing! employerId=${employer.id}, employerName=${employer.name}" } + employerService.createIdMapping(mnEmployer.id!!, employer.id) + } catch (throwable: Throwable) { + "Fail to register employer-creation; employerId=${employer.id}, employerName=${employer.name}".let { message -> + throw Exception(message, throwable) + } } } } diff --git a/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerService.kt b/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerService.kt index dffa256..8685c83 100644 --- a/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerService.kt +++ b/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerService.kt @@ -3,6 +3,12 @@ package uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.applicati import org.springframework.stereotype.Service import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.config.ConditionalOnIntegrationEnabled import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.Employer +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerExternalId +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerExternalIdRepository +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefData +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefData.EmployerSector +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefData.EmployerStatus +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefDataMappingRepository import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.domain.JobsBoardApiClient import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.domain.MNJobBoardApiClient import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.infrastructure.CreatEmployerRequest @@ -13,12 +19,13 @@ import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.infrastructur class EmployerService( private val jobsBoardApiClient: JobsBoardApiClient, private val mnJobBoardApiClient: MNJobBoardApiClient, + private val employerExternalIdRepository: EmployerExternalIdRepository, + private val refDataMappingRepository: RefDataMappingRepository, ) { fun retrieveById(id: String): Employer? = jobsBoardApiClient.getEmployer(id) fun create(mnEmployer: MNEmployer): MNEmployer { val request = CreatEmployerRequest.from(mnEmployer) - // TODO cater optional fields for employerStatus = KEY_PARTNER (sectorId==2) return mnJobBoardApiClient.createEmployer(request) } @@ -26,15 +33,25 @@ class EmployerService( MNEmployer( employerName = name, employerBio = description, - // FIXME translate from employer.sector - sectorId = 1, - // FIXME translate from employer.status - partnerId = 1, + sectorId = translateId(EmployerSector, sector), + partnerId = translateId(EmployerStatus, status), ) } - fun createIdMapping(mnId: Long, employerId: String) { - // TODO persist ID mapping - throw NotImplementedError("ID Mapping is not yet implemented") + fun existsIdMappingById(id: String): Boolean = retrieveExternalIdById(id) != null + + fun createIdMapping(externalId: Long, id: String) { + if (!existsIdMappingById(id)) { + employerExternalIdRepository.save(EmployerExternalId(id, externalId)) + } else { + throw Exception("Employer ID cannot be created! ID mapping already exists. ID pair: externalId=$externalId, id=$id") + } } + + private fun retrieveExternalIdById(id: String): Long? = employerExternalIdRepository.findByKeyId(id)?.key?.externalId + + private fun translateId(refData: RefData, value: String) = + refDataMappingRepository.findByDataRefDataAndDataValue(refData.type, value)?.data?.externalId ?: run { + throw IllegalArgumentException("Reference data does not exist! refData=${refData.type}: value=$value") + } } diff --git a/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/refdata/domain/RefData.kt b/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/refdata/domain/RefData.kt new file mode 100644 index 0000000..ec5d2f6 --- /dev/null +++ b/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/refdata/domain/RefData.kt @@ -0,0 +1,6 @@ +package uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain + +enum class RefData(val type: String) { + EmployerStatus("employer_status"), + EmployerSector("employer_sector"), +} diff --git a/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/refdata/domain/RefDataMapping.kt b/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/refdata/domain/RefDataMapping.kt index bf18f1b..0d55fe9 100644 --- a/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/refdata/domain/RefDataMapping.kt +++ b/src/main/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/refdata/domain/RefDataMapping.kt @@ -13,7 +13,7 @@ import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.domain.ReadOn data class RefDataMapping( @EmbeddedId var data: RefDataMappingKey, ) { - constructor(refData: String, value: String, externalId: Long) : this(RefDataMappingKey(refData, value, externalId)) + constructor(refData: String, value: String, externalId: Int) : this(RefDataMappingKey(refData, value, externalId)) constructor() : this(RefDataMappingKey()) } @@ -21,7 +21,7 @@ data class RefDataMapping( data class RefDataMappingKey( @Column(name = "ref_data") val refData: String, @Column(name = "value") val value: String, - @Column(name = "ext_id") val externalId: Long, + @Column(name = "ext_id") val externalId: Int, ) { constructor() : this("", "", 0) } @@ -30,7 +30,7 @@ data class RefDataMappingKey( interface RefDataMappingRepository : ReadOnlyRepository { fun findByDataRefData(refData: String): List - fun findByDataRefDataAndDataValue(refData: String, dataValue: String): List + fun findByDataRefDataAndDataValue(refData: String, dataValue: String): RefDataMapping? - fun findByDataRefDataAndDataExternalId(refData: String, dataExternalId: Long): List + fun findByDataRefDataAndDataExternalId(refData: String, dataExternalId: Int): RefDataMapping? } diff --git a/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerRegistrarShould.kt b/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerRegistrarShould.kt new file mode 100644 index 0000000..8f41ec4 --- /dev/null +++ b/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerRegistrarShould.kt @@ -0,0 +1,94 @@ +package uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.application + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test +import org.mockito.InjectMocks +import org.mockito.Mock +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.Employer +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerObjects.mnEmployer +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerObjects.sainsburys +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.application.UnitTestBase +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.infrastructure.MNEmployer +import kotlin.test.assertFailsWith + +class EmployerRegistrarShould : UnitTestBase() { + @Mock + private lateinit var employerService: EmployerService + + @InjectMocks + private lateinit var employerRegistrar: EmployerRegistrar + + @Nested + @DisplayName("Given a valid employer to be registered") + inner class GivenAnEmployerToRegister { + private val employer = sainsburys + private val externalId = 1L + private val mnEmployer = employer.mnEmployer(externalId) + private val mnEmployerNoId = mnEmployer.copy(id = null) + + @Test + fun `register a valid employer`() { + givenMNEmployerCreated(employer, mnEmployerNoId, mnEmployer) + + employerRegistrar.registerCreation(employer) + + verify(employerService).createIdMapping(externalId, employer.id) + } + + @Test + fun `skip registering existing employer`() { + val id = employer.id + whenever(employerService.existsIdMappingById(id)).thenReturn(true) + + employerRegistrar.registerCreation(employer) + + verify(employerService, never()).convert(employer) + verify(employerService, never()).create(mnEmployerNoId) + verify(employerService, never()).createIdMapping(externalId, id) + } + + @Test + fun `NOT finish registering employer without external ID received`() { + givenMNEmployerCreated(employer, mnEmployerNoId, mnEmployerNoId) + + val exception = assertFailsWith { + employerRegistrar.registerCreation(employer) + } + + assertThat(exception.message) + .startsWith("Fail to register employer-creation").contains("employerId=${employer.id}") + with(exception.cause) { + assertThat(this).isNotNull.isInstanceOfAny(AssertionError::class.java) + assertThat(this!!.message) + .startsWith("MN Employer ID is missing!").contains("employerId=${employer.id}") + } + verify(employerService, never()).createIdMapping(externalId, employer.id) + } + + @Test + fun `NOT finish registering employer, with ID mapping clash while saving it`() { + whenever(employerService.existsIdMappingById(employer.id)).thenReturn(false, true) + whenever(employerService.convert(employer)).thenReturn(mnEmployerNoId) + whenever(employerService.create(mnEmployerNoId)).thenReturn(mnEmployer) + whenever(employerService.createIdMapping(externalId, employer.id)).thenCallRealMethod() + + val exception = assertFailsWith { + employerRegistrar.registerCreation(employer) + } + + assertThat(exception.message) + .startsWith("Fail to register employer-creation").contains("employerId=${employer.id}") + } + } + + private fun givenMNEmployerCreated(employer: Employer, convertedEmployer: MNEmployer, mnEmployer: MNEmployer) { + whenever(employerService.existsIdMappingById(employer.id)).thenReturn(false) + whenever(employerService.convert(employer)).thenReturn(convertedEmployer) + whenever(employerService.create(convertedEmployer)).thenReturn(mnEmployer) + } +} diff --git a/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerServiceShould.kt b/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerServiceShould.kt new file mode 100644 index 0000000..d9a2c7e --- /dev/null +++ b/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/application/EmployerServiceShould.kt @@ -0,0 +1,189 @@ +package uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.application + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test +import org.mockito.InjectMocks +import org.mockito.kotlin.any +import org.mockito.kotlin.argumentCaptor +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerExternalId +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerObjects.mnEmployer +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerObjects.sainsburys +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerObjects.tesco +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefData.EmployerSector +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefData.EmployerStatus +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.application.ServiceTestCase +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.infrastructure.CreatEmployerRequest +import kotlin.test.assertFailsWith + +class EmployerServiceShould : ServiceTestCase() { + @InjectMocks + private lateinit var employerService: EmployerService + + private val employer = sainsburys + private val externalId = 1L + private val mnEmployer = employer.mnEmployer(externalId) + private val mnEmployerNoId = mnEmployer.copy(id = null) + + @Nested + @DisplayName("Given a valid employer") + inner class GivenAnEmployer { + @Test + fun `return a valid employer`() { + val id = employer.id + whenever(jobsBoardApiClient.getEmployer(id)).thenReturn(employer) + + val actualEmployer = employerService.retrieveById(id) + + assertThat(actualEmployer).isNotNull.isEqualTo(employer) + } + + @Test + fun `return true, when external ID exists`() { + val id = employer.id + givenEmployerExternalIDExists(id, externalId) + + val exists = employerService.existsIdMappingById(id) + + assertThat(exists).isTrue + } + + @Test + fun `return false, when external ID does not exists`() { + val id = employer.id + givenEmployerExternalIDNotExist(id) + + employerService.existsIdMappingById(id) + + val exists = employerService.existsIdMappingById(id) + assertThat(exists).isFalse() + } + + @Test + fun `create employer at MN`() { + CreatEmployerRequest.from(mnEmployerNoId).let { + whenever(mnJobBoardApiClient.createEmployer(it)).thenReturn(mnEmployer) + } + + val actualMNEmployer = employerService.create(mnEmployerNoId) + + assertThat(actualMNEmployer).isEqualTo(mnEmployer) + } + + @Test + fun `convert employer to MN`() { + with(employer) { givenRefDataMappings(status, sector) } + + val actualMNEmployer = employerService.convert(employer) + + assertThat(actualMNEmployer).isEqualTo(mnEmployerNoId) + } + + @Test + fun `create ID mapping, when external ID does not exist`() { + val id = employer.id + givenEmployerExternalIDNotExist(id) + val expectedEmployerId = id + val expectedExternalId = externalId + + employerService.createIdMapping(externalId, id) + + val captor = argumentCaptor() + verify(employerExternalIdRepository).save(captor.capture()) + val savedExternalId = captor.firstValue + + with(savedExternalId.key) { + assertThat(id).isEqualTo(expectedEmployerId) + assertThat(externalId).isEqualTo(expectedExternalId) + } + } + + @Test + fun `NOT create ID mapping, when external ID exists`() { + val id = employer.id + givenEmployerExternalIDExists(id, 2) + + val exception = assertFailsWith { + employerService.createIdMapping(externalId, id) + } + + assertThat(exception.message) + .startsWith("Employer ID cannot be created! ID mapping already exists") + .contains("id=$id").contains("externalId=$externalId") + + verify(employerExternalIdRepository, never()).save(any()) + } + } + + @Nested + @DisplayName("Given a non-existent employer") + inner class GivenNonExistentEmployer { + @Test + fun `NOT return a non-existent employer`() { + val id = tesco.id + whenever(jobsBoardApiClient.getEmployer(id)).thenReturn(null) + + val actualEmployer = employerService.retrieveById(id) + + assertThat(actualEmployer).isNull() + } + } + + @Nested + @DisplayName("Given an invalid employer") + inner class GivenInvalidEmployer { + @Test + fun `NOT convert employer to MN, with invalid status`() { + val refData = EmployerStatus.type + val invalidStatus = "INVALID" + val invalidEmployer = employer.copy( + id = randomUUID(), + status = invalidStatus, + ) + with(invalidEmployer) { givenRefDataMappings(status, sector) } + + val exception = assertFailsWith { + employerService.convert(invalidEmployer) + } + + assertThat(exception.message) + .startsWith("Reference data does not exist!").contains("refData=$refData: value=$invalidStatus") + } + + @Test + fun `NOT convert employer to MN, with invalid sector`() { + val refData = EmployerSector.type + val invalidSector = "INVALID" + val invalidEmployer = employer.copy( + id = randomUUID(), + sector = invalidSector, + ) + givenRefDataIdMapping(EmployerSector.type, invalidEmployer.sector) + + val exception = assertFailsWith { + employerService.convert(invalidEmployer) + } + + assertThat(exception.message) + .startsWith("Reference data does not exist!").contains("refData=$refData: value=$invalidSector") + } + } + + private fun givenEmployerExternalIDExists(id: String, externalId: Long) { + val employerExternalId = EmployerExternalId(id, externalId) + whenever(employerExternalIdRepository.findByKeyId(id)).thenReturn(employerExternalId) + } + + private fun givenEmployerExternalIDNotExist(id: String) { + whenever(employerExternalIdRepository.findByKeyId(id)).thenReturn(null) + } + + private fun givenRefDataMappings(employerStatus: String, employerSector: String) { + givenRefDataIdMapping(EmployerStatus.type, employerStatus) + givenRefDataIdMapping(EmployerSector.type, employerSector) + } +} diff --git a/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/domain/EmployerObjects.kt b/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/domain/EmployerObjects.kt index 7a10cfa..e195a20 100644 --- a/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/domain/EmployerObjects.kt +++ b/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/employers/domain/EmployerObjects.kt @@ -1,6 +1,8 @@ package uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain -object EmployerObjects { +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.infrastructure.MNEmployer + +internal object EmployerObjects { val tesco = Employer( id = "89de6c84-3372-4546-bbc1-9d1dc9ceb354", name = "Tesco", @@ -40,4 +42,44 @@ object EmployerObjects { sector = "CONSTRUCTION", status = "SILVER", ) + + val statusToPartnerIdMap: Map by lazy { + mapOf( + "KEY_PARTNER" to 1, + "GOLD" to 2, + "SILVER" to 3, + ) + } + + val sectorToIdMap: Map by lazy { + mapOf( + "ADMIN_SUPPORT" to 14, + "AGRICULTURE" to 1, + "ARTS_ENTERTAINMENT" to 18, + "CONSTRUCTION" to 6, + "EDUCATION" to 16, + "ENERGY" to 4, + "FINANCE" to 11, + "HEALTH_SOCIAL" to 17, + "HOSPITALITY_CATERING" to 9, + "LOGISTICS" to 8, + "MANUFACTURING" to 3, + "MINING" to 2, + "OTHER" to 19, + "PROFESSIONALS_SCIENTISTS_TECHNICIANS" to 13, + "PROPERTY" to 12, + "PUBLIC_ADMIN_DEFENCE" to 15, + "WASTE_MANAGEMENT" to 5, + "RETAIL" to 7, + "TECHNOLOGY" to 10, + ) + } + + internal fun Employer.mnEmployer(externalId: Long) = MNEmployer( + id = externalId, + employerName = name, + employerBio = description, + sectorId = sectorToIdMap[sector]!!, + partnerId = statusToPartnerIdMap[status]!!, + ) } diff --git a/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/shared/application/ServiceTestCase.kt b/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/shared/application/ServiceTestCase.kt new file mode 100644 index 0000000..1c992e7 --- /dev/null +++ b/src/test/kotlin/uk/gov/justice/digital/hmpps/jobsboardintegrationapi/shared/application/ServiceTestCase.kt @@ -0,0 +1,38 @@ +package uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.application + +import org.mockito.Mock +import org.mockito.kotlin.whenever +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerExternalIdRepository +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerObjects.sectorToIdMap +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.employers.domain.EmployerObjects.statusToPartnerIdMap +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefData.EmployerSector +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefData.EmployerStatus +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefDataMapping +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.refdata.domain.RefDataMappingRepository +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.domain.JobsBoardApiClient +import uk.gov.justice.digital.hmpps.jobsboardintegrationapi.shared.domain.MNJobBoardApiClient + +abstract class ServiceTestCase : UnitTestBase() { + @Mock + protected lateinit var jobsBoardApiClient: JobsBoardApiClient + + @Mock + protected lateinit var mnJobBoardApiClient: MNJobBoardApiClient + + @Mock + protected lateinit var employerExternalIdRepository: EmployerExternalIdRepository + + @Mock + protected lateinit var refDataMappingRepository: RefDataMappingRepository + + private val refDataMappingsMap = mapOf( + EmployerStatus.type to statusToPartnerIdMap, + EmployerSector.type to sectorToIdMap, + ) + + protected fun givenRefDataIdMapping(refData: String, dataValue: String) { + whenever(refDataMappingRepository.findByDataRefDataAndDataValue(refData, dataValue)).thenAnswer { + refDataMappingsMap[refData]?.get(dataValue)?.let { RefDataMapping(refData, dataValue, it) } + } + } +}