Scala GuiceOneAppPerSuite类代码示例

//设置package包名称以及导入依赖的类
import org.scalatestplus.play._
import org.scalatestplus.play.guice.GuiceOneAppPerSuite
import play.api._
import play.api.cache.CacheApi
import play.api.inject._
import play.api.inject.guice.GuiceApplicationBuilder
import play.api.test.Helpers._
import play.api.test._
import util.FakeCache


class ApplicationSpec extends PlaySpec with GuiceOneAppPerSuite {

  implicit override lazy val app = new GuiceApplicationBuilder()
    .overrides(bind[CacheApi].to[FakeCache])
    .loadConfig(env => Configuration.load(env))
    .in(Mode.Test)
    .build

  "Routes" should {

    "send 404 on a bad request" in {
      route(app, FakeRequest(GET, "/boum")).map(status(_)) mustBe Some(NOT_FOUND)
    }

  }

  "NewsPageController" should {

    "render the index page" in {
      val home = route(app, FakeRequest(GET, "/")).get

      status(home) mustBe OK
      contentType(home) mustBe Some("text/html")
      contentAsString(home) must include("Aktuelles der Fakultät Informatik")
    }

  }

} 

//设置package包名称以及导入依赖的类
import auth.UserAuthenticator
import com.jasperdenkers.play.auth.LoginData
import org.scalatestplus.play.guice.GuiceOneAppPerSuite
import play.api.libs.json.Json
import play.api.test.FakeRequest
import play.api.test.Helpers._

trait AuthenticationHelper { self: GuiceOneAppPerSuite =>

  def userAuthenticator: UserAuthenticator

  def adminLoginData(remember: Boolean) = LoginData("admin", "123", remember)
  def userLoginData(remember: Boolean) = LoginData("user", "321", remember)
  val invalidLoginData = LoginData("invalid", "invalid", false)

  def loginResult(loginData: LoginData) = {
    val data = Map(
      "username" -> loginData.identifier,
      "password" -> loginData.plaintextPassword,
      "remember" -> loginData.remember.toString
    )

    route(app, FakeRequest(controllers.routes.LoginLogout.doLogin()).withJsonBody(Json.toJson(data))).get
  }

  def getSessionCookie(loginData: LoginData) = {
    val result = loginResult(loginData)

    cookies(result).get(userAuthenticator.cookieName)
  }

} 

//设置package包名称以及导入依赖的类
package controllers

import io.toolsplus.atlassian.connect.play.models.AddonProperties
import org.scalatestplus.play.PlaySpec
import org.scalatestplus.play.guice.GuiceOneAppPerSuite
import play.api.Configuration
import play.api.inject.guice.GuiceApplicationBuilder
import play.api.libs.json.Json
import play.api.test.FakeRequest
import play.api.test.Helpers._

class AddonDescriptorControllerSpec extends PlaySpec with GuiceOneAppPerSuite {

  val config = Configuration.reference ++ TestData.configuration
  val addonProperties = new AddonProperties(config)
  val $ = new AddonDescriptorController(addonProperties)

  override def fakeApplication() = {
    GuiceApplicationBuilder(configuration = config).build()
  }

  "AddonDescriptorController" when {

    "GET atlassian-connect.json" should {

      "render descriptor" in {
        val descriptor = $.descriptor.apply(FakeRequest())

        status(descriptor) mustBe OK
        contentType(descriptor) mustBe Some(JSON)

        val json = Json.parse(contentAsString(descriptor))
        (json \ "key").as[String] mustBe addonProperties.key
        (json \ "baseUrl").as[String] mustBe addonProperties.baseUrl
        (json \ "name")
          .as[String] mustBe config.getString("atlassian.connect.name").get
      }

    }

    "GET to base URL" should {

      "redirect to descriptor" in {
        val redirect = $.redirectToDescriptor.apply(FakeRequest())

        redirectLocation(redirect) mustBe Some(
          routes.AddonDescriptorController
            .descriptor()
            .url)
      }

    }

  }

} 

//设置package包名称以及导入依赖的类
package controllers

import org.scalatest.concurrent.ScalaFutures
import org.scalatestplus.play.PlaySpec
import org.scalatestplus.play.guice.GuiceOneAppPerSuite
import play.api.test.FakeRequest
import play.api.test.Helpers._


class EventSourceControllerSpec extends PlaySpec
    with GuiceOneAppPerSuite
    with ScalaFutures
{
  "event source controller" should {
    "return OK through route" in {
      val request = FakeRequest(method = GET, path = "/scala/eventSource/liveClock")
      route(app, request) match {
        case Some(future) =>
          whenReady(future) { result =>
            result.header.status mustEqual(OK)
          }
        case None =>
          fail
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
package controllers

import org.scalatest.concurrent.ScalaFutures
import org.scalatestplus.play.PlaySpec
import org.scalatestplus.play.guice.GuiceOneAppPerSuite
import play.api.test.FakeRequest
import play.api.test.Helpers._


class ScalaCommentControllerSpec extends PlaySpec
  with GuiceOneAppPerSuite
  with ScalaFutures
{

  "comment controller" should {
    "return OK through route" in {
      val request = FakeRequest(method = GET, path = "/scala/comet/liveClock")
      route(app, request) match {
        case Some(future) =>
          whenReady(future) { result =>
            result.header.status mustEqual(OK)
          }
        case None =>
          fail
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
import org.scalatestplus.play._
import play.api.mvc.Results
import controllers.CarAdvertController
import org.scalatestplus.play.guice.GuiceOneAppPerSuite
import play.api.test.FakeRequest
import repository.DBResource

import scala.concurrent.ExecutionContext


class CarAdvertControllerTest extends PlaySpec with Results with GuiceOneAppPerSuite{
  "test create" should {
    "should create a new car advert" in {
      implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
      val dbResouce = app.injector.instanceOf[DBResource]
      val controller = new CarAdvertController(dbResouce)
      val body = controller.create().apply(FakeRequest())
      controller.list()
    }
  }
} 

//设置package包名称以及导入依赖的类
import services.AuthService
import org.scalatestplus.play._
import play.core.server.Server
import play.api.routing.sird._
import play.api.test._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._
import models.GithubUser
import org.scalatestplus.play.guice.GuiceOneAppPerSuite

class AuthServiceSpec extends PlaySpec with GuiceOneAppPerSuite {
  "AuthServiceSpec" should {
    "return return an access_token via postCode method call" in {
      Server.withRouter() {
        case POST(p"/login/oauth/access_token") => ActionMocks.getGithubTokenResponse()
      } { implicit port =>
        WsTestClient.withClient { client =>
          val authService = new AuthService(client, app.environment, app.configuration ,"", "")
          val result = Await.result(authService.postCode("1234"), 10.seconds)
          result must be ("12345551233123a")
        }
      }
    }

    "return a github user object via getUserInfo method" in {
      Server.withRouter() {
        case GET(p"/user") => ActionMocks.getGithubUserResponse()
      } { implicit port =>
        WsTestClient.withClient { client =>

          val authService = new AuthService(client, app.environment, app.configuration ,"", "")
          val resp = Await.result(authService.getUserInfo("1234"), 10.seconds)
          val jsresp = resp.validate[GithubUser]
          jsresp.fold(
            error => assertTypeError("GithubUser validation fails"),
            result => {
              result.login must be ("poweruser")
              result.id must be (12313)
            }
          )
        }
      }
    }

  }
} 

//设置package包名称以及导入依赖的类
package controllers
import org.scalatestplus.play._
import org.scalatestplus.play.guice.GuiceOneAppPerSuite
import play.api.Play
import play.api.inject.guice.GuiceApplicationBuilder
import play.api.mvc._
import play.api.test.Helpers.{GET => GET_REQUEST, _}
import play.api.test._

import scala.concurrent.Future


class ControllerTest extends PlaySpec with Results {


  "Test function indexx " should {
    "should be valid" in {
      val controller = new Application(stubControllerComponents())
      val result: Future[Result] = controller.indexx().apply(FakeRequest())
      controller.insert
      val bodyText: String = contentAsString(result)
      bodyText mustBe "Hello world!"
    }
  }

  "Application  controller " should {
    "url should open side for input " in {

      val request = FakeRequest()
      val controller = new Application(stubControllerComponents())
      val result: Future[Result] = controller.insert().apply(FakeRequest())
      val bodyText: String = contentAsString(result)
      bodyText must endWith ("</html>")
    }

  }
}





class ExampleSpec extends PlaySpec with GuiceOneAppPerSuite {


  // Override fakeApplication if you need a Application with other than
  // default parameters.
  override def fakeApplication() = new GuiceApplicationBuilder().configure(Map("ehcacheplugin" -> "disabled")).build()

  "The GuiceOneAppPerSuite trait" must {
    "provide an Application" in {
      app.configuration.getOptional[String]("ehcacheplugin") mustBe Some("disabled")
    }
    "start the Application" in {
      Play.maybeApplication mustBe Some(app)
    }
  }
} 

//设置package包名称以及导入依赖的类
package v1.post.test.functional

import play.api.test._
import org.scalatestplus.play._
import org.scalatestplus.play.guice.GuiceOneServerPerSuite
import play.api.{ Application, Play }
import play.api.inject.guice._
import play.api.routing._
import org.openqa.selenium.htmlunit.HtmlUnitDriver
import org.openqa.selenium.WebDriver
import org.scalatest.Matchers
import org.scalatest.selenium.WebBrowser
import org.scalatestplus.play.guice.GuiceOneAppPerSuite

class PostSpec extends PlaySpec with GuiceOneAppPerSuite {

  // Override fakeApplication if you need a Application with other than
  // default parameters.
  override def fakeApplication() = new GuiceApplicationBuilder().build()

  "The GuiceOneAppPerSuite trait" must {
    "start the Application" in {
      app.configuration != null mustBe true
      app.configuration.getConfig("play") != null mustBe true
    }
  }
}