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

import play.api.libs.concurrent.Execution.Implicits.defaultContext
import uk.gov.hmrc.agentmappingfrontend.controllers.BaseControllerISpec
import uk.gov.hmrc.agentmappingfrontend.stubs.MappingStubs.{mappingExists, mappingIsCreated, mappingKnownFactsIssue}
import uk.gov.hmrc.agentmtdidentifiers.model.{Arn, Utr}
import uk.gov.hmrc.domain.SaAgentReference
import uk.gov.hmrc.play.http.HeaderCarrier

class MappingConnectorISpec extends BaseControllerISpec {
  private val arn = Arn("ARN0001")
  private val saAgentReference = SaAgentReference("ARN0001")
  private val utr = Utr("2000000000")

  private def connector = app.injector.instanceOf[MappingConnector]
  private implicit val hc = HeaderCarrier()

  "createMapping" should {
    "create a mapping" in {
      mappingIsCreated(utr, arn, saAgentReference)
      await(connector.createMapping(utr, arn, saAgentReference)) shouldBe 201
    }

    "not create a mapping when one already exists" in {
      mappingExists(utr, arn, saAgentReference)
      await(connector.createMapping(utr, arn, saAgentReference)) shouldBe 409
    }

    "not create a mapping when there is a problem with the supplied known facts" in {
      mappingKnownFactsIssue(utr, arn, saAgentReference)
      await(connector.createMapping(utr, arn, saAgentReference)) shouldBe 403
    }
  }
} 

//设置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.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.gform.support

import org.scalatestplus.play.{BaseOneServerPerTest, FakeApplicationFactory}
import play.api.ApplicationLoader.Context
import play.api.libs.ws.WSClient
import play.api.{Application, Configuration, Environment}
import play.core.DefaultWebCommands
import uk.gov.hmrc.gform.ApplicationModule
import uk.gov.hmrc.gform.gformbackend.GformConnector
import uk.gov.hmrc.gform.wshttp.WSHttp
import uk.gov.hmrc.play.http.HeaderCarrier

FakeApplicationFactory {

  override def fakeApplication(): Application = application

  lazy val wsclient = new WSHttp

  private lazy val mongoDbName: String = "test-" + this.getClass.getSimpleName
  private lazy val env: Environment = Environment.simple()
  private lazy val configurationOverridings = Map(
    "mongodb.uri" -> s"mongodb://localhost:27017/$mongoDbName",
    "auditing.enabled" -> "false",
    "feature.basicAuthEnabled" -> "true"
  )
  private lazy val context: Context = Context(
    environment = env,
    sourceMapper = None,
    webCommands = new DefaultWebCommands(),
    initialConfiguration = Configuration.load(env)
  )
  private lazy val applicationModule = new ApplicationModule(context) {
    override lazy val httpFilters = Nil
  }
  private lazy val application = applicationModule.application

  implicit lazy val hc = HeaderCarrier()

  lazy val baseUrl = s"http://localhost:${port}"

  lazy val gformConnector = new GformConnector(wsclient, s"$baseUrl/gform")
} 

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

import java.net.URL

import org.scalatestplus.play.OneAppPerSuite
import uk.gov.hmrc.agentsubscription.WSHttp
import uk.gov.hmrc.agentsubscription.auth.Authority
import uk.gov.hmrc.agentsubscription.stubs.AuthStub
import uk.gov.hmrc.agentsubscription.support.WireMockSupport
import uk.gov.hmrc.play.http.HeaderCarrier
import uk.gov.hmrc.play.http.logging.MdcLoggingExecutionContext._
import uk.gov.hmrc.play.test.UnitSpec

class AuthConnectorISpec extends UnitSpec with OneAppPerSuite with WireMockSupport with AuthStub {
  private implicit val hc = HeaderCarrier()

  private val authBaseUrl = new URL(s"http://localhost:$wireMockPort")
  private lazy val connector: AuthConnector = new AuthConnector(authBaseUrl, WSHttp)
  private val authorityUrl = new URL(authBaseUrl, "/auth/authority")

  "AuthConnector currentAuthority" should {
    "return Authority when an authority detail is available" in {
      requestIsAuthenticated().andIsAnAgent()
      await(connector.currentAuthority()) shouldBe Some(Authority(
        fetchedFrom = authorityUrl,
        authProviderId = Some("12345-credId"),
        authProviderType = Some("GovernmentGateway"),
        affinityGroup = "Agent",
        enrolmentsUrl = "/auth/oid/556737e15500005500eaf68f/enrolments"))
    }

    "return Authority when user-details does not include an auth provider" in {
      requestIsAuthenticated().andIsAnAgentWithoutAuthProvider()
      await(connector.currentAuthority()) shouldBe Some(Authority(
        fetchedFrom = authorityUrl,
        authProviderId = None,
        authProviderType = None,
        affinityGroup = "Agent",
        enrolmentsUrl = "/auth/oid/556737e15500005500eaf68f/enrolments"))
    }

    "return none when an authority detail is unavailable" in {
      requestIsNotAuthenticated()
      await(connector.currentAuthority()) shouldBe None
    }
  }
}