//设置package包名称以及导入依赖的类
package com.clemble.loveit.common.util

import java.util.concurrent.ConcurrentHashMap

import com.mohiva.play.silhouette.api.util.{ExtractableRequest, HTTPLayer}
import com.mohiva.play.silhouette.impl.providers._
import play.api.libs.json.{JsValue, Json}
import play.api.mvc.{AnyContentAsJson, Result}
import com.clemble.loveit.user.model.User.socialProfileJsonFormat

import scala.concurrent.Future

case class TestSocialProvider(
                               protected val httpLayer: HTTPLayer,
                               protected val stateProvider: OAuth2StateProvider,
                               val settings: OAuth2Settings)
  extends OAuth2Provider
    with CommonSocialProfileBuilder {

  override type Content = JsValue
  override protected def urls: Map[String, String] = Map.empty
  override val id = "test"
  override type Self = TestSocialProvider

  val cache = new ConcurrentHashMap[String, CommonSocialProfile]()

  override def authenticate[B]()(implicit request: ExtractableRequest[B]): Future[Either[Result, OAuth2Info]] = {
    val user = request.body match {
      case AnyContentAsJson(json) => json.as[CommonSocialProfile]
    }
    cache.put(user.loginInfo.providerKey, user)
    Future.successful(Right(OAuth2Info(accessToken = user.loginInfo.providerKey)))
  }

  override def withSettings(f: (Settings) => Settings) = {
    new TestSocialProvider(httpLayer, stateProvider, f(settings))
  }

  override protected def buildProfile(authInfo: OAuth2Info): Future[Profile] = {
    Future.successful(cache.remove(authInfo.accessToken))
  }

  override protected def profileParser: SocialProfileParser[JsValue, Profile, OAuth2Info] = ???

} 

//设置package包名称以及导入依赖的类
package cjp.catalogue.resource

import java.util.concurrent.TimeUnit

import akka.util.Timeout
import org.joda.time.DateTime
import org.mockito.Mockito._
import cjp.catalogue.repository.EffectiveDateRepository
import org.scalatest.mock.MockitoSugar
import org.scalatest.{Matchers, BeforeAndAfter, WordSpec}
import play.api.GlobalSettings
import play.api.http.{Status, HeaderNames}
import play.api.libs.json.Json
import play.api.mvc.{AnyContentAsJson, AnyContentAsText}
import play.api.test._

class EffectiveDateResourceTimemachineOffSpec extends WordSpec with BeforeAndAfter with PlayRunners with ResultExtractors with HeaderNames with Status with Matchers with MockitoSugar {
  implicit val timeout = Timeout(10L, TimeUnit.SECONDS)

  private val effectiveDateRepository = mock[EffectiveDateRepository]
  private val controller = new EffectiveDateResource(effectiveDateRepository, enableTimemachine = false)

  object TestGlobal extends GlobalSettings {
    override def getControllerInstance[A](controllerClass: Class[A]): A =
      controller.asInstanceOf[A]
  }

  before {
    reset(effectiveDateRepository)
  }

  "calling PUT /manage/effectiveDate" should {
    "return 403 if timemachine feature switch is disabled" in {
      running(TestServer(18888, FakeApplication(withGlobal = Some(TestGlobal)))) {
        val json = Json.parse("""{"effectiveDate":"2015-04-10T14:12:57.159Z"}""")
        val request: FakeRequest[AnyContentAsJson] = FakeRequest().withJsonBody(json).withHeaders("ContentType" -> "application/json")

        val result = controller.setEffectiveDate.apply(request)

        status(result) should be(403)
        verifyZeroInteractions(effectiveDateRepository)
      }
    }
  }

  "calling DELETE /manage/effectiveDate" should {
    "return 403 if timemachine feature switch is disabled" in {
      running(TestServer(18888, FakeApplication(withGlobal = Some(TestGlobal)))) {
        val result = controller.resetEffectiveDate.apply(FakeRequest())

        status(result) should be(403)
        verifyZeroInteractions(effectiveDateRepository)
      }
    }
  }
}