//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.support

import play.mvc.Http.HeaderNames.LOCATION
import uk.gov.hmrc.agentinvitations.support.EmbeddedSection.EmbeddedInvitation
import uk.gov.hmrc.agentinvitations.support.HalTestHelpers.HalResourceHelper
import uk.gov.hmrc.agentmtdidentifiers.model.Arn
import uk.gov.hmrc.domain.Nino
import uk.gov.hmrc.play.http.{HeaderCarrier, HttpResponse}
import uk.gov.hmrc.play.http.logging.SessionId

class AgencyRequests(requests: Requests, val arn: Arn, implicit val port: Int) {

  implicit val hc: HeaderCarrier = HeaderCarrier(sessionId = Some(SessionId(arn.value)))

  def sendInvitation(clientId: Nino, service: String = "HMRC-MTD-IT", clientIdType: String = "ni", clientPostcode: String = "AA1 1AA"): String = {

    val response = requests.agencySendInvitation(arn, requests.AgencyInvitationRequest(service, clientIdType, clientId.value, clientPostcode))
    require(response.status == 201, s"Creating an invitation should return 201, was [${response.status}]")
    response.header(LOCATION).get
  }

  def sentInvitations(filteredBy:Seq[(String, String)] = Nil): HalResourceHelper = {

    val response = requests.agencyGetSentInvitations(arn, filteredBy)
    require(response.status == 200, s"Couldn't get invitations, response status [${response.status}]")
    HalTestHelpers(response.json)
  }

  def sentInvitation(invitationId:String): HalResourceHelper = {
    val response = requests.agencyGetSentInvitation(arn, invitationId)
    require(response.status == 200, s"Couldn't get invitations, response status [${response.status}]")
    HalTestHelpers(response.json)
  }

  def cancelInvitation(invitation: EmbeddedInvitation): HttpResponse = {
    invitation.links.cancelLink.map { cancelLink =>
      val response: HttpResponse = new Resource(cancelLink, port).putEmpty()(hc)
      require(response.status == 204, s"response for canceling invitation should be 204, was [${response.status}]")
      response
    } .getOrElse (throw new IllegalStateException("Can't cancel this invitation the cancel link is not defined"))
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.support

import uk.gov.hmrc.domain.{AgentCode, Nino}
import uk.gov.hmrc.play.http.HttpResponse
import uk.gov.hmrc.play.test.UnitSpec
import uk.gov.hmrc.agentinvitations.controllers.ErrorResults._

trait SecuredEndpointBehaviours extends AkkaMaterializerSpec {
  this: UnitSpec with AppAndStubs   =>


  def anEndpointAccessibleForMtdAgentsOnly(makeRequest: => HttpResponse): Unit = {
    "return 401 when the requester is an Agent but not authenticated" in {
      given().agentAdmin(RandomArn(), AgentCode("tehCode")).isNotLoggedIn()
      makeRequest.status shouldBe 401
      makeRequest.body shouldBe bodyOf(GenericUnauthorized)
    }

    "return 403 Forbidden when the requester is a logged as a NON MTD Agent" in {
      given().agentAdmin(RandomArn(), AgentCode("tehCode")).isLoggedIn().andIsNotSubscribedToAgentServices()
      makeRequest.status shouldBe 403
      makeRequest.body shouldBe bodyOf(AgentNotSubscribed)
    }
  }

  def anEndpointAccessibleForSaClientsOnly(id: Nino)(makeRequest: => HttpResponse): Unit = {
    "return 401 when the requester is not authenticated" in {
      given().client(clientId = id).isNotLoggedIn()
      makeRequest.status shouldBe 401
      makeRequest.body shouldBe bodyOf(GenericUnauthorized)
    }

  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.support

import uk.gov.hmrc.agentinvitations.support.EmbeddedSection.EmbeddedInvitation
import uk.gov.hmrc.agentinvitations.support.HalTestHelpers.HalResourceHelper
import uk.gov.hmrc.domain.Nino
import uk.gov.hmrc.play.http.{HeaderCarrier, HttpResponse}
import uk.gov.hmrc.play.http.logging.SessionId

class ClientRequests(val requests: Requests, val clientId: Nino, implicit val port: Int) {

  implicit val hc: HeaderCarrier = HeaderCarrier(sessionId = Some(SessionId(clientId.value)))

  def acceptInvitation(invitation: EmbeddedInvitation): HttpResponse = {
    invitation.links.acceptLink.map (requests.updateInvitationResource)
      .getOrElse (throw new IllegalStateException("Can't accept this invitation the accept link is not defined"))
  }

  def rejectInvitation(invitation: EmbeddedInvitation): HttpResponse = {
    invitation.links.rejectLink.map(requests.updateInvitationResource)
      .getOrElse (throw new IllegalStateException("Can't reject this invitation the reject link is not defined"))
  }

  def getInvitations(filteredBy: Seq[(String, String)] = Nil): HalResourceHelper = {
    val response = requests.clientGetReceivedInvitations(clientId, filteredBy)(port, hc)
    require(response.status == 200, s"Couldn't get invitations, response status [${response.status}]")
    HalTestHelpers(response.json)
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentinvitations.support

import akka.stream.ActorMaterializer
import com.fasterxml.jackson.databind.JsonMappingException
import org.scalatest.matchers.{MatchResult, Matcher}
import play.api.mvc.Result
import uk.gov.hmrc.play.http.HttpResponse
import uk.gov.hmrc.play.test.UnitSpec

import scala.util.Try


trait ErrorResultMatchers { this: UnitSpec =>

  implicit def materializer: ActorMaterializer

  class ErrorResultMatcher(expectedResult: Result) extends Matcher[HttpResponse] {
    override def apply(left: HttpResponse): MatchResult = {
      val expectedBodyJson = jsonBodyOf(expectedResult)
      val rawNegatedFailureMessage =
        s"""Response had expected status ${expectedResult.header.status} and body "$expectedBodyJson""""
      if (left.status != expectedResult.header.status) {
        MatchResult(
          false,
          s"""Response had status ${left.status} not expected status ${expectedResult.header.status}""",
          rawNegatedFailureMessage
        )
      } else {
        Try(left.json)
          .map(json =>
            MatchResult(
              json == expectedBodyJson,
              s"""Response had body "$json" not expected body "$expectedBodyJson""",
              rawNegatedFailureMessage))
          .recover {
            case e: JsonMappingException =>
              MatchResult(
                false,
                s"""Response had body "${left.body}" which did not parse as JSON due to exception:\n$e""",
                rawNegatedFailureMessage)
          }.get
      }
    }
  }

  def matchErrorResult(expectedResult: Result) = new ErrorResultMatcher(expectedResult)

}