HIPP-1695: Use Hip Environments in the ApplicationsLifecycleService (#…

…211) * HIPP-1695: Use Hip Environments in the ApplicationsLifecycleService * HIPP-1695: Address PR comments
hmrc · Nov 27, 2024 · a4e7b9e · a4e7b9e
1 parent c8462a7
commit a4e7b9e
Show file tree

Hide file tree

Showing 5 changed files with 71 additions and 69 deletions.
diff --git a/app/uk/gov/hmrc/apihubapplications/services/ApplicationsLifecycleService.scala b/app/uk/gov/hmrc/apihubapplications/services/ApplicationsLifecycleService.scala
@@ -18,9 +18,10 @@ package uk.gov.hmrc.apihubapplications.services
 
 import com.google.inject.{Inject, Singleton}
 import play.api.Logging
+import uk.gov.hmrc.apihubapplications.config.HipEnvironments
 import uk.gov.hmrc.apihubapplications.connectors.{EmailConnector, IdmsConnector}
 import uk.gov.hmrc.apihubapplications.models.application.{Application, Deleted, NewApplication, Primary, Secondary, TeamMember}
-import uk.gov.hmrc.apihubapplications.models.application.ApplicationLenses._
+import uk.gov.hmrc.apihubapplications.models.application.ApplicationLenses.*
 import uk.gov.hmrc.apihubapplications.models.exception.{ApplicationsException, ExceptionRaising}
 import uk.gov.hmrc.apihubapplications.repositories.ApplicationsRepository
 import uk.gov.hmrc.apihubapplications.services.helpers.ApplicationEnrichers
@@ -46,7 +47,8 @@ class ApplicationsLifecycleServiceImpl @ Inject()(
   repository: ApplicationsRepository,
   idmsConnector: IdmsConnector,
   emailConnector: EmailConnector,
-  clock: Clock
+  clock: Clock,
+  hipEnvironments: HipEnvironments,
 )(implicit ec: ExecutionContext) extends ApplicationsLifecycleService with Logging with ExceptionRaising {
 
   override def registerApplication(newApplication: NewApplication)(implicit hc: HeaderCarrier): Future[Either[ApplicationsException, Application]] = {
@@ -55,10 +57,7 @@ class ApplicationsLifecycleServiceImpl @ Inject()(
 
     ApplicationEnrichers.process(
       application,
-      Seq(
-        ApplicationEnrichers.credentialCreatingApplicationEnricher(Primary, application, idmsConnector, clock),
-        ApplicationEnrichers.credentialCreatingApplicationEnricher(Secondary, application, idmsConnector, clock)
-      )
+      hipEnvironments.environments.map(ApplicationEnrichers.credentialCreatingApplicationEnricher(_, application, idmsConnector, clock))
     ).flatMap {
       case Right(enriched) =>
         repository.insert(enriched).flatMap {

diff --git a/app/uk/gov/hmrc/apihubapplications/services/helpers/ApplicationEnricher.scala b/app/uk/gov/hmrc/apihubapplications/services/helpers/ApplicationEnricher.scala
@@ -16,9 +16,10 @@
 
 package uk.gov.hmrc.apihubapplications.services.helpers
 
+import uk.gov.hmrc.apihubapplications.config.HipEnvironment
 import uk.gov.hmrc.apihubapplications.connectors.IdmsConnector
 import uk.gov.hmrc.apihubapplications.models.application.ApplicationLenses.ApplicationLensOps
-import uk.gov.hmrc.apihubapplications.models.application._
+import uk.gov.hmrc.apihubapplications.models.application.*
 import uk.gov.hmrc.apihubapplications.models.exception.IdmsException
 import uk.gov.hmrc.apihubapplications.models.exception.IdmsException.ClientNotFound
 import uk.gov.hmrc.apihubapplications.models.idms.{Client, ClientResponse, ClientScope}
@@ -177,25 +178,23 @@ object ApplicationEnrichers {
   }
 
   def credentialCreatingApplicationEnricher(
-                                             environmentName: EnvironmentName,
+                                             hipEnvironment: HipEnvironment,
                                              original: Application,
                                              idmsConnector: IdmsConnector,
                                              clock: Clock,
                                              hiddenPrimary: Boolean = true
                                            )(implicit ec: ExecutionContext, hc: HeaderCarrier): Future[Either[IdmsException, ApplicationEnricher]] = {
-    idmsConnector.createClient(environmentName, Client(original)).map {
-      case Right(clientResponse) =>
-        Right(
-          (application: Application) => {
-            environmentName match {
-              case Primary if hiddenPrimary => application.addCredential(Primary, clientResponse.asNewHiddenCredential(clock))
-              case Primary => application.addCredential(Primary, clientResponse.asNewCredential(clock))
-              case Secondary => application.addCredential(Secondary, clientResponse.asNewCredential(clock))
+      idmsConnector.createClient(hipEnvironment.environmentName, Client(original)).map {
+        case Right(clientResponse) =>
+          Right(
+            (application: Application) => {
+              if hipEnvironment.isProductionLike && hiddenPrimary then
+                  application.addCredential(hipEnvironment.environmentName, clientResponse.asNewHiddenCredential(clock))
+              else application.addCredential(hipEnvironment.environmentName, clientResponse.asNewCredential(clock))
             }
-          }
-        )
-      case Left(e) => Left(e)
-    }
+          )
+        case Left(e) => Left(e)
+      }
   }
 
   def scopeAddingApplicationEnricher(

diff --git a/test-common/uk/gov/hmrc/apihubapplications/testhelpers/FakeHipEnvironments.scala b/test-common/uk/gov/hmrc/apihubapplications/testhelpers/FakeHipEnvironments.scala
@@ -21,29 +21,32 @@ import uk.gov.hmrc.apihubapplications.models.application.{Primary, Secondary}
 
 object FakeHipEnvironments extends HipEnvironments {
 
+  val primaryEnvironment: HipEnvironment = HipEnvironment(
+    id = "production",
+    rank = 1,
+    environmentName = Primary,
+    isProductionLike = true,
+    apimUrl = "http://apim.test/production",
+    clientId = "test-production-client-id",
+    secret = "test-production-secret",
+    useProxy = false,
+    apiKey = None
+  )
+  val secondaryEnvironment: HipEnvironment = HipEnvironment(
+    id = "test",
+    rank = 2,
+    environmentName = Secondary,
+    isProductionLike = false,
+    apimUrl = "http://apim.test/test",
+    clientId = "test-test-client-id",
+    secret = "test-test-secret",
+    useProxy = false,
+    apiKey = None
+  )
+
   override val environments: Seq[HipEnvironment] = Seq(
-    HipEnvironment(
-      id = "production",
-      rank = 1,
-      environmentName = Primary,
-      isProductionLike = true,
-      apimUrl = "http://apim.test/production",
-      clientId = "test-production-client-id",
-      secret = "test-production-secret",
-      useProxy = false,
-      apiKey = None
-    ),
-    HipEnvironment(
-      id = "test",
-      rank = 2,
-      environmentName = Secondary,
-      isProductionLike = false,
-      apimUrl = "http://apim.test/test",
-      clientId = "test-test-client-id",
-      secret = "test-test-secret",
-      useProxy = false,
-      apiKey = None
-    )
+    primaryEnvironment,
+    secondaryEnvironment
   )
 
 }
diff --git a/test/uk/gov/hmrc/apihubapplications/services/ApplicationsLifecycleServiceSpec.scala b/test/uk/gov/hmrc/apihubapplications/services/ApplicationsLifecycleServiceSpec.scala
@@ -17,7 +17,7 @@
 package uk.gov.hmrc.apihubapplications.services
 
 import org.mockito.ArgumentCaptor
-import org.mockito.ArgumentMatchers.{any, eq => eqTo}
+import org.mockito.ArgumentMatchers.{any, eq as eqTo}
 import org.mockito.Mockito.{never, times, verify, verifyNoMoreInteractions, when}
 import org.scalatest.EitherValues
 import org.scalatest.freespec.AsyncFreeSpec
@@ -26,12 +26,13 @@ import org.scalatestplus.mockito.MockitoSugar
 import play.api.http.Status.INTERNAL_SERVER_ERROR
 import uk.gov.hmrc.apihubapplications.connectors.{EmailConnector, IdmsConnector}
 import uk.gov.hmrc.apihubapplications.models.accessRequest.{AccessRequest, Approved}
-import uk.gov.hmrc.apihubapplications.models.application.ApplicationLenses._
-import uk.gov.hmrc.apihubapplications.models.application._
+import uk.gov.hmrc.apihubapplications.models.application.ApplicationLenses.*
+import uk.gov.hmrc.apihubapplications.models.application.*
 import uk.gov.hmrc.apihubapplications.models.exception.IdmsException.CallError
-import uk.gov.hmrc.apihubapplications.models.exception._
+import uk.gov.hmrc.apihubapplications.models.exception.*
 import uk.gov.hmrc.apihubapplications.models.idms.{Client, ClientResponse}
 import uk.gov.hmrc.apihubapplications.repositories.ApplicationsRepository
+import uk.gov.hmrc.apihubapplications.testhelpers.FakeHipEnvironments
 import uk.gov.hmrc.http.HeaderCarrier
 
 import java.time.{Clock, Instant, LocalDateTime, ZoneId}
@@ -692,7 +693,7 @@ class ApplicationsLifecycleServiceSpec extends AsyncFreeSpec with Matchers with
     val repository = mock[ApplicationsRepository]
     val idmsConnector = mock[IdmsConnector]
     val emailConnector = mock[EmailConnector]
-    val service = new ApplicationsLifecycleServiceImpl(searchService, accessRequestsService, repository, idmsConnector, emailConnector, clock)
+    val service = new ApplicationsLifecycleServiceImpl(searchService, accessRequestsService, repository, idmsConnector, emailConnector, clock, FakeHipEnvironments)
     Fixture(searchService, accessRequestsService, repository, idmsConnector, emailConnector, service)
   }
 

diff --git a/test/uk/gov/hmrc/apihubapplications/services/helpers/ApplicationEnricherSpec.scala b/test/uk/gov/hmrc/apihubapplications/services/helpers/ApplicationEnricherSpec.scala
@@ -28,6 +28,7 @@ import uk.gov.hmrc.apihubapplications.models.application.*
 import uk.gov.hmrc.apihubapplications.models.exception.IdmsException
 import uk.gov.hmrc.apihubapplications.models.exception.IdmsException.CallError
 import uk.gov.hmrc.apihubapplications.models.idms.{Client, ClientResponse, ClientScope}
+import uk.gov.hmrc.apihubapplications.testhelpers.FakeHipEnvironments
 import uk.gov.hmrc.http.HeaderCarrier
 
 import java.time.{Clock, Instant, LocalDateTime, ZoneId}
@@ -352,42 +353,41 @@ class ApplicationEnricherSpec extends AsyncFreeSpec
 
 
   "credentialCreatingApplicationEnricher" - {
-    "must create a credential in the primary environment and enrich the application with it" in {
-      val expected = testApplication.setCredentials(Primary, Seq(Credential(testClientResponse1.clientId, LocalDateTime.now(clock), None, None)))
+    "must create a credential in the hip environments and enrich the application with it" in {
+      val expected = Seq(
+        testApplication.setCredentials(FakeHipEnvironments.primaryEnvironment, Seq(testClientResponse1.asNewHiddenCredential(clock))),
+        testApplication.setCredentials(FakeHipEnvironments.secondaryEnvironment, Seq(testClientResponse2.asNewCredential(clock))),
+      )
 
       val idmsConnector = mock[IdmsConnector]
       when(idmsConnector.createClient(eqTo(Primary), eqTo(Client(testApplication)))(any()))
         .thenReturn(Future.successful(Right(testClientResponse1)))
-
-      ApplicationEnrichers.credentialCreatingApplicationEnricher(Primary, testApplication, idmsConnector, clock).map {
-        case Right(enricher) => enricher.enrich(testApplication) mustBe expected
-        case Left(e) => fail("Unexpected Left response", e)
-      }
-    }
-
-    "must create a credential in the secondary environment and enrich the application with it" in {
-      val expected = testApplication.setCredentials(Secondary, Seq(testClientResponse1.asNewCredential(clock)))
-
-      val idmsConnector = mock[IdmsConnector]
       when(idmsConnector.createClient(eqTo(Secondary), eqTo(Client(testApplication)))(any()))
-        .thenReturn(Future.successful(Right(testClientResponse1)))
+        .thenReturn(Future.successful(Right(testClientResponse2)))
 
-      ApplicationEnrichers.credentialCreatingApplicationEnricher(Secondary, testApplication, idmsConnector, clock).map {
-        case Right(enricher) => enricher.enrich(testApplication) mustBe expected
-        case Left(e) => fail("Unexpected Left response", e)
-      }
+      val results = Future.sequence(
+        FakeHipEnvironments.environments.map(
+          ApplicationEnrichers.credentialCreatingApplicationEnricher(_, testApplication, idmsConnector, clock)
+        )).map(_.map {
+            case Right(enricher) => enricher.enrich(testApplication)
+            case Left(e) => fail("Unexpected Left response", e)
+          })
+
+      results.map(
+        _ mustBe expected
+      )
     }
 
     "must return IdmsException if any call to IDMS fails" in {
       val expected = IdmsException("test-message", CallError)
 
       val idmsConnector = mock[IdmsConnector]
-      when(idmsConnector.createClient(eqTo(Primary), eqTo(Client(testApplication)))(any()))
+      when(idmsConnector.createClient(any, eqTo(Client(testApplication)))(any()))
         .thenReturn(Future.successful(Left(expected)))
 
-      ApplicationEnrichers.credentialCreatingApplicationEnricher(Primary, testApplication, idmsConnector, clock).map {
-        actual =>
-          actual mustBe Left(expected)
+      ApplicationEnrichers.credentialCreatingApplicationEnricher(FakeHipEnvironments.environments.head, testApplication, idmsConnector, clock).map {
+        case Right(_) => fail("Unexpected Right response")
+        case Left(e) => e mustBe expected
       }
     }
   }