Merge pull request #81 from hmrc/API-4485

API-4485: Remove references to subscriberId in PPNS components

app/uk/gov/hmrc/apisubscriptionfields/connector/Model.scala

@@ -16,13 +16,13 @@
 
 package uk.gov.hmrc.apisubscriptionfields.connector
 
-import uk.gov.hmrc.apisubscriptionfields.model.{BoxId, ClientId, SubscriptionFieldsId}
+import uk.gov.hmrc.apisubscriptionfields.model.{BoxId, ClientId}
 
 private[connector] case class CreateBoxRequest(boxName: String, clientId: ClientId)
 
 private[connector] case class CreateBoxResponse(boxId: BoxId)
 
-private[connector] case class SubscriberRequest(callBackUrl: String, subscriberType: String, subscriberId: Option[SubscriptionFieldsId] = None)
+private[connector] case class SubscriberRequest(callBackUrl: String, subscriberType: String)
 
 private[connector] case class UpdateSubscriberRequest(subscriber: SubscriberRequest)
 

app/uk/gov/hmrc/apisubscriptionfields/connector/PushPullNotificationServiceConnector.scala

@@ -17,20 +17,19 @@
 package uk.gov.hmrc.apisubscriptionfields.connector
 
 import javax.inject.{Inject, Singleton}
+import uk.gov.hmrc.apisubscriptionfields.config.ApplicationConfig
+import uk.gov.hmrc.apisubscriptionfields.model.{BoxId, ClientId}
+import uk.gov.hmrc.http.HeaderCarrier
 import uk.gov.hmrc.play.bootstrap.http.HttpClient
 import uk.gov.hmrc.play.http.metrics._
-import uk.gov.hmrc.apisubscriptionfields.config.ApplicationConfig
+
 import scala.concurrent.{ExecutionContext, Future}
-import uk.gov.hmrc.apisubscriptionfields.model.ClientId
-import uk.gov.hmrc.apisubscriptionfields.model.BoxId
-import uk.gov.hmrc.http.HeaderCarrier
 import scala.util.control.NonFatal
-import uk.gov.hmrc.apisubscriptionfields.model.SubscriptionFieldsId
 
 @Singleton
 class PushPullNotificationServiceConnector @Inject()(http: HttpClient, appConfig: ApplicationConfig, val apiMetrics: ApiMetrics)
                                                     (implicit ec: ExecutionContext) extends RecordMetrics {
-  import  uk.gov.hmrc.apisubscriptionfields.connector.JsonFormatters._
+  import uk.gov.hmrc.apisubscriptionfields.connector.JsonFormatters._
 
   val api = API("api-subscription-fields")
 
@@ -46,8 +45,8 @@ class PushPullNotificationServiceConnector @Inject()(http: HttpClient, appConfig
     }
   }
 
-  def subscribe(subscriberFieldsId: SubscriptionFieldsId, boxId: BoxId, callbackUrl: String)(implicit hc: HeaderCarrier): Future[Unit] = {
-    val payload = UpdateSubscriberRequest(SubscriberRequest(callbackUrl, "API_PUSH_SUBSCRIBER", Some(subscriberFieldsId)))
+  def subscribe(boxId: BoxId, callbackUrl: String)(implicit hc: HeaderCarrier): Future[Unit] = {
+    val payload = UpdateSubscriberRequest(SubscriberRequest(callbackUrl, "API_PUSH_SUBSCRIBER"))
 
     http.PUT[UpdateSubscriberRequest, UpdateSubscriberResponse](s"$externalServiceUri/box/${boxId.value.toString}/subscriber", payload)
     .map(_ => ())

app/uk/gov/hmrc/apisubscriptionfields/service/PushPullNotificationService.scala

@@ -27,25 +27,31 @@ import scala.concurrent.ExecutionContext
 import uk.gov.hmrc.http.HeaderCarrier
 
 @Singleton
-class PushPullNotificationService @Inject() (ppnsConnector: PushPullNotificationServiceConnector)(implicit ec: ExecutionContext) {
+class PushPullNotificationService @Inject()(ppnsConnector: PushPullNotificationServiceConnector)(implicit ec: ExecutionContext) {
   def makeBoxName(apiContext: ApiContext, apiVersion: ApiVersion, fieldDefinition: FieldDefinition) : String = {
     val separator = "##"
     s"${apiContext.value}${separator}${apiVersion.value}${separator}${fieldDefinition.name.value}"
   }
 
-  private def subscribeToPPNS(clientId: ClientId, apiContext: ApiContext, apiVersion: ApiVersion, subscriptionFieldsId: SubscriptionFieldsId, fieldDefinition: FieldDefinition, oFieldValue: Option[FieldValue])(implicit hc: HeaderCarrier) = {
+  private def subscribeToPPNS(clientId: ClientId,
+                              apiContext: ApiContext,
+                              apiVersion: ApiVersion,
+                              fieldDefinition: FieldDefinition,
+                              oFieldValue: Option[FieldValue])
+                             (implicit hc: HeaderCarrier) = {
     for {
       boxId <- ppnsConnector.ensureBoxIsCreated(makeBoxName(apiContext, apiVersion, fieldDefinition), clientId)
-      _ <- oFieldValue.fold(Future.successful(()))(fieldValue => ppnsConnector.subscribe(subscriptionFieldsId, boxId, fieldValue))
+      _ <- oFieldValue.fold(Future.successful(()))(fieldValue => ppnsConnector.subscribe(boxId, fieldValue))
     } yield ()
   }
 
-  def subscribeToPPNS(clientId: ClientId, apiContext: ApiContext, apiVersion: ApiVersion, subscriptionFieldsId: SubscriptionFieldsId, fieldDefinitions: NEL[FieldDefinition], fields: Fields)(implicit hc: HeaderCarrier): Future[Unit] = {
+  def subscribeToPPNS(clientId: ClientId, apiContext: ApiContext, apiVersion: ApiVersion, fieldDefinitions: NEL[FieldDefinition], fields: Fields)
+                     (implicit hc: HeaderCarrier): Future[Unit] = {
     val subscriptionResponses : List[Future[Unit]] =
       fieldDefinitions
       .filter(_.`type` == FieldDefinitionType.PPNS_FIELD )
       .map { fieldDefn =>
-        subscribeToPPNS(clientId, apiContext, apiVersion, subscriptionFieldsId, fieldDefn, fields.get(fieldDefn.name).filterNot(_.isEmpty))
+        subscribeToPPNS(clientId, apiContext, apiVersion, fieldDefn, fields.get(fieldDefn.name).filterNot(_.isEmpty))
       }
 
     Future.sequence(subscriptionResponses).map(_ => ())

app/uk/gov/hmrc/apisubscriptionfields/service/SubscriptionFieldsService.scala

@@ -24,7 +24,7 @@ import Types._
 
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
-import scala.concurrent.Future.{successful}
+import scala.concurrent.Future.successful
 import cats.data.NonEmptyList
 import uk.gov.hmrc.apisubscriptionfields.repository.SubscriptionFieldsRepository
 import uk.gov.hmrc.http.HeaderCarrier
@@ -55,7 +55,7 @@ class SubscriptionFieldsService @Inject() (
 
     for {
       result  <- repository.saveAtomic(subscriptionFields)
-      _       <- pushPullNotificationService.subscribeToPPNS(clientId, apiContext, apiVersion, subscriptionFieldsId, fieldDefinitions, fields)
+      _       <- pushPullNotificationService.subscribeToPPNS(clientId, apiContext, apiVersion, fieldDefinitions, fields)
     } yield SuccessfulSubsFieldsUpsertResponse(result._1, result._2)
   }
 

test/uk/gov/hmrc/apisubscriptionfields/connector/PushPullNotificationServiceConnectorSpec.scala

@@ -105,7 +105,7 @@ class PushPullNotificationServiceConnectorSpec
 
     "send proper request to subscribe" in new Setup {
       val callbackUrl = "my-callback"
-      val updateRequest: UpdateSubscriberRequest = UpdateSubscriberRequest(SubscriberRequest(callbackUrl, "API_PUSH_SUBSCRIBER", Some(subscriptionFieldsId)))
+      val updateRequest: UpdateSubscriberRequest = UpdateSubscriberRequest(SubscriberRequest(callbackUrl, "API_PUSH_SUBSCRIBER"))
       val requestBody = Json.stringify(Json.toJson(updateRequest))
       val response: UpdateSubscriberResponse = UpdateSubscriberResponse(boxId)
 
@@ -119,8 +119,8 @@ class PushPullNotificationServiceConnectorSpec
 
       implicit val hc: HeaderCarrier = HeaderCarrier()
 
-      val ret = await(connector.subscribe(subscriptionFieldsId, boxId, callbackUrl))
-      ret shouldBe (())
+      val ret = await(connector.subscribe(boxId, callbackUrl))
+      ret shouldBe ()
 
       wireMockServer.verify(
         putRequestedFor(urlPathEqualTo(path))

test/uk/gov/hmrc/apisubscriptionfields/service/PushPullNotificationServiceSpec.scala

@@ -33,7 +33,6 @@ class PushPullNotificationServiceSpec extends AsyncHmrcSpec with SubscriptionFie
   val clientId: ClientId = ClientId(ju.UUID.randomUUID().toString)
   val apiContext: ApiContext = ApiContext("aContext")
   val apiVersion: ApiVersion = ApiVersion("aVersion")
-  val subscriptionFieldsId: SubscriptionFieldsId = SubscriptionFieldsId(ju.UUID.randomUUID())
 
   trait Setup {
     val mockPPNSConnector = mock[PushPullNotificationServiceConnector]
@@ -55,31 +54,31 @@ class PushPullNotificationServiceSpec extends AsyncHmrcSpec with SubscriptionFie
     "succeed and return boxId when fields with a PPNS_FIELD are provided" in new Setup {
 
       when(mockPPNSConnector.ensureBoxIsCreated(eqTo(expectedTopicName), any[ClientId])(*)).thenReturn(successful(boxId))
-      when(mockPPNSConnector.subscribe(subscriptionFieldsId,boxId,callbackUrl)(hc)).thenReturn(successful(()))
+      when(mockPPNSConnector.subscribe(boxId, callbackUrl)(hc)).thenReturn(successful(()))
 
-      await(service.subscribeToPPNS(clientId, apiContext, apiVersion, subscriptionFieldsId, fieldDefns, fields)) shouldBe (())
+      await(service.subscribeToPPNS(clientId, apiContext, apiVersion, fieldDefns, fields)) shouldBe (())
     }
 
     "succeed and return boxId when fields with a PPNS_FIELD but no field value is provided" in new Setup {
 
       when(mockPPNSConnector.ensureBoxIsCreated(eqTo(expectedTopicName), any[ClientId])(*)).thenReturn(successful(boxId))
       val fieldsWithNoCallbackUrl = Map(fieldN(2) -> "Some other")
 
-      await(service.subscribeToPPNS(clientId, apiContext, apiVersion, subscriptionFieldsId, fieldDefns, fieldsWithNoCallbackUrl)) shouldBe (())
+      await(service.subscribeToPPNS(clientId, apiContext, apiVersion, fieldDefns, fieldsWithNoCallbackUrl)) shouldBe (())
     }
 
     "succeed and return boxId when fields with a PPNS_FIELD but empty field value is provided" in new Setup {
 
       when(mockPPNSConnector.ensureBoxIsCreated(eqTo(expectedTopicName), any[ClientId])(*)).thenReturn(successful(boxId))
       val fieldsWithBlankCallbackUrl = Map(fieldN(1) -> "", fieldN(2) -> "Some other")
 
-      await(service.subscribeToPPNS(clientId, apiContext, apiVersion, subscriptionFieldsId, fieldDefns, fieldsWithBlankCallbackUrl)) shouldBe (())
+      await(service.subscribeToPPNS(clientId, apiContext, apiVersion, fieldDefns, fieldsWithBlankCallbackUrl)) shouldBe (())
     }
 
     "gracefully do nothing when no PPNS_FIELD field is provided" in new Setup {
       val localFieldDefns: NEL[FieldDefinition] = NEL.of(fieldDef2)
       val localFields: Types.Fields = Map(fieldN(2) -> "something else")
-      await(service.subscribeToPPNS(clientId, apiContext, apiVersion, subscriptionFieldsId, localFieldDefns, localFields)) shouldBe (())
+      await(service.subscribeToPPNS(clientId, apiContext, apiVersion, localFieldDefns, localFields)) shouldBe (())
 
       verify(mockPPNSConnector, never).ensureBoxIsCreated(*, any[ClientId])(*)
     }
@@ -88,16 +87,16 @@ class PushPullNotificationServiceSpec extends AsyncHmrcSpec with SubscriptionFie
       when(mockPPNSConnector.ensureBoxIsCreated(*, any[ClientId])(*)).thenReturn(failed(new RuntimeException))
 
       intercept[RuntimeException] {
-        await(service.subscribeToPPNS(clientId, apiContext, apiVersion, subscriptionFieldsId, fieldDefns, fields))
+        await(service.subscribeToPPNS(clientId, apiContext, apiVersion, fieldDefns, fields))
       }
     }
 
     "fail when subscribe to box fails" in new Setup {
       when(mockPPNSConnector.ensureBoxIsCreated((*), any[ClientId])(*)).thenReturn(successful(boxId))
-      when(mockPPNSConnector.subscribe(subscriptionFieldsId,boxId,callbackUrl)(hc)).thenReturn(failed(new RuntimeException))
+      when(mockPPNSConnector.subscribe(boxId, callbackUrl)(hc)).thenReturn(failed(new RuntimeException))
 
       intercept[RuntimeException] {
-        await(service.subscribeToPPNS(clientId, apiContext, apiVersion, subscriptionFieldsId, fieldDefns, fields))
+        await(service.subscribeToPPNS(clientId, apiContext, apiVersion, fieldDefns, fields))
       }
     }
   }

test/uk/gov/hmrc/apisubscriptionfields/service/SubscriptionFieldsServiceSpec.scala

@@ -39,7 +39,8 @@ class SubscriptionFieldsServiceSpec extends AsyncHmrcSpec with SubscriptionField
 
     implicit val hc: HeaderCarrier = HeaderCarrier()
 
-    val service = new SubscriptionFieldsService(mockSubscriptionFieldsRepository, mockUuidCreator, mockApiFieldDefinitionsService, mockPushPullNotificationService)
+    val service =
+      new SubscriptionFieldsService(mockSubscriptionFieldsRepository, mockUuidCreator, mockApiFieldDefinitionsService, mockPushPullNotificationService)
 
   }
 
@@ -129,7 +130,7 @@ class SubscriptionFieldsServiceSpec extends AsyncHmrcSpec with SubscriptionField
 
     "return false when updating an existing `api subscription fields" in new Setup {
       when(mockApiFieldDefinitionsService.get(FakeContext, FakeVersion)).thenReturn(successful(Some(FakeApiFieldDefinitionsResponseWithRegex)))
-      when(mockPushPullNotificationService.subscribeToPPNS(eqTo(FakeClientId), eqTo(FakeContext), eqTo(FakeVersion), eqTo(FakeFieldsId), any, eqTo(fields))(any)).thenReturn(ppnsResponse)
+      when(mockPushPullNotificationService.subscribeToPPNS(eqTo(FakeClientId), eqTo(FakeContext), eqTo(FakeVersion), any, eqTo(fields))(any)).thenReturn(ppnsResponse)
       when(mockSubscriptionFieldsRepository.saveAtomic(*)).thenReturn(successful((subscriptionFields, false)))
 
       val result = await(service.upsert(FakeClientId, FakeContext, FakeVersion, SubscriptionFieldsMatchRegexValidation))
@@ -139,7 +140,7 @@ class SubscriptionFieldsServiceSpec extends AsyncHmrcSpec with SubscriptionField
 
     "return true when creating a new api subscription fields" in new Setup {
       when(mockApiFieldDefinitionsService.get(FakeContext, FakeVersion)).thenReturn(successful(Some(FakeApiFieldDefinitionsResponseWithRegex)))
-      when(mockPushPullNotificationService.subscribeToPPNS(eqTo(FakeClientId), eqTo(FakeContext), eqTo(FakeVersion), eqTo(FakeFieldsId), any, eqTo(fields))(any)).thenReturn(ppnsResponse)
+      when(mockPushPullNotificationService.subscribeToPPNS(eqTo(FakeClientId), eqTo(FakeContext), eqTo(FakeVersion), any, eqTo(fields))(any)).thenReturn(ppnsResponse)
       when(mockSubscriptionFieldsRepository.saveAtomic(*)).thenReturn(successful((subscriptionFields, true)))
 
       val result = await(service.upsert(FakeClientId, FakeContext, FakeVersion, SubscriptionFieldsMatchRegexValidation))