Merge pull request #149 from hmrc/MTDSA-31559

MTDSA-31559 - Raised coverage to 95%

Author: stephen-oppong-beduh

app/api/controllers/AuditHandler.scala

@@ -55,21 +55,6 @@ object AuditHandler {
       responseBodyMap = if (includeResponse) identity else const(None)
     )
 
-  def custom[A: Writes](auditService: AuditService,
-                        auditType: String,
-                        transactionName: String,
-                        auditDetailCreator: AuditDetailCreator[A],
-                        requestBody: Option[JsValue] = None,
-                        responseBodyMap: Option[JsValue] => Option[JsValue]): AuditHandler =
-    new AuditHandlerImpl[A](
-      auditService = auditService,
-      auditType = auditType,
-      transactionName = transactionName,
-      auditDetailCreator,
-      requestBody = requestBody,
-      responseBodyMap = responseBodyMap
-    )
-
   private class AuditHandlerImpl[A: Writes](auditService: AuditService,
                                             auditType: String,
                                             transactionName: String,

app/definition/ApiDefinition.scala

@@ -20,12 +20,6 @@ import play.api.libs.json.{Format, Json, OFormat}
 import routing.Version
 import utils.enums.Enums
 
-case class Parameter(name: String, required: Boolean = false)
-
-object Parameter {
-  implicit val formatParameter: OFormat[Parameter] = Json.format[Parameter]
-}
-
 case class PublishingException(message: String) extends Exception(message)
 
 enum APIStatus {

project/CodeCoverageSettings.scala

@@ -34,7 +34,7 @@ object CodeCoverageSettings {
 
   val settings: Seq[Setting[?]] = Seq(
     ScoverageKeys.coverageExcludedPackages := excludedPackages.mkString(";"),
-    ScoverageKeys.coverageMinimumStmtTotal := 88,
+    ScoverageKeys.coverageMinimumStmtTotal := 95,
     ScoverageKeys.coverageFailOnMinimum := true,
     ScoverageKeys.coverageHighlighting := true
   )

test/api/connectors/parsers/StandardDownstreamHttpParserSpec.scala

@@ -115,6 +115,48 @@ class StandardDownstreamHttpParserSpec extends UnitSpec {
     }
   }
 
+  "validateJson" when {
+    implicit val reads: Reads[SomeModel] = Json.reads[SomeModel]
+
+    "the JSON is valid" should {
+      "return the parsed model" in {
+        val validJsonResponse: HttpResponse = HttpResponse(
+          OK,
+          desExpectedJson,
+          Map("CorrelationId" -> Seq(correlationId))
+        )
+
+        val result: Option[SomeModel] = validJsonResponse.validateJson[SomeModel]
+
+        result shouldBe Some(desModel)
+      }
+    }
+
+    "the JSON is invalid" should {
+      "return None" in {
+        val invalidJsonResponse: HttpResponse = HttpResponse(
+          OK,
+          Json.obj("data"     -> 1234),
+          Map("CorrelationId" -> Seq(correlationId))
+        )
+
+        val result: Option[SomeModel] = invalidJsonResponse.validateJson[SomeModel]
+
+        result shouldBe None
+      }
+    }
+
+    "the response contains no JSON" should {
+      "return None" in {
+        val emptyResponse: HttpResponse = HttpResponse(OK, "", Map("CorrelationId" -> Seq(correlationId)))
+
+        val result: Option[SomeModel] = emptyResponse.validateJson[SomeModel]
+
+        result shouldBe None
+      }
+    }
+  }
+
   val singleErrorJson: JsValue = Json.parse(
     """
       |{

test/api/models/domain/TaxYearRangeSpec.scala

@@ -16,6 +16,7 @@
 
 package api.models.domain
 
+import api.models.domain.TaxYear.currentTaxYear
 import support.UnitSpec
 
 import java.time.LocalDate
@@ -53,6 +54,14 @@ class TaxYearRangeSpec extends UnitSpec {
       val result: TaxYearRange = TaxYearRange.todayMinus(years = 4)
       result shouldBe TaxYearRange(expectedFrom, TaxYear.fromMtd(currentTaxYear))
     }
+
+    "return a TaxYearRange using the default systemUTC clock when no implicit clock is provided" in {
+      val expectedRange: TaxYearRange = TaxYearRange(TaxYear.fromDownstreamInt(currentTaxYear().year - 1), currentTaxYear())
+
+      val actualRange: TaxYearRange = TaxYearRange.todayMinus(1)
+
+      actualRange shouldBe expectedRange
+    }
   }
 
 }

test/api/models/domain/TimestampSpec.scala

@@ -74,6 +74,12 @@ class TimestampSpec extends UnitSpec {
     }
   }
 
+  "Timestamp.toString" should {
+    "return the string value" in {
+      Timestamp("2023-01-20T01:20:30.000Z").toString shouldBe "2023-01-20T01:20:30.000Z"
+    }
+  }
+
   "Timestamp serialised to a JSON string field" should {
     "serialise correctly" in {
       val result = Json.toJson(response)

test/api/models/errors/MtdErrorSpec.scala

@@ -38,6 +38,15 @@ class MtdErrorSpec extends UnitSpec {
     }
   }
 
+  "maybeWithPath" should {
+    "add a path to the error" when {
+      "a path is provided" in {
+        val result = error.maybeWithPath(Some("path")).paths
+        result shouldBe Some(List("path"))
+      }
+    }
+  }
+
   "maybeWithExtraPath" should {
     "add an extra path to the error" when {
       "a path is provided" in {

test/api/services/EnrolmentsAuthServiceSpec.scala

@@ -74,9 +74,10 @@ class EnrolmentsAuthServiceSpec extends ServiceSpec with MockAppConfig {
       behave like authorisedSupportingAgent(authValidationEnabled, initialPredicate, primaryAgentPredicate, supportingAgentPredicate)
 
       behave like disallowSupportingAgentForPrimaryOnlyEndpoint(authValidationEnabled, initialPredicate, primaryAgentPredicate)
-
+      behave like disallowInvalidAffinityGroup(authValidationEnabled, initialPredicate)
       behave like disallowUsersWithoutEnrolments(authValidationEnabled, initialPredicate)
       behave like disallowWhenNotLoggedIn(authValidationEnabled, initialPredicate)
+      behave like handleUnexpectedError(authValidationEnabled, initialPredicate)
     }
 
     def authorisedIndividual(authValidationEnabled: Boolean, initialPredicate: Predicate): Unit =
@@ -237,6 +238,21 @@ class EnrolmentsAuthServiceSpec extends ServiceSpec with MockAppConfig {
         result shouldBe Left(ClientOrAgentNotAuthorisedError)
       }
 
+    def disallowInvalidAffinityGroup(authValidationEnabled: Boolean, initialPredicate: Predicate): Unit =
+      "disallow users with an invalid affinity group" in new Test {
+        mockConfidenceLevelCheckConfig(authValidationEnabled = authValidationEnabled)
+
+        val retrievalsResult = new ~(None, Enrolments(Set.empty))
+
+        MockedAuthConnector
+          .authorised(initialPredicate, affinityGroup and authorisedEnrolments)
+          .once()
+          .returns(Future.successful(retrievalsResult))
+
+        val result: AuthOutcome = await(enrolmentsAuthService.authorised(mtdId))
+        result shouldBe Left(ClientOrAgentNotAuthorisedError)
+      }
+
     def disallowWhenNotLoggedIn(authValidationEnabled: Boolean, initialPredicate: Predicate): Unit =
       "disallow users that are not logged in" in new Test {
         mockConfidenceLevelCheckConfig(authValidationEnabled = authValidationEnabled)
@@ -264,6 +280,22 @@ class EnrolmentsAuthServiceSpec extends ServiceSpec with MockAppConfig {
       }
   }
 
+  def handleUnexpectedError(authValidationEnabled: Boolean, initialPredicate: Predicate): Unit =
+    "return InternalError on unexpected error" in new Test {
+      val exception = new RuntimeException("Unexpected error")
+
+      mockConfidenceLevelCheckConfig(authValidationEnabled = authValidationEnabled)
+
+      MockedAuthConnector
+        .authorised(initialPredicate, affinityGroup and authorisedEnrolments)
+        .once()
+        .returns(Future.failed(exception))
+
+      val result: AuthOutcome = await(enrolmentsAuthService.authorised(mtdId))
+      result shouldBe Left(InternalError)
+
+    }
+
   trait Test {
     val mockAuthConnector: AuthConnector = mock[AuthConnector]
 

test/definition/ApiDefinitionSpec.scala

@@ -16,6 +16,7 @@
 
 package definition
 
+import play.api.libs.json.*
 import definition.APIStatus.BETA
 import routing.Version1
 import support.UnitSpec
@@ -25,6 +26,50 @@ class ApiDefinitionSpec extends UnitSpec {
   val apiVersion: APIVersion       = APIVersion(Version1, BETA, endpointsEnabled = false)
   val apiDefinition: APIDefinition = APIDefinition("b", "c", "d", Seq("e"), Seq(apiVersion), Some(false))
 
+  private val apiVersionJson = Json.parse("""
+      {
+        "version": "1.0",
+        "status": "BETA",
+        "endpointsEnabled": false
+      }
+    """)
+
+  private val apiDefinitionJson = Json.parse("""
+      {
+        "name": "b",
+        "description": "c",
+        "context": "d",
+        "categories": ["e"],
+        "versions": [
+          {
+            "version": "1.0",
+            "status": "BETA",
+            "endpointsEnabled": false
+          }
+        ],
+        "requiresTrust": false
+      }
+    """)
+
+  private val definitionJson = Json.parse("""
+      {
+        "api": {
+          "name": "b",
+          "description": "c",
+          "context": "d",
+          "categories": ["e"],
+          "versions": [
+            {
+              "version": "1.0",
+              "status": "BETA",
+              "endpointsEnabled": false
+            }
+          ],
+          "requiresTrust": false
+        }
+      }
+    """)
+
   "APIDefinition" when {
     "the 'name' parameter is empty" should {
       "throw an 'IllegalArgumentException'" in {
@@ -75,4 +120,36 @@ class ApiDefinitionSpec extends UnitSpec {
     }
   }
 
+  "APIVersion" should {
+    "deserialise to model" in {
+      apiVersionJson.as[APIVersion] shouldBe apiVersion
+    }
+
+    "serialise to JSON" in {
+      Json.toJson(apiVersion) shouldBe apiVersionJson
+    }
+  }
+
+  "APIDefinition" should {
+    "deserialise to model" in {
+      apiDefinitionJson.as[APIDefinition] shouldBe apiDefinition
+    }
+
+    "serialise to JSON" in {
+      Json.toJson(apiDefinition) shouldBe apiDefinitionJson
+    }
+  }
+
+  "Definition" should {
+    val definition = Definition(apiDefinition)
+
+    "deserialise to model" in {
+      definitionJson.as[Definition] shouldBe definition
+    }
+
+    "serialise to JSON" in {
+      Json.toJson(definition) shouldBe definitionJson
+    }
+  }
+
 }

test/utils/EmptinessCheckerSpec.scala

@@ -101,4 +101,19 @@ class EmptinessCheckerSpec extends UnitSpec {
     }
   }
 
+  "given primitives, Options, Seq and List with no emptiness" must {
+    "return NoEmptyPaths" in {
+      EmptinessChecker[String].findEmptyPaths("test") shouldBe NoEmptyPaths
+      EmptinessChecker[Int].findEmptyPaths(1) shouldBe NoEmptyPaths
+      EmptinessChecker[Double].findEmptyPaths(1.00) shouldBe NoEmptyPaths
+      EmptinessChecker[Boolean].findEmptyPaths(true) shouldBe NoEmptyPaths
+      EmptinessChecker[BigInt].findEmptyPaths(BigInt(1)) shouldBe NoEmptyPaths
+      EmptinessChecker[BigDecimal].findEmptyPaths(BigDecimal(1)) shouldBe NoEmptyPaths
+      EmptinessChecker[Option[String]].findEmptyPaths(Some("test")) shouldBe NoEmptyPaths
+      EmptinessChecker[Option[String]].findEmptyPaths(None) shouldBe NoEmptyPaths
+      EmptinessChecker[List[Int]].findEmptyPaths(List(1, 2)) shouldBe NoEmptyPaths
+      EmptinessChecker[Seq[String]].findEmptyPaths(Vector("test", "test")) shouldBe NoEmptyPaths
+    }
+  }
+
 }