DL-18194, makes the HIP Switch sensitive to values in application.conf

app/services/DeRegistrationService.scala

@@ -21,14 +21,15 @@ import play.api.Logging
 import play.api.http.Status
 import play.api.libs.json._
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.{AWRSFeatureSwitches, Utility}
 
 import javax.inject.Inject
 import scala.concurrent.{ExecutionContext, Future}
 
 class DeRegistrationService @Inject()(etmpConnector: EtmpConnector,
                                       hipConnector: HipConnector)
-                                     (implicit ec: ExecutionContext)
+                                     (implicit ec: ExecutionContext, config: ServicesConfig)
   extends Logging {
 
   private val acknowledgementReference: String = "acknowledgementReference"

app/services/EtmpRegimeService.scala

@@ -25,6 +25,7 @@ import play.api.http.Status._
 import uk.gov.hmrc.auth.core.retrieve.v2.Retrievals
 import uk.gov.hmrc.auth.core.{AffinityGroup, AuthConnector, AuthorisedFunctions, User}
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.{AWRSFeatureSwitches, HipHelpers, Utility}
 
 import scala.concurrent.{ExecutionContext, Future}
@@ -33,7 +34,8 @@ import scala.util.{Failure, Success, Try}
 class EtmpRegimeService @Inject()(etmpConnector: EtmpConnector,
                                   hipConnector: HipConnector,
                                   val enrolmentStoreConnector: EnrolmentStoreConnector,
-                                  val authConnector: AuthConnector) extends AuthorisedFunctions
+                                  val authConnector: AuthConnector)
+                                 (implicit config: ServicesConfig) extends AuthorisedFunctions
                                   with NonSelfHealStatus
                                   with Logging {
 

app/services/EtmpStatusService.scala

@@ -24,9 +24,11 @@ import play.api.libs.json.Json
 import javax.inject.Inject
 import scala.concurrent.{ExecutionContext, Future}
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.{AWRSFeatureSwitches, Utility}
 
-class EtmpStatusService @Inject()(etmpConnector: EtmpConnector, hipConnector: HipConnector) extends Logging {
+class EtmpStatusService @Inject()(etmpConnector: EtmpConnector, hipConnector: HipConnector)
+                                 (implicit config: ServicesConfig) extends Logging {
 
   def checkStatus(awrsRefNo: String)(implicit headerCarrier: HeaderCarrier, ec: ExecutionContext): Future[HttpResponse] =
     if (AWRSFeatureSwitches.hipSwitch().enabled) {

app/services/LookupService.scala

@@ -20,6 +20,7 @@ import connectors.{EtmpConnector, HipConnector}
 import play.api.http.Status
 import play.api.libs.json.Json
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.Utility.logger
 import utils.{AWRSFeatureSwitches, Utility}
 
@@ -28,7 +29,8 @@ import scala.concurrent.{ExecutionContext, Future}
 
 class LookupService @Inject()(etmpConnector: EtmpConnector,
                               hipConnector: HipConnector)
-                             (implicit ec: ExecutionContext) {
+                             (implicit ec: ExecutionContext,
+                              config: ServicesConfig) {
 
   def lookupApplication(awrsRefNo: String)(implicit headerCarrier: HeaderCarrier): Future[HttpResponse] = {
 

app/services/SubscriptionService.scala

@@ -23,6 +23,7 @@ import play.api.Logging
 import play.api.http.Status._
 import play.api.libs.json.{JsError, JsObject, JsResult, JsSuccess, JsValue, Json}
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.{AWRSFeatureSwitches, SessionUtils, Utility}
 
 import javax.inject.Inject
@@ -33,7 +34,7 @@ class SubscriptionService @Inject()(
                                      val enrolmentStoreConnector: EnrolmentStoreConnector,
                                      val etmpConnector: EtmpConnector,
                                      val hipConnector: HipConnector
-                                   )(implicit ec: ExecutionContext) extends Logging {
+                                   )(implicit ec: ExecutionContext, config: ServicesConfig) extends Logging {
 
   val AWRS_SERVICE_NAME = "HMRC-AWRS-ORG"
   private val acknowledgmentReference: String = "acknowledgmentReference"

app/services/WithdrawalService.scala

@@ -27,10 +27,12 @@ import play.api.libs.json._
 
 import scala.concurrent.{ExecutionContext, Future}
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.{AWRSFeatureSwitches, Utility}
 
 class WithdrawalService @Inject()(metrics: AwrsMetrics, etmpConnector: EtmpConnector, hipConnector: HipConnector)
-                                 (implicit ec: ExecutionContext) extends Logging {
+                                 (implicit ec: ExecutionContext,
+                                  config: ServicesConfig) extends Logging {
 
   def withdrawal(withdrawalData: JsValue, awrsRefNo: String)(implicit headerCarrier: HeaderCarrier): Future[HttpResponse] = {
     if (AWRSFeatureSwitches.hipSwitch().enabled) {

app/utils/FeatureSwitch.scala

@@ -16,6 +16,8 @@
 
 package utils
 
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
+
 import java.time.format.DateTimeFormatter
 import java.time.{ZoneId, ZonedDateTime}
 import scala.util.matching.Regex
@@ -54,19 +56,18 @@ object FeatureSwitch {
   val dateFormat: DateTimeFormatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME
 
 
-  private[utils] def getProperty(name: String): FeatureSwitch = {
+  private[utils] def getProperty(name: String)(implicit config: ServicesConfig): FeatureSwitch = {
     val value = sys.props.get(systemPropertyName(name))
-
     value match {
       case Some("true") => BooleanFeatureSwitch(name, enabled = true)
       case Some(DisabledIntervalExtractor(start, end)) => DisabledTimedFeatureSwitch(name, toDate(start), toDate(end), ZonedDateTime.now(ZoneId.of("UTC")))
       case Some(EnabledIntervalExtractor(start, end)) => EnabledTimedFeatureSwitch(name, toDate(start), toDate(end), ZonedDateTime.now(ZoneId.of("UTC")))
 
-      case _ => BooleanFeatureSwitch(name, enabled = false)
+      case _ => BooleanFeatureSwitch(name, enabled = config.getBoolean(s"feature.$name"))
     }
   }
 
-  private[utils] def setProperty(name: String, value: String): FeatureSwitch = {
+  private[utils] def setProperty(name: String, value: String)(implicit config: ServicesConfig): FeatureSwitch = {
     sys.props += ((systemPropertyName(name), value))
     getProperty(name)
   }
@@ -81,21 +82,21 @@ object FeatureSwitch {
 
   private[utils] def systemPropertyName(name: String) = s"feature.$name"
 
-  def enable(fs: FeatureSwitch): FeatureSwitch = setProperty(fs.name, "true")
-  def disable(fs: FeatureSwitch): FeatureSwitch = setProperty(fs.name, "false")
+  def enable(fs: FeatureSwitch)(implicit config: ServicesConfig): FeatureSwitch = setProperty(fs.name, "true")
+  def disable(fs: FeatureSwitch)(implicit config: ServicesConfig): FeatureSwitch = setProperty(fs.name, "false")
 
-  def apply(name: String, enabled: Boolean = false): FeatureSwitch = getProperty(name)
+  def apply(name: String, enabled: Boolean = false)(implicit config: ServicesConfig): FeatureSwitch = getProperty(name)
   def unapply(fs: FeatureSwitch): Option[(String, Boolean)] = Some(fs.name -> fs.enabled)
 }
 
 object AWRSFeatureSwitches extends AWRSFeatureSwitches
 
 trait AWRSFeatureSwitches {
 
-  def regimeCheck(): FeatureSwitch = FeatureSwitch.getProperty("regimeCheck")
-  def hipSwitch(): FeatureSwitch = FeatureSwitch.getProperty("hipSwitch")
+  def regimeCheck()(implicit config: ServicesConfig): FeatureSwitch = FeatureSwitch.getProperty("regimeCheck")
+  def hipSwitch()(implicit config: ServicesConfig): FeatureSwitch = FeatureSwitch.getProperty("hipSwitch")
 
-  def apply(name: String): Option[FeatureSwitch] = name match {
+  def apply(name: String)(implicit config: ServicesConfig): Option[FeatureSwitch] = name match {
     case "regimeCheck" => Some(regimeCheck())
     case "hipSwitch" => Some(hipSwitch())
     case _ => None

it/test/controllers/EtmpCheckControllerSpec.scala

@@ -22,11 +22,13 @@ import play.api.http.Status.{NOT_FOUND, NO_CONTENT, OK}
 import play.api.libs.ws.WSResponse
 import uk.gov.hmrc.helpers.utils.Stubs
 import uk.gov.hmrc.helpers.{AuthHelpers, IntegrationSpec}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.{AWRSFeatureSwitches, FeatureSwitch}
 
 class EtmpCheckControllerSpec extends IntegrationSpec with AuthHelpers with Matchers with Stubs {
 
   val controllerUrl: String = routes.EtmpCheckController.checkEtmp().url
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
 
   "checkEtmp()" should {
 

it/test/controllers/SubscriptionControllerSpec.scala

@@ -23,6 +23,7 @@ import play.api.http.Status._
 import play.api.libs.ws.WSResponse
 import uk.gov.hmrc.helpers.utils.{IntegrationData, Stubs}
 import uk.gov.hmrc.helpers.{AuthHelpers, IntegrationSpec}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.{AWRSFeatureSwitches, FeatureSwitch}
 
 import scala.concurrent.duration.FiniteDuration
@@ -33,6 +34,8 @@ class SubscriptionControllerSpec extends IntegrationSpec with AuthHelpers with M
 
   val controllerUrl = "/awrs/send-data"
 
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
+
   "subscribe()" should {
     "return 200" when {
       "EMAC feature switch is true" when {

test/services/DeRegistrationServiceTest.scala

@@ -24,6 +24,7 @@ import play.api.libs.json.{JsObject, JsResult, JsValue, Json}
 import play.api.test.Helpers.{OK, await, defaultAwaitTimeout}
 import play.mvc.Http.Status
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.AwrsTestJson.testRefNo
 import utils.{AWRSFeatureSwitches, BaseSpec, FeatureSwitch}
 
@@ -34,10 +35,11 @@ class DeRegistrationServiceTest extends BaseSpec with AnyWordSpecLike{
   val mockEtmpConnector: EtmpConnector = mock[EtmpConnector]
   val mockHipConnector: HipConnector = mock[HipConnector]
   implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
 
   object TestLookupService$ extends LookupService(mockEtmpConnector, mockHipConnector)
 
-  val testDeRegistrationService: DeRegistrationService = new DeRegistrationService(mockEtmpConnector, mockHipConnector)(ec)
+  val testDeRegistrationService: DeRegistrationService = new DeRegistrationService(mockEtmpConnector, mockHipConnector)(ec, config)
 
   val groupEndedJson: JsValue = api10RequestJson
   val otherReason: JsValue = api10OtherReasonRequestJson

test/services/EtmpRegimeServiceTest.scala

@@ -27,6 +27,7 @@ import play.api.test.Helpers
 import play.api.test.Helpers.{await, _}
 import uk.gov.hmrc.auth.core.{AffinityGroup, AuthConnector}
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse, SessionId}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.FeatureSwitch.disable
 import utils.{AWRSFeatureSwitches, AwrsTestJson, BaseSpec, FeatureSwitch}
 
@@ -37,6 +38,7 @@ import scala.concurrent.Future
 class EtmpRegimeServiceTest extends BaseSpec with AnyWordSpecLike with BeforeAndAfterEach with BeforeAndAfterAll {
 
   implicit val hc: HeaderCarrier = HeaderCarrier(sessionId = Some(SessionId(s"session-${UUID.randomUUID}")))
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
 
   val mockEtmpConnector: EtmpConnector = mock[EtmpConnector]
   val mockHipConnector: HipConnector = mock[HipConnector]

test/services/EtmpStatusInfoServiceTest.scala

@@ -22,6 +22,7 @@ import org.scalatest.matchers.should.Matchers.convertToAnyShouldWrapper
 import org.scalatest.wordspec.AnyWordSpecLike
 import play.api.test.Helpers._
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse, SessionId}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.AwrsTestJson.testRefNo
 import utils.BaseSpec
 
@@ -32,6 +33,7 @@ class EtmpStatusInfoServiceTest extends BaseSpec with AnyWordSpecLike {
 
   implicit val hc: HeaderCarrier = HeaderCarrier(sessionId = Some(SessionId(s"session-${UUID.randomUUID}")))
   implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
 
   val mockEtmpConnector: EtmpConnector = mock[EtmpConnector]
 

test/services/EtmpStatusServiceTest.scala

@@ -24,6 +24,7 @@ import play.api.libs.json.{JsValue, Json}
 import play.api.test.Helpers._
 import play.mvc.Http.Status
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse, SessionId}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.{AWRSFeatureSwitches, BaseSpec, FeatureSwitch}
 
 import java.util.UUID
@@ -33,6 +34,7 @@ class EtmpStatusServiceTest extends BaseSpec with AnyWordSpecLike {
 
   implicit val hc: HeaderCarrier = HeaderCarrier(sessionId = Some(SessionId(s"session-${UUID.randomUUID}")))
   implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
 
   val mockEtmpConnector: EtmpConnector = mock[EtmpConnector]
   val mockHipConnector: HipConnector = mock[HipConnector]

test/services/LookupServiceTest.scala

@@ -25,6 +25,8 @@ import play.api.libs.json.{JsValue, Json}
 import play.api.test.Helpers._
 import play.mvc.Http.Status
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse, SessionId}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
+import utils.AwrsTestJson.testRefNo
 import utils.AwrsTestJson._
 import utils.FeatureSwitch.disable
 import utils.{AWRSFeatureSwitches, BaseSpec, FeatureSwitch}
@@ -36,6 +38,7 @@ class LookupServiceTest extends BaseSpec with AnyWordSpecLike with BeforeAndAfte
 
   implicit val hc: HeaderCarrier = HeaderCarrier(sessionId = Some(SessionId(s"session-${UUID.randomUUID}")))
   implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
 
   val mockEtmpConnector: EtmpConnector = mock[EtmpConnector]
   val mockHipConnector: HipConnector = mock[HipConnector]

test/services/SubscriptionServiceTest.scala

@@ -38,12 +38,12 @@ class SubscriptionServiceTest extends BaseSpec with AnyWordSpecLike {
 
   implicit val ec: ExecutionContext =
     scala.concurrent.ExecutionContext.Implicits.global
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
   val mockEtmpConnector: EtmpConnector = mock[EtmpConnector]
   val mockHipConnector: HipConnector = mock[HipConnector]
   val mockEnrolmentStoreConnector: EnrolmentStoreConnector =
     mock[EnrolmentStoreConnector]
   val mockAuditConnector: AuditConnector = mock[AuditConnector]
-  val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
 
   val inputJson: JsValue = api4EtmpLTDJson
   val inputJsonUpdate: JsValue = api6RequestUpdateJsonWithAck

test/services/WithdrawalServiceTest.scala

@@ -25,6 +25,7 @@ import play.api.libs.json.{JsValue, Json}
 import play.api.test.Helpers._
 import play.mvc.Http.Status
 import uk.gov.hmrc.http.{HeaderCarrier, HttpResponse, SessionId}
+import uk.gov.hmrc.play.bootstrap.config.ServicesConfig
 import utils.AwrsTestJson.testRefNo
 import utils._
 
@@ -37,6 +38,7 @@ class WithdrawalServiceTest extends BaseSpec with AnyWordSpecLike {
   val requestJson: JsValue = api8ValidRequestJson
   val ackReference: String = SessionUtils.getUniqueAckNo
   implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
+  implicit val config: ServicesConfig = app.injector.instanceOf[ServicesConfig]
 
   object TestWithdrawalService extends WithdrawalService(app.injector.instanceOf[AwrsMetrics], mockEtmpConnector, mockHipConnector)