Scala Fragments类代码示例

//设置package包名称以及导入依赖的类
package spray.testkit

import org.specs2.execute.{ Failure, FailureException }
import org.specs2.specification.core.{ Fragments, SpecificationStructure }
import org.specs2.specification.create.DefaultFragmentFactory

trait Specs2Interface extends TestFrameworkInterface with SpecificationStructure {

  def failTest(msg: String) = {
    val trace = new Exception().getStackTrace.toList
    val fixedTrace = trace.drop(trace.indexWhere(_.getClassName.startsWith("org.specs2")) - 1)
    throw new FailureException(Failure(msg, stackTrace = fixedTrace))
  }

  override def map(fs: ? Fragments) = super.map(fs).append(DefaultFragmentFactory.step(cleanUp()))
}

trait NoAutoHtmlLinkFragments extends org.specs2.specification.dsl.ReferenceDsl {
  override def linkFragment(alias: String) = super.linkFragment(alias)
  override def seeFragment(alias: String) = super.seeFragment(alias)
} 

//设置package包名称以及导入依赖的类
package janstenpickle.vault.core

import java.net.URL

import janstenpickle.scala.syntax.SyntaxRequest._
import janstenpickle.scala.syntax.ResponseSyntax._
import janstenpickle.scala.syntax.VaultConfigSyntax._
import org.scalacheck.Gen
import org.specs2.Specification
import org.specs2.specification.core.Fragments
import uscala.result.specs2.ResultMatchers

import scala.concurrent.ExecutionContext
import scala.io.Source


trait VaultSpec extends Specification with ResultMatchers {
  implicit val errConverter: Throwable => String = _.getMessage
  implicit val ec: ExecutionContext = ExecutionContext.global

  lazy val rootToken = Source.fromFile("/tmp/.root-token").mkString.trim
  lazy val roleId = Source.fromFile("/tmp/.role-id").mkString.trim
  lazy val secretId = Source.fromFile("/tmp/.secret-id").mkString.trim

  lazy val rootConfig: VaultConfig = VaultConfig(
    WSClient(new URL("http://localhost:8200")), rootToken
  )
  lazy val badTokenConfig = VaultConfig(
    rootConfig.wsClient,
    "face-off"
  )
  lazy val config = VaultConfig(
    rootConfig.wsClient,
    AppRole(roleId, secretId)
  )
  lazy val badServerConfig = VaultConfig(
    WSClient(new URL("http://nic-cage.xyz")),
    "con-air"
  )

  def check = config.token.attemptRun(_.getMessage) must beOk

  override def map(fs: => Fragments) =
    s2"""
      Can receive a token for an AppRole $check
    """ ^
    fs
}

object VaultSpec {
  val longerStrGen = Gen.alphaStr.suchThat(_.length >= 3)
  val strGen = Gen.alphaStr.suchThat(_.nonEmpty)
} 

//设置package包名称以及导入依赖的类
package spray.testkit

import org.specs2.execute.{Failure, FailureException}
import org.specs2.specification.core.{Fragments, SpecificationStructure}
import org.specs2.specification.create.DefaultFragmentFactory

trait Specs2Interface extends TestFrameworkInterface with SpecificationStructure {

  def failTest(msg: String) = {
    val trace      = new Exception().getStackTrace.toList
    val fixedTrace = trace.drop(trace.indexWhere(_.getClassName.startsWith("org.specs2")) - 1)
    throw new FailureException(Failure(msg, stackTrace = fixedTrace))
  }

  override def map(fs: ? Fragments) = super.map(fs).append(DefaultFragmentFactory.step(cleanUp()))
}

trait NoAutoHtmlLinkFragments extends org.specs2.specification.dsl.ReferenceDsl {
  override def linkFragment(alias: String) = super.linkFragment(alias)
  override def seeFragment(alias: String)  = super.seeFragment(alias)
} 

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

import eval.impl.EvalExMathStringEvaluatorException
import org.specs2.specification.core.Fragments

import scala.util.{Failure, Success, Try}


abstract class MathStringEvaluatorTest extends org.specs2.mutable.Specification {

  def evaluator: MathStringEvaluator

  val testCases = Seq[(String, Try[Double])] (
    // successes
    "1 + 1"         -> Success(2.0),
    "4 - 1"         -> Success(3.0),
    "3 * 12"        -> Success(36.0),
    "5 / 2"         -> Success(2.5),
    "500 * 1000"    -> Success(500000.0),
    "1.049 * 1.049" -> Success(1.0),
    "12345"         -> Success(12345.0),
    "1 + 2 + 3 + 4" -> Success(10.0),
    "2 * 3 + 4"     -> Success(10.0),

    // failures
    "2 -= 1"                          -> Failure(EvalExMathStringEvaluatorException("Unknown operator '-=' at position 3")),
    "String string = \"Some string\"" -> Failure(EvalExMathStringEvaluatorException("Unknown operator '\"' at position 17"))
  )

  s"A ${evaluator.getClass.getSimpleName}" should {
    Fragments.foreach(testCases) {
      case (expression, expectedResult) =>
        expectedResult match {
          case Success(value) =>
            s"Successfully evaluate $expression = $value" in {
              evaluator.evaluateExpression(expression) must beEqualTo(expectedResult)
            }
          case Failure(value) =>
            s"Fail to evaluate $expression = $value" in {
              evaluator.evaluateExpression(expression) must beEqualTo(expectedResult)
            }
        }

    }
  }
} 

//设置package包名称以及导入依赖的类
package spray.testkit

import org.specs2.execute.{ Failure, FailureException }
import org.specs2.specification.core.{ Fragments, SpecificationStructure }
import org.specs2.specification.create.DefaultFragmentFactory

// see https://groups.google.com/forum/#!msg/spray-user/2T6SBp4OJeI/zPDqlrumoOMJ
// https://gist.github.com/gmalouf/51a8722b50f6a9d30404
trait Specs2Interface extends TestFrameworkInterface with SpecificationStructure {

  def failTest(msg: String) = {
    val trace = new Exception().getStackTrace.toList
    val fixedTrace = trace.drop(trace.indexWhere(_.getClassName.startsWith("org.specs2")) - 1)
    throw new FailureException(Failure(msg, stackTrace = fixedTrace))
  }

  override def map(fs: ? Fragments) = super.map(fs).append(DefaultFragmentFactory.step(cleanUp()))
}

trait NoAutoHtmlLinkFragments extends org.specs2.specification.dsl.ReferenceDsl {
  override def linkFragment(alias: String) = super.linkFragment(alias)
  override def seeFragment(alias: String) = super.seeFragment(alias)
} 

//设置package包名称以及导入依赖的类
package com.komanov.serialization.domain

import com.komanov.serialization.converters.TestData
import org.specs2.mutable.SpecificationWithJUnit
import org.specs2.specification.core.Fragments

class EventProcessorTest extends SpecificationWithJUnit {

  "apply/unapply" should {
    Fragments.foreach(TestData.sites) { case (name, site) =>
      s"serialize and deserialize a site [$name]" in {
        val parsed = EventProcessor.apply(EventProcessor.unapply(site))
        parsed must be_===(site)
      }
    }
  }

} 

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

import de.flapdoodle.embed.mongo.MongodStarter
import de.flapdoodle.embed.mongo.config.{MongodConfigBuilder, Net}
import de.flapdoodle.embed.mongo.distribution.Version
import de.flapdoodle.embed.process.runtime.Network
import org.specs2.mutable.Specification
import org.specs2.specification.core.Fragments
import reactivemongo.api.{MongoConnection, MongoDriver}

trait EmbeddedConnection extends Specification {
  val Port = 12345
  private val starter = MongodStarter.getDefaultInstance
  private val mongodConfig = new MongodConfigBuilder()
    .version(Version.Main.PRODUCTION)
    .net(new Net(Port, Network.localhostIsIPv6()))
    .build()
  private val mongodExecutable = starter.prepare(mongodConfig)

  override def map(fs: => Fragments) = startMongo ^ fs ^ stopMongo

  private def startMongo = step {
    mongodExecutable.start
    Thread.sleep(2000)
    success
  }

  private def stopMongo() = step {
    Thread.sleep(10000)
    mongodExecutable.stop()
    success
  }

  def getConnection: MongoConnection = {
    Thread.sleep(2000)
    val driver = new MongoDriver
    val connection = driver.connection("localhost:12345" :: Nil)
    Thread.sleep(2000)
    connection
  }
} 

//设置package包名称以及导入依赖的类
package com.komanov.mysql.streaming

import org.specs2.mutable.SpecificationWithJUnit
import org.specs2.specification.Scope
import org.specs2.specification.core.Fragments

import scala.collection.mutable

class QueryTest extends SpecificationWithJUnit {

  sequential

  MysqlRunner.run()

  Fragments.foreach(Drivers.list) { driver =>
    s"${driver.name}" should {
      s"prepare/select/clear database" in new ctx {
        Query.clearTable(driver)
        Query.prepareTable(driver)
        Query.selectAtOnce(driver) must be_===(Query.TestData)
        Query.selectViaStreaming(driver) must be_===(Query.TestData)
        Query.clearTable(driver)
        Query.selectAtOnce(driver) must beEmpty
      }

      s"stream everything" in new ctx {
        Query.clearTable(driver)
        Query.prepareTable(driver)
        val result = mutable.ListBuffer[TestTableRow]()
        Query.forEach(driver, row => result += row)
        result.toList must be_===(Query.TestData)
      }
    }
  }

  class ctx extends Scope {
  }

}