org.specs2.mutable.Specification Scala Examples

package de.frosner.broccoli.services

import java.util.concurrent.TimeUnit

import de.frosner.broccoli.controllers.ServiceMocks
import de.frosner.broccoli.nomad.NomadConfiguration
import de.frosner.broccoli.nomad.models.Job.jobFormat
import de.frosner.broccoli.nomad.models._
import org.mockito.Mockito._
import org.specs2.mutable.Specification
import play.api.libs.json._
import play.api.mvc._
import play.api.routing.sird._
import play.api.test._
import play.core.server.Server
import squants.information.InformationConversions._
import squants.time.FrequencyConversions._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.{Await, Future}
import scala.concurrent.duration.Duration

class NomadServiceSpec extends Specification with ServiceMocks {

  sequential

  "Requesting services for specific job" should {

    "ask consul for the services that nomad returns" in {
      val service = Service("my-service")
      val resources = Resources(
        shapeless.tag[Resources.CPU](20.megahertz),
        shapeless.tag[Resources.Memory](1.gigabytes)
      )
      val task = Task(shapeless.tag[Task.Name]("foo"), resources, Some(Seq(service)))
      val taskGroup = TaskGroup(Seq(task))
      val job = Job(Seq(taskGroup))
      val jobId = "my-job"
      Server.withRouter() {
        case GET(p"/v1/job/my-job") =>
          Action {
            Results.Ok(Json.toJson(job))
          }
      } { implicit port =>
        WsTestClient.withClient { client =>
          val configuration = NomadConfiguration(url = s"http://localhost:$port")
          val nomadService = new NomadService(configuration, client)
          val result = Await.result(nomadService.requestServices(jobId), Duration(5, TimeUnit.SECONDS))
          result === Seq(service.name)
        }
      }
    }

    "not explode when receiving tasks without services" in {
      val service1 = Service("my-service")
      val resources = Resources(
        shapeless.tag[Resources.CPU](100.megahertz),
        shapeless.tag[Resources.Memory](100.megabytes)
      )
      val task1 = Task(shapeless.tag[Task.Name]("foo1"), resources, Some(Seq(service1)))
      val task2 = Task(shapeless.tag[Task.Name]("foo2"), resources, None)
      val taskGroup1 = TaskGroup(Seq(task1))
      val taskGroup2 = TaskGroup(Seq(task2))
      val job = Job(Seq(taskGroup1, taskGroup2))
      val jobId = "my-job"
      Server.withRouter() {
        case GET(p"/v1/job/my-job") =>
          Action {
            Results.Ok(Json.toJson(job))
          }
      } { implicit port =>
        WsTestClient.withClient { client =>
          val configuration = NomadConfiguration(url = s"http://localhost:$port")
          val nomadService = new NomadService(configuration, client)
          val result = Await.result(nomadService.requestServices(jobId), Duration(5, TimeUnit.SECONDS))
          result === Seq(service1.name)
        }
      }
    }

  }

} 

package de.frosner.broccoli.services

import cats.data.OptionT
import com.mohiva.play.silhouette.api.LoginInfo
import com.mohiva.play.silhouette.api.services.IdentityService
import com.mohiva.play.silhouette.api.util.Credentials
import com.mohiva.play.silhouette.impl.exceptions.InvalidPasswordException
import com.mohiva.play.silhouette.impl.providers.CredentialsProvider
import de.frosner.broccoli.auth.{Account, AuthConfiguration, AuthMode, Role}
import org.mockito.Mock
import org.specs2.concurrent.ExecutionEnv
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import org.specs2.specification.mutable.ExecutionEnvironment

import scala.concurrent.Future
import scala.concurrent.duration.Duration

class SecurityServiceSpec extends Specification with Mockito with ExecutionEnvironment {

  def configWithAccounts(accounts: Seq[Account]): AuthConfiguration =
    AuthConfiguration(
      mode = AuthMode.Conf,
      session = AuthConfiguration.Session(timeout = Duration(1, "hour"), allowMultiLogin = true),
      cookie = AuthConfiguration.Cookie(secure = true),
      conf = AuthConfiguration.Conf(
        accounts = accounts
          .map(
            a =>
              AuthConfiguration.ConfAccount(
                a.name,
                "",
                a.instanceRegex,
                a.role
            ))
          .toList),
      allowedFailedLogins = 3
    )

  val identityService = mock[IdentityService[Account]]

  val account = Account("frank", "^test.*", Role.Administrator)

  override def is(implicit executionEnv: ExecutionEnv): Any =
    "An authentication check" should {

      "succeed if the credentials provider authenticates" in {
        val login = LoginInfo(CredentialsProvider.ID, account.name)
        val credentials = Credentials(account.name, "pass")

        val credentialsProvider = mock[CredentialsProvider]
        credentialsProvider.authenticate(credentials) returns Future.successful(login)

        SecurityService(configWithAccounts(List(account)), credentialsProvider, identityService)
          .authenticate(credentials) must beSome(login).await
      }

      "fail if the credentials provider fails to authenticate" in {
        val credentials = Credentials(account.name, "pass")

        val credentialsProvider = mock[CredentialsProvider]
        credentialsProvider.authenticate(credentials) returns Future.failed(new InvalidPasswordException("foo"))

        SecurityService(configWithAccounts(List(account)), credentialsProvider, identityService)
          .authenticate(credentials) must beNone.await
      }

      "succeed if the number of failed logins is equal to the allowed ones" in {
        val credentials = Credentials(account.name, "pass")
        val failedCredentials = credentials.copy(password = "foo")
        val login = LoginInfo(CredentialsProvider.ID, credentials.identifier)

        val credentialsProvider = mock[CredentialsProvider]
        credentialsProvider.authenticate(failedCredentials) returns Future.failed(new InvalidPasswordException("foo"))
        credentialsProvider.authenticate(credentials) returns Future.successful(login)

        val service = SecurityService(configWithAccounts(List(account)), credentialsProvider, identityService)
        val failedAttempts = for (attemptNo <- 1 to service.allowedFailedLogins) {
          service.authenticate(failedCredentials) must beNone.await
        }
        service.authenticate(credentials) must beSome(login).await
      }

      "fail if the number of failed logins is greater than the allowed number" in {
        val credentials = Credentials(account.name, "password")
        val failedCredentials = credentials.copy(password = "foo")
        val login = LoginInfo(CredentialsProvider.ID, credentials.identifier)

        val credentialsProvider = mock[CredentialsProvider]
        credentialsProvider.authenticate(failedCredentials) returns Future.failed(new InvalidPasswordException("foo"))
        credentialsProvider.authenticate(credentials) returns Future.successful(login)

        val service = SecurityService(configWithAccounts(List(account)), credentialsProvider, identityService)
        val failedAttempts = for (attemptNo <- 0 to service.allowedFailedLogins) {
          service.authenticate(failedCredentials) must beNone.await
        }
        service.authenticate(credentials) must beNone.await
      }

    }
} 

package de.frosner.broccoli.instances.storage

import de.frosner.broccoli.models._
import org.specs2.mutable.Specification
import play.api.Logger

import scala.util.{Failure, Try}

class InstanceStorageSpec extends Specification {

  "Any instance storage" should {

    def testStorage = new InstanceStorage {
      protected override val log = Logger(getClass)
      protected override def readInstancesImpl: Try[Set[Instance]] = Failure(new Exception())
      override def readInstancesImpl(idFilter: (String) => Boolean): Try[Set[Instance]] = Failure(new Exception())
      override def readInstanceImpl(id: String): Try[Instance] = Failure(new Exception())
      override def deleteInstanceImpl(toDelete: Instance): Try[Instance] = Failure(new Exception())
      override def writeInstanceImpl(instance: Instance): Try[Instance] = Failure(new Exception())
      override def closeImpl(): Unit = {}
    }

    "be closed after closing" in {
      val storage = testStorage
      storage.close()
      storage.isClosed === true
    }

    "not be closed before closing" in {
      testStorage.isClosed === false
    }

    "should not allow readInstances if closed" in {
      val storage = testStorage
      storage.close()
      storage.readInstances should throwA[IllegalStateException]
    }

    "should not allow readInstances(filter) if closed" in {
      val storage = testStorage
      storage.close()
      storage.readInstances(_ => true) should throwA[IllegalStateException]
    }

    "should not allow readInstance if closed" in {
      val storage = testStorage
      storage.close()
      storage.readInstance("id") should throwA[IllegalStateException]
    }

    "should not allow deleteInstance if closed" in {
      val storage = testStorage
      storage.close()
      val instance = Instance(
        id = "1",
        template = Template(
          id = "1",
          template = "\"{{id}} {{age}}\"",
          description = "desc",
          parameterInfos = Map(
            "id" -> ParameterInfo("id", None, None, None, ParameterType.Raw, None),
            "age" -> ParameterInfo("age",
                                   None,
                                   None,
                                   secret = Some(false),
                                   `type` = ParameterType.Integer,
                                   orderIndex = None)
          )
        ),
        parameterValues = Map("id" -> StringParameterValue("Frank"), "age" -> IntParameterValue(50))
      )
      storage.deleteInstance(instance) should throwA[IllegalStateException]
    }

    "should not allow writeInstance if closed" in {
      val storage = testStorage
      storage.close()
      val instance = Instance(
        id = "1",
        template = Template(
          id = "1",
          template = "\"{{id}} {{age}}\"",
          description = "desc",
          parameterInfos = Map(
            "id" -> ParameterInfo("id", None, None, None, ParameterType.Raw, None),
            "age" -> ParameterInfo("age",
                                   None,
                                   None,
                                   secret = Some(false),
                                   `type` = ParameterType.Integer,
                                   orderIndex = None)
          )
        ),
        parameterValues = Map("id" -> StringParameterValue("Frank"), "age" -> IntParameterValue(50))
      )
      storage.writeInstance(instance) should throwA[IllegalStateException]
    }

  }

} 

package de.frosner.broccoli

import org.mockito.{ArgumentCaptor, Matchers}
import org.scalacheck.Gen
import org.specs2.ScalaCheck
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification

import scala.util.matching.Regex

class LoggingSpec extends Specification with Mockito with ScalaCheck {
  import logging._

  trait F[T] {
    def body(): T

    def log(message: String): Unit
  }

  "logging the execution time" should {

    "execute the block just once" in {
      val f = mock[F[Unit]]

      logExecutionTime("foo") {
        f.body()
      }(Function.const(()))

      there was one(f).body()
      there was no(f).log(Matchers.any[String]())
    }

    "invokes the log function" in prop { label: String =>
      val f = mock[F[Int]]

      logExecutionTime(label) {
        42
      }(f.log(_))

      val message = ArgumentCaptor.forClass(classOf[String])
      there was one(f).log(message.capture())
      message.getValue must beMatching(s"${Regex.quote(label)} took \\d+ ms")

      there was no(f).body()
    }.setGen(Gen.identifier.label("label"))

    "returns the result of the body" in prop { ret: Int =>
      logExecutionTime("foo") {
        ret
      }(Function.const(())) === ret
    }
  }

} 

package de.frosner.broccoli.nomad.models

import de.frosner.broccoli.util
import org.specs2.mutable.Specification
import play.api.libs.json.Json

class NodeSpec extends Specification {
  "Node" should {
    "decode from JSON" in {
      val node = Json
        .parse(util.Resources.readAsString("/de/frosner/broccoli/services/nomad/node.json"))
        .validate[Node]
        .asEither

      node should beRight(
        Node(
          id = shapeless.tag[Node.Id]("4beac5b7-3974-3ddf-b572-9db5906fb891"),
          name = shapeless.tag[Node.Name]("vc31"),
          httpAddress = shapeless.tag[Node.HttpAddress]("127.0.0.1:4646")
        ))
    }
  }
} 

package de.frosner.broccoli.nomad.models

import de.frosner.broccoli.util
import org.specs2.mutable.Specification
import play.api.libs.json.Json

class AllocationSpec extends Specification {

  "Allocation" should {

    "decode from JSON" in {
      val allocations = Json
        .parse(util.Resources.readAsString("/de/frosner/broccoli/services/nomad/allocations.json"))
        .validate[List[Allocation]]
        .asEither

      allocations should beRight(
        List(Allocation(
          id = shapeless.tag[Allocation.Id]("520bc6c3-53c9-fd2e-5bea-7d0b9dbef254"),
          jobId = shapeless.tag[Job.Id]("tvftarcxrPoy9wNhghqQogihjha"),
          nodeId = shapeless.tag[Node.Id]("cf3338e9-5ed0-88ef-df7b-9dd9708130c8"),
          clientStatus = ClientStatus.Running,
          taskStates = Map(shapeless.tag[Task.Name]("http-task") -> TaskStateEvents(TaskState.Running))
        )))
    }
  }
} 

package org.eichelberger.sfc.examples

import com.typesafe.scalalogging.slf4j.LazyLogging
import org.eichelberger.sfc.SpaceFillingCurve._
import org.eichelberger.sfc.study.composition.CompositionSampleData._
import org.eichelberger.sfc.utils.Timing
import org.eichelberger.sfc.{DefaultDimensions, Dimension}
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner

@RunWith(classOf[JUnitRunner])
class GeohashTest extends Specification with LazyLogging {
  val xCville = -78.488407
  val yCville = 38.038668

  "Geohash example" should {
    val geohash = new Geohash(35)

    "encode/decode round-trip for an interior point" >> {
      // encode
      val hash = geohash.pointToHash(Seq(xCville, yCville))
      hash must equalTo("dqb0muw")

      // decode
      val cell = geohash.hashToCell(hash)
      println(s"[Geohash example, Charlottesville] POINT($xCville $yCville) -> $hash -> $cell")
      cell(0).containsAny(xCville) must beTrue
      cell(1).containsAny(yCville) must beTrue
    }

    "encode/decode properly at the four corners and the center" >> {
      for (x <- Seq(-180.0, 0.0, 180.0); y <- Seq(-90.0, 0.0, 90.0)) {
        // encode
        val hash = geohash.pointToHash(Seq(x, y))

        // decode
        val cell = geohash.hashToCell(hash)
        println(s"[Geohash example, extrema] POINT($x $y) -> $hash -> $cell")
        cell(0).containsAny(x) must beTrue
        cell(1).containsAny(y) must beTrue
      }

      // degenerate test outcome
      1 must equalTo(1)
    }

    def getCvilleRanges(curve: Geohash): (OrdinalPair, OrdinalPair, Iterator[OrdinalPair]) = {
      val lonIdxRange = OrdinalPair(
        curve.children(0).asInstanceOf[Dimension[Double]].index(bboxCville._1),
        curve.children(1).asInstanceOf[Dimension[Double]].index(bboxCville._3)
      )
      val latIdxRange = OrdinalPair(
        curve.children(0).asInstanceOf[Dimension[Double]].index(bboxCville._2),
        curve.children(1).asInstanceOf[Dimension[Double]].index(bboxCville._4)
      )
      val query = Query(Seq(OrdinalRanges(lonIdxRange), OrdinalRanges(latIdxRange)))
      val cellQuery = Cell(Seq(
        DefaultDimensions.createDimension("x", bboxCville._1, bboxCville._3, 0),
        DefaultDimensions.createDimension("y", bboxCville._2, bboxCville._4, 0)
      ))
      (lonIdxRange, latIdxRange, curve.getRangesCoveringCell(cellQuery))
    }
    
    "generate valid selection indexes" >> {
      val (_, _, ranges) = getCvilleRanges(geohash)

      ranges.size must equalTo(90)
    }
    
    "report range efficiency" >> {
      def atPrecision(xBits: OrdinalNumber, yBits: OrdinalNumber): (Long, Long) = {
        val curve = new Geohash(xBits + yBits)
        val (lonRange, latRange, ranges) = getCvilleRanges(curve)
        (lonRange.size * latRange.size, ranges.size.toLong)
      }

      for (dimPrec <- 10 to 25) {
        val ((numCells, numRanges), ms) = Timing.time{ () => atPrecision(dimPrec, dimPrec - 1) }
        println(s"[ranges across scales, Charlottesville] precision ($dimPrec, ${dimPrec - 1}) -> $numCells / $numRanges = ${numCells / numRanges} in $ms milliseconds")
      }

      1 must equalTo(1)
    }
  }

} 

package org.eichelberger.sfc.utils

import com.typesafe.scalalogging.slf4j.LazyLogging
import org.eichelberger.sfc.SpaceFillingCurve.{OrdinalVector, ords2ordvec}
import org.eichelberger.sfc.{DefaultDimensions, ZCurve}
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner

@RunWith(classOf[JUnitRunner])
class LexicographicTest extends Specification with LazyLogging {
  sequential
  
  "Lexicographical encoding" should {
    val precisions = new ords2ordvec(Seq(18L, 17L)).toOrdinalVector

    val sfc = ZCurve(precisions)

    val Longitude = DefaultDimensions.createLongitude(18L)
    val Latitude = DefaultDimensions.createLatitude(17L)

    "work for a known point" >> {
      val x = -78.488407
      val y = 38.038668

      val point = OrdinalVector(Longitude.index(x), Latitude.index(y))
      val idx = sfc.index(point)
      val gh = sfc.lexEncodeIndex(idx)

      gh must equalTo("dqb0muw")
    }

    "be consistent round-trip" >> {
      val xs = (-180.0 to 180.0 by 33.3333).toSeq ++ Seq(180.0)
      val ys = (-90.0 to 90.0 by 33.3333).toSeq ++ Seq(90.0)
      for (x <- xs; y <- ys) {
        val ix = Longitude.index(x)
        val iy = Latitude.index(y)
        val point = OrdinalVector(ix, iy)
        val idx = sfc.index(point)
        val gh = sfc.lexEncodeIndex(idx)
        val idx2 = sfc.lexDecodeIndex(gh)
        idx2 must equalTo(idx)
        val point2 = sfc.inverseIndex(idx2)
        point2(0) must equalTo(ix)
        point2(1) must equalTo(iy)
        val rx = Longitude.inverseIndex(ix)
        val ry = Latitude.inverseIndex(iy)

        val sx = x.formatted("%8.3f")
        val sy = y.formatted("%8.3f")
        val sidx = idx.formatted("%20d")
        println(s"[LEXI ROUND-TRIP] POINT($sx $sy) -> $sidx = $gh -> ($rx, $ry)")
      }

      // degenerate
      1 must equalTo(1)
    }
  }

  "multiple lexicographical encoders" should {
    "return different results for different base resolutions" >> {
      val x = -78.488407
      val y = 38.038668

      for (xBits <- 1 to 30; yBits <- xBits - 1 to xBits if yBits > 0) {
        val precisions = new ords2ordvec(Seq(xBits, yBits)).toOrdinalVector
        val sfc = ZCurve(precisions)

        val Longitude = DefaultDimensions.createLongitude(xBits)
        val Latitude = DefaultDimensions.createLatitude(yBits)

        val idx = sfc.index(OrdinalVector(Longitude.index(x), Latitude.index(y)))
        val gh = sfc.lexEncodeIndex(idx)
        val idx2 = sfc.lexDecodeIndex(gh)

        idx2 must equalTo(idx)

        println(s"[LEXI ACROSS RESOLUTIONS] mx $xBits + my $yBits = base ${sfc.alphabet.size}, idx $idx -> gh $gh -> $idx2")
      }

      // degenerate
      1 must equalTo(1)
    }
  }
} 

package org.eichelberger.sfc.utils

import com.typesafe.scalalogging.slf4j.LazyLogging
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner

import BitManipulations._

@RunWith(classOf[JUnitRunner])
class BitManipulationsTest extends Specification with LazyLogging {
  "static methods" should {
    "usedMask" >> {
      // single bits
      for (pos <- 0 to 62) {
        val v = 1L << pos.toLong
        val actual = usedMask(v)
        val expected = (1L << (pos + 1L)) - 1L
        println(s"[usedMask single bit]  pos $pos, value $v, actual $actual, expected $expected")
        actual must equalTo(expected)
      }

      // full bit masks
      for (pos <- 0 to 62) {
        val expected = (1L << (pos.toLong + 1L)) - 1L
        val actual = usedMask(expected)
        println(s"[usedMask full bit masks]  pos $pos, value $expected, actual $actual, expected $expected")
        actual must equalTo(expected)
      }

      usedMask(0) must equalTo(0)
    }

    "sharedBitPrefix" >> {
      sharedBitPrefix(2, 3) must equalTo(2)
      sharedBitPrefix(178, 161) must equalTo(160)
    }

    "common block extrema" >> {
      commonBlockMin(178, 161) must equalTo(160)
      commonBlockMax(178, 161) must equalTo(191)
    }
  }
} 

package org.eichelberger.sfc.utils

import com.typesafe.scalalogging.slf4j.LazyLogging
import org.eichelberger.sfc.SpaceFillingCurve.SpaceFillingCurve
import org.eichelberger.sfc.SpaceFillingCurve.SpaceFillingCurve
import org.eichelberger.sfc._
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner

@RunWith(classOf[JUnitRunner])
class CompositionParserTest extends Specification {
  sequential

  def parsableCurve(curve: SpaceFillingCurve): String = curve match {
    case c: ComposedCurve =>
      c.delegate.name.charAt(0).toString + c.children.map {
        case d: Dimension[_]      => d.precision
        case s: SubDimension[_]   => s.precision
        case c: SpaceFillingCurve => parsableCurve(c)
      }.mkString("(", ", ", ")")
    case s =>
      s.name.charAt(0).toString + s.precisions.toSeq.map(_.toString).mkString("(", ", ", ")")
  }

  def eval(curve: ComposedCurve): Boolean = {
    val toParse: String = parsableCurve(curve)
    val parsed: ComposedCurve = CompositionParser.buildWholeNumberCurve(toParse)
    val fromParse: String = parsableCurve(parsed)
    println(s"[CURVE PARSER]\n  Input:  $toParse\n  Output:  $fromParse")
    toParse == fromParse
  }

  "simple expressions" should {
    val R23 = new ComposedCurve(
      RowMajorCurve(2, 3),
      Seq(
        DefaultDimensions.createIdentityDimension(2),
        DefaultDimensions.createIdentityDimension(3)
      )
    )
    val H_2_R23 = new ComposedCurve(
      CompactHilbertCurve(2),
      Seq(
        DefaultDimensions.createIdentityDimension(2),
        R23
      )
    )
    val Z_R23_2 = new ComposedCurve(
      ZCurve(2),
      Seq(
        R23,
        DefaultDimensions.createIdentityDimension(2)
      )
    )

    "parse correctly" >> {
      eval(R23) must beTrue
      eval(H_2_R23) must beTrue
      eval(Z_R23_2) must beTrue
    }
  }
} 

package org.eichelberger.sfc.utils

import com.typesafe.scalalogging.slf4j.LazyLogging
import org.eichelberger.sfc.{CompactHilbertCurve, RowMajorCurve, ZCurve}
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner

@RunWith(classOf[JUnitRunner])
class LocalityEstimatorTest extends Specification with LazyLogging {
  sequential

  "locality" should {
    "evaluate on square 2D curves" >> {
      (1 to 6).foreach { p =>
        val locR = LocalityEstimator(RowMajorCurve(p, p)).locality
        println(s"[LOCALITY R($p, $p)] $locR")

        val locZ = LocalityEstimator(ZCurve(p, p)).locality
        println(s"[LOCALITY Z($p, $p)] $locZ")

        val locH = LocalityEstimator(CompactHilbertCurve(p, p)).locality
        println(s"[LOCALITY H($p, $p)] $locH")
      }

      1 must beEqualTo(1)
    }

    "evaluate on non-square 2D curves" >> {
      (1 to 6).foreach { p =>
        val locR = LocalityEstimator(RowMajorCurve(p << 1L, p)).locality
        println(s"[LOCALITY R(${p*2}, $p)] $locR")

        val locZ = LocalityEstimator(ZCurve(p << 1L, p)).locality
        println(s"[LOCALITY Z(${p*2}, $p)] $locZ")

        val locH = LocalityEstimator(CompactHilbertCurve(p << 1L, p)).locality
        println(s"[LOCALITY H(${p*2}, $p)] $locH")
      }

      1 must beEqualTo(1)
    }
  }
} 

package org.eichelberger.sfc

import com.typesafe.scalalogging.slf4j.LazyLogging
import org.eichelberger.sfc.CompactHilbertCurve.Mask
import org.eichelberger.sfc.SpaceFillingCurve.{OrdinalVector, SpaceFillingCurve, _}
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner

@RunWith(classOf[JUnitRunner])
class RowMajorCurveTest extends Specification with GenericCurveValidation with LazyLogging {
  sequential

  def curveName = "RowmajorCurve"

  def createCurve(precisions: OrdinalNumber*): SpaceFillingCurve =
    RowMajorCurve(precisions.toOrdinalVector)

  "rowmajor space-filling curves" should {
    "satisfy the ordering constraints" >> {
      timeTestOrderings() must beTrue
    }

    "identify sub-ranges correctly" >> {
      val sfc = createCurve(3, 3)
      val query = Query(Seq(OrdinalRanges(OrdinalPair(1, 2)), OrdinalRanges(OrdinalPair(1, 3))))
      val ranges = sfc.getRangesCoveringQuery(query).toList

      for (i <- 0 until ranges.size) {
        println(s"[rowmajor ranges:  query $query] range $i = ${ranges(i)}")
      }

      ranges(0) must equalTo(OrdinalPair(9, 11))
      ranges(1) must equalTo(OrdinalPair(17, 19))
    }
  }
} 

package typedapi.server

import typedapi.dsl._
import shapeless._

import org.specs2.mutable.Specification

final class ApiToEndpointLinkSpec extends Specification {

  import StatusCodes._

  case class Foo(name: String)

  "link api definitions to endpoint functions" >> { 
    val Api = := :> "find" :> typedapi.dsl.Segment[String]('name) :> 
                    Query[Int]('limit) :> 
                    Client.Header('hello, 'world) :> 
                    Server.Send('foo, 'bar) :> Server.Match[String]("hi") :>
                    Get[Json, List[Foo]]

    val endpoint0 = derive[Option](Api).from((name, limit, hi) => Some(successWith(Ok)(List(Foo(name)).take(limit))))
    endpoint0("john" :: 10 :: Map("hi" -> "whats", "hi-ho" -> "up") :: HNil) === Some(Right(Ok -> List(Foo("john"))))
    endpoint0.headers == Map("foo" -> "bar")
    endpoint0.method == "GET"
  }
} 

package http.support.tests.client

import http.support.tests.{User, UserCoding, Api}
import typedapi.client._
import typedapi.client.akkahttp._
import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import akka.http.scaladsl.Http
import de.heikoseeberger.akkahttpcirce.FailFastCirceSupport
import org.specs2.mutable.Specification
import org.specs2.concurrent.ExecutionEnv

import scala.concurrent.duration._
import scala.concurrent.{Future, Await}

final class AkkaHttpClientSupportSpec(implicit ee: ExecutionEnv) extends Specification {

  import UserCoding._
  import FailFastCirceSupport._

  sequential

  implicit val timeout = 5.second
  implicit val system  = ActorSystem("akka-http-client-spec", defaultExecutionContext = Some(ee.ec))
  implicit val mat     = ActorMaterializer()

  import system.dispatcher

  val cm     = ClientManager(Http(), "http://localhost", 9001)
  val server = TestServer.start()

  "akka http client support" >> {
    val (p, s, q, header, fixed, clInH, clFixH, clColl, serMatchH, serSendH, m0, m1, m2, m3, m4, m5, _, _, _) = deriveAll(Api)

    "paths and segments" >> {
      p().run[Future](cm) must beEqualTo(User("foo", 27)).awaitFor(timeout)
      s("jim").run[Future](cm) must beEqualTo(User("jim", 27)).awaitFor(timeout)
    }
    
    "queries" >> {
      q(42).run[Future](cm) must beEqualTo(User("foo", 42)).awaitFor(timeout)
    }
    
    "headers" >> {
      header(42).run[Future](cm) must beEqualTo(User("foo", 42)).awaitFor(timeout)
      fixed().run[Future](cm) must beEqualTo(User("joe", 27)).awaitFor(timeout)
      clInH("jim").run[Future](cm) must beEqualTo(User("jim", 27)).awaitFor(timeout)
      clFixH().run[Future](cm) must beEqualTo(User("joe", 27)).awaitFor(timeout)
      clColl(Map("coll" -> "joe", "collect" -> "jim")).run[Future](cm) must beEqualTo(User("coll: joe,collect: jim", 27)).awaitFor(timeout)
      serMatchH().run[Future](cm) must beEqualTo(User("joe", 27)).awaitFor(timeout)
      serSendH().run[Future](cm) must beEqualTo(User("joe", 27)).awaitFor(timeout)
    }

    "methods" >> {
      m0().run[Future](cm) must beEqualTo(User("foo", 27)).awaitFor(timeout)
      m1().run[Future](cm) must beEqualTo(User("foo", 27)).awaitFor(timeout)
      m2(User("jim", 42)).run[Future](cm) must beEqualTo(User("jim", 42)).awaitFor(timeout)
      m3().run[Future](cm) must beEqualTo(User("foo", 27)).awaitFor(timeout)
      m4(User("jim", 42)).run[Future](cm) must beEqualTo(User("jim", 42)).awaitFor(timeout)
      m5(List("because")).run[Future](cm) must beEqualTo(User("foo", 27)).awaitFor(timeout)
    }

    step {
      server.shutdown.unsafeRunSync()
      Await.ready(system.terminate, timeout)
    }
  }
} 

package http.support.tests.client

import http.support.tests.{UserCoding, User, Api}
import typedapi.client._
import typedapi.client.scalajhttp._
import scalaj.http.Http
import io.circe.parser._
import io.circe.syntax._
import org.specs2.mutable.Specification

final class ScalajHttpClientSupportSpec extends Specification {

  import UserCoding._

  sequential

  case class DecodeException(msg: String) extends Exception

  implicit val decoder = typedapi.util.Decoder[Id, User](json => decode[User](json).fold(
    error => Left(DecodeException(error.toString())),
    user  => Right(user)
  ))
  implicit val encoder = typedapi.util.Encoder[Id, User](user => user.asJson.noSpaces)

  val cm = ClientManager(Http, "http://localhost", 9001)

  val server = TestServer.start()

  "http4s client support" >> {
    val (p, s, q, header, fixed, clInH, clFixH, clColl, serMatchH, serSendH, m0, m1, m2, m3, m4, m5, _, _, _) = deriveAll(Api)

    "paths and segments" >> {
      p().run[Blocking](cm) === Right(User("foo", 27))
      s("jim").run[Blocking](cm) === Right(User("jim", 27))
    }
    
    "queries" >> {
      q(42).run[Blocking](cm) === Right(User("foo", 42))
    }
    
    "headers" >> {
      header(42).run[Blocking](cm) === Right(User("foo", 42))
      fixed().run[Blocking](cm) === Right(User("joe", 27))
      clInH("jim").run[Blocking](cm) === Right(User("jim", 27))
      clFixH().run[Blocking](cm) === Right(User("joe", 27))
      clColl(Map("coll" -> "joe", "collect" -> "jim")).run[Blocking](cm) === Right(User("collect: jim,coll: joe", 27))
      serMatchH().run[Blocking](cm) === Right(User("joe", 27))
      serSendH().run[Blocking](cm) === Right(User("joe", 27))
    }

    "methods" >> {
      m0().run[Blocking](cm) === Right(User("foo", 27))
      m1().run[Blocking](cm) === Right(User("foo", 27))
      m2(User("jim", 42)).run[Blocking](cm) === Right(User("jim", 42))
      m3().run[Blocking](cm) === Right(User("foo", 27))
      m4(User("jim", 42)).run[Blocking](cm) === Right(User("jim", 42))
      m5(List("because")).run[Blocking](cm) === Right(User("foo", 27))
    }

    "raw" >> {
      m0().run[Id].raw(cm).body === """{"name":"foo","age":27}"""
    }

    step {
      server.shutdown.unsafeRunSync()
    }
  }
} 

package http.support.tests.client

import http.support.tests.{UserCoding, User, Api}
import typedapi.client._
import typedapi.client.http4s._
import cats.effect.IO
import org.http4s.client.blaze.Http1Client
import org.specs2.mutable.Specification

final class Http4sClientSupportSpec extends Specification {

  import UserCoding._

  sequential

  val cm = ClientManager(Http1Client[IO]().unsafeRunSync, "http://localhost", 9001)

  val server = TestServer.start()

  "http4s client support" >> {
    val (p, s, q, header, fixed, clInH, clFixH, clColl, serMatchH, serSendH, m0, m1, m2, m3, m4, m5, _, _, _) = deriveAll(Api)

    "paths and segments" >> {
      p().run[IO](cm).unsafeRunSync() === User("foo", 27)
      s("jim").run[IO](cm).unsafeRunSync() === User("jim", 27)
    }
    
    "queries" >> {
      q(42).run[IO](cm).unsafeRunSync() === User("foo", 42)
    }
    
    "headers" >> {
      header(42).run[IO](cm).unsafeRunSync() === User("foo", 42)
      fixed().run[IO](cm).unsafeRunSync() === User("joe", 27)
      clInH("jim").run[IO](cm).unsafeRunSync === User("jim", 27)
      clFixH().run[IO](cm).unsafeRunSync() === User("joe", 27)
      clColl(Map("coll" -> "joe", "collect" -> "jim")).run[IO](cm).unsafeRunSync === User("coll: joe,collect: jim", 27)
      serMatchH().run[IO](cm).unsafeRunSync() === User("joe", 27)
      serSendH().run[IO](cm).unsafeRunSync() === User("joe", 27)
    }

    "methods" >> {
      m0().run[IO](cm).unsafeRunSync() === User("foo", 27)
      m1().run[IO](cm).unsafeRunSync() === User("foo", 27)
      m2(User("jim", 42)).run[IO](cm).unsafeRunSync() === User("jim", 42)
      m3().run[IO](cm).unsafeRunSync() === User("foo", 27)
      m4(User("jim", 42)).run[IO](cm).unsafeRunSync() === User("jim", 42)
      m5(List("because")).run[IO](cm).unsafeRunSync() === User("foo", 27)
    }

    step {
      server.shutdown.unsafeRunSync()
    }
  }
} 

package cool.graph.stub

import cool.graph.stub.StubDsl.Default.Request
import org.specs2.mutable.Specification

class StubDslSpec extends Specification {

  val path   = "some/freaking/path"
  val params = Map("a" -> 1)

  val responseBody = "the body"
  val response     = StaticStubResponse(333, responseBody)

  "using the default stub DSL" should {
    "produce a stub response with headers" in {
      val stub: Stub = Request("POST", path).stub(200, responseBody, Map("X-Test" -> "Test"))
      stub.stubbedResponse.headers("X-Test") must equalTo("Test")
      stub.stubbedResponse.body must equalTo(responseBody)
    }
  }
} 

package mdmoss.doobiegen.queries

import doobie.imports._
import mdmoss.doobiegen.db.gen
import org.specs2.matcher.ThrownExpectations
import org.specs2.mutable.Specification
import scalaz.concurrent.Task

object MultigetSpec extends Specification with ThrownExpectations {

  val xa = DriverManagerTransactor[Task]("org.postgresql.Driver", "jdbc:postgresql:gen", "test", "test")

  val Fk1RowCount       = 3
  val Fk2RowPerFk1Count = 3

  "multiget query functions" >> {
    val (fk1Rows, fk2Rows) = {
      for {
        fk1 <- gen.TestFk_1.createMany(List.fill(Fk1RowCount)(gen.TestFk_1.Shape()))
        fk2 <- gen.TestFk_2.createMany(fk1.flatMap(fkRow => List.fill(Fk2RowPerFk1Count)(gen.TestFk_2.Shape(fkRow.id))))
      } yield (fk1, fk2)
    }.transact(xa).unsafePerformSync

    "over primary keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).unsafePerformSync
        }
      }

      "return the same row multiple times if a duplicate primary key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).unsafePerformSync
        }
      }
    }

    "over foreign keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).unsafePerformSync.map(_.fk)
        }
      }

      "return the same matching set of rows multiple times if a duplicate foreign key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).unsafePerformSync.map(_.fk)
        }
      }

      "only return all matching rows" >> {
        val fk2RowsByFk = fk2Rows.groupBy(_.fk).mapValues(_.toSet)
        val fkToQuery = fk1Rows.tail.map(_.id)
        val expectedResult = fkToQuery.toSet.flatMap(fk2RowsByFk)
        expectedResult must_=== gen.TestFk_2.multigetByFk(fkToQuery).transact(xa).unsafePerformSync.toSet
      }
    }
  }
} 

package mdmoss.doobiegen.queries

import doobie.imports._
import mdmoss.doobiegen.db.gen
import org.specs2.matcher.ThrownExpectations
import org.specs2.mutable.Specification
import scalaz.concurrent.Task

object MultigetSpec extends Specification with ThrownExpectations {

  val xa = DriverManagerTransactor[Task]("org.postgresql.Driver", "jdbc:postgresql:gen", "test", "test")

  val Fk1RowCount       = 3
  val Fk2RowPerFk1Count = 3

  "multiget query functions" >> {
    val (fk1Rows, fk2Rows) = {
      for {
        fk1 <- gen.TestFk_1.createMany(List.fill(Fk1RowCount)(gen.TestFk_1.Shape()))
        fk2 <- gen.TestFk_2.createMany(fk1.flatMap(fkRow => List.fill(Fk2RowPerFk1Count)(gen.TestFk_2.Shape(fkRow.id))))
      } yield (fk1, fk2)
    }.transact(xa).run

    "over primary keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).run
        }
      }

      "return the same row multiple times if a duplicate primary key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).run
        }
      }
    }

    "over foreign keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).run.map(_.fk)
        }
      }

      "return the same matching set of rows multiple times if a duplicate foreign key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).run.map(_.fk)
        }
      }

      "only return all matching rows" >> {
        val fk2RowsByFk = fk2Rows.groupBy(_.fk).mapValues(_.toSet)
        val fkToQuery = fk1Rows.tail.map(_.id)
        val expectedResult = fkToQuery.toSet.flatMap(fk2RowsByFk)
        expectedResult must_=== gen.TestFk_2.multigetByFk(fkToQuery).transact(xa).run.toSet
      }
    }
  }
} 

package mdmoss.doobiegen.queries

import doobie.imports._
import mdmoss.doobiegen.db.gen
import org.specs2.matcher.ThrownExpectations
import org.specs2.mutable.Specification
import scalaz.concurrent.Task

object MultigetSpec extends Specification with ThrownExpectations {

  val xa = DriverManagerTransactor[Task]("org.postgresql.Driver", "jdbc:postgresql:gen", "test", "test")

  val Fk1RowCount       = 3
  val Fk2RowPerFk1Count = 3

  "multiget query functions" >> {
    val (fk1Rows, fk2Rows) = {
      for {
        fk1 <- gen.TestFk_1.createMany(List.fill(Fk1RowCount)(gen.TestFk_1.Shape()))
        fk2 <- gen.TestFk_2.createMany(fk1.flatMap(fkRow => List.fill(Fk2RowPerFk1Count)(gen.TestFk_2.Shape(fkRow.id))))
      } yield (fk1, fk2)
    }.transact(xa).unsafePerformSync

    "over primary keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).unsafePerformSync
        }
      }

      "return the same row multiple times if a duplicate primary key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).unsafePerformSync
        }
      }
    }

    "over foreign keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).unsafePerformSync.map(_.fk)
        }
      }

      "return the same matching set of rows multiple times if a duplicate foreign key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).unsafePerformSync.map(_.fk)
        }
      }

      "only return all matching rows" >> {
        val fk2RowsByFk = fk2Rows.groupBy(_.fk).mapValues(_.toSet)
        val fkToQuery = fk1Rows.tail.map(_.id)
        val expectedResult = fkToQuery.toSet.flatMap(fk2RowsByFk)
        expectedResult must_=== gen.TestFk_2.multigetByFk(fkToQuery).transact(xa).unsafePerformSync.toSet
      }
    }
  }
} 

package mdmoss.doobiegen.queries

import doobie.imports._
import mdmoss.doobiegen.db.gen
import org.specs2.matcher.ThrownExpectations
import org.specs2.mutable.Specification
import scalaz.concurrent.Task

object MultigetSpec extends Specification with ThrownExpectations {

  val xa = DriverManagerTransactor[Task]("org.postgresql.Driver", "jdbc:postgresql:gen", "test", "test")

  val Fk1RowCount       = 3
  val Fk2RowPerFk1Count = 3

  "multiget query functions" >> {
    val (fk1Rows, fk2Rows) = {
      for {
        fk1 <- gen.TestFk_1.createMany(List.fill(Fk1RowCount)(gen.TestFk_1.Shape()))
        fk2 <- gen.TestFk_2.createMany(fk1.flatMap(fkRow => List.fill(Fk2RowPerFk1Count)(gen.TestFk_2.Shape(fkRow.id))))
      } yield (fk1, fk2)
    }.transact(xa).run

    "over primary keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).run
        }
      }

      "return the same row multiple times if a duplicate primary key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).run
        }
      }
    }

    "over foreign keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).run.map(_.fk)
        }
      }

      "return the same matching set of rows multiple times if a duplicate foreign key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).run.map(_.fk)
        }
      }

      "only return all matching rows" >> {
        val fk2RowsByFk = fk2Rows.groupBy(_.fk).mapValues(_.toSet)
        val fkToQuery = fk1Rows.tail.map(_.id)
        val expectedResult = fkToQuery.toSet.flatMap(fk2RowsByFk)
        expectedResult must_=== gen.TestFk_2.multigetByFk(fkToQuery).transact(xa).run.toSet
      }
    }
  }
} 

package mdmoss.doobiegen.queries

import doobie.imports._
import org.specs2.matcher.ThrownExpectations
import org.specs2.mutable.Specification
import scalaz.concurrent.Task

import mdmoss.doobiegen.db.gen

object MultigetSpec extends Specification with ThrownExpectations {

  val xa = DriverManagerTransactor[Task]("org.postgresql.Driver", "jdbc:postgresql:gen", "test", "test")

  val Fk1RowCount       = 3
  val Fk2RowPerFk1Count = 3

  "multiget query functions" >> {
    val (fk1Rows, fk2Rows) = {
      for {
        fk1 <- gen.TestFk_1.createMany(List.fill(Fk1RowCount)(gen.TestFk_1.Shape()))
        fk2 <- gen.TestFk_2.createMany(fk1.flatMap(fkRow => List.fill(Fk2RowPerFk1Count)(gen.TestFk_2.Shape(fkRow.id))))
      } yield (fk1, fk2)
    }.transact(xa).unsafePerformSync

    "over primary keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).unsafePerformSync
        }
      }

      "return the same row multiple times if a duplicate primary key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        permutations must_=== permutations.map { rows =>
          gen.TestFk_1.multiget(rows.map(_.id)).transact(xa).unsafePerformSync
        }
      }
    }

    "over foreign keys must" >> {
      "order returned rows by input order" >> {
        val permutations = fk1Rows.permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).unsafePerformSync.map(_.fk)
        }
      }

      "return the same matching set of rows multiple times if a duplicate foreign key is specified in the input" >> {
        val permutations = (fk1Rows.tail.head :: fk1Rows).permutations.toList
        val expectedResult = permutations.map(_.flatMap(x => List.fill(Fk2RowPerFk1Count)(x.id)))
        expectedResult must_=== permutations.map { rows =>
          gen.TestFk_2.multigetByFk(rows.map(_.id)).transact(xa).unsafePerformSync.map(_.fk)
        }
      }

      "only return all matching rows" >> {
        val fk2RowsByFk = fk2Rows.groupBy(_.fk).mapValues(_.toSet)
        val fkToQuery = fk1Rows.tail.map(_.id)
        val expectedResult = fkToQuery.toSet.flatMap(fk2RowsByFk)
        expectedResult must_=== gen.TestFk_2.multigetByFk(fkToQuery).transact(xa).unsafePerformSync.toSet
      }
    }
  }
} 

package shield.routing

import org.specs2.mutable.Specification
import shield.config.{HttpServiceLocation, ServiceLocation}
import spray.http.Uri

import scala.util.Try

class UpstreamServiceLocationSpec extends Specification {
  "UpstreamServiceLocation" should {
    "accept valid https urls" in {
      val svc = HttpServiceLocation(Uri("https://example.edu"))
      svc.baseUrl.scheme must be equalTo "https"
      svc.baseUrl.authority.host.address must be equalTo "example.edu"
    }

    "accept valid http urls" in {
      val svc = HttpServiceLocation(Uri("http://example.edu"))
      svc.baseUrl.scheme must be equalTo "http"
      svc.baseUrl.authority.host.address must be equalTo "example.edu"
    }

    "use the correct port" in {
      val default_http = HttpServiceLocation(Uri("http://example.edu"))
      default_http.baseUrl.authority.port must be equalTo 0

      val custom_http = HttpServiceLocation(Uri("http://example.edu:5001"))
      custom_http.baseUrl.authority.port must be equalTo 5001

      val default_https = HttpServiceLocation(Uri("https://example.edu"))
      default_https.baseUrl.authority.port must be equalTo 0

      val custom_https = HttpServiceLocation(Uri("https://example.edu:8443"))
      custom_https.baseUrl.authority.port must be equalTo 8443
    }

    "reject unrecognized schemes" in {
      val ftp = Try { HttpServiceLocation(Uri("ftp://example.edu")) }
      ftp.isSuccess must be equalTo false

      val mailto = Try { HttpServiceLocation(Uri("mailto://example.edu")) }
      mailto.isSuccess must be equalTo false
    }

    "ignore case in urls" in {
      val svc = HttpServiceLocation(Uri("HTTPs://EXamPLE.edu"))
      svc.baseUrl.authority.host.address must be equalTo "example.edu"
      svc.baseUrl.scheme must be equalTo "https"
    }

    "reject urls with a path" in {
      val empty = Try { HttpServiceLocation(Uri("http://example.edu/")) }
      empty.isSuccess must be equalTo false

      val nonempty = Try { HttpServiceLocation(Uri("http://example.edu/foobar")) }
      nonempty.isSuccess must be equalTo false
    }

    "reject urls with a fragment" in {
      val empty = Try { HttpServiceLocation(Uri("http://example.edu#")) }
      empty.isSuccess must be equalTo false

      val nonempty = Try { HttpServiceLocation(Uri("http://example.edu#foobar")) }
      nonempty.isSuccess must be equalTo false
    }

    "reject urls with a query" in {
      val empty = Try { HttpServiceLocation(Uri("http://example.edu?")) }
      empty.isSuccess must be equalTo false

      val nonempty = Try { HttpServiceLocation(Uri("http://example.edu?foo=bar")) }
      nonempty.isSuccess must be equalTo false
    }

    "reject urls with a auth information" in {
      val empty = Try { HttpServiceLocation(Uri("http://:@example.edu")) }
      empty.isSuccess must be equalTo false

      val nonempty = Try { HttpServiceLocation(Uri("http://foo:[email protected]")) }
      nonempty.isSuccess must be equalTo false
    }

    "reject relative urls" in {
      val relative = Try { HttpServiceLocation(Uri("/foobar")) }
      relative.isSuccess must be equalTo false
    }

    "reject empty urls" in {
      val relative = Try { HttpServiceLocation(Uri("")) }
      relative.isSuccess must be equalTo false
    }
  }
} 

package shield.routing

import org.specs2.mutable.Specification

class RouteSortingSpec extends Specification {
  "RouteSorting" should {
    "prefer more specific routes" in {
      val static = Path("/foo")
      val wild = Path("/{}")
      val path = Path("/{+}")

      static must beLessThan(wild)
      wild must beLessThan(path)
      static must beLessThan(path)
    }

    "give higher precedence to earlier static segments" in {
      val high = Path("/foo/{}")
      val low = Path("/{}/bar")

      high must beLessThan(low)
    }

    "use later segments as tie breakers" in {
      val fbf = Path("/foo/bar/fizz")
      val fb_ = Path("/foo/bar/{}")
      val f_f = Path("/foo/{}/fizz")
      val f__ = Path("/foo/{}/{}")

      fbf must beLessThan(fb_)
      fbf must beLessThan(f_f)
      fbf must beLessThan(f__)

      fb_ must beLessThan(f_f)
      fb_ must beLessThan(f__)

      f_f must beLessThan(f__)
    }

    "use Nil segments as lowest priority" in {
      // this may seem counter-intuitive at first glance.  However, if there exists a segment
      // after a regex or path segment, that is more specific than if the regex or path segment
      // consumed that later segment.
      val root = Path("/")
      val foo = Path("/foo")
      val foobar = Path("/foo/bar")
      val nested = Path("/foo/{}")

      root must beGreaterThan(foo)

      foo must beGreaterThan(foobar)
      foo must beGreaterThan(nested)
    }

    "treat path segments as lower priority than any number of static or wild segments" in {
      val wilds = Path("/foo/{}/{]/{}/{}")
      val nestedPath = Path("/foo/{+}")
      val pathSegment = Path("/{+}")

      wilds must beLessThan(nestedPath)
      wilds must beLessThan(pathSegment)

      nestedPath must beLessThan(pathSegment)
    }

    "prioritize path segments with trailing segments" in {
      val trailingStatic = Path("/{+}/foo")
      val trailingWild = Path("/{+}/{}")
      val path = Path("/{+}")

      trailingStatic must beLessThan(trailingWild)
      trailingStatic must beLessThan(path)

      trailingWild must beLessThan(path)
    }

    "handle edge cases" in {
      val root = Path("/")
      val empty = Path("")

      root must beEqualTo(empty)
    }
  }
} 

package shield.routing

import org.specs2.mutable.Specification
import spray.http.Uri

class PathParsingSpec extends Specification {
  "PathParsing" should {
    "handle empty paths" in {
      val emptyPath = Path("")

      emptyPath.segments must be equalTo Nil
    }

    "handle root paths" in {
      val rootPath = Path("/")

      rootPath.segments must be equalTo Nil
    }

    "handle static segments" in {
      val foo = Path("/foo")

      foo.segments must be equalTo List(StaticSegment("foo"))
    }

    "handle nested static segments" in {
      val foobar = Path("/foo/bar")

      foobar.segments must be equalTo List(StaticSegment("foo"), SlashSegment, StaticSegment("bar"))
    }

    "handle wildcard segments" in {
      val wild = Path("/foo/{bar}")
      wild.segments must be equalTo List(StaticSegment("foo"), SlashSegment, WildcardSegment)
    }

    "handle path segments" in {
      val path = Path("/foo/{+bar}")
      path.segments must be equalTo List(StaticSegment("foo"), SlashSegment, PathSegment)
    }

    "handles wildcards adjacent to static" in {
      val path = Path("/foo{.media}")
      path.segments must be equalTo List(StaticSegment("foo"), ExtensionSegment)
    }
  }
} 

package shield.implicits

import com.amazonaws.auth.{AWSCredentials, AWSCredentialsProvider, AWSCredentialsProviderChain}
import org.specs2.mutable.Specification
import shield.aws.{AWSSigningConfig, AuthUtil}
import spray.http._


class AuthUtilSpec extends Specification {
  //Set consistant times that will produce consistant results for the tests
  val d1 = "20160315T141234Z"
  val d2 = "20160315"

  //Create a new config, these values are typically found in application.conf
  val config = new AWSSigningConfig("example-elasticsearch-host", "us-west-1", "es", true, new AWSCredentialsProviderChain(new StaticCredentialProvider()))

  "AuthUtil" should {

    "Use SHA256" in {
      println(AuthUtil.hashAsString("Hello world!"))
      AuthUtil.hashAsString("Hello world!") must be equalTo "c0535e4be2b79ffd93291305436bf889314e4a3faec05ecffcbb7df31ad9e51a"
      AuthUtil.hashAsString("123$%^abcDEF") must be equalTo "3b43642576e2c2cf349f34ff7f10e700bf485e6982647a50e361e883a5aaafa2"
      AuthUtil.hashAsString("  _***~`  ") must be equalTo "0597e54e8278a8673f09842d03e4af3a2688d1a15a55a640968382a5311416b4"
    }

    "Create canonical request hash" in {
      val request = new HttpRequest(HttpMethods.GET, Uri("https://example-elasticsearch-host.com:80"), List(), HttpEntity(HttpData("Sample data for a sample request ~*)@#$) @#(((")))

      println(AuthUtil.createCanonicalHash(request, "example-elasticsearch-host"))
      AuthUtil.createCanonicalHash(request, "example-elasticsearch-host") must be equalTo "05ef99e67afa47f06ed12084460baa4fca0bfbf92faebabed00fa78796028c5d"
    }

    "Create string to sign from a given canonical request" in {
      val canonicalRequestHash = "05ef99e67afa47f06ed12084460baa4fca0bfbf92faebabed00fa78796028c5d"

      AuthUtil.createStringToSign(d1, d2, config.region, config.service, canonicalRequestHash) must be equalTo "AWS4-HMAC-SHA256\n20160315\n20160315T141234Z/us-west-1/es/aws4_request\n05ef99e67afa47f06ed12084460baa4fca0bfbf92faebabed00fa78796028c5d"
    }

    "Create a signature" in {
      val stringToSign = "AWS4-HMAC-SHA256\n20160315\n20160315T141234Z/us-west-1/es/aws4_request\n05ef99e67afa47f06ed12084460baa4fca0bfbf92faebabed00fa78796028c5d"
      val signature = AuthUtil.hmacSHA256AsString("AWS4-HMAC-SHA256\n20160315\n20160315T141234Z/us-west-1/es/aws4_request\n05ef99e67afa47f06ed12084460baa4fca0bfbf92faebabed00fa78796028c5d", AuthUtil.createSignatureKey(config.getSecretKey(), d1, config.region, config.service))

      signature must be equalTo "68e811337b35141320236cf585a7fefad71d8948e4d1e9d5eb3583474d31eb6a"
    }
  }
}

//Create a static credential provider so that the access key and secret key stay the same for the purposes of testing
class StaticCredentialProvider extends AWSCredentialsProvider {
  override def refresh(): Unit = { }

  override def getCredentials: AWSCredentials = new AWSCredentials {
    override def getAWSAccessKeyId: String = "AccessKeyId"

    override def getAWSSecretKey: String = "SuperSecretKey"
  }
} 

package shield.implicits

import org.specs2.mutable.Specification
import spray.http.HttpHeaders.RawHeader
import spray.http.{HttpResponse, HttpRequest}
import shield.implicits.HttpImplicits._

class ImplicitsSpec extends Specification {
  "HttpImplicits" should {
    "Replace a request header" in {
      var request = HttpRequest().withHeaders(
        RawHeader("sample", "header")
      )
      request = request.withReplacedHeaders(RawHeader("sample","newHeader"))
      request.headers.length must be equalTo 1
      request.headers(0).name must be equalTo "sample"
      request.headers(0).value must be equalTo "newHeader"
    }

    "Add a request header" in {
      var request = HttpRequest().withHeaders(
        RawHeader("sample", "header")
      )
      request = request.withAdditionalHeaders(
        RawHeader("additional", "testHeader")
      )

      request.headers.length must be equalTo 2
      request.headers.find(_.lowercaseName == "additional").get.value must be equalTo "testHeader"
      request.headers.find(_.lowercaseName == "sample").get.value must be equalTo "header"
    }

    "Strip a request header" in {
      var request = HttpRequest().withHeaders(
        RawHeader("sample", "header"),
        RawHeader("additional", "testHeader")
      )

      request = request.withStrippedHeaders(Set("sample"))
      request.headers.length must be equalTo 1
      request.headers(0).name must be equalTo "additional"
      request.headers(0).value must be equalTo "testHeader"
    }

    "Replace a response header" in {
      var response = HttpResponse().withHeaders(
        RawHeader("sample", "header")
      )
      response = response.withReplacedHeaders(RawHeader("sample","newHeader"))
      response.headers.length must be equalTo 1
      response.headers(0).name must be equalTo "sample"
      response.headers(0).value must be equalTo "newHeader"
    }

    "Add a response header" in {
      var response = HttpResponse().withHeaders(
        RawHeader("sample", "header")
      )
      response = response.withAdditionalHeaders(
        RawHeader("additional", "testHeader")
      )

      response.headers.length must be equalTo 2
      response.headers.find(_.lowercaseName == "additional").get.value must be equalTo "testHeader"
      response.headers.find(_.lowercaseName == "sample").get.value must be equalTo "header"
    }

    "Strip a response header" in {
      var response = HttpResponse().withHeaders(
        RawHeader("sample", "header"),
        RawHeader("additional", "testHeader")
      )

      response = response.withStrippedHeaders(Set("sample"))
      response.headers.length must be equalTo 1
      response.headers(0).name must be equalTo "additional"
      response.headers(0).value must be equalTo "testHeader"
    }

    "Strip a response header that is capitalized" in {
      var response = HttpResponse().withHeaders(
        RawHeader("X-Cache", "header"),
        RawHeader("additional","testHeader")
      )

      response = response.withStrippedHeaders(Set("X-Cache"))
      response.headers.length must be equalTo 1
      response.headers(0).name must be equalTo "additional"
      response.headers(0).value must be equalTo "testHeader"
    }
  }
} 

package shield.proxying

import org.specs2.mutable.Specification
import spray.http.HttpHeaders.RawHeader
import spray.http.{HttpHeaders, HttpRequest}
import shield.implicits.HttpImplicits._

class HttpProxyLogicSpec extends Specification {
  "HttpProxyLogic" should {
    "Use remote-address when adding to x-forwarded-for" in {
      val request = HttpRequest().withHeaders(
        RawHeader("X-Forwarded-For", "1.1.1.1"),
        RawHeader("Remote-Address", "2.2.2.2")
      ).withTrustXForwardedFor(1)
      getRemoteAddress(request) must be equalTo "2.2.2.2"
      getClientIp(request) must be equalTo "1.1.1.1"
    }

    "Add remote-address to x-forward-for header" in {
      val request = HttpRequest().withHeaders(
        RawHeader("X-Forwarded-For", "1.1.1.1, 2.2.2.2"),
        RawHeader("Remote-Address", "3.3.3.3")
      ).withTrustXForwardedFor(1)
      HttpProxyLogic.forwardedHeader(request.headers) must be equalTo RawHeader("X-Forwarded-For", "1.1.1.1, 2.2.2.2, 3.3.3.3")
    }

    "Add remote-address to x-forwarded-for header" in {
      val request = HttpRequest().withHeaders(
        RawHeader("X-Forwarded-For", "1.1.1.1, 2.2.2.2"),
        RawHeader("Remote-Address", "3.3.3.3")
      )
      HttpProxyLogic.forwardedHeader(request.headers) must be equalTo RawHeader("X-Forwarded-For", "1.1.1.1, 2.2.2.2, 3.3.3.3")
    }

    "If remote-address does not exist then append 127.0.0.1" in {
      val request = HttpRequest().withHeaders(
        RawHeader("X-Forwarded-For", "1.1.1.1, 2.2.2.2")
      )
      HttpProxyLogic.forwardedHeader(request.headers) must be equalTo RawHeader("X-Forwarded-For", "1.1.1.1, 2.2.2.2, 127.0.0.1")
    }

    "Scrub requests of unrequired headers" in {
      val request = HttpRequest().withHeaders(
        HttpHeaders.`X-Forwarded-For`("1.1.1.1"),
        HttpHeaders.`Remote-Address`("2.2.2.2")
      ).withTrustXForwardedFor(1)

      HttpProxyLogic.scrubRequest(request).headers.exists(_.lowercaseName == "client-address") must be equalTo false
    }

    def getHeader(request: HttpRequest, header: String): Option[String] = {
      request.headers.find(_.lowercaseName == header).map(_.value)
    }

    def getRemoteAddress(request: HttpRequest) : String = {
      getHeader(request, "remote-address").get
    }

    def getClientIp(request: HttpRequest): String = {
      getHeader(request, "client-address").get
    }
  }
} 

package cats.effect.testing.specs2

import cats.effect._
import cats.effect.concurrent.Ref
import org.specs2.mutable.Specification

class CatsResourceSpecs extends Specification with CatsResourceIO[Ref[IO, Int]] {
  sequential

  override def resource: Resource[IO, Ref[IO, Int]] = Resource.make(Ref[IO].of(0))(_.set(Int.MinValue))

  "cats resource specifications" should {
    "run a resource modification" in withResource { ref => 
      ref.modify{a => 
        (a + 1, a)
      }.map(
        _ must_=== 0
      )
    }

    "be shared between tests" in withResource {ref => 
      ref.modify{a => 
        (a + 1, a)
      }.map(
        _ must_=== 1
      )
    }
  }
} 

package cats.effect.testing.specs2

import cats.effect.{IO, Resource}
import cats.effect.concurrent.{Ref, Deferred}
import cats.implicits._
import org.specs2.mutable.Specification

class CatsEffectSpecs extends Specification with CatsEffect {

  "cats effect specifications" should {
    "run a non-effectful test" in {
      true must beTrue
    }

    "run a simple effectful test" in IO {
      true must beTrue
      false must beFalse
    }

    "run a simple resource test" in {
      true must beTrue
    }.pure[Resource[IO, *]]

    "resource must be live for use" in {
      Resource.make(Ref[IO].of(true))(_.set(false)).map{ 
        _.get.map(_ must beTrue)
      }
    }

    "really execute effects" in {
      "First, this check creates a deferred value.".br

      val deferredValue = Deferred.unsafeUncancelable[IO, Boolean]

      "Then it executes two mutually associated steps:".br.tab

      "forcibly attempt to get the deferred value" in {
        deferredValue.get.unsafeRunTimed(Timeout) must beSome(true)
      }

      "Since specs2 executes steps in parallel by default, the second step gets executed anyway.".br

      "complete the deferred value inside IO context" in {
        deferredValue.complete(true) *> IO.pure(success)
      }

      "If effects didn't get executed then the previous step would fail after timeout.".br
    }

    // "timeout a failing test" in (IO.never: IO[Boolean])
  }
} 

package tasks

import cats.effect.IO
import controllers.{Authenticator, UserAccountAccessor}
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import vinyldns.core.domain.membership._

class UserSyncTaskSpec extends Specification with Mockito {
  val notAuthUser: User = User("not-authorized", "accessKey", "secretKey")
  val lockedNotAuthUser: User = notAuthUser.copy(lockStatus = LockStatus.Locked)
  val mockAuthenticator: Authenticator = {
    val mockObject = mock[Authenticator]
    mockObject.getUsersNotInLdap(List(notAuthUser)).returns(IO(List(notAuthUser)))
    mockObject
  }

  val mockUserAccountAccessor: UserAccountAccessor = {
    val mockObject = mock[UserAccountAccessor]
    mockObject.getAllUsers.returns(IO(List(notAuthUser)))
    mockObject
      .lockUsers(List(notAuthUser))
      .returns(IO(List(lockedNotAuthUser)))
    mockObject
  }

  "SyncUserTask" should {
    "successfully lock unauthorized, non-test users" in {
      new UserSyncTask(mockUserAccountAccessor, mockAuthenticator)
        .run()
        .unsafeRunSync() must beEqualTo(())

      there.was(one(mockUserAccountAccessor).lockUsers(List(notAuthUser)))
    }

    "successfully process if no users are found" in {
      val mockAuth: Authenticator = mock[Authenticator]
      mockAuth.getUsersNotInLdap(List(notAuthUser)).returns(IO(Nil))

      val mockUsers = mock[UserAccountAccessor]
      mockUsers
        .lockUsers(Nil)
        .returns(IO(Nil))

      mockUsers.getAllUsers.returns(IO(List(notAuthUser)))

      new UserSyncTask(mockUsers, mockAuth)
        .run()
        .unsafeRunSync() must beEqualTo(())
    }
  }
} 

package models
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import play.api.Configuration

class MetaSpec extends Specification with Mockito {
  "Meta" should {
    "load from config" in {
      val config = Map("vinyldns.version" -> "foo-bar")
      Meta(Configuration.from(config)).version must beEqualTo("foo-bar")
    }
    "default to false if shared-display-enabled is not found" in {
      val config = Map("vinyldns.version" -> "foo-bar")
      Meta(Configuration.from(config)).sharedDisplayEnabled must beFalse
    }
    "set to true if shared-display-enabled is true in config" in {
      val config = Map("shared-display-enabled" -> true)
      Meta(Configuration.from(config)).sharedDisplayEnabled must beTrue
    }
    "get the batch-change-limit value in config" in {
      val config = Map("batch-change-limit" -> 21)
      Meta(Configuration.from(config)).batchChangeLimit must beEqualTo(21)
    }
    "default to 1000 if batch-change-limit is not found" in {
      val config = Map("vinyldns.version" -> "foo-bar")
      Meta(Configuration.from(config)).batchChangeLimit must beEqualTo(1000)
    }
    "get the default-ttl value in config" in {
      val config = Map("default-ttl" -> 7210)
      Meta(Configuration.from(config)).defaultTtl must beEqualTo(7210)
    }
    "default to 7200 if default-ttl is not found" in {
      val config = Map("vinyldns.version" -> "foo-bar")
      Meta(Configuration.from(config)).defaultTtl must beEqualTo(7200)
    }
    "default to false if manual-batch-review-enabled is not found" in {
      val config = Map("vinyldns.version" -> "foo-bar")
      Meta(Configuration.from(config)).manualBatchChangeReviewEnabled must beFalse
    }
    "set to true if manual-batch-review-enabled is true in config" in {
      val config = Map("manual-batch-review-enabled" -> true)
      Meta(Configuration.from(config)).manualBatchChangeReviewEnabled must beTrue
    }
    "default to false if scheduled-batch-change-enabled is not found" in {
      val config = Map("vinyldns.version" -> "foo-bar")
      Meta(Configuration.from(config)).scheduledBatchChangesEnabled must beFalse
    }
    "set to true if scheduled-batch-change-enabled is true in config" in {
      val config = Map("scheduled-changes-enabled" -> true)
      Meta(Configuration.from(config)).scheduledBatchChangesEnabled must beTrue
    }
  }
} 

package models

import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import play.api.Configuration

class CustomLinksSpec extends Specification with Mockito {
  "CustomLinks" should {
    "load link from config" in {
      val linkOne = CustomLink(false, true, "title 1", "href 1", "icon 1")
      val config = Map(
        "links" -> List(
          Map(
            "displayOnSidebar" -> linkOne.displayOnSidebar,
            "displayOnLoginScreen" -> linkOne.displayOnLoginScreen,
            "title" -> linkOne.title,
            "href" -> linkOne.href,
            "icon" -> linkOne.icon
          )
        )
      )
      val customLinks = CustomLinks(Configuration.from(config))
      customLinks.links must beEqualTo(List[CustomLink](linkOne))
    }

    "load multiple links from config" in {
      val linkOne = CustomLink(false, true, "title 1", "href 1", "icon 1")
      val linkTwo = CustomLink(true, false, "title 2", "href 2", "icon 2")
      val config = Map(
        "links" -> List(
          Map(
            "displayOnSidebar" -> linkOne.displayOnSidebar,
            "displayOnLoginScreen" -> linkOne.displayOnLoginScreen,
            "title" -> linkOne.title,
            "href" -> linkOne.href,
            "icon" -> linkOne.icon
          ),
          Map(
            "displayOnSidebar" -> linkTwo.displayOnSidebar,
            "displayOnLoginScreen" -> linkTwo.displayOnLoginScreen,
            "title" -> linkTwo.title,
            "href" -> linkTwo.href,
            "icon" -> linkTwo.icon
          )
        )
      )
      val customLinks = CustomLinks(Configuration.from(config))
      customLinks.links must beEqualTo(List[CustomLink](linkOne, linkTwo))
    }

    "load empty list if no links in config" in {
      val customLinks = CustomLinks(Configuration.from(Map()))
      customLinks.links must beEqualTo(List[CustomLink]())
    }
  }
} 

package controllers

import cats.effect.IO
import org.joda.time.DateTime
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import org.specs2.specification.BeforeEach
import vinyldns.core.domain.membership._

class UserAccountAccessorSpec extends Specification with Mockito with BeforeEach {

  private val user = User(
    "fbaggins",
    "key",
    "secret",
    Some("Frodo"),
    Some("Baggins"),
    Some("[email protected]"),
    DateTime.now,
    "frodo-uuid"
  )

  private val userLog = UserChange(
    "frodo-uuid",
    user,
    "fbaggins",
    DateTime.now,
    None,
    UserChangeType.Create
  ).toOption.get

  private val mockRepo = mock[UserRepository]
  private val mockChangeRepo = mock[UserChangeRepository]
  private val underTest = new UserAccountAccessor(mockRepo, mockChangeRepo)

  protected def before: Any =
    org.mockito.Mockito.reset(mockRepo, mockChangeRepo)

  "UserAccountAccessor" should {
    "return the user when storing a user that does not exist already" in {
      mockRepo.save(any[User]).returns(IO.pure(user))
      mockChangeRepo.save(any[UserChange]).returns(IO.pure(userLog))
      underTest.create(user).unsafeRunSync() must beEqualTo(user)
      there.was(one(mockChangeRepo).save(any[UserChange]))
    }

    "return the new user when storing a user that already exists in the store" in {
      val newUser = user.copy(accessKey = "new-key", secretKey = "new-secret")
      mockRepo.save(any[User]).returns(IO.pure(newUser))
      mockChangeRepo.save(any[UserChange]).returns(IO.pure(userLog))
      underTest.update(newUser, user).unsafeRunSync() must beEqualTo(newUser)
      there.was(one(mockChangeRepo).save(any[UserChange]))
    }

    "return the user when retrieving a user that exists by name" in {
      mockRepo.getUserByName(user.userName).returns(IO.pure(Some(user)))
      mockRepo.getUser(user.userName).returns(IO.pure(None))
      underTest.get("fbaggins").unsafeRunSync() must beSome(user)
    }

    "return the user when retrieving a user that exists by user ID" in {
      mockRepo.getUserByName(user.id).returns(IO.pure(None))
      mockRepo.getUser(user.id).returns(IO.pure(Some(user)))
      underTest.get(user.id).unsafeRunSync() must beSome(user)
    }

    "return None when the user to be retrieved does not exist" in {
      mockRepo.getUserByName(any[String]).returns(IO.pure(None))
      mockRepo.getUser(any[String]).returns(IO.pure(None))
      underTest.get("fbaggins").unsafeRunSync() must beNone
    }

    "return the user by access key" in {
      mockRepo.getUserByAccessKey(user.id).returns(IO.pure(Some(user)))
      underTest.getUserByKey(user.id).unsafeRunSync() must beSome(user)
    }

    "return all users" in {
      val userList = List(user, user.copy(id = "user2", userName = "user2"))
      mockRepo.getAllUsers.returns(IO.pure(userList))
      underTest.getAllUsers.unsafeRunSync() must beEqualTo(userList)
    }

    "lock specified users" in {
      val lockedUser = user.copy(lockStatus = LockStatus.Locked)
      val lockedUserChange = UserChange.UpdateUser(
        user.copy(lockStatus = LockStatus.Locked),
        "system",
        DateTime.now,
        user
      )
      mockRepo.save(List(lockedUser)).returns(IO(List(lockedUser)))
      mockChangeRepo.save(any[UserChange]).returns(IO(lockedUserChange))
      underTest.lockUsers(List(user)).unsafeRunSync() must beEqualTo(List(lockedUser))
    }
  }
} 

package controllers

import cats.effect.IO
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner
import play.api.mvc.ControllerComponents
import play.api.test.Helpers.{GET, status}
import play.api.test.{FakeRequest, Helpers}
import vinyldns.core.health.HealthService
import vinyldns.core.health.HealthCheck._
import play.api.test.Helpers._

@RunWith(classOf[JUnitRunner])
class HealthControllerSpec extends Specification {

  val components: ControllerComponents = Helpers.stubControllerComponents()

  "HealthController" should {
    "send 200 if the healthcheck succeeds" in {
      val healthService =
        new HealthService(List(IO.unit.attempt.asHealthCheck(classOf[HealthControllerSpec])))
      val controller = new HealthController(components, healthService)

      val result = controller
        .health()
        .apply(FakeRequest(GET, "/health"))

      status(result) must beEqualTo(200)
    }
    "send 500 if a healthcheck fails" in {
      val err = IO
        .raiseError(new RuntimeException("bad!!"))
        .attempt
        .asHealthCheck(classOf[HealthControllerSpec])
      val healthService =
        new HealthService(List(IO.unit.attempt.asHealthCheck(classOf[HealthControllerSpec]), err))
      val controller = new HealthController(components, healthService)

      val result = controller
        .health()
        .apply(FakeRequest(GET, "/health"))

      status(result) must beEqualTo(500)
    }
  }
} 

package org.questions.arrays

import org.specs2.mutable.Specification


trait LongestIncreasingTest extends Specification {
  val finder: LongestIncreasing

  "empty seq" should {
    "throw argument exception" in {
      finder.findLongestIncreasing(Nil) must throwA[IllegalArgumentException]
    }
  }

  "single item" should {
    "return a seq with that item" in {
      finder.findLongestIncreasing(Seq(1)) must be_===(Seq(1))
    }
  }

  "all increasing seq" should {
    "return the seq" in {
      finder.findLongestIncreasing(Seq(1, 2, 3, 4)) must be_===(Seq(1, 2, 3, 4))
    }
  }

  "increasing starts not in the beginning" should {
    "return the increasing seq" in {
      finder.findLongestIncreasing(Seq(8, 1, 2, 3)) must be_===(Seq(1, 2, 3))
    }
  }

  "findLongestIncreasing" should {
    "return the longest increasing seq" in {
      finder.findLongestIncreasing(Seq(1, 2, 0, 0, 3, 0, 4, 5, 6, 5, 2, 3)) must be_===(Seq(0, 4, 5, 6))
    }
  }
}

class LongestIncreasingRecursiveTest extends LongestIncreasingTest {
  override val finder = new LongestIncreasingRecursive
}

class LongestIncreasingIterativeTest extends LongestIncreasingTest {
  override val finder = new LongestIncreasingIterative
} 

package org.questions.arrays

import org.specs2.matcher.Matcher
import org.specs2.mutable.Specification
import org.specs2.specification.Scope


class TwoSumTest extends Specification {

  class Context extends Scope {
    val arrayUtils = new TwoSum

    def sumTo(sum: Int): Matcher[(Int, Int)] = (_: (Int, Int)) match {
      case (a, b) => a + b must be_===(sum)
    }
  }

  "under 2 elements in seq" should {
    "be none" in new Context {
      arrayUtils.findPairSum(Seq(1), 8) must beNone
    }
  }

  "two elements that sum" should {
    "return these elements" in new Context {
      arrayUtils.findPairSum(Seq(2, 3), 5) must beSome(sumTo(5))
    }
  }

  "two elements that doesn't sum" should {
    "return these none" in new Context {
      arrayUtils.findPairSum(Seq(2, 3), 4) must beNone
    }
  }

  "more elements that sum" should {
    "return the sum" in new Context {
      arrayUtils.findPairSum(Seq(1, 2, 3), 5) must beSome(sumTo(5))
    }
  }
} 

package org.questions.strings

import org.specs2.mutable.Specification


class WildCardMatchingTest extends Specification {
  val matcher = new WildCardMatching


  "same string" should {
    "be matching" in {
      val string = "abc"
      matcher.isMatching(string, string) must beTrue
    }
  }

  "different string" should {
    "not match" in {
      matcher.isMatching("ab", "bc") must beFalse
    }
  }

  "question mark" should {
    "allow to skip one char" in {
      matcher.isMatching("abc", "a?c") must beTrue
    }
  }

  "star" should {
    "replace many chars" in {
      matcher.isMatching("abcd", "a*d") must beTrue
    }

    "replace zero chars" in {
      matcher.isMatching("abc", "ab*c") must beTrue
    }

    "replace one char" in {
      matcher.isMatching("abc", "a*c") must beTrue
    }

    "match if star is in the end" in {
      matcher.isMatching("abc", "a*") must beTrue
    }
  }
} 

package org.questions.strings

import org.specs2.mutable.Specification


class ParenthesesValidatorTest extends Specification {
  val validator = new ParenthesesValidator

  "empty parentheses" should {
    "be valid" in {
      validator.validate("(abc)") must beTrue
    }
  }

  "no parentheses" should {
    "be valid" in {
      validator.validate("abc") must beTrue
    }
  }

  "unclosed" should {
    "be invalid" in {
      validator.validate("((abc)") must beFalse
    }
  }

  "unopened" should {
    "be invalid" in {
      validator.validate("(abc))") must beFalse
    }

    "be invalid in beginning" in {
      validator.validate(")abc(") must beFalse
    }
  }
} 

package org.questions

import org.questions.fibonacci.{Fibonacci, Iterative, Recursive, TailRecursion}
import org.scalacheck.Gen
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

import scala.concurrent.duration.Duration
import scala.concurrent.{Await, Future}


trait FibonacciTest extends Specification with FibonacciProperty {
  val fib: Fibonacci

  "negative input" should {
    "be invalid" in {
      fib.nth(-1) must throwA[IllegalArgumentException]
    }
  }

  "0th" should {
    "be 0" in {
      fib.nth(0) must be_===(0)
    }
  }

  "1st" should {
    "be 1" in {
      fib.nth(1) must be_===(1)
    }
  }

  "2nd" should {
    "be 1" in {
      fib.nth(2) must be_===(1)
    }
  }
}

trait BigN {
  self: FibonacciTest =>

  import scala.concurrent.ExecutionContext.Implicits.global

  "big N" should {
    "be computed in sub seconds" in {
      val calcBigN = Future.apply {
        fib.nth(100)
      }

      Await.ready(calcBigN, Duration("1 second")).isCompleted must beTrue
    }
  }
}

trait FibonacciProperty extends ScalaCheck {
  self: FibonacciTest =>

  val smallInteger = Gen.choose[Int](2,30)

  "fib(n)" should {
    "be equal to the sum of the results of last 2 elements" >> prop { n: Int =>
      fib.nth(n) must be_===(fib.nth(n - 1) + fib.nth(n - 2))
    }.setGen(smallInteger)
  }
}

class RecursiveTest extends FibonacciTest {
  override val fib = new Recursive
}

class IterativeTest extends FibonacciTest with BigN {
  override val fib = new Iterative
}

class TailRecursionTest extends FibonacciTest with BigN {
  override val fib: Fibonacci = new TailRecursion
} 

package org.questions.fill

import org.specs2.mutable.Specification
import org.specs2.specification.Scope


class CanvasTest extends Specification {

  class Context extends Scope {
    private val sample =
      """............
        |.*******....
        |.*....***...
        |.**.....*...
        |..*....**...
        |...*****....""".stripMargin

    private def toCharsCanvas(s: String) =
      new CharsCanvas(s.lines.map(_.toCharArray).toArray)

    val canvas = toCharsCanvas(sample)
    val drawUtils = new DrawUtils(canvas)

    def >(canvas: Canvas) = {
      val (rows, cols) = canvas.getSize

      for {r <- 0 until rows} {
        for {c <- 0 until cols} {
          Predef.print(canvas.getColor(r, c))
        }
        println()
      }
    }
  }

  Seq((1, 100), (100, 1), (-1, 1), (1, -1)) foreach { case (x, y) =>
    "outside of the canvas" should {
      "result in error" in new Context {
        drawUtils.fill(x, y, 'X') must throwA[IndexOutOfBoundsException]
      }
    }
  }

  "adjacent fields with same color" should {
    "be filled" in new Context {
      drawUtils.fill(3, 4, '#')

      Seq((3, 5), (3, 3), (2, 4), (4, 4)) foreach { case (x, y) =>
        canvas.getColor(x, y) must be_===('#')
      }
    }
  }

  "adjacent fields with different color" should {
    "stay with previous color" in new Context {
      drawUtils.fill(0, 1, '#')
      canvas.getColor(1, 1) must be_===('*')
    }
  }

  "selected field" should {
    "be colored" in new Context {
      drawUtils.fill(0, 0, '#')
      canvas.getColor(0, 0) must be_===('#')
    }
  }

  "far fields that in same shape" should {
    "be colored" in new Context {
      drawUtils.fill(0, 0, '#')
      canvas.getColor(5, 11) must be_===('#')
    }
  }
} 

package com.gilt.gfc.aws.kinesis.client

import java.util.UUID

import com.amazonaws.services.kinesis.model.{PutRecordsRequestEntry, PutRecordsResultEntry}
import org.specs2.mutable.Specification

class KinesisPublisherPutRecordsCallResultsTest
  extends Specification {

  "KinesisPublisherPutRecordsCallResults" should {
    "handle empty results" in {
      val r = KinesisPublisherPutRecordsCallResults(Seq.empty)

      r.successes.isEmpty must_===(true)
      r.failures.isEmpty must_===(true)
      r.softFailures.isEmpty must_===(true)
      r.hardFailures.isEmpty must_===(true)
      r.isGenericServerError must_===(false)
    }


    "handle generic service errors" in {
      val r = KinesisPublisherPutRecordsCallResults(Seq(
        e -> None
      , e -> None
      ))

      r.successes.isEmpty must_===(true)
      r.failures.size must_===(2)
      r.softFailures.size must_===(2)
      r.hardFailures.isEmpty must_===(true)
      r.isGenericServerError must_===(true)
    }


    "handle successful calls" in {
      val r = KinesisPublisherPutRecordsCallResults(Seq(
        e -> re(null)
      , e -> re(null)
      ))

      r.successes.size must_===(2)
      r.failures.isEmpty must_===(true)
      r.softFailures.isEmpty must_===(true)
      r.hardFailures.isEmpty must_===(true)
      r.isGenericServerError must_===(false)
    }

    "handle partial batch failures" in {
      val r = KinesisPublisherPutRecordsCallResults(Seq(
        e -> re(null) // success
      , e -> re("blahblah") // 'hard' error, no retry
      , e -> re("foobar") // 'hard' error, no retry
      , e -> re("InternalFailure") // 'soft' error, should retry
      ))

      r.successes.size must_===(1)
      r.failures.size must_===(3)
      r.softFailures.size must_===(1)
      r.hardFailures.size must_===(2)
      r.isGenericServerError must_===(false)
    }
  }


  def e: PutRecordsRequestEntry = {
    new PutRecordsRequestEntry().withPartitionKey(UUID.randomUUID.toString)
  }

  def re( errCode: String
        ): Option[PutRecordsResultEntry] = {
    Some(new PutRecordsResultEntry().withErrorCode(errCode))
  }
} 

package pathy

import org.specs2.mutable.Specification
import pathy.Path._

class PosixPrintPathSpecs extends Specification {
  import posixCodec._

  "two directories" in {
    unsafePrintPath(dir("foo") </> file("bar")) must_=== "./foo/bar"
  }

  "file with two parents" in {
    unsafePrintPath(dir("foo") </> dir("bar") </> file("image.png")) must_=== "./foo/bar/image.png"
  }

  "file without extension" in {
    unsafePrintPath(file("image") <:> "png") must_=== "./image.png"
  }

  "file with extension" in {
    unsafePrintPath(file("image.jpg") <:> "png") must_=== "./image.png"
  }

  "printPath - ./../" in {
    unsafePrintPath(parentDir1(currentDir)) must_=== "./../"
  }
} 

package pathy

import slamdata.Predef._
import pathy.scalacheck._

import scala.Predef.identity

import org.scalacheck._, Arbitrary.arbitrary
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification
import scalaz.scalacheck.ScalazProperties._
import scalaz.syntax.foldable._

class PathSpecs extends Specification with ScalaCheck {
  import Path._, PathyArbitrary._

  "FileName" in {
    "order laws" >> order.laws[FileName]
  }

  "DirName" in {
    "order laws" >> order.laws[DirName]
  }

  "Path" in {
    implicit val arbitraryPath: Arbitrary[Path[Any,Any,Sandboxed]] =
      Arbitrary(Gen.oneOf(
        arbitrary[AbsFile[Sandboxed]],
        arbitrary[RelFile[Sandboxed]],
        arbitrary[AbsDir[Sandboxed]],
        arbitrary[RelDir[Sandboxed]]))

    "order laws" >> order.laws[Path[Any,Any,Sandboxed]]
  }

  "</> - ./../foo/" in {
    posixCodec.unsafePrintPath(parentDir1(currentDir) </> unsandbox(dir("foo"))) must_== "./../foo/"
  }

  "parentDir1 - ./../foo/../" in {
    posixCodec.unsafePrintPath((parentDir1(currentDir) </> unsandbox(dir("foo"))) </> parentDir1(currentDir)) must_== "./../foo/../"
  }

  "<::>" >> {
    "./../" in {
      posixCodec.unsafePrintPath(currentDir <::> currentDir) must_== "./../"
    }

    "./../foo/" in {
      posixCodec.unsafePrintPath(currentDir <::> dir("foo")) must_== "./../foo/"
    }

    "./../foo/../" in {
      posixCodec.unsafePrintPath((currentDir <::> dir("foo")) <::> currentDir) must_== "./../foo/../"
    }
  }

  "canonicalize" >> {
    "1 down, 1 up" in {
      canonicalize(parentDir1(dir("foo"))) must_== currentDir
    }

    "2 down, 2 up" in {
      canonicalize(parentDir1(parentDir1(dir("foo") </> dir("bar")))) must_== currentDir
    }
  }

  "relativeTo" >> {
    "simple case" >> {
      (rootDir </> dir("foo")).relativeTo(rootDir) must_== Some(dir("foo"))
    }
    "return currentDir if same path" >> {
      (rootDir </> dir("foo")).relativeTo(rootDir </> dir("foo")) must_== Some(currentDir)
    }
  }

  "renameFile - single level deep" in {
    renameFile(file("image.png"), _.dropExtension) must_== file("image")
  }

  "sandbox - sandbox absolute dir to one level higher" in {
    sandbox(rootDir </> dir("foo"), rootDir </> dir("foo") </> dir("bar")) must beSome.which {
      _ must_== dir("bar")
    }
  }

  "depth - negative" in {
    depth(parentDir1(parentDir1(parentDir1(currentDir)))) must_== -3
  }

  "flatten - returns NEL of result of folding each layer of path" in {
    flatten(
      "r", "c", "p", identity, identity,
      currentDir </> dir("foo") </> dir("bar") </> file("flat.md")
    ).toList must_== List("c", "foo", "bar", "flat.md")
  }
} 

package skuber.networking

import org.specs2.mutable.Specification
import play.api.libs.json._
import skuber.LabelSelector.dsl._
import skuber._
import skuber.json.networking.format._


class IngressSpec extends Specification {
  "This is a unit specification for the skuber Ingress class. ".txt

  "An Ingress object can be written to Json and then read back again successfully" >> {
    val ingress=Ingress("example")
          .addHttpRule("example.com", Map(
            "/" -> "service:80",
            "/about" -> "another-service:http"
          ))

      val readIng = Json.fromJson[Ingress](Json.toJson(ingress)).get
      readIng mustEqual ingress
  }

  "An Ingress object with empty Path can be read directly from a JSON string" >> {
    val ingJsonStr =
      """
        |{
        |  "apiVersion": "networking.k8s.io/v1beta1",
        |  "kind": "Ingress",
        |  "metadata": {
        |    "creationTimestamp": "2017-04-02T19:39:34Z",
        |    "generation": 3,
        |    "labels": {
        |      "app": "ingress"
        |    },
        |    "name": "example-ingress",
        |    "namespace": "default",
        |    "resourceVersion": "1313499",
        |    "selfLink": "/apis/extensions/v1beta1/namespaces/default/ingresses/example",
        |    "uid": "192dd131-17dc-11e7-bd9c-0a5e79684354"
        |  },
        |  "spec": {
        |    "rules": [
        |      {
        |        "host": "example.com",
        |        "http": {
        |          "paths": [
        |            {
        |              "backend": {
        |                "serviceName": "service",
        |                "servicePort": "http"
        |              }
        |            }
        |          ]
        |        }
        |      }
        |    ],
        |    "tls": [
        |      {
        |        "hosts": ["abc","def"]
        |      }  
        |    ]
        |  },
        |  "status": {
        |    "loadBalancer": {
        |      "ingress": [
        |        {
        |          "hostname": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-1111111111.us-east-1.elb.amazonaws.com"
        |        }
        |      ]
        |    }
        |  }
        |}""".stripMargin

    val ing = Json.parse(ingJsonStr).as[Ingress]
    ing.kind mustEqual "Ingress"
    ing.name mustEqual "example-ingress"

    ing.spec.get.rules.head.host must beSome("example.com")
    ing.spec.get.rules.head.http.paths must_== List(Ingress.Path(
      path = "",
      backend = Ingress.Backend("service", "http")
    ))
    ing.spec.get.tls must_== List(Ingress.TLS(
      hosts = List("abc","def"),
      secretName = None
    ))

  }
} 

package skuber.json

import org.specs2.mutable.Specification
import skuber.{ObjectMeta, Secret} // for unit-style testing
import format._

import play.api.libs.json._


class SecretSpec extends Specification {

  "A Secret containing a byte array can symmetrically be written to json and the same value read back in" >> {
    val dataBytes = "hello".getBytes
    val secret = Secret(metadata = ObjectMeta("mySecret"), data = Map("key" -> dataBytes))
    val resultBytes = Json.fromJson[Secret](Json.toJson(secret)).get.data("key")
    dataBytes mustEqual resultBytes
  }
  "this can be done with an empty data map" >> {
    val mySecret = Secret(metadata = ObjectMeta("mySecret"))
    val json = Json.toJson(mySecret)
    val readSecret = Json.fromJson[Secret](Json.toJson(mySecret)).get
    mySecret mustEqual readSecret
  }
  "this can be done with the type member defined" >> {
    val mySecret = Secret(metadata = ObjectMeta("mySecret"), `type` = "myType")
    val readSecret = Json.fromJson[Secret](Json.toJson(mySecret)).get
    mySecret mustEqual readSecret
  }
} 

package skuber.json

import java.net.URL

import org.specs2.execute.{Failure, Result}
import org.specs2.mutable.Specification
import play.api.libs.json._
import skuber._
import skuber.settings.PodPreset

import scala.io.Source


class PodPresetFormatSpec extends Specification {
  "This is a unit specification for the skuber PodPreset related json formatter.\n ".txt

  "a podpreset can be read and written as json successfully" >> {
    val podPresetJsonSource=Source.fromURL(getClass.getResource("/examplePodPreset.json"))
    val podPresetJsonStr = podPresetJsonSource.mkString
    val podPreset = Json.parse(podPresetJsonStr).as[PodPreset]

    // write and read it back in again and compare
    val json = Json.toJson(podPreset)
    val readPodPreset = Json.fromJson[PodPreset](json).get
    readPodPreset mustEqual podPreset
  }

} 

package skuber.model

import java.time.Instant

import org.specs2.mutable.Specification
import skuber.api.client._



class AuthSpec extends Specification {
  "This is a unit specification for the auth data model. ".txt
  
  
  // Auth
  "Auth toString works when empty" >> {
    NoAuth.toString mustEqual "NoAuth"
  }

  "CertAuth toString masks cert, key but not user" >> {
    val auth = CertAuth(
      clientCertificate = Right("secretPem".getBytes),
      clientKey = Right("secretKey".getBytes),
      user = Some("someUser")
    )
    auth.toString mustEqual "CertAuth(clientCertificate=<PEM masked> clientKey=<PEM masked> userName=someUser )"
  }

  "CertAuth toString doesn't mask username, certPath, keyPath" >> {
    val auth = CertAuth(
      clientCertificate = Left("certPath"),
      clientKey = Left("keyPath"),
      user = Option("aUser")
    )
    auth.toString mustEqual "CertAuth(clientCertificate=certPath clientKey=keyPath userName=aUser )"
  }

  "TokenAuth toString masks token" >> {
    TokenAuth("myToken").toString mustEqual "TokenAuth(token=<redacted>)"
  }

  "GcpAuth toString masks accessToken" >> {
    GcpAuth(accessToken = Some("MyAccessToken"), expiry = Some(Instant.now), cmdPath = "gcp", cmdArgs = "").toString mustEqual
      "GcpAuth(accessToken=<redacted>)"
  }

  "OidcAuth toString masks idToken" >> {
    OidcAuth(idToken = "MyToken").toString mustEqual "OidcAuth(idToken=<redacted>)"
  }

} 

package skuber.policy.v1beta1

import org.specs2.mutable.Specification
import play.api.libs.json.{JsSuccess, Json}
import skuber.LabelSelector.dsl._

class PodDisruptionBudgetSpec extends Specification {
  import PodDisruptionBudget._
  "A PodDisruptionBudget can" >> {
    "decoded from json" >> {
      val pdb = PodDisruptionBudget("someName")
        .withMaxUnavailable(Left(2))
        .withMinAvailable(Left(1))
        .withLabelSelector("application" is "someApplicationName")

      Json.parse(createJson("/examplePodDisruptionBudget.json")).validate[PodDisruptionBudget] mustEqual JsSuccess(pdb)
    }
    "encode to json" >> {
      Json.toJson(
        PodDisruptionBudget("someName")
          .withMaxUnavailable(Left(2))
          .withMinAvailable(Left(1))
          .withLabelSelector("application" is "someApplicationName")
      ) mustEqual Json.parse(createJson("/examplePodDisruptionBudget.json"))
    }
  }

  private def createJson(file: String): String = {
    val source = scala.io.Source.fromURL(getClass.getResource(file))
    try source.mkString finally source.close()
  }
} 

package skuber.apps.v1

import org.specs2.mutable.Specification
import play.api.libs.json._
import skuber.LabelSelector.dsl._
import skuber._

class StatefulSetSpec extends Specification {
  "This is a unit specification for the skuber apps/v1 StatefulSet class. ".txt

  "A StatefulSet object can be constructed from a name and pod template spec" >> {
    val container=Container(name="example",image="example")
    val template=Pod.Template.Spec.named("example").addContainer(container)
    val stateSet=StatefulSet("example")
      .withReplicas(200)
      .withServiceName("nginx-service")
      .withTemplate(template)
      .withVolumeClaimTemplate(PersistentVolumeClaim("hello"))
    stateSet.spec.get.template mustEqual template
    stateSet.spec.get.serviceName mustEqual Some("nginx-service")
    stateSet.spec.get.replicas must beSome(200)
    stateSet.spec.get.volumeClaimTemplates.size mustEqual 1
    stateSet.name mustEqual "example"
    stateSet.status mustEqual None
  }

  "A StatefulSet object can be written to Json and then read back again successfully" >> {
    val container=Container(name="example",image="example")
    val template=Pod.Template.Spec.named("example").addContainer(container)
    val stateSet=StatefulSet("example")
      .withTemplate(template)
      .withLabelSelector(LabelSelector("live" doesNotExist, "microservice", "tier" is "cache", "env" isNotIn List("dev", "test")))


    val readSSet = Json.fromJson[StatefulSet](Json.toJson(stateSet)).get
    readSSet mustEqual stateSet
  }

  "A StatefulSet object properly writes with zero replicas" >> {
    val sset=StatefulSet("example").withReplicas(0)

    val writeSSet = Json.toJson(sset)
    (writeSSet \ "spec" \ "replicas").asOpt[Int] must beSome(0)
  }

  "A StatefulSet object can be read directly from a JSON string" >> {
    import scala.io.Source
    val ssJsonSource=Source.fromURL(getClass.getResource("/exampleStatefulSet.json"))
    val ssetJsonStr = ssJsonSource.mkString
    val stateSet = Json.parse(ssetJsonStr).as[StatefulSet]

    stateSet.kind mustEqual "StatefulSet"
    stateSet.name mustEqual "nginx-stateset"
    stateSet.spec.get.replicas must beSome(7)
    stateSet.spec.get.updateStrategy.get.`type` mustEqual StatefulSet.UpdateStrategyType.RollingUpdate
    stateSet.spec.get.updateStrategy.get.rollingUpdate.get.partition mustEqual(5)
    stateSet.spec.get.volumeClaimTemplates.size mustEqual 1
    stateSet.spec.get.serviceName.get mustEqual "nginx-service"
    stateSet.spec.get.template.metadata.labels mustEqual Map("domain" -> "www.example.com","proxies" -> "microservices")
    val podSpec=stateSet.spec.get.template.spec.get
    podSpec.containers.length mustEqual 1
    val container=podSpec.containers(0)
    container.resources.get.requests.get("cpu").get mustEqual Resource.Quantity("500m")
    container.lifecycle.get.preStop.get mustEqual ExecAction(List("/bin/sh", "-c", "PID=$(pidof java) && kill $PID && while ps -p $PID > /dev/null; do sleep 1; done"))
    container.readinessProbe.get.action mustEqual ExecAction(List("/bin/sh", "-c", "./ready.sh"))
    container.readinessProbe.get.initialDelaySeconds mustEqual 15
    container.readinessProbe.get.timeoutSeconds mustEqual 5
    stateSet.spec.get.selector.get.requirements.size mustEqual 4
    stateSet.spec.get.selector.get.requirements.find(r => (r.key == "env")) mustEqual Some("env" isNotIn List("dev"))
    stateSet.spec.get.selector.get.requirements.find(r => (r.key == "domain")) mustEqual Some("domain" is "www.example.com")

    // write and read back in again, should be unchanged
    val json = Json.toJson(stateSet)
    val readSS = Json.fromJson[StatefulSet](json).get
    readSS mustEqual stateSet
  }
} 

package skuber.autoscaling
import org.specs2.mutable.Specification

import scala.math.BigInt
import skuber.{Container, ObjectMeta, Pod, ReplicationController}
import play.api.libs.json._
import skuber.autoscaling.HorizontalPodAutoscaler.CrossVersionObjectReference


class HPASSpec extends Specification {
  "This is a unit specification for the skuber HorizontalPodAutoscaler class. ".txt
  
  "A HPAS object can be constructed from the object it scales\n" >> {
    "A HPAS can be constructed from a replication controller" >> {
      val container=Container(name="example",image="example")
      val rc=ReplicationController("example", container, Map("app" -> "example"))
      val hpas=HorizontalPodAutoscaler.scale(rc).
                    withMinReplicas(1).
                    withMaxReplicas(10).
                    withCPUTargetUtilization(80)
      hpas.name mustEqual "example"
      hpas.spec.scaleTargetRef.kind mustEqual "ReplicationController"
      hpas.spec.maxReplicas must_== 10
      hpas.spec.minReplicas must beSome(1)
      hpas.spec.cpuUtilization mustEqual Some(CPUTargetUtilization(80))
    }
  }

  "A HPAS object properly writes with zero minReplicas" >> {
    val hpas=HorizontalPodAutoscaler(
      metadata = ObjectMeta("example"),
      spec = HorizontalPodAutoscaler.Spec(
        scaleTargetRef = CrossVersionObjectReference(name="example")
      )
    ).withMaxReplicas(0).withMinReplicas(0)

    val writeHPAS = Json.toJson(hpas)
    (writeHPAS \ "spec" \ "minReplicas").asOpt[Int] must beSome(0)
    (writeHPAS \ "spec" \ "maxReplicas").asOpt[Int] must beSome(0)
  }
} 

package skuber.apps

import org.specs2.mutable.Specification
import skuber.{Container, LabelSelector, ObjectMeta, Pod, ReplicationController, Scale}
import play.api.libs.json.Json


class ScaleSpec extends Specification {
  "This is a unit specification for the skuber Scale class. ".txt
  
  "A Scale object can be constructed from a name and replica count" >> {
    val scale=Scale.named("example").withSpecReplicas(10)
    scale.spec.replicas mustEqual Some(10)
    scale.name mustEqual "example"
    scale.status mustEqual None
  }
  
  "A scale object can be written to Json and then read back again successfully" >> {

      val scale= Scale(
        apiVersion="autoscaling/v1",
        metadata=ObjectMeta(name="example", namespace="na"),
        spec=Scale.Spec(replicas=Some(10))
      )
      
      val readScale = Json.fromJson[Scale](Json.toJson(scale)).get
      readScale mustEqual scale
  }
  
  "A scale object can be read directly from a JSON string" >> {
    val scaleJsonStr = """
{
  "kind": "Scale",
  "apiVersion": "extensions/v1beta1",
  "metadata": {
    "name": "redis-master",
    "namespace": "default",
    "selfLink": "/apis/extensions/v1beta1/namespaces/default/replicationcontrollers/redis-master/scale",
    "creationTimestamp": "2015-12-29T11:55:14Z"
  },
  "spec": {
    "replicas": 1
  },
  "status": {
    "replicas": 1,
    "targetSelector": "redis-master"
  }
}
"""
    val scale = Json.parse(scaleJsonStr).as[Scale]
    scale.kind mustEqual "Scale"
    scale.name mustEqual "redis-master"
    scale.spec.replicas mustEqual Some(1)
    scale.status mustEqual Some(Scale.Status(replicas=1, selector=None, targetSelector=Some("redis-master")))
  }

  "A scale object can contain NO replicas" >> {
    val scaleJsonObj =
      """
        |{
        |  "kind": "Scale",
        |  "apiVersion": "extensions/v1beta1",
        |  "metadata": {
        |    "name": "redis-master",
        |    "namespace": "default",
        |    "selfLink": "/apis/extensions/v1beta1/namespaces/default/replicationcontrollers/redis-master/scale",
        |    "creationTimestamp": "2015-12-29T11:55:14Z"
        |  },
        |  "spec": {
        |  },
        |  "status": {
        |    "replicas": 1,
        |    "targetSelector": "redis-master"
        |  }
        |}
      """.stripMargin
    val scale = Json.parse(scaleJsonObj).as[Scale]
    scale.kind mustEqual "Scale"
    scale.name mustEqual "redis-master"
    scale.spec.replicas mustEqual None
  }
} 

package com.github.vonnagy.service.container.metrics

import java.net.InetAddress

import akka.http.scaladsl.model.headers.{Accept, `Remote-Address`}
import akka.http.scaladsl.model.{ContentTypes, MediaTypes, RemoteAddress, StatusCodes}
import com.github.vonnagy.service.container.Specs2RouteTest
import com.github.vonnagy.service.container.http.routing.Rejection.NotFoundRejection
import org.specs2.mutable.Specification

class MetricsEndpointsSpec extends Specification with Specs2RouteTest {

  val endpoints = new MetricsEndpoints()(system, system.dispatcher)

  def remoteAddress(ip: String) = RemoteAddress(InetAddress.getByName(ip))

  "The routing infrastructure should support" should {

    "a call to /metrics to be handled" in {
      Get("/metrics").withHeaders(`Remote-Address`(remoteAddress("127.0.0.1"))) ~> endpoints.route ~> check {
        handled must beTrue
        contentType === ContentTypes.`application/json`
        status must be equalTo (StatusCodes.OK)
      }
    }

    "a call to /metrics should return json" in {
      Get("/metrics").withHeaders(Accept(MediaTypes.`application/json`),
        `Remote-Address`(remoteAddress("127.0.0.1"))) ~> endpoints.route ~> check {
        handled must beTrue
        contentType === ContentTypes.`application/json`
      }
    }

    "a call to /metrics should return an error due to CIDR rules" in {
      Get("/metrics").withHeaders(Accept(MediaTypes.`application/json`),
        `Remote-Address`(remoteAddress("192.168.1.1"))) ~> endpoints.route ~> check {
        handled must beFalse
        rejections.size must beEqualTo(1)
        rejections.head must be equalTo(NotFoundRejection("The requested resource could not be found"))
      }
    }
  }

} 

package com.github.vonnagy.service.container.metrics

import com.codahale.metrics.MetricRegistry
import com.github.vonnagy.service.container.http.DefaultMarshallers
import org.specs2.mutable.Specification

class MetricsWriterSpec extends Specification with DefaultMarshallers {

  val reg = new MetricRegistry()
  val writer = new MetricsWriter(reg)

  step {
    reg.counter("test.counter").inc(10)
    reg.meter("test.meter").mark(10)
    reg.timer("test.timer")
    reg.histogram("test.histogram").update(10)
    reg.register("test.gauge", new com.codahale.metrics.Gauge[Int] {
      def getValue: Int = 10
    })
    reg.counter("jvm.test").inc(20)
  }

  "The metrics writer" should {
    "create json for custom metrics" in {
      val json = writer.getMetrics(false)
      val value = json \ "system" \ "metrics" \ "test.counter"
      value.extract[Int] must be equalTo 10
    }

    "create json for custom and jvm metrics" in {
      val json = writer.getMetrics(true)
      val value = json \ "system" \ "metrics" \ "test.counter"
      value.extract[Int] must be equalTo 10

      val value2 = json \ "system" \ "jvm" \ "unkown" \ "jvm.test"
      value2.extract[Int] must be equalTo 20
    }
  }
} 

package com.github.vonnagy.service.container.http

import akka.http.scaladsl.marshalling._
import akka.http.scaladsl.model.MediaTypes._
import akka.http.scaladsl.model.headers.Accept
import akka.http.scaladsl.model.{MediaType, MediaTypes}
import akka.http.scaladsl.server.{ContentNegotiator, Route, UnacceptedResponseContentTypeRejection}
import com.github.vonnagy.service.container.Specs2RouteTest
import org.specs2.mutable.Specification


class BaseDirectivesSpec extends Specification with BaseDirectives with DefaultMarshallers with Specs2RouteTest {

  val `application/vnd.com.github.vonnagy.container.health-v1+json` =
    MediaType.custom("application/vnd.com.github.vonnagy.container.health-v1+json", false)

  "The base directives" should {

    "allow the use of the `acceptableMediaTypes` directive" in {

      import MediaTypes._

      implicit val marsh: ToEntityMarshaller[Seq[String]] = jsonMarshaller

      implicit val vndMarsh: ToEntityMarshaller[String] =
        Marshaller.StringMarshaller.wrap(`application/vnd.com.github.vonnagy.container.health-v1+json`)(_.toString)

      val route: Route =
        path("app-json") {
          acceptableMediaTypes(`application/json`, `application/vnd.com.github.vonnagy.container.health-v1+json`) {
            complete(Seq())
          }
        } ~
          path("app-custom") {
            acceptableMediaTypes(`application/json`, `application/vnd.com.github.vonnagy.container.health-v1+json`) {
              complete("[]")
            }
          }

      Get("/app-json")
        .withHeaders(Accept(`application/json`, `application/vnd.com.github.vonnagy.container.health-v1+json`)) ~>
        route ~> check {
        responseAs[String] === "[]"
        mediaType === MediaTypes.`application/json`
      }

      Get("/app-custom")
        .withHeaders(Accept(`application/vnd.com.github.vonnagy.container.health-v1+json`, `application/json`)) ~>
        route ~> check {
        responseAs[String] === "[]"
        mediaType === `application/vnd.com.github.vonnagy.container.health-v1+json`
      }

      Get("/app-json").withHeaders(Accept(`text/plain`)) ~> route ~> check {
        rejection === UnacceptedResponseContentTypeRejection(Set(ContentNegotiator.Alternative(`application/json`),
          ContentNegotiator.Alternative(`application/vnd.com.github.vonnagy.container.health-v1+json`)))
      }
    }
  }

  "allow for the use of json response type" in {

    implicit val marsh: ToEntityMarshaller[Seq[String]] = jsonMarshaller

    Get() ~> {
      complete(Seq())
    } ~> check {
      mediaType === `application/json`
    }
  }

  "allow for the use of plain response type" in {

    Get() ~> {
      complete("[]")
    } ~> check {
      mediaType === `text/plain`
    }

  }

} 

package com.github.vonnagy.service.container.http.directives

import java.net.InetAddress

import akka.http.scaladsl.model.headers._
import akka.http.scaladsl.model.{RemoteAddress, StatusCodes}
import com.github.vonnagy.service.container.Specs2RouteTest
import com.github.vonnagy.service.container.http.routing.Rejection.NotFoundRejection
import org.specs2.mutable.Specification


class CIDRDirectivesSpec extends Specification with CIDRDirectives with Specs2RouteTest {

  val yeah = complete("Yeah!")

  def remoteAddress(ip: String) = RemoteAddress(InetAddress.getByName(ip))

  "CIDRDirectives" should {

    "allow call when no allows or denies" in {
      Get() ~> addHeaders(`Remote-Address`(remoteAddress("192.168.1.1"))) ~> {
        cidrFilter(Seq(), Seq()) {
          yeah
        }
      } ~> check {
        handled === true
        status === StatusCodes.OK
      }
    }

    "allow call when no denies, but matches allow" in {
      Get() ~> addHeaders(`Remote-Address`(remoteAddress("192.168.1.1"))) ~> {
        cidrFilter(Seq("192.168.1.1/1"), Seq()) {
          yeah
        }
      } ~> check {
        handled === true
        status === StatusCodes.OK
      }
    }

    "allow call when does not match deny, but matches allow" in {
      Get() ~> addHeaders(`Remote-Address`(remoteAddress("192.168.1.1"))) ~> {
        cidrFilter(Seq("192.168.1.1/1"), Seq("10.0.0.1/1")) {
          yeah
        }
      } ~> check {
        handled === true
        status === StatusCodes.OK
      }
    }

    "disallow call when no denies and does not match allow" in {
      Get() ~> addHeaders(`Remote-Address`(remoteAddress("192.168.1.1"))) ~> {
        cidrFilter(Seq("127.0.0.1/1"), Seq()) {
          yeah
        }
      } ~> check {
        handled must beFalse
        rejections.size must beEqualTo(1)
        rejections.head must be equalTo(NotFoundRejection("The requested resource could not be found"))
      }
    }

    "disallow call when matches a deny" in {
      Get() ~> addHeaders(`Remote-Address`(remoteAddress("10.0.0.1"))) ~> {
        cidrFilter(Seq("192.168.1.1/1"), Seq("10.0.0.1/1")) {
          yeah
        }
      } ~> check {
        handled must beFalse
        rejections.size must beEqualTo(1)
        rejections.head must be equalTo(NotFoundRejection("The requested resource could not be found"))
      }
    }

    "disallow because there is no remote address header that has been injected" in {
      Get() ~> {
        cidrFilter(Seq(), Seq()) {
          yeah
        }
      } ~> check {
        handled must beFalse
        rejections.size must beEqualTo(1)
        rejections.head must be equalTo(NotFoundRejection("The requested resource could not be found"))
      }
    }
  }
} 

package com.github.vonnagy.service.container.http.routing

import akka.http.scaladsl.model.StatusCodes._
import akka.http.scaladsl.model.ContentTypes._
import akka.http.scaladsl.server.{Directives, MalformedRequestContentRejection, MissingCookieRejection, Route}
import com.github.vonnagy.service.container.Specs2RouteTest
import com.github.vonnagy.service.container.http.routing.Rejection.DuplicateRejection
import org.specs2.mutable.Specification


class RoutingHandlerSpec extends Specification with Specs2RouteTest with Directives {

  val handler = new RoutingHandler {
    def conf = system.settings.config
  }

  val dummyRoute =
    pathPrefix("test") {
      get {
        path("duplicate") {
          reject(DuplicateRejection("test"))
        } ~
        path("malformed") {
          reject(MalformedRequestContentRejection("test", new Exception("test")))
        } ~
        path("cookie") {
          reject(MissingCookieRejection("test"))
        } ~
        path("exception") {
          throw new NullPointerException("test")
        }
      }
    }

  "the routing handler" should {

    "provide custom rejection handlers" in {
      implicit val rejHandler = handler.rejectionHandler
      val sr = Route.seal(dummyRoute)

      Get("/test/duplicate") ~> sr ~> check {
        status must be equalTo BadRequest
        responseAs[String] must be equalTo(
          """{"code":400,"message":"The request contains bad syntax or cannot be fulfilled.","details":"\"test\""}""")
      }

      Get("/test/malformed") ~> sr ~> check {
        status must be equalTo UnprocessableEntity
        responseAs[String] must be equalTo(
          """{"code":422,"message":"The request was well-formed but was unable to be followed due to semantic errors.","details":"\"test\""}""")
      }
    }

    "use the default rejection handler as a fallback" in {
      implicit val rejHandler = handler.rejectionHandler
      val sr = Route.seal(dummyRoute)

      Get("/test/cookie") ~> sr ~> check {
        status must be equalTo BadRequest
        responseAs[String] must be equalTo(
          """{"code":400,"message":"The request contains bad syntax or cannot be fulfilled.","details":"Request is missing required cookie 'test'"}""")
      }
    }

    "provide custom exception handlers" in {
      implicit val exHandler = handler.exceptionHandler
      val sr = Route.seal(dummyRoute)

      Get("/test/exception") ~> sr ~> check {
        status must be equalTo InternalServerError
        contentType must be equalTo `application/json`
        responseAs[String] must be equalTo(
          """{"code":500,"message":"There was an internal server error.","details":"Something bad happened"}""")
      }
 }

  }
} 

package com.github.vonnagy.service.container.http.routing

import akka.actor._
import akka.http.scaladsl.model.{HttpEntity, MediaTypes, StatusCodes}
import akka.http.scaladsl.server.{Directives, Route}
import akka.testkit.{TestActorRef, TestProbe}
import com.github.vonnagy.service.container.Specs2RouteTest
import com.github.vonnagy.service.container.http.{DefaultMarshallers, RejectionResponse}
import org.specs2.mutable.Specification

class RoutedServiceSpec extends Specification with Directives with Specs2RouteTest {

  case class TestEntity(id: Int, name: String)

  val probe = new TestProbe(system)
  val httpAct = TestActorRef(Props(new Actor with RoutedService with DefaultMarshallers {
    def receive = routeReceive
  }), "http")

  val svc = httpAct.underlyingActor.asInstanceOf[RoutedService]

  def echoComplete[T]: T => Route = { x ⇒ complete(x.toString) }

  "The RoutedService" should {

    "allow for routes to be added after the system is already loaded" in {
      // This should create the actor and register the endpoints
      val r = new RoutedEndpoints {
        def route = {
          path("test2") {
            complete("test2")
          }
        }
      }

      probe.send(httpAct, AddRoute(r))
      probe.expectMsg(RouteAdded)

      Get("/test2") ~> svc.buildRoute(svc.routes) ~> check {
        responseAs[String] must be equalTo "test2"
      }
    }

    "respond with UnprocessableEntity for requests resulting in a MalformedFormFieldRejection" in {

      implicit val unmarsh = svc.jsonUnmarshaller[TestEntity]
      implicit val rejMarsh = svc.jsonUnmarshaller[RejectionResponse]

      val postRoute = new RoutedEndpoints {
        def route = {
          post {
            path("test4") {
              entity(as[TestEntity]) {
                echoComplete
              }
            }
          }
        }
      }

      probe.send(httpAct, AddRoute(postRoute))
      probe.expectMsg(RouteAdded)

      import svc.defaultJsonFormats
      val ent = TestEntity(100, "product")

      Post("/test4", HttpEntity(MediaTypes.`application/json`, svc.serialization.write(ent))) ~>
        handleRejections(svc.rejectionHandler)(svc.buildRoute(svc.routes)) ~> check {
        status === StatusCodes.UnprocessableEntity
        mediaType === MediaTypes.`application/json`
        responseAs[RejectionResponse] must not beNull
      }
    }

    "respond with RejectionResponse for requests that error out" in {

      implicit val rejMarsh = svc.jsonUnmarshaller[RejectionResponse]

      val postRoute = new RoutedEndpoints {
        def route = {
          get {
            path("test5") { ctx => throw new Exception("test") }
          }
        }
      }

      probe.send(httpAct, AddRoute(postRoute))
      probe.expectMsg(RouteAdded)

      Get("/test5") ~>
        Route.seal(svc.buildRoute(svc.routes))(svc.routeSettings,
          exceptionHandler = svc.exceptionHandler,
          rejectionHandler = svc.rejectionHandler) ~> check {

        mediaType === MediaTypes.`application/json`
        responseAs[RejectionResponse] must not beNull
      }
    }
  }

} 

package com.github.vonnagy.service.container.http

import java.net.InetAddress

import akka.http.scaladsl.model.headers.`Remote-Address`
import akka.http.scaladsl.model.{RemoteAddress, StatusCodes}
import akka.http.scaladsl.server.Directives
import com.github.vonnagy.service.container.Specs2RouteTest
import com.github.vonnagy.service.container.http.routing.Rejection.NotFoundRejection
import org.specs2.mutable.Specification

class BaseEndpointsSpec extends Specification with Directives with Specs2RouteTest {

  val endpoints = new BaseEndpoints

  "The base routing infrastructure" should {

    "return no content for favicon.ico" in {
      Get("/favicon.ico") ~> endpoints.route ~> check {
        status must be equalTo StatusCodes.NoContent
      }
    }

    "support a call to ping" in {
      Get("/ping") ~> endpoints.route ~> check {
        responseAs[String] must startWith("pong")
        status must beEqualTo(StatusCodes.OK)
      }
    }

    "a call to shutdown should return and error due to CIDR rules" in {
      Post("/shutdown").withHeaders(`Remote-Address`(RemoteAddress(InetAddress.getByName("192.168.1.1")))) ~> endpoints.route ~> check {
        handled must beFalse
        rejections.size must beEqualTo(1)
        rejections.head must be equalTo(NotFoundRejection("The requested resource could not be found"))
      }
    }

  }

} 

package com.github.vonnagy.service.container.health

import java.net.InetAddress

import akka.http.scaladsl.model.headers.{Accept, `Remote-Address`}
import akka.http.scaladsl.model.{ContentTypes, MediaTypes, RemoteAddress, StatusCodes}
import com.github.vonnagy.service.container.Specs2RouteTest
import com.github.vonnagy.service.container.http.routing.Rejection.NotFoundRejection
import org.specs2.mutable.Specification

import scala.concurrent.Future

class HealthEndpointsSpec extends Specification with Specs2RouteTest {

  sequential

  val endpoints = new HealthEndpoints()(system, system.dispatcher)
  def remoteAddress(ip: String) = RemoteAddress(InetAddress.getByName(ip))

  "The routing infrastructure" should {

    "support a call to /health" in {
      Get("/health").withHeaders(`Remote-Address`(remoteAddress("127.0.0.1"))) ~> endpoints.route ~> check {
        handled must beTrue
        contentType === ContentTypes.`application/json`
        status must be equalTo (StatusCodes.OK)
      }
    }

    "support a call to /health that should return json" in {
      Get("/health").withHeaders(Accept(MediaTypes.`application/json`),
        `Remote-Address`(remoteAddress("127.0.0.1"))) ~> endpoints.route ~> check {
        handled must beTrue
        mediaType === MediaTypes.`application/json`
        contentType === ContentTypes.`application/json`
      }
    }

    "a call to /health should return an error due to CIDR rules" in {
      Get("/health").withHeaders(Accept(MediaTypes.`application/json`),
        `Remote-Address`(remoteAddress("192.168.1.1"))) ~> endpoints.route ~> check {
        handled must beFalse
        rejections.size must beEqualTo(1)
        rejections.head must be equalTo(NotFoundRejection("The requested resource could not be found"))
      }
    }

    "support a call to /health/lb" in {
      Get("/health/lb").withHeaders(Accept(MediaTypes.`text/plain`),
        `Remote-Address`(remoteAddress("127.0.0.1"))) ~> endpoints.route ~> check {
        handled must beTrue
        mediaType === MediaTypes.`text/plain`
        responseAs[String].equals("UP")
      }
    }

    "support a call to health/lb that returns a status of `Ok` when a health check is marked as degraded" in {
      Health(system).addCheck(new HealthCheck {
        override def getHealth: Future[HealthInfo] = Future {
          HealthInfo("degraded", HealthState.DEGRADED, "")
        }
      })

      Get("/health/lb").withHeaders(Accept(MediaTypes.`text/plain`),
        `Remote-Address`(remoteAddress("127.0.0.1"))) ~> endpoints.route ~> check {
        handled must beTrue
        mediaType === MediaTypes.`text/plain`
        status === StatusCodes.OK
        responseAs[String].equals("UP")
      }
    }

    "support a call to health/lb that returns a status of `ServiceUnavailable` when a health check is marked as critical" in {
      Health(system).addCheck(new HealthCheck {
        override def getHealth: Future[HealthInfo] = Future {
          HealthInfo("critical", HealthState.CRITICAL, "")
        }
      })

      Get("/health/lb").withHeaders(Accept(MediaTypes.`text/plain`),
        `Remote-Address`(remoteAddress("127.0.0.1"))) ~> endpoints.route ~> check {
        //handled must beTrue
        mediaType === MediaTypes.`text/plain`
        status === StatusCodes.ServiceUnavailable
        responseAs[String].equals("DOWN")
      }
    }

  }
} 

package com.github.vonnagy.service.container.core

import akka.actor.{ActorSystem, Terminated}
import org.specs2.concurrent.ExecutionEnv
import org.specs2.mutable.Specification


class SystemShutdownSpec extends Specification {

  "SystemShutdown" should {

    "allow the ActorSystem to be shutdown" in {
      val sys = ActorSystem()
      val shut = new SystemShutdown {
        val system = sys
      }

      shut.shutdownActorSystem(false) {}
      implicit val ec = ExecutionEnv.fromExecutionContext(sys.dispatcher)
      shut.system.whenTerminated must beAnInstanceOf[Terminated].await

      sys.whenTerminated.isCompleted must beTrue
      success
    }
  }
} 

package com.iheart.playSwagger

import org.specs2.mutable.Specification

class PrefixDomainModelQualifierSpec extends Specification {
  "isModel with multiple packages" >> {

    val dmq = PrefixDomainModelQualifier("com.a", "com.b")

    "returns true if the class is in one of the packages" >> {

      dmq.isModel("com.a.foo") must beTrue
    }

    "returns false if the class is not in any of the packages" >> {
      dmq.isModel("com.c.foo") must beFalse
    }
  }

  "isModel with no packages" >> {
    "returns false" >> {
      val dmq = PrefixDomainModelQualifier()
      dmq.isModel("com.c.foo") must beFalse
    }
  }
} 

package com.iheart.playSwagger

import org.specs2.mutable.Specification

class NamingStrategySpec extends Specification {
  "naming strategy" >> {
    "none" >> {
      NamingStrategy.from("none")("attributeName") must be("attributeName")
    }

    "snake_case" >> {
      NamingStrategy.from("snake_case")("attributeName") must equalTo("attribute_name")
    }

    "kebab-case" >> {
      NamingStrategy.from("kebab-case")("attributeName") must equalTo("attribute-name")
    }

    "lowercase" >> {
      NamingStrategy.from("lowercase")("attributeName") must equalTo("attributename")
    }

    "UpperCamelCase" >> {
      NamingStrategy.from("UpperCamelCase")("attributeName") must equalTo("AttributeName")
    }
  }
} 

package com.redbubble.finchtemplate.api.v1.people

import com.redbubble.finchtemplate.model.Person
import com.redbubble.finchtemplate.util.spec.{FinchTemplateGenerators, SpecHelper}
import com.redbubble.util.http.ResponseOps.jsonBuf
import com.redbubble.util.json.JsonPrinter._
import io.circe.syntax._
import org.scalacheck.Prop._
import org.scalacheck.Properties
import org.specs2.mutable.Specification

final class PeopleEncodersSpec extends Specification with SpecHelper with FinchTemplateGenerators {

  private implicit val personEncoder = PeopleEncoders.personEncoder

  val encodePersonProp = new Properties("Person encoding") {
    property("encode") = forAll(genPerson) { (p: Person) =>
      val expected = parse(s"""{"person":{"name":"${p.name}","birth_year":"${p.birthYear}","hair_colour":"${p.hairColour}"}}""")
      val actual = parse(jsonToString(p.asJson))
      expected must beEqualTo(actual)
    }
  }

  s2"Person can be encoded into JSON$encodePersonProp"

  private implicit val personResponseEncoder = PeopleEncoders.personResponseEncode

  val personResponseProp = new Properties("Person JSON response encoding") {
    property("encode") = forAll(genPerson) { (p: Person) =>
      val expected = parse(s"""{"data":{"person":{"name":"${p.name}","birth_year":"${p.birthYear}","hair_colour":"${p.hairColour}"}}}""")
      val actual = parse(jsonBuf(p))
      expected must beEqualTo(actual)
    }
  }

  s2"Person can be encoded into a response JSON$personResponseProp"

  private implicit val peopleEncoder = PeopleEncoders.peopleEncoder

  val encodePeopleProp = new Properties("People encoding") {
    property("encode") = forAll(genPerson) { (p: Person) =>
      val expected = parse(s"""{"people":[{"name":"${p.name}","birth_year":"${p.birthYear}","hair_colour":"${p.hairColour}"}]}""")
      val actual = parse(jsonToString(Seq(p).asJson))
      expected must beEqualTo(actual)
    }
  }

  s2"People can be encoded into JSON$encodePeopleProp"

  private implicit val peopleResponseEncoder = PeopleEncoders.peopleResponseEncode

  val peopleResponseProp = new Properties("People JSON response encoding") {
    property("encode") = forAll(genPerson) { (p: Person) =>
      val expected = parse(s"""{"data":{"people":[{"name":"${p.name}","birth_year":"${p.birthYear}","hair_colour":"${p.hairColour}"}]}}""")
      val actual = parse(jsonBuf(Seq(p)))
      expected must beEqualTo(actual)
    }
  }

  s2"People can be encoded into a response JSON$peopleResponseProp"
} 

package com.redbubble.finchtemplate.backends.people

import com.redbubble.finchtemplate.model.Person
import com.redbubble.finchtemplate.util.spec.{FinchTemplateGenerators, SpecHelper}
import org.scalacheck.Prop._
import org.scalacheck.Properties
import org.specs2.mutable.Specification

final class PeopleDecodersSpec extends Specification with SpecHelper with FinchTemplateGenerators with PeopleApiJson {
  val decodingProp = new Properties("People decoding") {
    property("decoding a single person") = forAll(genPerson) { (person: Person) =>
      val json = personJson(person)
      val decoded = decode(json)(PeopleDecoders.personDecoder)
      decoded must beRight(person)
    }

    property("decoding a list of people") = forAll(genPerson) { (person: Person) =>
      val json = peopleJson(Seq(person))
      val decoded = decode(json)(PeopleDecoders.peopleDecoder)
      decoded must beRight(Seq(person))
    }
  }

  s2"Decoding people responses$decodingProp"
} 

package com.redbubble.finchtemplate.util.spec

import com.redbubble.util.async.singleThreadedFuturePool
import com.redbubble.util.json.CodecOps
import com.redbubble.util.log.Logger
import org.specs2.ScalaCheck
import org.specs2.execute.{Failure, Result}
import org.specs2.mutable.Specification
import org.specs2.specification.BeforeAll

trait SpecLogging {
  final val log = new Logger("finch-template-test")(singleThreadedFuturePool)
}

object SpecLogging extends SpecLogging

trait SpecHelper extends TestEnvironmentSetter with SpecLogging with ScalaCheck with FinchTemplateGenerators
    with CodecOps with BeforeAll {
  self: Specification =>
  override def beforeAll(): Unit = setEnvironment()

  final def fail(message: String, t: Throwable): Result = Failure(message, "", t.getStackTrace.toList)
} 

package com.redbubble.finchtemplate.util.config

import com.redbubble.finchtemplate.util.spec.SpecHelper
import org.specs2.mutable.Specification

final class EnvironmentSpec extends Specification with SpecHelper {
  val development = Development
  val test = Test
  val production = Production

  "When running tests" >> {
    "the environment is 'test'" >> {
      Environment.env.name must beEqualTo("test")
      Environment.env.isTest must beTrue
    }
  }

  "Environment details" >> {
    "development" >> {
      development.name mustEqual "development"
      development.isDevelopment must beTrue
      development.isTest must beFalse
      development.isProduction must beFalse
    }

    "test" >> {
      test.name mustEqual "test"
      test.isDevelopment must beFalse
      test.isTest must beTrue
      test.isProduction must beFalse
    }

    "production" >> {
      production.name mustEqual "production"
      production.isDevelopment must beFalse
      production.isTest must beFalse
      production.isProduction must beTrue
    }
  }

  // We instantiate these to ensure they are valid URLs (they're lazy)
  "Backend URLs" >> {
    "for development" >> {
      "are valid" >> {
        development.peopleApiUrl must not(beNull)
      }
    }

    "for test" >> {
      "are valid" >> {
        test.peopleApiUrl must not(beNull)
      }
    }

    "for production" >> {
      "are valid" >> {
        production.peopleApiUrl must not(beNull)
      }
    }
  }
} 

package de.zalando.play.controllers

import akka.util.ByteString
import de.zalando.play.controllers.ResponseWriters.choose
import org.specs2.mutable.Specification
import play.api.http.Writeable
import play.api.mvc.RequestHeader

import scala.concurrent.ExecutionContext.Implicits


    override val custom: Seq[(String, ParserWrapper[_])] = Seq(
      "text/plain" -> any
    )
  }

  "WrappedBodyParsers" should {
    "find something" in {
      WrappedBodyParsers.anyParser[Any] must_== Nil
    }
    "not find anything for wrong type" in {
      binaryString.anyParser[String] must_== Nil
    }
    "find something for correct type" in {
      binaryString.anyParser[BinaryString].size must_== 1
    }
    "find something for every type if target is 'Any'" in {
      catchAll.anyParser[String].size must_== 1
      catchAll.anyParser[BinaryString].size must_== 1
    }
  }
}

object TestEnvironment {
  import Implicits.global
  val transformSeq: Seq[Any] => ByteString = a => ByteString.fromString(a.toString)
  val transformStr: String => ByteString = ByteString.fromString

  val seqText: WriteableWrapper[Seq[Any]] = Writeable(transformSeq, Some("text/plain"))

  val stringText: WriteableWrapper[String] = Writeable(transformStr, Some("text/plain"))

  val reg = Seq(seqText, stringText)
} 

package io.chrisdavenport.mules.reload

import cats.effect.IO
import cats.effect.concurrent.Ref
import cats.implicits._
import io.chrisdavenport.mules._
import org.specs2.mutable.Specification

import scala.concurrent.ExecutionContext
import scala.concurrent.duration._

class AutoFetchingCacheSpec extends Specification {

  implicit val ctx = IO.contextShift(ExecutionContext.global)
  implicit val timer = IO.timer(ExecutionContext.Implicits.global)

  "AutoFetchingCache" should {
    "get a value in a quicker period than the timeout" in {
      val setup = for {

        count <- Ref.of[IO, Int](0)

        cache <- AutoFetchingCache.createCache[IO, String, Int](Some(TimeSpec.unsafeFromDuration(1.second)), None)(_ =>
          count.update( _ + 1).as(1)
        )
        value <- cache.lookupCurrent("Foo")
        cValue <- count.get
      } yield (cValue, value)
      setup.unsafeRunSync must_=== ((1, 1))
    }


    "refetch value after expiration timeout" in {
      val setup = for {
        count <- Ref.of[IO, Int](0)

        cache <- AutoFetchingCache.createCache[IO, String, Int](Some(TimeSpec.unsafeFromDuration(1.second)), None)(_ =>
          count.update( _ + 1).as(1)
        )
        _ <- cache.lookupCurrent("Foo")
        _ <- timer.sleep(2.seconds)
        value <- cache.lookupCurrent("Foo")
        cValue <- count.get

      } yield (cValue, value)
      setup.unsafeRunSync must_=== ((2, 1))
    }


    "refetch value after autoReload timeout" in {
      val setup = for {
        count <- Ref.of[IO, Int](0)

        cache <- AutoFetchingCache.createCache[IO, String, Int](None, Some(AutoFetchingCache.RefreshConfig(TimeSpec.unsafeFromDuration(500.milliseconds))))(_ =>
          count.update( _ + 1).as(1)
        )
        _ <- cache.lookupCurrent("Foo")
        _ <- timer.sleep(2.seconds)
        value <- cache.lookupCurrent("Foo")
        cValue <- count.get

      } yield (cValue, value)

      val (cValue, value) = setup.unsafeRunSync
      (value must_=== 1).and(cValue >= 4)
    }

    "refetch value after autoReload timeout and before default expiration" in {
      val setup = for {
        count <- Ref.of[IO, Int](0)

        cache <- AutoFetchingCache.createCache[IO, String, Int](
          TimeSpec.fromDuration(3.second),
          Some(AutoFetchingCache.RefreshConfig(TimeSpec.unsafeFromDuration(500.milliseconds))))(_ =>
          count.update( _ + 1) *> count.get
        )
        _ <- cache.lookupCurrent("Foo")
        _ <- timer.sleep(2.seconds)
        value <- cache.lookupCurrent("Foo")
        cValue <- count.get

      } yield (cValue, value)

      val (cValue, value) = setup.unsafeRunSync
      (value must be >= 4).and(cValue >= 4)
    }

  }
} 

package io.chrisdavenport.mules.caffeine

import org.specs2.mutable.Specification
import scala.concurrent.duration._
import cats.effect._
// import cats.effect.implicits._
import cats.effect.IO
import cats.effect.testing.specs2.CatsIO
import io.chrisdavenport.mules.TimeSpec

class CaffeineCacheSpec extends Specification with CatsIO {
  "CaffeineCache" should {
    "get a value in a quicker period than the timeout" in {
      val setup = for {
        cache <- CaffeineCache.build[IO, String, Int](Some(TimeSpec.unsafeFromDuration(1.second)), None, None)
        _ <- cache.insert("Foo", 1)
        _ <- Timer[IO].sleep(1.milli)
        value <- cache.lookup("Foo")
      } yield value
      setup.map(_ must_=== Some(1))
    }


    "remove a value after delete" in {
      val setup = for {
        cache <- CaffeineCache.build[IO, String, Int](None, None, None)
        _ <- cache.insert("Foo", 1)
        _ <- cache.delete("Foo")
        value <- cache.lookup("Foo")
      } yield value
      setup.map(_ must_=== None)
    }


    "Lookup after interval fails to get a value" in {
      val setup = for {
        cache <- CaffeineCache.build[IO, String, Int](Some(TimeSpec.unsafeFromDuration(1.second)), None, None)
        _ <- cache.insert("Foo", 1)
        _ <- Timer[IO].sleep(2.second)
        value <- cache.lookup("Foo")
      } yield value
      setup.map(_ must_=== None)
    }


  }
} 

package io.chrisdavenport.mules

import org.specs2.mutable.Specification
import scala.concurrent.duration._
import cats.implicits._
import cats.effect._
import cats.effect.concurrent._
// import cats.effect.implicits._
import cats.effect.IO
import cats.effect.testing.specs2.CatsIO

class DispatchOneCacheSpec extends Specification with CatsIO {
  "DispatchOneCache" should {
    "only run once" in {
      for {
        ref <- Ref[IO].of(0)
        cache <- DispatchOneCache.ofSingleImmutableMap[IO, Unit, Int](None)
        action = {_: Unit => Timer[IO].sleep(1.second) >> ref.modify(i => (i+1, i))}
        first <- cache.lookupOrLoad((), action).start
        second <- cache.lookupOrLoad((), action).start
        third <- cache.lookupOrLoad((), action).start
        _ <- first.join
        _ <- second.join
        _ <- third.join
        testValue <- ref.get
      } yield testValue must_=== 1
    }

    "only run till errors cease" in {
      for {
        ref <- Ref[IO].of(0)
        errorFunction = ref.modify(i => (i+1, if (i > 3) i.pure[IO] else  Timer[IO].sleep(1.second) >> IO.raiseError(new Throwable("whoopsie")))).flatten
        cache <- DispatchOneCache.ofSingleImmutableMap[IO, Unit, Int](None)
        first <- cache.lookupOrLoad((), { _ => errorFunction}).start
        second <- cache.lookupOrLoad((), { _ => errorFunction}).start
        third <- cache.lookupOrLoad((), { _ => errorFunction}).start
        _ <- first.join
        _ <- second.join
        _ <- third.join
        testValue <- ref.get
      } yield testValue must_=== 5
    }

    "insert places a value" in {
      for {
        cache <- DispatchOneCache.ofSingleImmutableMap[IO, Unit, Int](None)
        action = {_: Unit => IO.pure(5)}
        _ <- cache.insert((), 1)
        now <- cache.lookupOrLoad((), action)
      } yield {
        now must_=== 1
      }
    }

    "insert overrides background action for first action" in {
      for {
        cache <- DispatchOneCache.ofSingleImmutableMap[IO, Unit, Int](None)
        action = {_: Unit => Timer[IO].sleep(5.seconds).as(5)}
        first <- cache.lookupOrLoad((), action).start
        _ <- cache.insert((), 1)
        value <- first.join
      } yield {
        value must_=== 1
      }
    }

    "insert overrides background action for secondary action" in {
      for {
        cache <- DispatchOneCache.ofSingleImmutableMap[IO, Unit, Int](None)
        action = {_: Unit => Timer[IO].sleep(5.seconds).as(5)}
        first <- cache.lookupOrLoad((),action).start
        second <- cache.lookupOrLoad((), action).start
        _ <- cache.insert((), 1)
        resultSecond <- second.join
        _ <- first.cancel.timeout(1.second).attempt.void
      } yield {
        resultSecond must_=== 1
      }
    }


    "insert overrides set value" in {
      for {
        cache <- DispatchOneCache.ofSingleImmutableMap[IO, Unit, Int](None)
        action = {_: Unit => IO.pure(2)}
        first <- cache.lookupOrLoad((), action)
        _ <- cache.insert((), 1)
        second <- cache.lookupOrLoad((), action)
      } yield {
        (first,second).must_===((2, 1))
        
      }
    }
  }
} 

package io.chrisdavenport.github
package endpoints

import cats.effect._
import cats.effect.testing.specs2.CatsEffect

import org.http4s._
import org.http4s.client._
import org.http4s.dsl.io._
import org.http4s.implicits._

import org.specs2.mutable.Specification

class RepositoriesSpec extends Specification with CatsEffect {
  "Repositories" should {
    "delete correctly" in {
      val delete = HttpRoutes.of[IO]{
        case DELETE -> Root / "repos" / _ / _ => NoContent()
      }
      val client = Client.fromHttpApp(delete.orNotFound)
      io.chrisdavenport.github.endpoints.Repositories.delete[IO]("foo", "bar", OAuth(""))
        .run(client)
        .attempt
        .map(_ must beRight)
    }
  }

} 

package io.chrisdavenport.github.endpoints.repositories

import cats.effect._
import cats.effect.testing.specs2.CatsEffect

import io.circe.literal._

import org.http4s._
import org.http4s.client._
import org.http4s.circe._
import org.http4s.dsl.io._
import org.http4s.implicits._

import org.specs2.mutable.Specification

class ContentSpec extends Specification with CatsEffect {
  "Content endpoints" should {
    val getContent = HttpRoutes.of[IO]{
      case GET -> Root / "repos" / _ / _ / "contents" / "file" =>
        val json = json"""
{
  "type": "file",
  "encoding": "base64",
  "size": 5362,
  "name": "README.md",
  "path": "README.md",
  "content": "encoded content ...",
  "sha": "3d21ec53a331a6f037a91c368710b99387d012c1",
  "url": "https://api.github.com/repos/octokit/octokit.rb/contents/README.md",
  "git_url": "https://api.github.com/repos/octokit/octokit.rb/git/blobs/3d21ec53a331a6f037a91c368710b99387d012c1",
  "html_url": "https://github.com/octokit/octokit.rb/blob/master/README.md",
  "download_url": "https://raw.githubusercontent.com/octokit/octokit.rb/master/README.md",
  "_links": {
    "git": "https://api.github.com/repos/octokit/octokit.rb/git/blobs/3d21ec53a331a6f037a91c368710b99387d012c1",
    "self": "https://api.github.com/repos/octokit/octokit.rb/contents/README.md",
    "html": "https://github.com/octokit/octokit.rb/blob/master/README.md"
  }
}
        """
        Ok(json)
      case GET -> Root / "repos" / _ / _ / "contents" / "directory" =>
        val json = json"""
        [
  {
    "type": "file",
    "size": 625,
    "name": "octokit.rb",
    "path": "lib/octokit.rb",
    "sha": "fff6fe3a23bf1c8ea0692b4a883af99bee26fd3b",
    "url": "https://api.github.com/repos/octokit/octokit.rb/contents/lib/octokit.rb",
    "git_url": "https://api.github.com/repos/octokit/octokit.rb/git/blobs/fff6fe3a23bf1c8ea0692b4a883af99bee26fd3b",
    "html_url": "https://github.com/octokit/octokit.rb/blob/master/lib/octokit.rb",
    "download_url": "https://raw.githubusercontent.com/octokit/octokit.rb/master/lib/octokit.rb",
    "_links": {
      "self": "https://api.github.com/repos/octokit/octokit.rb/contents/lib/octokit.rb",
      "git": "https://api.github.com/repos/octokit/octokit.rb/git/blobs/fff6fe3a23bf1c8ea0692b4a883af99bee26fd3b",
      "html": "https://github.com/octokit/octokit.rb/blob/master/lib/octokit.rb"
    }
  },
  {
    "type": "dir",
    "size": 0,
    "name": "octokit",
    "path": "lib/octokit",
    "sha": "a84d88e7554fc1fa21bcbc4efae3c782a70d2b9d",
    "url": "https://api.github.com/repos/octokit/octokit.rb/contents/lib/octokit",
    "git_url": "https://api.github.com/repos/octokit/octokit.rb/git/trees/a84d88e7554fc1fa21bcbc4efae3c782a70d2b9d",
    "html_url": "https://github.com/octokit/octokit.rb/tree/master/lib/octokit",
    "download_url": null,
    "_links": {
      "self": "https://api.github.com/repos/octokit/octokit.rb/contents/lib/octokit",
      "git": "https://api.github.com/repos/octokit/octokit.rb/git/trees/a84d88e7554fc1fa21bcbc4efae3c782a70d2b9d",
      "html": "https://github.com/octokit/octokit.rb/tree/master/lib/octokit"
    }
  }
]
        """
        Ok(json)
    }
    "get content correct if given a file" in {
      Content.contentsFor[IO]("foo", "bar", "file", None, None)
        .run(Client.fromHttpApp(getContent.orNotFound))
        .attempt
        .map{_ must beRight}
    }
    "get contents correct if given a directory" in {
      Content.contentsFor[IO]("foo", "bar", "directory", None, None)
        .run(Client.fromHttpApp(getContent.orNotFound))
        .attempt
        .map{_ must beRight}
    }
  }
} 

package io.chrisdavenport.github.endpoints

import cats.effect._
import cats.effect.testing.specs2.CatsEffect

import io.chrisdavenport.github.OAuth
import io.chrisdavenport.github.data.Teams._
import io.chrisdavenport.github.endpoints.organizations.Teams.{addOrUpdateTeamRepo}

import org.http4s._
import org.http4s.client._
import org.http4s.dsl.io._
import org.http4s.implicits._

import org.specs2.mutable.Specification

class TeamsSpec extends Specification with CatsEffect {

  "Teams.addOrUpdateRepo" should {
    "return right on the expected json" in {
      val client = Client.fromHttpApp(
        HttpRoutes.of[IO]{
          case PUT -> Root / "teams" / _ / "repos" / _ / _ =>
            NoContent()
        }.orNotFound
      )
      addOrUpdateTeamRepo[IO](3, "foo", "bar", Permission.Admin, OAuth("asdfa"))
        .run(client)
        .attempt
        .map(_ must beRight)
    }
  }
} 

package io.chrisdavenport.github.endpoints

import cats.effect._
import cats.effect.testing.specs2.CatsEffect

import io.chrisdavenport.github.data.Sort
import io.chrisdavenport.github.endpoints.utils.PaginatedJsonFiles
import io.chrisdavenport.github.internals.RequestConstructor.GithubError

import org.http4s._
import org.http4s.client._
import org.http4s.dsl.io._
import org.http4s.implicits._

import org.specs2.mutable.Specification

class SearchUsersSpec extends Specification with CatsEffect with PaginatedJsonFiles {

  override def baseUri: Uri = uri"https://api.github.com/search/users?q=scala&sort=repositories"

  override def pageFileName: Int => String = page => s"search/users/q_scala_sort_repositories_page_$page.json"

  override def extractRequest: PartialFunction[Request[IO], Request[IO]] = {
    case request @ GET -> Root / "search" / "users" => request
  }

  "Search.users" should {

    "be able to fetch multiple pages" in {
      Search.users[IO]("scala", Some(Sort.Repositories), None, None)
        .run(Client.fromHttpApp(paginatedEndpoint(numPages = 3)))
        .take(3)
        .compile
        .toList
        .map { searchResults =>
          searchResults.size mustEqual (3)
          searchResults.head.totalCount mustEqual (3343)
          searchResults.head.incompleteResults mustEqual (false)
          searchResults.head.items.size mustEqual (30)
          searchResults.head.items.head.login mustEqual ("DefinitelyScala")
          searchResults.head.items.last.login mustEqual ("ashwanthkumar")
          searchResults(1).items.size mustEqual (30)
          searchResults(1).items.head.login mustEqual ("kitlangton")
          searchResults(1).items.last.login mustEqual ("Andrea")
          searchResults(2).items.size mustEqual (30)
          searchResults(2).items.head.login mustEqual ("ryan-williams")
          searchResults(2).items.last.login mustEqual ("heguangwu")
        }
    }

    "fail when not being able to fetch a page" in {
      Search.users[IO]("scala", Some(Sort.Repositories), None, None)
        .run(Client.fromHttpApp(paginatedEndpoint(numPages = 4)))
        .compile
        .toList
        .attempt
        .map {
          _ must beLeft(new GithubError(NotFound, "Page does not exist: 4"))
        }
    }

  }


} 

package io.chrisdavenport.github.endpoints.miscellaneous

import cats.effect._
import cats.effect.testing.specs2.CatsEffect

import io.circe.literal._

import org.http4s._
import org.http4s.client._
import org.http4s.circe._
import org.http4s.dsl.io._
import org.http4s.implicits._

import org.specs2.mutable.Specification

class RateLimitSpec extends Specification with CatsEffect {

  "RateLimit" should {

    "return a valid rate-limit response" in {
      RateLimit.rateLimit[IO](None)
        .run(Client.fromHttpApp(rateLimit.orNotFound))
        .attempt
        .map(_ must beRight)
    }

  }

  val rateLimit : HttpRoutes[IO] = HttpRoutes.of {
    case GET -> Root / "rate_limit" =>
      Ok(
        json"""
        {
          "resources": {
            "core": {
              "limit": 5000,
              "remaining": 4999,
              "reset": 1372700873
            },
            "search": {
              "limit": 30,
              "remaining": 18,
              "reset": 1372697452
            },
            "graphql": {
              "limit": 5000,
              "remaining": 4993,
              "reset": 1372700389
            },
            "integration_manifest": {
              "limit": 5000,
              "remaining": 4999,
              "reset": 1551806725
            }
          },
          "rate": {
            "limit": 5000,
            "remaining": 4999,
            "reset": 1372700873
          }
        }
      """
      )
  }

} 

package io.chrisdavenport.github.endpoints

import cats.effect._
import cats.effect.testing.specs2.CatsEffect

import io.chrisdavenport.github.data.Sort.Stars
import io.chrisdavenport.github.endpoints.utils.PaginatedJsonFiles
import io.chrisdavenport.github.internals.RequestConstructor.GithubError

import org.http4s._
import org.http4s.client._
import org.http4s.dsl.io._
import org.http4s.implicits._

import org.specs2.mutable.Specification

class SearchRepositorySpec extends Specification with CatsEffect with PaginatedJsonFiles {

  override def baseUri: Uri = uri"https://api.github.com/search/repositories?q=scala&sort=stars"

  override def pageFileName: Int => String = page => s"search/repositories/q_scala_sort_stars_page_$page.json"

  override def extractRequest: PartialFunction[Request[IO], Request[IO]] = {
    case request @ GET -> Root / "search" / "repositories" => request
  }

  "Search.repository" should {

    "be able to fetch multiple pages" in {
      Search.repository[IO]("scala", Some(Stars), None, None)
        .run(Client.fromHttpApp(paginatedEndpoint(numPages = 3)))
        .compile
        .toList
        .map { searchResults =>
          searchResults.size mustEqual (3)
          searchResults.head.totalCount mustEqual (82020)
          searchResults.head.incompleteResults mustEqual (false)
          searchResults.head.items.size mustEqual (30)
          searchResults.head.items.head.name mustEqual ("spark")
          searchResults.head.items.last.name mustEqual ("scala_school")
          searchResults(1).items.size mustEqual (30)
          searchResults(1).items.head.name mustEqual ("TensorFlowOnSpark")
          searchResults(1).items.last.name mustEqual ("spark-cassandra-connector")
          searchResults(2).items.size mustEqual (30)
          searchResults(2).items.head.name mustEqual ("sangria")
          searchResults(2).items.last.name mustEqual ("json4s")
        }
    }

    "fail when not being able to fetch a page" in {
      Search.repository[IO]("scala", Some(Stars), None, None)
        .run(Client.fromHttpApp(paginatedEndpoint(numPages = 4)))
        .compile
        .toList
        .attempt
        .map {
          _ must beLeft(new GithubError(NotFound, "Page does not exist: 4"))
        }
    }

  }


} 

package com.danielasfregola.twitter4s.entities

import java.time.Instant

import com.danielasfregola.randomdatagenerator.RandomDataGenerator
import com.danielasfregola.twitter4s.http.serializers.JsonSupport
import org.json4s.native.Serialization
import org.scalacheck.Gen.alphaChar
import org.scalacheck.{Arbitrary, Gen}
import org.specs2.mutable.Specification
import org.specs2.specification.core.Fragment

import scala.reflect._

class SerializationRoundtripSpec extends Specification with RandomDataGenerator with JsonSupport {

  "JSON serialization" should {

    def roundtripTest[T <: AnyRef: Manifest: Arbitrary]: Fragment = {

      val className = classTag[T].runtimeClass.getSimpleName

      s"round-trip successfully for $className" in {
        val randomEntity = random[T]

        val serializedJson = Serialization.write[T](randomEntity)

        val deserializedEntity = Serialization.read[T](serializedJson)

        deserializedEntity === randomEntity
      }
    }

    roundtripTest[User]
  }

  // We serialize dates to second precision
  implicit val arbitraryDate: Arbitrary[Instant] = Arbitrary {
    for {
      timeInSeconds: Long <- Gen.chooseNum(1142899200L, 1512442349L)
    } yield Instant.ofEpochSecond(timeInSeconds)
  }

  implicit val arbitraryProfileImage: Arbitrary[ProfileImage] = Arbitrary {
    for {
      prefix: String <- Gen.nonEmptyListOf(alphaChar).map(_.mkString)
      suffix: String <- Gen.oneOf("_mini", "_normal", "_bigger", "")
    } yield ProfileImage(s"${prefix}_$suffix.jpg")
  }
} 

package com.danielasfregola.twitter4s.entities

import com.danielasfregola.twitter4s.helpers.{FixturesSupport, JsonDiffSupport}
import org.json4s.native.Serialization.writePretty
import org.json4s.native.{JsonParser, Serialization}
import org.json4s.{JNothing, JValue}
import org.specs2.matcher.{Expectable, Matcher}
import org.specs2.mutable.Specification
import org.specs2.specification.core.Fragment

import scala.reflect._

class DeserializationRoundtripSpec extends Specification with FixturesSupport with JsonDiffSupport {

  "JSON deserialization" should {

    def roundtripTest[T <: AnyRef: Manifest](jsonFile: String): Fragment = {

      val className = classTag[T].runtimeClass.getSimpleName

      s"round-trip successfully for $className in $jsonFile" in {
        val originalJson = load(jsonFile)

        val deserializedEntity = Serialization.read[T](originalJson)

        val serializedJson = Serialization.writePretty[T](deserializedEntity)

        originalJson must beASubsetOfJson(serializedJson)
      }
    }

    roundtripTest[User]("/twitter/rest/users/user.json")
  }

  def beASubsetOfJson(otherJson: String): Matcher[String] = new Matcher[String] {

    def apply[S <: String](t: Expectable[S]) = {
      val alpha: JValue = JsonParser.parse(t.value)
      val beta: JValue = JsonParser.parse(otherJson)

      jsonDiff(alpha, beta) match {
        case diff @ JsonDiff(JNothing, _, JNothing) =>
          success(s"""${t.value}
               |is a subset of
               |$otherJson
               |${renderDiff(diff)}
             """.stripMargin,
                  t)
        case diff =>
          failure(s"""${t.value}
               |is not a subset of
               |$otherJson
               |${renderDiff(diff)}
             """.stripMargin,
                  t)
      }
    }

    private def renderDiff(diff: JsonDiff) = {
      val changed = diff.changed.toOption.map { c =>
        s"""Changed:
           |${writePretty(c)}
          """.stripMargin
      }
      val deleted = diff.deleted.toOption.map { d =>
        s"""Deleted:
           |${writePretty(d)}
          """.stripMargin
      }
      val added = diff.added.toOption.map { a =>
        s"""Added:
           |${writePretty(a)}
          """.stripMargin
      }

      (changed ++ deleted ++ added).mkString
    }
  }
} 

package com.danielasfregola.twitter4s.http

import org.specs2.mutable.Specification

class packageHttpSpec extends Specification {

  "Rich String" should {

    "convert a text to ascii encoding" in {
      "Ladies + Gentlemen".urlEncoded === "Ladies%20%2B%20Gentlemen"
      "An encoded string!".urlEncoded === "An%20encoded%20string%21"
      "Dogs, Cats & Mice".urlEncoded === "Dogs%2C%20Cats%20%26%20Mice"
      "☃".urlEncoded === "%E2%98%83"
    }
  }
} 

package com.danielasfregola.twitter4s.util

import org.specs2.mutable.Specification

class EncoderSpec extends Specification with Encoder {

  "HmacSha1 Encoder" should {

    "encode a base and secret as expected" in {
      val base = "POST&" +
        "https%3A%2F%2Fapi.twitter.com%2F1%2Fstatuses%2Fupdate.json&" +
        "include_entities%3Dtrue%26" +
        "oauth_consumer_key%3Dxvz1evFS4wEEPTGEFPHBog%26" +
        "oauth_nonce%3DkYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg%26" +
        "oauth_signature_method%3DHMAC-SHA1%26" +
        "oauth_timestamp%3D1318622958%26" +
        "oauth_token%3D370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb%26" +
        "oauth_version%3D1.0%26" +
        "status%3DHello%2520Ladies%2520%252B%2520Gentlemen%252C%2520a%2520signed%2520OAuth%2520request%2521"
      val secret = "kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw&LswwdoUaIvS8ltyTt5jkRh4J50vUPVVHtR2YPi5kE"
      toHmacSha1(base, secret) === "tnnArxj06cWHq44gCs1OSKk/jLY="
    }

    "encode a base and secret as expected with callback" in {
      val base = "POST&" +
        "https%3A%2F%2Fapi.twitter.com%2Foauth%2Frequest_token&" +
        "oauth_callback%3Dhttp%253A%252F%252Flocalhost%252Fsign-in-with-twitter%252F%26" +
        "oauth_consumer_key%3DcChZNFj6T5R0TigYB9yd1w%26" +
        "oauth_nonce%3Dea9ec8429b68d6b77cd5600adbbb0456%26" +
        "oauth_signature_method%3DHMAC-SHA1%26" +
        "oauth_timestamp%3D1318467427%26" +
        "oauth_version%3D1.0"
      val secret = "L8qq9PZyRg6ieKGEKhZolGC0vJWLw8iEJ88DRdyOg&"
      toHmacSha1(base, secret) === "F1Li3tvehgcraF8DMJ7OyxO4w9Y="
    }
  }
} 

package com.danielasfregola.twitter4s.util

import akka.http.scaladsl.model.Uri
import org.specs2.mutable.Specification

class UriHelpersSpec extends Specification with UriHelpers {

  "UriHelpers" should {

    "extract an endpoint representation" in {

      "from a uri" in {
        val uri = Uri("https://api.twitter.com/1.1/lists/members/create.json?param1=8044403&param2=daniela")
        uri.endpoint === "https://api.twitter.com/1.1/lists/members/create.json"
      }

      "from a uri with explicit port" in {
        val uri = Uri("http://example.com:8080/path?p=test")
        uri.endpoint === "http://example.com:8080/path"
      }
    }
  }
} 

package com.danielasfregola.twitter4s.util

import com.typesafe.config.{Config, ConfigException}
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import org.specs2.specification.Scope

class ConfigurationDetectorSpec extends Specification with Mockito {

  val myConfigFromEnvVar = "my-configuration-from-env-var"
  val myConfigFromFile = "my-configuration-from-file"

  abstract class ConfigurationDetectorSpecContext extends Scope {
    def config = mock[Config]

    val variableName = "MY-CONFIG"
    val configName = "my.config"
  }

  trait NoEnvVariable extends ConfigurationDetector {
    override protected def environmentVariable(name: String) = None
  }

  trait WithEnvVariable extends ConfigurationDetector {
    override protected def environmentVariable(name: String) = Some(myConfigFromEnvVar)
  }

  trait NoConfigFromFile extends ConfigurationDetector {
    override protected def configuration(path: String) = throw new ConfigException.Missing(path)
  }

  trait WithConfigFromFile extends ConfigurationDetector {
    override protected def configuration(path: String) = myConfigFromFile
  }

  "ConfigurationDetector" should {

    "if environment variable exists" in {

      "if configuration from file does not exists" in {
        "detect the configuration from the environment variable" in
          new ConfigurationDetectorSpecContext with WithEnvVariable with NoConfigFromFile {
            envVarOrConfig(variableName, configName) === myConfigFromEnvVar
          }
      }

      "if configuration from file exists" in {
        "detect the configuration from the environment variable" in
          new ConfigurationDetectorSpecContext with WithEnvVariable with WithConfigFromFile {
            envVarOrConfig(variableName, configName) === myConfigFromEnvVar
          }
      }
    }

    "if environment variable does not exist" in {

      "if configuration from file exists" in {
        "detect the configuration from the configuration file" in
          new ConfigurationDetectorSpecContext with NoEnvVariable with WithConfigFromFile {
            envVarOrConfig(variableName, configName) === myConfigFromFile
          }
      }

      "if configuration from file does not exist" in {
        "throw an exception" in
          new ConfigurationDetectorSpecContext with NoEnvVariable with NoConfigFromFile {
            envVarOrConfig(variableName, configName) must throwA[RuntimeException]
          }
      }
    }
  }
} 

package com.jcranky.scalando.cap12

import com.jcranky.scalando.cap11.{Foto, XMLParser}
import org.specs2.mutable.Specification

class XMLSpec extends Specification {
  "the xml parser" should {
    "turn the xml into the model class" in {
      val fotosXml =
        <rsp stat="ok">
          <photos>
            <photo id="123" owner="jcranky" server="6" title="jcranky test"></photo>
          </photos>
        </rsp>

      new XMLParser().parse(fotosXml.toString()) must_== Seq(
        Foto(123, "jcranky", 6, "jcranky test"))
    }
  }
} 

package com.jcranky.flickr

import org.specs2.mutable.Specification

class ResponseParserSpec extends Specification {
  "ResponseParser.flickrBoolean" should {
    "return true for 1" in {
      ResponseParser.flickrBoolean("1") ==== true
    }

    "return false for 0" in {
      ResponseParser.flickrBoolean("0") ==== false
    }

    "return false for 3" in {
      ResponseParser.flickrBoolean("3") ==== false
    }
  }
} 

package com.jcranky.flickr

import com.jcranky.flickr.HttpClient.{GetError, GetResponse}
import org.specs2.mutable.Specification


class HttpClientSpec extends Specification {
  "the http client" should {
    "respond with a body" in {
      new HttpClient().get("https://httpbin.org/get") must beRight[GetResponse]
    }

    "respond with an error" in {
      new HttpClient().get("bla-bla") must beLeft[GetError]
    }
  }
} 

package com.jcranky.flickr

import com.jcranky.flickr.model.Foto
import com.typesafe.config.ConfigFactory
import org.specs2.mutable.Specification

import scala.io.Source

class XmlFlickrParserSpec extends Specification {
  val config = ConfigFactory.load("test/resources/app-test.conf")

  "the response parser" should {
    "get a list of photos" in {
      val parsed = parseFrom("src/test/resources/flickr/responses/photos-list.xml")

      parsed should beRight.like { case res =>
        res should containTheSameElementsAs (List(
          Foto("29195658220", "28437914@N03", "cfe85ac898", "8457", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195655410", "28437914@N03", "c4e6935947", "8353", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195651850", "28437914@N03", "51449e97fc", "8845", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195648660", "28437914@N03", "2529785ac8", "8537", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("28862292093", "28437914@N03", "0097cc7e69", "8521", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195634910", "28437914@N03", "a4959f2252", "8009", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195632880", "28437914@N03", "ac48c82796", "8289", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195630990", "28437914@N03", "e8077623c9", "8300", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195629640", "28437914@N03", "0b5dcba3b7", "7536", 8, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195627610", "28437914@N03", "cbd39378ef", "7561", 8, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195624830", "28437914@N03", "2e4182f583", "8283", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("28862264913", "28437914@N03", "20b5061be3", "8830", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("28862261533", "28437914@N03", "b847eb1e9f", "8426", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("28862258423", "28437914@N03", "342002b429", "8438", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195617710", "28437914@N03", "30857f493b", "7461", 8, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195614540", "28437914@N03", "08b335036e", "8537", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195611040", "28437914@N03", "173b37d510", "8371", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195605970", "28437914@N03", "9607915a90", "8538", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false),
          Foto("29195600910", "28437914@N03", "7c21f55703", "8197", 9, "MITO_SettembreMusica2016_Inaugurazione_Milano_high", true, false, false)
        ))
      }
    }

    "parse the error response" in {
      val parsed = parseFrom("src/test/resources/flickr/responses/error.xml")
      parsed should beLeft(FlickrKnownError(100, "Invalid API Key (Key has invalid format)"))
    }

    "return unknown error for invalid file" in {
      val parsed = parseFrom("src/test/resources/flickr/responses/unknown.xml")
      parsed should beLeft(FlickrUnknownError(ResponseParser.unknownFlickrResp))
    }

    "return unknown error for rsp without err" in {
      val parsed = parseFrom("src/test/resources/flickr/responses/empty-error.xml")
      parsed should beLeft(FlickrUnknownError(ResponseParser.errNotFound))
    }
  }

  def parseFrom(file: String): Either[FlickrError, Seq[Foto]] = {
    val parser = new XmlFlickrParser()
    val response = Source.fromFile(file).getLines().mkString("\n")

    parser.parse(response)
  }
} 

package com.jcranky.flickr

import com.jcranky.flickr.FlickrClient.ClientError
import com.jcranky.flickr.HttpClient.{GetError, GetResponse}
import com.jcranky.flickr.model.Foto
import com.typesafe.config.{ConfigException, ConfigFactory}
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification

class FlickrClientSpec extends Specification with Mockito {
  "FlickrClient.fromConfig" should {
    "work with valid configuration" in {
      val client = FlickrClient.fromConfig(ConfigFactory.load("app-test.conf"))
      client !=== null
    }

    "fail if some configuration is missing" in {
      FlickrClient.fromConfig(ConfigFactory.load("acre.conf")) should throwAn[ConfigException]
    }
  }

  "FlickrClient.buscaFotos" should {
    "ask the httpclient for the photos and pass the response to the response parser" in {
      val fotos = List(Foto("1", "jcranky", "123", "321", 1, "my pic", true, false, false))
      val resp = buscaFotos(
        Right(GetResponse(200, "fotos-xml-here")),
        Right(fotos)
      )

      resp should beRight(fotos)
    }

    "return a client error if the parser returns a FlickrError" in {
      val error = FlickrKnownError(100, "Invalid API Key (Key has invalid format)")
      val resp = buscaFotos(
        Right(GetResponse(200, "error-xml-here")),
        Left(error)
      )

      resp should beLeft(ClientError(error.toString))
    }
  }

  
  def buscaFotos(httpResp: Either[GetError, GetResponse], parsed: Either[FlickrError, Seq[Foto]]): Either[ClientError, Seq[Foto]] = {
    val httpClient = mock[HttpClient]
    val parser = mock[ResponseParser]

    httpClient.get(any[String]) returns httpResp
    parser.parse(any[String]) returns parsed

    val client = new FlickrClient("api-key", "base-url", httpClient, parser)
    val resp = client.buscaFotos(List("scala"))

    there was one(httpClient).get(anyString)

    resp
  }
} 

package com.github.kikuomax.spray.jwt

import com.nimbusds.jose.{
  JWSAlgorithm,
  JWSObject
}
import com.nimbusds.jwt.JWTClaimsSet
import java.util.Calendar
import org.specs2.mutable.Specification
import scala.concurrent.{
  ExecutionContext,
  Future
}
import scala.concurrent.duration.{
  Duration,
  SECONDS
}
import spray.routing.HttpService
import spray.routing.authentication.UserPass
import spray.testkit.Specs2RouteTest
import JwtClaimBuilder.claimExpiration


class JwtDirectivesSpec
  extends Specification with Specs2RouteTest with HttpService with JwtDirectives
{
  // uses the one provided by spray.testkit
  override def actorRefFactory = system

  // implicit execution context
  implicit val executionContext = system.dispatcher

  // creates signer and verifier
  val signature = JwtSignature(JWSAlgorithm.HS256, "thisHasGotToBeAtleast32BitsLong.")

  // claims set builder that builds a claims set valid for one second
  val oneSecondBuilder: String => Option[JWTClaimsSet] =
    claimExpiration(Duration(1, SECONDS))

  // route that builds a claims set valid for one second
  val oneSecondRoute =
    get {
      def authenticator = jwtAuthenticator(up => Future { up.map(_.user) })(
        oneSecondBuilder, signature.jwtSigner, executionContext)
      def authentication = authenticator(Some(UserPass("user", "pass"))).map {
        u => Right(u.get)
      }
      authenticate(authentication) { jws =>
        complete(jws.serialize())
      }
    }

  "One second claims set builder" should {
    "build claims set valid for one second" in {
      val now = Calendar.getInstance()
      val expireBefore = now.clone().asInstanceOf[Calendar]
      expireBefore.add(Calendar.SECOND, 2)  // in 2 seconds
      Get() ~> oneSecondRoute ~> check {
        val jws = JWSObject.parse(responseAs[String])
        val claims = JWTClaimsSet.parse(jws.getPayload().toJSONObject())
        // expects claims set
        // should expire after now but in 2 seconds from `now`
        claims.getExpirationTime().after(now.getTime()) must beTrue
        claims.getExpirationTime().before(expireBefore.getTime()) must beTrue
      }
    }
  }
} 

package com.github.dtaniwaki.akka_pusher

import akka.http.scaladsl.model.Uri
import org.specs2.mutable.Specification
import org.specs2.specification.process.RandomSequentialExecution

class UtilsSpec extends Specification
    with SpecHelper
    with RandomSequentialExecution {
  "#byteArrayToString" should {
    "convert a byte array to a string" in {
      Utils.byteArrayToString(Array[Byte](10, 11, 12)) === "000000000000000000000000000a0b0c"
    }
  }
  "#md5" should {
    "generate hex digest md5" in {
      Utils.md5("foo") === "acbd18db4cc2f85cedef654fccc4a4d8"
    }
  }
  "#sha256" should {
    "generate hex digest sha256" in {
      Utils.sha256("secret", "foo") === "773ba44693c7553d6ee20f61ea5d2757a9a4f4a44d2841ae4e95b52e4cd62db4"
    }
    "generate hex digest sha256 of strings with 日本語" in {
      Utils.sha256("secret", "Digest me 日本語") === "b52446253d26c4bd19c1200e310ddc8ff3678f3422b2df6c47b153209cadec0b"
      // echo -n "Digest me 日本語" | openssl dgst -sha256 -hmac "secret"
    }
  }
  "#normalizeQuery" should {
    "make the key lower case" in {
      Utils.normalizeQuery(Uri.Query(Map("abc" -> "abc", "CDE" -> "CDE"))).toString === "abc=abc&cde=CDE"
    }
    "make the order alphabetical" in {
      Utils.normalizeQuery(Uri.Query(Map("cde" -> "cde", "abc" -> "abc"))).toString === "abc=abc&cde=cde"
    }
  }
} 

package com.github.dtaniwaki.akka_pusher

import com.github.dtaniwaki.akka_pusher.PusherMessages._
import com.github.dtaniwaki.akka_pusher.attributes.{ PusherChannelsAttributes, PusherChannelAttributes }
import org.specs2.mutable.Specification
import org.specs2.specification.process.RandomSequentialExecution
import spray.json._

class PusherMessagesSpec extends Specification
    with SpecHelper
    with RandomSequentialExecution
    with PusherJsonSupport {

  "ChannelMessage" in {
    "#apply" should {
      "(deprecated) convert the argument type" in {
        ChannelMessage("channel", Some(Seq("user_count"))) === ChannelMessage("channel", Seq(PusherChannelAttributes.userCount))
      }
    }
  }
  "ChannelsMessage" in {
    "#apply" should {
      "(deprecated) convert the argument type" in {
        ChannelsMessage("channel", Some(Seq("user_count"))) === ChannelsMessage("channel", Seq(PusherChannelsAttributes.userCount))
      }
    }
  }
} 

package com.protectwise.cql

import org.specs2.mutable.{After, Specification}

class CQLHelperSpec extends Specification {

  "CQLHelper" should {

    "provide a stringcontext to compose CQL statements" in {
      cql"foo" must beAnInstanceOf[CQLStatement]
    }

    "provide parameter binding" in {
      val bar=1
      val c = cql"foo $bar"
      c.cqlParts mustEqual Seq("foo ", "")
      c.rawParams mustEqual Seq(bar)
    }

    "handle the In() operator" in {
      val c = cql"foo ${In(Seq(1,2))} bar"
      c.cql mustEqual "foo ?,? bar"
      c.parameters mustEqual Seq(1,2)
      c.debugString(null) mustEqual "foo 1,2 bar;"
    }

    "handle the In() operator with just one value" in {
      val c = cql"foo ${In(Seq(1))} bar"
      c.cql mustEqual "foo ? bar"
      c.parameters mustEqual Seq(1)
    }

    "handle an empty In() operator" in {
      val c = cql"foo ${In(Seq())} bar"
      c.cql mustEqual "foo  bar"
      c.parameters mustEqual Seq()
    }

    "accept an Inline() text" in {
      val c = cql"foo ${Inline("x")} bar"
      c.cql mustEqual "foo x bar"
      c.parameters mustEqual Seq()
    }

    "handle a NoArg" in {
      val c = cql"foo $NoArg bar"
      c.cql mustEqual "foo  bar"
      c.parameters mustEqual Seq()
    }

    "handle .withValues on an In() operator" in {
      val a = cql"a ${} b ${} c ${} d"
      val b = a.withValues(1, In(Seq(2,3,4)), 5)
      b.cql mustEqual "a ? b ?,?,? c ? d"
      b.parameters mustEqual(Seq(1,2,3,4,5))
    }

  }

} 

package com.qvantel.jsonapi.model

import org.specs2.mutable.Specification

import spray.json._

class LinkSpec extends Specification {
  "handle / in id correctly" >> {
    val url = "/api/foo%2Fbar/rel"
    val url1 =
      s"""
         |"$url"
      """.stripMargin.parseJson

    val url2 =
      s"""
         |{
         |  "href": "$url"
         |}
      """.stripMargin.parseJson

    url1 must be equalTo url1.convertTo[Link].toJson
    url2 must be equalTo url2.convertTo[Link].toJson

    url1.convertTo[Link].href.toString(Link.uriConfig) must be equalTo url
    url2.convertTo[Link].href.toString(Link.uriConfig) must be equalTo url
  }

  "handle : in id correctly" >> {
    val url = "/api/foo%3Abar/rel"
    val url1 =
      s"""
         |"$url"
      """.stripMargin.parseJson

    val url2 =
      s"""
         |{
         |  "href": "$url"
         |}
      """.stripMargin.parseJson

    url1 must be equalTo url1.convertTo[Link].toJson
    url2 must be equalTo url2.convertTo[Link].toJson

    url1.convertTo[Link].href.toString(Link.uriConfig) must be equalTo url
    url2.convertTo[Link].href.toString(Link.uriConfig) must be equalTo url
  }
} 

package com.qvantel.jsonapi.spray

import org.specs2.mutable.Specification
import _root_.spray.http.StatusCodes._
import _root_.spray.http.{ContentType, MediaTypes}
import _root_.spray.json.DefaultJsonProtocol._
import _root_.spray.json.lenses.JsonLenses._
import _root_.spray.json.{JsArray, JsonParser}
import _root_.spray.routing.Directives
import _root_.spray.testkit.Specs2RouteTest

class SprayExceptionHandlerSpec extends Specification with Directives with Specs2RouteTest {
  class TestSprayExceptionHandler extends SprayExceptionHandler

  val testSprayExceptionHandler = new TestSprayExceptionHandler
  private[this] val wrap        = handleExceptions(testSprayExceptionHandler.defaultSprayExceptionHandler)
  val JSON                      = ContentType(MediaTypes.`application/vnd.api+json`, None)

  "The spray ExceptionHandler" should {
    "Respond with InternalServerError and specified error message" in {
      Get() ~> wrap {
        failWith(new Exception("Specified error message"))
      } ~> check {
        status must_== InternalServerError
        contentType must_== JSON

        val json  = JsonParser(body.asString)
        val error = json.extract[JsArray]('errors).elements.headOption
        error.map(_.extract[String]('detail)) must beSome("Specified error message")
      }
    }

    "Respond with InternalServerError and default error message" in {
      Get() ~> wrap {
        failWith(new Exception)
      } ~> check {
        status must_== InternalServerError
        contentType must_== JSON

        val json  = JsonParser(body.asString)
        val error = json.extract[JsArray]('errors).elements.headOption
        error.map(_.extract[String]('detail)) must beSome(InternalServerError.defaultMessage)
      }
    }

    "None should return 404 with proper jsonapi.org error object" in {
      Get() ~> wrap {
        val x: Option[String] = None

        SprayExceptionHandler.noneHandler {
          complete(x)
        }
      } ~> check {
        status must_== NotFound
        contentType must_== JSON

        val json  = JsonParser(body.asString)
        val error = json.extract[JsArray]('errors).elements.headOption
        error.map(_.extract[String]('detail)) must beSome(NotFound.defaultMessage)
        error.map(_.extract[String]('title)) must beSome(NotFound.reason)
      }
    }
  }
} 

package com.qvantel.jsonapi

import org.specs2.ScalaCheck
import org.specs2.mutable.Specification
import spray.json.{JsArray, JsNull, JsObject}
import _root_.spray.json._
import _root_.spray.json.DefaultJsonProtocol._

class RelatedResponseSpec extends Specification with ScalaCheck {
  implicit val apiRoot: com.qvantel.jsonapi.ApiRoot = ApiRoot(None)

  @jsonApiResource final case class Test(id: String, name: String, age: Int)
  @jsonApiResource final case class Test2(id: String, name: String, age: Int)

  val test: Option[Test]      = Some(Test("teståöä•Ωé®", "someName", 20)) // test UTF-8
  val emptyTest: Option[Test] = None
  val tests: List[Test]       = List(Test("test 1", "someName1", 20), Test("test 2", "someName2", 21))
  val emptyTests: List[Test]  = List.empty

  def transformToTest2(in: Test): Test2 = Test2(in.id + "-2", in.name, in.age)

  "correctly write to one none case" in {
    RelatedResponse(emptyTest).toResponse must be equalTo JsObject(
      "data" -> JsNull
    )

    RelatedResponse(emptyTest).map(transformToTest2).toResponse must be equalTo JsObject(
      "data" -> JsNull
    )
  }

  "correctly write to one some case" in {
    val answer = rawOne(test.get)

    RelatedResponse(test).toResponse must be equalTo answer
    RelatedResponse(test.get).toResponse must be equalTo answer

    val transformedAnswer = rawOne(transformToTest2(test.get))
    RelatedResponse(test).map(transformToTest2).toResponse must be equalTo transformedAnswer
    RelatedResponse(test.get).map(transformToTest2).toResponse must be equalTo transformedAnswer
  }

  "correctly write to many empty case" in {
    RelatedResponse(emptyTests).toResponse must be equalTo JsObject(
      "data" -> JsArray.empty
    )

    RelatedResponse(emptyTests).map(transformToTest2).toResponse must be equalTo JsObject(
      "data" -> JsArray.empty
    )
  }

  "correctly write to many non-empty case" in {
    val answer = rawCollection(tests)

    RelatedResponse(tests).toResponse must be equalTo answer
    RelatedResponse(tests.toSeq).toResponse must be equalTo answer
    RelatedResponse(tests.toIterable).toResponse must be equalTo answer
    RelatedResponse(tests.toSet).toResponse must be equalTo answer

    val transformedAnswer = rawCollection(tests.map(transformToTest2))

    RelatedResponse(tests).map(transformToTest2).toResponse must be equalTo transformedAnswer
    RelatedResponse(tests.toSeq).map(transformToTest2).toResponse must be equalTo transformedAnswer
    RelatedResponse(tests.toIterable).map(transformToTest2).toResponse must be equalTo transformedAnswer
    RelatedResponse(tests.toSet).map(transformToTest2).toResponse must be equalTo transformedAnswer
  }

  "correctly write sparse fieldsets" in {
    implicit val sparseFields: Map[String, List[String]] = Map("tests" -> List("age"), "test2s" -> List("age"))
    val answer                                           = rawOne(test.get)

    RelatedResponse(test).toResponse must be equalTo answer
    RelatedResponse(test.get).toResponse must be equalTo answer

    val transformedAnswer = rawOne(transformToTest2(test.get))

    RelatedResponse(test).map(transformToTest2).toResponse must be equalTo transformedAnswer
    RelatedResponse(test.get).map(transformToTest2).toResponse must be equalTo transformedAnswer
  }
} 

package com.qvantel.jsonapi

import org.specs2.mutable.Specification
import _root_.spray.json._
import _root_.spray.json.DefaultJsonProtocol._

class WithoutIdSpec extends Specification {
  implicit val apiRoot: com.qvantel.jsonapi.ApiRoot = ApiRoot(None)

  @jsonApiResource("normal", "no-id") case class Test(name: String, child: ToOne[Child])
  @jsonApiResource case class Child(id: String, name: String, age: Int)

  "json api resource" should {
    "work without id" in {
      val c = Child("test-id", "test-name", 20)
      val t = Test("test", ToOne.loaded(c))

      val primaryJson =
        """
          |{
          |  "type": "tests",
          |  "attributes": {
          |    "name": "test"
          |  },
          |  "relationships": {
          |    "child": {
          |      "data": {
          |        "type": "children",
          |        "id": "test-id"
          |      }
          |    }
          |  }
          |}
        """.stripMargin.parseJson

      implicitly[JsonApiWriter[Test]].write(t) must be equalTo primaryJson
      implicitly[JsonApiWriter[Test]].included(t) must be equalTo Set(
        implicitly[JsonApiWriter[Child]].write(c).asJsObject)
    }

    "work without id and sparse fields" in {
      val c            = Child("test-id", "test-name", 20)
      val t            = Test("test", ToOne.loaded(c))
      val sparseFields = Map("tests" -> List("name"), "children" -> List("age"))

      val primaryJson =
        """
          |{
          |  "type": "tests",
          |  "attributes": {
          |    "name": "test"
          |  }
          |}
        """.stripMargin.parseJson

      implicitly[JsonApiWriter[Test]].write(t, sparseFields) must be equalTo primaryJson
      implicitly[JsonApiWriter[Test]].included(t, sparseFields) must be equalTo Set(
        implicitly[JsonApiWriter[Child]].write(c, sparseFields).asJsObject)
    }
  }
} 

package com.qvantel.jsonapi

import org.specs2.mutable.Specification
import com.netaporter.uri.dsl._
import _root_.spray.json.DefaultJsonProtocol._

class PathToSpec extends Specification {
  implicit val apiRoot = ApiRoot(Some("foo" / "bar"))

  @jsonApiResource final case class Test(id: String)

  "apiRoot should be printed to PathTo output" >> {
    val t = Test("1")

    PathTo[Test].entity(t) must be equalTo "foo/bar/tests/1"
    PathToId[Test].self("test") must be equalTo "foo/bar/tests/test"

    rawOne(t)
      .fields("data")
      .asJsObject
      .fields("links")
      .asJsObject
      .fields("self")
      .convertTo[String] must be equalTo "foo/bar/tests/1"
  }

  "root should print out apiRoot" >> {
    PathTo[Test].root must be equalTo "foo/bar/tests"
  }
} 

package highperfscala.orderbook

import highperfscala.orderbook.Commands.{AddLimitOrder, CancelOrder}
import highperfscala.orderbook.Events.{OrderCancelRejected, OrderCanceled}
import org.scalacheck.Prop
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

class ListOrderBookCancelingSpec extends Specification with ScalaCheck {

  """Given empty book
    |When cancel order arrives
    |Then OrderCancelRejected
  """.stripMargin ! Prop.forAll(
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (id, ci, ei) =>
    ListOrderBook.handle(
      () => ei, ListOrderBook.empty, CancelOrder(ci, id))._2 ====
      OrderCancelRejected(ei, id)
  }

  """Given empty book
    |and buy limit order added
    |When cancel order arrives
    |Then OrderCanceled
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (o, ci, ei) =>
    (ListOrderBook.handle(
      () => ei, _: ListOrderBook, AddLimitOrder(ci, o))).andThen {
      case (ob, _) => ListOrderBook.handle(
        () => ei, ob, CancelOrder(ci, o.id))._2
    }(ListOrderBook.empty) ==== OrderCanceled(ei, o.id)
  }

  """Given empty book
    |and sell limit order added
    |When cancel order arrives
    |Then OrderCanceled
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (o, ci, ei) =>
    (ListOrderBook.handle(
      () => ei, _: ListOrderBook, AddLimitOrder(ci, o))).andThen {
      case (ob, _) => ListOrderBook.handle(
        () => ei, ob, CancelOrder(ci, o.id))._2
    }(ListOrderBook.empty) ==== OrderCanceled(ei, o.id)
  }

} 

package highperfscala.orderbook

import highperfscala.orderbook.Commands.{AddLimitOrder, CancelOrder}
import highperfscala.orderbook.Events.{OrderCancelRejected, OrderCanceled}
import org.scalacheck.Prop
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

class QueueOrderBookCancelingSpec extends Specification with ScalaCheck {

  """Given empty book
    |When cancel order arrives
    |Then OrderCancelRejected
  """.stripMargin ! Prop.forAll(
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (id, ci, ei) =>
    QueueOrderBook.handle(
      () => ei, QueueOrderBook.empty, CancelOrder(ci, id))._2 ====
      OrderCancelRejected(ei, id)
  }

  """Given empty book
    |and buy limit order added
    |When cancel order arrives
    |Then OrderCanceled
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (o, ci, ei) =>
    (QueueOrderBook.handle(
      () => ei, _: QueueOrderBook, AddLimitOrder(ci, o))).andThen {
      case (ob, _) => QueueOrderBook.handle(
        () => ei, ob, CancelOrder(ci, o.id))._2
    }(QueueOrderBook.empty) ==== OrderCanceled(ei, o.id)
  }

  """Given empty book
    |and sell limit order added
    |When cancel order arrives
    |Then OrderCanceled
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (o, ci, ei) =>
    (QueueOrderBook.handle(
      () => ei, _: QueueOrderBook, AddLimitOrder(ci, o))).andThen {
      case (ob, _) => QueueOrderBook.handle(
        () => ei, ob, CancelOrder(ci, o.id))._2
    }(QueueOrderBook.empty) ==== OrderCanceled(ei, o.id)
  }

} 

package highperfscala.orderbook

import highperfscala.orderbook.Commands.{AddLimitOrder, CancelOrder}
import highperfscala.orderbook.Events.{LimitOrderAdded, OrderCancelRejected, OrderExecuted}
import org.scalacheck.Prop
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

class LazyCancelOrderBookTradingSpec extends Specification with ScalaCheck {

  """Given empty book
    |When limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    LimitOrder.genLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (l, ci, ei) =>
    LazyCancelOrderBook.handle(
      () => ei, LazyCancelOrderBook.empty, AddLimitOrder(ci, l))._2 ====
      LimitOrderAdded(ei)
  }

  """Given empty book
    |and buy limit order added
    |When resting sell limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (buy, id, ci, ei) =>
    (LazyCancelOrderBook.handle(
      () => ei, _: LazyCancelOrderBook, AddLimitOrder(ci, buy))).andThen {
      case (ob, _) => LazyCancelOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
        SellLimitOrder(id, Price(buy.price.value + 0.01))))._2
    }(LazyCancelOrderBook.empty) ==== LimitOrderAdded(ei)
  }

  """Given empty book
    |and sell limit order added
    |When resting buy limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (sell, id, ci, ei) =>
    (LazyCancelOrderBook.handle(() => ei, _: LazyCancelOrderBook, AddLimitOrder(ci, sell)))
      .andThen {
        case (ob, _) => LazyCancelOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          BuyLimitOrder(id, Price(sell.price.value - 0.01))))._2
      }(LazyCancelOrderBook.empty) ==== LimitOrderAdded(ei)
  }

  """Given empty book
    |and buy limit order added
    |When crossing sell limit order arrives
    |Then OrderExecuted
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (buy, id, ci, ei) =>
    (LazyCancelOrderBook.handle(() => ei, _: LazyCancelOrderBook, AddLimitOrder(ci, buy)))
      .andThen {
        case (ob, _) => LazyCancelOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          SellLimitOrder(id, Price(buy.price.value - 0.01))))._2
      }(LazyCancelOrderBook.empty) ==== OrderExecuted(ei,
      Execution(buy.id, buy.price), Execution(id, buy.price))
  }

  """Given empty book
    |and sell limit order added
    |When crossing buy limit order arrives
    |Then OrderExecuted
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (sell, id, ci, ei) =>
    (LazyCancelOrderBook.handle(() => ei, _: LazyCancelOrderBook, AddLimitOrder(ci, sell)))
      .andThen {
        case (ob, _) => LazyCancelOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          BuyLimitOrder(id, Price(sell.price.value + 0.01))))._2
      }(LazyCancelOrderBook.empty) ==== OrderExecuted(ei,
      Execution(id, sell.price), Execution(sell.id, sell.price))
  }

  """Given empty book
    |When cancel order command arrives
    |Then OrderCancelRejected
  """.stripMargin ! Prop.forAll(
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (id, ci, ei) =>
    LazyCancelOrderBook.handle(() => ei, LazyCancelOrderBook.empty, CancelOrder(ci, id))
      ._2 ==== OrderCancelRejected(ei, id)
  }
} 

package highperfscala.orderbook

import highperfscala.orderbook.Commands.{AddLimitOrder, CancelOrder}
import highperfscala.orderbook.Events.{OrderCancelRejected, OrderCanceled}
import org.scalacheck.Prop
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

class LazyCancelOrderBookCancelingSpec extends Specification with ScalaCheck {

  """Given empty book
    |When cancel order arrives
    |Then OrderCancelRejected
  """.stripMargin ! Prop.forAll(
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (id, ci, ei) =>
    LazyCancelOrderBook.handle(
      () => ei, LazyCancelOrderBook.empty, CancelOrder(ci, id))._2 ====
      OrderCancelRejected(ei, id)
  }

  """Given empty book
    |and buy limit order added
    |When cancel order arrives
    |Then OrderCanceled
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (o, ci, ei) =>
    (LazyCancelOrderBook.handle(
      () => ei, _: LazyCancelOrderBook, AddLimitOrder(ci, o))).andThen {
      case (ob, _) => LazyCancelOrderBook.handle(
        () => ei, ob, CancelOrder(ci, o.id))._2
    }(LazyCancelOrderBook.empty) ==== OrderCanceled(ei, o.id)
  }

  """Given empty book
    |and sell limit order added
    |When cancel order arrives
    |Then OrderCanceled
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (o, ci, ei) =>
    (LazyCancelOrderBook.handle(
      () => ei, _: LazyCancelOrderBook, AddLimitOrder(ci, o))).andThen {
      case (ob, _) => LazyCancelOrderBook.handle(
        () => ei, ob, CancelOrder(ci, o.id))._2
    }(LazyCancelOrderBook.empty) ==== OrderCanceled(ei, o.id)
  }

} 

package highperfscala.orderbook

import highperfscala.orderbook.Commands.{AddLimitOrder, CancelOrder}
import highperfscala.orderbook.Events.{LimitOrderAdded, OrderCancelRejected, OrderExecuted}
import org.scalacheck.Prop
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

class ListOrderBookTradingSpec extends Specification with ScalaCheck {

  """Given empty book
    |When limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    LimitOrder.genLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (l, ci, ei) =>
    ListOrderBook.handle(
      () => ei, ListOrderBook.empty, AddLimitOrder(ci, l))._2 ====
      LimitOrderAdded(ei)
  }

  """Given empty book
    |and buy limit order added
    |When resting sell limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (buy, id, ci, ei) =>
    (ListOrderBook.handle(
      () => ei, _: ListOrderBook, AddLimitOrder(ci, buy))).andThen {
      case (ob, _) => ListOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
        SellLimitOrder(id, Price(buy.price.value + 0.01))))._2
    }(ListOrderBook.empty) ==== LimitOrderAdded(ei)
  }

  """Given empty book
    |and sell limit order added
    |When resting buy limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (sell, id, ci, ei) =>
    (ListOrderBook.handle(() => ei, _: ListOrderBook, AddLimitOrder(ci, sell)))
      .andThen {
        case (ob, _) => ListOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          BuyLimitOrder(id, Price(sell.price.value - 0.01))))._2
      }(ListOrderBook.empty) ==== LimitOrderAdded(ei)
  }

  """Given empty book
    |and buy limit order added
    |When crossing sell limit order arrives
    |Then OrderExecuted
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (buy, id, ci, ei) =>
    (ListOrderBook.handle(() => ei, _: ListOrderBook, AddLimitOrder(ci, buy)))
      .andThen {
        case (ob, _) => ListOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          SellLimitOrder(id, Price(buy.price.value - 0.01))))._2
      }(ListOrderBook.empty) ==== OrderExecuted(ei,
      Execution(buy.id, buy.price), Execution(id, buy.price))
  }

  """Given empty book
    |and sell limit order added
    |When crossing buy limit order arrives
    |Then OrderExecuted
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (sell, id, ci, ei) =>
    (ListOrderBook.handle(() => ei, _: ListOrderBook, AddLimitOrder(ci, sell)))
      .andThen {
        case (ob, _) => ListOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          BuyLimitOrder(id, Price(sell.price.value + 0.01))))._2
      }(ListOrderBook.empty) ==== OrderExecuted(ei,
      Execution(id, sell.price), Execution(sell.id, sell.price))
  }

  """Given empty book
    |When cancel order command arrives
    |Then OrderCancelRejected
  """.stripMargin ! Prop.forAll(
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (id, ci, ei) =>
    ListOrderBook.handle(() => ei, ListOrderBook.empty, CancelOrder(ci, id))
      ._2 ==== OrderCancelRejected(ei, id)
  }
} 

package highperfscala.orderbook

import highperfscala.orderbook.Commands.{AddLimitOrder, CancelOrder}
import highperfscala.orderbook.Events.{LimitOrderAdded, OrderCancelRejected, OrderExecuted}
import org.scalacheck.Prop
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

class QueueOrderBookTradingSpec extends Specification with ScalaCheck {

  """Given empty book
    |When limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    LimitOrder.genLimitOrder,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (l, ci, ei) =>
     QueueOrderBook.handle(
      () => ei,  QueueOrderBook.empty, AddLimitOrder(ci, l))._2 ====
      LimitOrderAdded(ei)
  }

  """Given empty book
    |and buy limit order added
    |When resting sell limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (buy, id, ci, ei) =>
    ( QueueOrderBook.handle(
      () => ei, _:  QueueOrderBook, AddLimitOrder(ci, buy))).andThen {
      case (ob, _) =>  QueueOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
        SellLimitOrder(id, Price(buy.price.value + 0.01))))._2
    }( QueueOrderBook.empty) ==== LimitOrderAdded(ei)
  }

  """Given empty book
    |and sell limit order added
    |When resting buy limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (sell, id, ci, ei) =>
    ( QueueOrderBook.handle(() => ei, _:  QueueOrderBook, AddLimitOrder(ci, sell)))
      .andThen {
        case (ob, _) =>  QueueOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          BuyLimitOrder(id, Price(sell.price.value - 0.01))))._2
      }( QueueOrderBook.empty) ==== LimitOrderAdded(ei)
  }

  """Given empty book
    |and buy limit order added
    |When crossing sell limit order arrives
    |Then OrderExecuted
  """.stripMargin ! Prop.forAll(
    BuyLimitOrder.genBuyLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (buy, id, ci, ei) =>
    ( QueueOrderBook.handle(() => ei, _:  QueueOrderBook, AddLimitOrder(ci, buy)))
      .andThen {
        case (ob, _) =>  QueueOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          SellLimitOrder(id, Price(buy.price.value - 0.01))))._2
      }( QueueOrderBook.empty) ==== OrderExecuted(ei,
      Execution(buy.id, buy.price), Execution(id, buy.price))
  }

  """Given empty book
    |and sell limit order added
    |When crossing buy limit order arrives
    |Then OrderExecuted
  """.stripMargin ! Prop.forAll(
    SellLimitOrder.genSellLimitOrder,
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (sell, id, ci, ei) =>
    ( QueueOrderBook.handle(() => ei, _:  QueueOrderBook, AddLimitOrder(ci, sell)))
      .andThen {
        case (ob, _) =>  QueueOrderBook.handle(() => ei, ob, AddLimitOrder(ci,
          BuyLimitOrder(id, Price(sell.price.value + 0.01))))._2
      }( QueueOrderBook.empty) ==== OrderExecuted(ei,
      Execution(id, sell.price), Execution(sell.id, sell.price))
  }

  """Given empty book
    |When cancel order command arrives
    |Then OrderCancelRejected
  """.stripMargin ! Prop.forAll(
    OrderId.genOrderId,
    CommandInstant.genCommandInstant,
    EventInstant.genEventInstant) { (id, ci, ei) =>
     QueueOrderBook.handle(() => ei,  QueueOrderBook.empty, CancelOrder(ci, id))
      ._2 ==== OrderCancelRejected(ei, id)
  }
} 

package highperfscala.dataanalysis

import org.joda.time.DateTime
import org.specs2.mutable.Specification

class MidpointSeriesSpec extends Specification {

  "A MidpointSeries" should {

    "be properly created from execution data points" in {
      val t0 = TimestampMinutes.fromDateTime(DateTime.now)
      val t1 = t0.next
      val t2 = t1.next
      val t3 = t2.next
      val t4 = t3.next
      val t5 = t4.next
      val t6 = t5.next
      val executions = Vector(
        Execution(t0, AskPrice(40), BidPrice(20)),
        Execution(t1, AskPrice(30), BidPrice(25)),
        Execution(t1, AskPrice(50), BidPrice(22)),
        Execution(t4, AskPrice(24), BidPrice(16)),
        Execution(t4, AskPrice(84), BidPrice(78)),
        Execution(t4, AskPrice(64), BidPrice(37)),
        Execution(t6, AskPrice(41), BidPrice(23))
      )

      val series = MidpointSeries.fromExecution(executions)
      series.size ==== 7
      series.midpointAt(t0).get ==== Midpoint(t0, 30)
      series.midpointAt(t1).get ==== Midpoint(t1, 31.75)
      series.midpointAt(t2).get ==== Midpoint(t2, 31.75)
      series.midpointAt(t3).get ==== Midpoint(t3, 31.75)
      series.midpointAt(t4).get ==== Midpoint(t4, 50.5)
      series.midpointAt(t5).get ==== Midpoint(t5, 50.5)
      series.midpointAt(t6).get ==== Midpoint(t6, 32)
      series.midpointAt(t6.next) ==== None
    }

  }

} 

package highperfscala.orderbook

import highperfscala.orderbook.Commands.{CancelOrder, AddLimitOrder}
import highperfscala.orderbook.Events.{OrderCancelRejected, OrderExecuted, LimitOrderAdded}
import org.scalacheck.Prop
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

class OrderBookTradingSpec extends Specification with ScalaCheck {

  """Given empty book
    |When limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(LimitOrder.genLimitOrder) { l =>
    OrderBook.handle(OrderBook.empty, AddLimitOrder(l))._2 ==== LimitOrderAdded
  }

  """Given empty book
    |and buy limit order added
    |When resting sell limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(BuyLimitOrder.genBuyLimitOrder,
    OrderId.genOrderId) { (buy, id) =>
    (OrderBook.handle(_: OrderBook, AddLimitOrder(buy))).andThen {
      case (ob, _) => OrderBook.handle(ob, AddLimitOrder(
        SellLimitOrder(id, Price(buy.price.value + 0.01))))._2
    }(OrderBook.empty) ==== LimitOrderAdded
  }

  """Given empty book
    |and sell limit order added
    |When resting buy limit order arrives
    |Then LimitOrderAdded
  """.stripMargin ! Prop.forAll(SellLimitOrder.genSellLimitOrder,
    OrderId.genOrderId) { (sell, id) =>
    (OrderBook.handle(_: OrderBook, AddLimitOrder(sell))).andThen {
      case (ob, _) => OrderBook.handle(ob, AddLimitOrder(
        BuyLimitOrder(id, Price(sell.price.value - 0.01))))._2
    }(OrderBook.empty) ==== LimitOrderAdded
  }

  """Given empty book
    |and buy limit order added
    |When crossing sell limit order arrives
    |Then OrderExecuted
  """.stripMargin ! Prop.forAll(BuyLimitOrder.genBuyLimitOrder,
    OrderId.genOrderId) { (buy, id) =>
    (OrderBook.handle(_: OrderBook, AddLimitOrder(buy))).andThen {
      case (ob, _) => OrderBook.handle(ob, AddLimitOrder(
        SellLimitOrder(id, Price(buy.price.value - 0.01))))._2
    }(OrderBook.empty) ==== OrderExecuted(
      Execution(buy.id, buy.price), Execution(id, buy.price))
  }

  """Given empty book
    |and sell limit order added
    |When crossing buy limit order arrives
    |Then OrderExecuted
  """.stripMargin ! Prop.forAll(SellLimitOrder.genSellLimitOrder,
    OrderId.genOrderId) { (sell, id) =>
    (OrderBook.handle(_: OrderBook, AddLimitOrder(sell))).andThen {
      case (ob, _) => OrderBook.handle(ob, AddLimitOrder(
        BuyLimitOrder(id, Price(sell.price.value + 0.01))))._2
    }(OrderBook.empty) ==== OrderExecuted(
      Execution(id, sell.price), Execution(sell.id, sell.price))
  }

  """Given empty book
    |When cancel order command arrives
    |Then OrderCancelRejected
  """.stripMargin ! Prop.forAll(OrderId.genOrderId) { id =>
    OrderBook.handle(OrderBook.empty, CancelOrder(id))._2 ====
      OrderCancelRejected
  }
} 

package highperfscala
package orderbook

import highperfscala.orderbook.Commands.{AddLimitOrder, CancelOrder}
import highperfscala.orderbook.Events.{OrderCanceled, OrderCancelRejected}
import org.scalacheck.Prop
import org.specs2.ScalaCheck
import org.specs2.mutable.Specification

class OrderBookCancelingSpec extends Specification with ScalaCheck {

  """Given empty book
    |When cancel order arrives
    |Then OrderCancelRejected
  """.stripMargin ! Prop.forAll(OrderId.genOrderId) { id =>
    OrderBook.handle(OrderBook.empty, CancelOrder(id))._2 ====
      OrderCancelRejected
  }

  """Given empty book
    |and buy limit order added
    |When cancel order arrives
    |Then OrderCanceled
  """.stripMargin ! Prop.forAll(BuyLimitOrder.genBuyLimitOrder) { o =>
    (OrderBook.handle(_: OrderBook, AddLimitOrder(o))).andThen {
      case (ob, _) => OrderBook.handle(ob, CancelOrder(o.id))._2
    }(OrderBook.empty) ==== OrderCanceled
  }

  """Given empty book
    |and sell limit order added
    |When cancel order arrives
    |Then OrderCanceled
  """.stripMargin ! Prop.forAll(SellLimitOrder.genSellLimitOrder) { o =>
    (OrderBook.handle(_: OrderBook, AddLimitOrder(o))).andThen {
      case (ob, _) => OrderBook.handle(ob, CancelOrder(o.id))._2
    }(OrderBook.empty) ==== OrderCanceled
  }

} 

package com.es.scala.chapter07

import org.specs2.mutable.Specification

class IntTreeTest extends Specification {
  "com.es.scala.chapter07.IntTree" should {
    "confirm that the EmptyTree does not contain any element" in {
      val instance = Node(5, EmptyTree, EmptyTree)
      instance.contains(EmptyTree, 5) mustEqual(false)
    }
    "confirm that a tree with one element contains that element" in {
      val instance = Node(1, EmptyTree, EmptyTree)
      instance.contains(instance, 1) mustEqual(true)
    }
    "confirm that a tree with two elements contains both of them" in {
      val instance = Node(1, EmptyTree, EmptyTree)
      val instance2 = Node(2, instance, EmptyTree)
      instance.contains(instance2, 2) mustEqual(true)
      instance.contains(instance2, 1) mustEqual(true)
    }
    "confirm that a tree with multiple elements contains every one of them" in {
      val instance = Node (3, Node(1, EmptyTree, EmptyTree), Node(2, EmptyTree, EmptyTree))
      instance.contains(instance, 1) mustEqual(true)
      instance.contains(instance, 2) mustEqual(true)
      instance.contains(instance, 3) mustEqual(true)
    }
    "by the way, confirm that case classes allow to easily reference what went into their constructor" in {
      val instance = Node (3, Node(1, EmptyTree, EmptyTree), Node(2, EmptyTree, EmptyTree))
      instance.elem mustEqual 3
      instance.left mustEqual(Node(1, EmptyTree, EmptyTree))
      instance.right mustEqual(Node(2, EmptyTree, EmptyTree))
    }
  }
} 

package com.es.scala.chapter06

import org.specs2.mutable.Specification

class RationalTest extends Specification {
  "com.es.scala.chapter06.Rational" should {
    "compute the sum of rational numbers from 1/1 to 1/10" in {
      var i = 1
      var x = new Rational(0, 1)
      while (i <= 10) {
        x += new Rational(1, i)
        i += 1
      }
      (new Rational(7381, 2520) == x) must beTrue
    }
  }
} 

package com.es.scala.chapter06

import org.specs2.mutable.Specification

class SetTest extends Specification {
  "com.es.scala.chapter06.IntSet" should {
    "verify that no element belongs to EmptySet" in {
      new EmptySet().contains(1) must beFalse
    }
    "verify that correct elements belong to NonEmptySet" in {
      val set = new EmptySet
      val set1 = set.incl(3)
      set1.contains(1) must beFalse
      set1.contains(3) must beTrue
    }
  }
} 

package com.es.scala.chapter06

import org.specs2.mutable.Specification

class SetTest6 extends Specification {
  "com.es.scala.chapter06.IntSet6" should {
    "verify that no element belongs to EmptySet" in {
      new EmptySet6().contains(1) must beFalse
    }
    "verify that correct elements belong to NonEmptySet" in {
      val set = new EmptySet6
      val set1 = set.incl(3)
      set1.contains(1) must beFalse
      set1.contains(3) must beTrue
    }
    "verify that union works as expected" in {
      val set = new EmptySet6
      val set1 = set.incl(3).incl(5).incl(1)
      val set2 = set.incl(4).incl(2)
      val set3 = set1.union(set2)
      set3.contains(1) must beTrue
      set3.contains(2) must beTrue
      set3.contains(3) must beTrue
      set3.contains(4) must beTrue
      set3.contains(5) must beTrue
    }
    "verify that intersection works as expected" in {
      val set = new EmptySet6
      val set1 = set.incl(1).incl(3).incl(4).incl(5)
      println("set1 = " + set1.toString)
      val set2 = set.incl(3).incl(4)
      println("set2 = " + set2.toString)
      val set3 = set1.intersection(set2)
      println("set3 = " + set3.toString)
      println("")
      set3.contains(1) must beFalse
      set3.contains(2) must beFalse
      set3.contains(3) must beTrue
      set3.contains(4) must beTrue
      set3.contains(5) must beFalse
      set3.intersection(set).contains(1) must beFalse
    }
  }
} 

package com.es.scala.chapter04

import org.specs2.mutable.Specification


class FactorialTest extends Specification {

  "com.es.scala.chapter04.Factorial.factorial" should {
    "calculate factorial" in {
      new Factorial().factorial(5) mustEqual (120)
    }
  }

  "com.es.scala.chapter04.Factorial.factorialR" should {
    "calculate factorial but not require stack" in {
      println("new Factorial().factorialR(5)=" + new Factorial().factorialR(5))
      new Factorial().factorialR(5) mustEqual (120)
    }
  }
} 

package com.es.scala.chapter04

import org.specs2.mutable.Specification
import Math.abs


class NewtonTest extends Specification {
  "com.es.scala.chapter04.Newton" should {
    "extract square root" in {
      abs(new Newton().sqrt(4) - 2) must be <= .1
    }
  }

  "com.es.scala.chapter04.Newton1" should {
    "extract square root better for small numbers" in {
      abs(new Newton1().sqrt(.01) - .1) must be <= .1
    }
  }

  "com.es.scala.chapter04.Newton2" should {
    "extract square root with tracing" in {
      abs(new Newton2().sqrt(.01) - .1) must be <= .1
    }
  }

  "com.es.scala.chapter04.Newton3" should {
    "also extract sqrt - it is just a rewrite with nested functions" in {
      abs(new Newton3().sqrt(.01) - .1) must be <= .1
    }
  }

  "com.es.scala.chapter04.Newton4" should {
    "do the same sqrt, just more concise" in {
      abs(new Newton4().sqrt(.01) - .1) must be <= .1
    }
  }
} 

package com.es.scala.chapter05

import com.es.scala.chapter04.Factorial
import org.specs2.mutable.Specification


class SumTest extends Specification {
  "com.es.scala.chapter05.Sum" should {
    "sum the numbers" in {
      new Sum().sum(x => x, 3, 5) mustEqual 12
    }
  }

  "com.es.scala.chapter05.Sum" should {
    "sum squares" in {
      new Sum().sum(x => x * x, 3, 4) mustEqual 25
    }
  }

  "com.es.scala.chapter05.Sum1" should {
    "sum the numbers, just be written shorter" in {
      new Sum1().sum(x => x)(3, 5) mustEqual 12
    }
  }
  "com.es.scala.chapter05.Sum2" should {
    "sum the numbers, shorter yet!" in {
      new Sum2().sum(x => x)(3, 5) mustEqual 12
    }
  }
  "com.es.scala.chapter05.Sum3" should {
    "sum the numbers in tail recursive way" in {
      new Sum3().sum(x => x)(3, 5) mustEqual 12
    }
  }
  "com.es.scala.chapter05.Product" should {
    "multiply numbers of an interval" in {
      new Product().product(x => x)(3, 5) mustEqual 60
    }
  }
} 

package com.es.scala.more

import org.specs2.mutable.Specification


class UseOfNullTest extends Specification {
  val days = List("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday")

  "com.es.scala.more.UseOfNull" should {
    "distinguish between being passed a null or a non-null" in {
      new UseOfNull().exampleOfNull(days) mustEqual ("Sunday")
      new UseOfNull().exampleOfNull(days) mustNotEqual ("Monday")
      (new UseOfNull().exampleOfNull(null) == null) must beTrue
    }
  }

  "com.es.scala.more.UseOfNil" should {
    "distinguish between being passed a Nil (empty list) or a non-Nil" in {
      new UseOfNull().exampleOfNil(days) mustEqual List("Sunday")
      new UseOfNull().exampleOfNil(Nil) mustEqual Nil
    }
  }

  // TODO this fails
//  "com.es.scala.more.UseOfNil" should {
//    "throw 'non implemented' exception" in {
//      new UseOfNull().notImplemented(1) must throwA[Exception]
//    }
//  }

} 

package bad.robot.temperature.server

import bad.robot.temperature._
import org.http4s.dsl.io._
import org.specs2.mutable.Specification

import scalaz.{-\/, \/-}

class EitherToResponseTest extends Specification {

  val okResponse = (_: Any) => Ok()

  "Error mappings" >> {
    -\/(CrcFailure()).toHttpResponse(okResponse).unsafeRunSync.status                    must_== InternalServerError
    -\/(SensorError("???")).toHttpResponse(okResponse).unsafeRunSync.status              must_== InternalServerError
    -\/(UnexpectedError("???")).toHttpResponse(okResponse).unsafeRunSync.status          must_== InternalServerError
    -\/(FailedToFindFile("???")).toHttpResponse(okResponse).unsafeRunSync.status         must_== NotFound
    -\/(FileError(new Exception("???"))).toHttpResponse(okResponse).unsafeRunSync.status must_== InternalServerError
  }

  "Success mapping" >> {
    \/-("Well done").toHttpResponse(okResponse).unsafeRunSync.status must_== Ok
  }
} 

package bad.robot.temperature.server

import java.time.{Clock, Instant, ZoneId}

import bad.robot.temperature._
import bad.robot.temperature.rrd.{Host, Seconds}
import org.specs2.mutable.Specification

class TemperaturesTest extends Specification {

  "Filter out old temperatures" >> {
    val measurement1 = Measurement(Host("lounge"), Seconds(0), List(
      SensorReading("28-00000dfg34ca", Temperature(31.1)),
      SensorReading("28-00000f33fdc3", Temperature(32.8))
    ))
    val measurement2 = Measurement(Host("bedroom"), Seconds(120), List(
      SensorReading("28-00000f3554ds", Temperature(21.1)),
      SensorReading("28-000003dd3433", Temperature(22.8))
    ))

    val temperatures = CurrentTemperatures(fixedClock(Instant.ofEpochSecond(300)))
    temperatures.updateWith(measurement1)
    temperatures.updateWith(measurement2)

    val expected = Map(
      Host("bedroom", None) -> Measurement(Host("bedroom"), Seconds(120), List(
        SensorReading("28-00000f3554ds", Temperature(21.1)),
        SensorReading("28-000003dd3433", Temperature(22.8))
      ))
    )

    temperatures.all must_== expected
  }

  "Filter out old temperatures when averaging" >> {
    val measurement1 = Measurement(Host("lounge"), Seconds(0), List(
      SensorReading("28-00000dfg34ca", Temperature(31.1)),
      SensorReading("28-00000f33fdc3", Temperature(32.8))
    ))
    val measurement2 = Measurement(Host("bedroom"), Seconds(60), List(
      SensorReading("28-00000f3554ds", Temperature(21.1)),
      SensorReading("28-000003dd3433", Temperature(22.8))
    ))

    val temperatures = CurrentTemperatures(fixedClock(Instant.ofEpochSecond(300)))
    temperatures.updateWith(measurement1)
    temperatures.updateWith(measurement2)

    val expected = Map(
      Host("bedroom", None) -> Measurement(Host("bedroom"), Seconds(60), List(
        SensorReading("Average", Temperature(21.950000000000003))
      ))
    )

    temperatures.average must_== expected
  }
  
  
  def fixedClock(instant: Instant = Instant.now) = Clock.fixed(instant, ZoneId.systemDefault())

} 

package bad.robot.temperature.server

import bad.robot.temperature.rrd.{Host, Seconds}
import bad.robot.temperature.{Measurement, SensorReading, Temperature}
import org.specs2.mutable.Specification

class AllTemperaturesTest extends Specification {

  "drain's partially based on time (the most recent 5 seconds are retained)" >> {
    val temperatures = AllTemperatures()
    temperatures.put(measurement("A", 0, 20.0, 20.1))
    temperatures.put(measurement("B", 1, 21.0, 21.1))
    temperatures.put(measurement("C", 2, 22.0, 22.1))
    temperatures.put(measurement("D", 3, 23.2, 23.3))
    temperatures.put(measurement("E", 4, 24.0, 24.1))
    temperatures.put(measurement("F", 5, 25.0, 25.1))
    temperatures.put(measurement("G", 6, 26.0, 26.1))
    temperatures.put(measurement("H", 7, 27.0, 27.1))
    temperatures.put(measurement("I", 8, 28.0, 28.1))
    temperatures.put(measurement("J", 9, 29.0, 29.1))


    temperatures.drainPartially(Seconds(10)) must containTheSameElementsAs(List(
      measurement("A", 0, 20.0, 20.1),
      measurement("B", 1, 21.0, 21.1),
      measurement("C", 2, 22.0, 22.1),
      measurement("D", 3, 23.2, 23.3),
      measurement("E", 4, 24.0, 24.1)
    ))

    temperatures.drainPartially(Seconds(20)) must containTheSameElementsAs(List(
      measurement("F", 5, 25.0, 25.1),
      measurement("G", 6, 26.0, 26.1),
      measurement("H", 7, 27.0, 27.1),
      measurement("I", 8, 28.0, 28.1),
      measurement("J", 9, 29.0, 29.1)
    ))

    temperatures.drainPartially(Seconds(30)) must_== List()
  }

  private def measurement(host: String, time: Long, temperatures: Double*) = {
    Measurement(Host(host), Seconds(time), temperatures.zipWithIndex.map { case (temperature, index) =>
      SensorReading(s"sensor-$index", Temperature(temperature))
    }.toList)
  }
} 

package bad.robot.temperature.server

import java.time.ZoneId
import java.time.format.DateTimeFormatter
import java.time.format.FormatStyle.SHORT
import java.util.Locale._

import cats.effect.IO
import org.http4s.Method.GET
import org.http4s.Status.Ok
import org.http4s.implicits._
import org.http4s.{Request, Uri}
import org.specs2.mutable.Specification

import scalaz.syntax.either._

class ExportEndpointTest extends Specification {

  sequential

  "convert json to csv" >> {
    val exampleJson =
      """
        |[
        |  {
        |    "label": "bedroom1-sensor-1",
        |    "data": [
        |      {
        |        "x": 1507709610000,
        |        "y": "NaN"
        |      },
        |      {
        |        "x": 1507709640000,
        |        "y": "+2.2062500000E01"
        |      },
        |      {
        |        "x": 1507709680000,
        |        "y": "+2.2262500000E01"
        |      }
        |    ]
        |  }
        |]
      """.stripMargin
    
    val expectedCsv = """"Sensor","Time","Temperature","Difference"
                        |"bedroom1-sensor-1","11/10/17 08:13","NaN","0"
                        |"bedroom1-sensor-1","11/10/17 08:14","22.0625","NaN"
                        |"bedroom1-sensor-1","11/10/17 08:14","22.2625","0.20"""".stripMargin

    val UkDateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(SHORT).withLocale(UK).withZone(ZoneId.of("GMT"))
    
    val request = Request[IO](GET, Uri.uri("/temperatures.csv"))
    val service = ExportEndpoint(exampleJson.right, UkDateTimeFormatter)
    val response = service.orNotFound.run(request).unsafeRunSync()
    response.as[String].unsafeRunSync must_== expectedCsv
    response.status must_== Ok
  }

} 

package bad.robot.temperature.server

import bad.robot.temperature._
import bad.robot.temperature.rrd.Host
import org.specs2.mutable.Specification

class ConnectionTest extends Specification {

  "Encode Json" >> {
    encode(Connection(Host("box.local", Some("Z"), Some("Europe/London")), IpAddress("127.0.0.1"))).spaces2ps must_==
      """{
        |  "host" : {
        |    "name" : "box.local",
        |    "utcOffset" : "Z",
        |    "timezone" : "Europe/London"
        |  },
        |  "ip" : {
        |    "value" : "127.0.0.1"
        |  }
        |}""".stripMargin
  }

} 

package bad.robot.temperature.server

import java.io.{BufferedWriter, FileWriter}

import org.specs2.matcher.DisjunctionMatchers.be_\/-
import org.specs2.mutable.Specification

class JsonFileTest extends Specification {

  val exampleJson =
    """
      |[
      |  {
      |    "label": "bedroom1-sensor-1",
      |    "data": [
      |      {
      |        "x": 1507709610000,
      |        "y": "NaN"
      |      },
      |      {
      |        "x": 1507709640000,
      |        "y": "+2.2062500000E01"
      |      },
      |      {
      |        "x": 1507709680000,
      |        "y": "+2.2262500000E01"
      |      }
      |    ]
      |  }
      |]
    """.stripMargin

  "Load a file" >> {
    createFile()
    JsonFile.load must be_\/-(exampleJson)
  }
  
  private def createFile() = {
    val writer = new BufferedWriter(new FileWriter(JsonFile.file))
    writer.write(exampleJson)
    writer.close()
  }

} 

package bad.robot.temperature.server

import java.net.{DatagramPacket, DatagramSocket, InetAddress, InetSocketAddress, Socket => _}

import bad.robot.temperature.server.DiscoveryServer.{Quit, ServerAddressRequestMessage, ServerAddressResponseMessage, UnknownRequestResponseMessage}
import bad.robot.temperature.server.Socket._
import org.specs2.matcher.DisjunctionMatchers._
import org.specs2.mutable.Specification

import scala.concurrent.duration._
import scalaz.\/-

class DiscoveryServerTest extends Specification {

  "When the discovery server is started" >> {
    val server = new Thread(new DiscoveryServer())
    server.start()

    "Server will respond with it's address once pinged" >> {
      val socket = new DatagramSocket()
      pingServerOn(ServerAddressRequestMessage, socket)

      val response = socket.await(30 seconds).map(server => (server.getAddress.getHostAddress, server.payload))
      socket.close()
      response must be_\/-
      response match {
        case \/-((ip, message)) if ip == InetAddress.getLocalHost.getHostAddress => message must_== ServerAddressResponseMessage
        case \/-((ip, message)) if ip == "127.0.0.1" || ip == "127.0.1.1"        => message must_== ServerAddressResponseMessage
        case \/-((ip, _))                                                        => throw new Exception(s"$ip wasn't expected")
        case _                                                                   => throw new Exception("specs2 is a dick")
      }
    }

    "Server response when unknown message is received" >> {
      val socket = new DatagramSocket()
      pingServerOn("UNKNOWN_MESSAGE", socket)

      val response = socket.await(30 seconds).map(_.payload)
      socket.close()
      response must be_\/-(UnknownRequestResponseMessage)
    }

    step {
      pingServerOn(Quit, new DatagramSocket())
    }
  }

  private def pingServerOn(message: String, socket: DatagramSocket) {
    val server = new InetSocketAddress(InetAddress.getLocalHost, 8888)
    val data = message.getBytes
    socket.send(new DatagramPacket(data, data.length, server))
  }

} 

package bad.robot.temperature.config

import java.io.File

import bad.robot.temperature.ConfigurationError
import bad.robot.temperature.config.ConfigFile.loadOrWarn
import knobs._
import org.specs2.mutable.Specification

class ConfigFileTest extends Specification {

  "Can be loaded" >> {
    loadOrWarn(Required(ClassPathResource("example.cfg"))).unsafeRunSync() must beRight
  }
  
  "Retrieve empty list for hosts" >> {
    loadOrWarn(Required(ClassPathResource("example-empty.cfg"))).unsafeRunSync() must beRight.like { case config => {
      config.mode must_== "client"
      config.hosts must throwA[KeyError]
    }}
  }
  
  "Retrieve no mode" >> {
    val config = loadOrWarn(Required(ClassPathResource("bad-example-missing-fields.cfg"))).unsafeRunSync()
    config must beRight.like { case config => {
      config.mode must throwA[KeyError]
      config.hosts must_== List("one", "two")
    }}
  }

  "Retrieve the values configuration items" >> {
    loadOrWarn(Required(ClassPathResource("example.cfg"))).unsafeRunSync() must beRight.like { case config => {
      config.mode must_== "server"
      config.hosts must_== List("one", "two")
    }}
  }
  
  "Example failure messages" >> {
    import scala.concurrent.ExecutionContext.Implicits.global     // todo replace with explicit one

    loadOrWarn(Required(FileResource.unwatched(new File("/foo.cfg")))).unsafeRunSync() must beLeft.like {
      case error: ConfigurationError => error.details must contain("/foo.cfg (No such file or directory)")
    }
    loadOrWarn(Required(FileResource.unwatched(new File(sys.props("user.home"))))).unsafeRunSync() must beLeft.like {
      case error: ConfigurationError => error.details must contain(s"${sys.props("user.home")} (Is a directory)")
    }
    loadOrWarn(Required(ClassPathResource("not/present/temperature-machine.cfg"))).unsafeRunSync() must beLeft.like {
      case error: ConfigurationError => error.details must contain("not/present/temperature-machine.cfg not found on classpath")
    }
    loadOrWarn(Required(ClassPathResource("bad-example.cfg"))).unsafeRunSync() must beLeft.like {
      case error: ConfigurationError => error.details must contain("expected configuration")
    }
    loadOrWarn(Required(ClassPathResource("bad-example-missing-values.cfg"))).unsafeRunSync() must beLeft.like {
      case error: ConfigurationError => error.details must contain("expected comment, newline, value, or whitespace")
    }
  }
  
} 

package bad.robot.temperature

import org.specs2.mutable.Specification

class IpAddressTest extends Specification {

  "Valid IP addresses" >> {
    IpAddress.isIpAddress("10.0.1.7") must_== true
    IpAddress.isIpAddress("0.0.0.0") must_== true
    IpAddress.isIpAddress("255.255.255.255") must_== true
  }

  "Invalid IP addresses" >> {
    IpAddress.isIpAddress("fe80:0:0:0:40c3:9f41:82e7:760d%utun1") must_== false
    IpAddress.isIpAddress("256.255.255.255") must_== false
    IpAddress.isIpAddress("255.256.255.255") must_== false
    IpAddress.isIpAddress("255.255.256.255") must_== false
    IpAddress.isIpAddress("256.255.255.256") must_== false
    IpAddress.isIpAddress("0.0.0.-1") must_== false
  }

  "Encode Json" >> {
    encode(IpAddress("10.0.1.7")).spaces2ps must_==
      """|{
         |  "value" : "10.0.1.7"
         |}""".stripMargin
  }
} 

package bad.robot.temperature.task

import java.net.{Socket => _}
import java.util.concurrent._
import java.util.concurrent.atomic.AtomicInteger

import bad.robot.temperature.task.Scheduler.ScheduledExecutorServiceOps
import org.specs2.mutable.Specification

import scala.concurrent.duration._

class SchedulerTest extends Specification {

  val errorHandler: Throwable => Runnable => Unit = _ => _ => ()

  "Exceptions aren't propagated when wrapped" >> {
    val handler = Scheduler.wrapWithErrorHandler(() => throw new Exception(), errorHandler)
    handler.run must not(throwA[Exception])
  }

  "Executes at fixed rate" >> {
    val scheduler = new ScheduledExecutorServiceOps(Executors.newSingleThreadScheduledExecutor())
    val counter = new AtomicInteger(0)
    scheduler.schedule(1 milliseconds, errorHandler, () => {
      counter.getAndIncrement()
      throw new Exception()
    })

    counter.get() must be_>(2).eventually
  }

  "Executes at fixed rate without stopping when exceptions are thrown" >> {
    val scheduler = new ScheduledExecutorServiceOps(Executors.newSingleThreadScheduledExecutor())
    val counter = new AtomicInteger(0)
    scheduler.schedule(1 milliseconds, errorHandler, () => {
      counter.getAndIncrement()
      throw new Exception()
    })

    counter.get() must be_>(2).eventually
  }

} 

package bad.robot.temperature

import org.specs2.mutable.Specification

import scala.Double._

class BarrierTest extends Specification {

  "No breach" >> {
    val barrier = Barrier(5)
    barrier.breached(Temperature(10.23), Temperature(11.22)) must_== false
    barrier.breached(Temperature(-10.23), Temperature(-10.23)) must_== false
    barrier.breached(Temperature(0), Temperature(0)) must_== false
    barrier.breached(Temperature(23.12), Temperature(23.12)) must_== false
    barrier.breached(Temperature(23.12), Temperature(24.11)) must_== false
  }
  
  "Positive breach" >> {
    val barrier = Barrier(1)
    barrier.breached(Temperature(10.23), Temperature(11.24)) must_== true
    barrier.breached(Temperature(10.24), Temperature(11.23)) must_== false
  }
  
  "Negative breach" >> {
    val barrier = Barrier(1)
    barrier.breached(Temperature(-10.23), Temperature(-11.24)) must_== true
    barrier.breached(Temperature(-10.24), Temperature(-11.23)) must_== false
  }

  "NaN" >> {
    val barrier = Barrier(1)
    barrier.breached(Temperature(-10.23), Temperature(NaN)) must_== false
    barrier.breached(Temperature(NaN), Temperature(10.23)) must_== false
    barrier.breached(Temperature(NaN), Temperature(NaN)) must_== false
  }
  
} 

package bad.robot.temperature.rrd

import org.specs2.mutable.Specification

import scala.concurrent.duration.Duration

class ArchiveTest extends Specification {

  "Some typical RRA values" >> {
    val frequency = Duration(30, "seconds")

    val daily = Archive.apply(aDay, frequency, frequency)
    val weekHourlyAvg = Archive.apply(aWeek, frequency, anHour)
    val monthTwoHourlyAvg = Archive.apply(aMonth, frequency, anHour * 2)

    daily             must_== Archive(1, 2880)
    weekHourlyAvg     must_== Archive(120, 168)
    monthTwoHourlyAvg must_== Archive(240, 360)
  }

  "Some typical RRA values (1 min frequency)" >> {
    val frequency = Duration(1, "minute")

    val daily = Archive.apply(aDay, frequency, frequency)
    val weekHourlyAvg = Archive.apply(aWeek, frequency, anHour)
    val monthTwoHourlyAvg = Archive.apply(aMonth, frequency, anHour * 2)

    daily             must_== Archive(1, 1440)
    weekHourlyAvg     must_== Archive(60, 168)
    monthTwoHourlyAvg must_== Archive(120, 360)
  }
} 

package bad.robot.temperature.rrd

import bad.robot.temperature.rrd.RpnGenerator.{Max, Min}
import org.specs2.mutable.Specification

class RpnGeneratorTest extends Specification {

  "generate a RPN string to aggregate sensors (Max)" >> {
    RpnGenerator.generateRpn(List("bedroom-1"), Max) must_== "bedroom-1,MAX"
    RpnGenerator.generateRpn(List("bedroom-1", "bedroom-2", "lounge-1"), Max) must_== "bedroom-1,bedroom-2,lounge-1,MAX,MAX"
  }

  "generate a RPN string to aggregate sensors (Min)" >> {
    RpnGenerator.generateRpn(List("bedroom-1"), Min) must_== "bedroom-1,MIN"
    RpnGenerator.generateRpn(List("bedroom-1", "bedroom-2", "lounge-1"), Min) must_== "bedroom-1,bedroom-2,lounge-1,MIN,MIN"
  }

} 

package bad.robot.temperature.rrd

import java.net.InetAddress

import bad.robot.temperature._
import org.specs2.matcher.DisjunctionMatchers.be_\/-
import org.specs2.mutable.Specification

class HostTest extends Specification {

  "Trims to max 20 characters (including the 'sensor-n' postfix)" >> {
    Host("cheetah.local") must_== Host("cheetah.loc") // aka the host name is equal
    "cheetah.loc-sensor-1".length must_== 20
  }

  "Doesn't trim" >> {
    Host("kitchen", None) must_== Host("kitchen", None, None)
  }

  "Local host" >> {
    Host.local.name must_== InetAddress.getLocalHost.getHostName.take(11)
  }

  "Encode Json" >> {
    encode(Host("local", None, None)).spaces2ps must_==
      """{
        |  "name" : "local",
        |  "utcOffset" : null,
        |  "timezone" : null
        |}""".stripMargin

    encode(Host("local", Some("+03:00"), Some("Tehran"))).spaces2ps must_==
      """{
        |  "name" : "local",
        |  "utcOffset" : "+03:00",
        |  "timezone" : "Tehran"
        |}""".stripMargin
  }

  "Decode Json (what happens if a UTC offset isn't supplied?)" >> {
    val json = """{ "name" : "local" }"""
    decodeAsDisjunction[Host](json) must be_\/-(Host("local", utcOffset = None, timezone = None))
  }
  
} 

package org.zalando.zhewbacca

import org.specs2.concurrent.ExecutionEnv
import org.specs2.mutable.Specification

class AlwaysPassAuthProviderSpec(implicit ee: ExecutionEnv) extends Specification {
  val testTokenInfo = TokenInfo("", Scope.Empty, "token type", "user uid", realm = "/employees")

  "'Always pass' Authorization Provider" should {
    "accept any tokens and scopes and treat them as valid" in {
      val authProvider = new AlwaysPassAuthProvider(testTokenInfo)
      val scope = Scope(Set("any_scope"))
      val token = Some(OAuth2Token("6afe9886-0a0a-4ace-8bc7-fb96920fb764"))

      authProvider.valid(token, scope) must beEqualTo(AuthTokenValid(testTokenInfo)).await
    }
  }

} 

package org.zalando.zhewbacca

import org.specs2.mutable.Specification

class ScopeTestSpec extends Specification {

  "in method" should {

    "return 'true' if this scope is completely in given scope" in {
      Scope(Set("uid")).in(Scope(Set("uid"))) must beTrue
      Scope(Set("uid", "cn")).in(Scope(Set("uid", "cn"))) must beTrue
      Scope(Set("uid")).in(Scope(Set("uid", "cn"))) must beTrue
      Scope(Set("uid", "cn")).in(Scope(Set("cn", "uid"))) must beTrue
    }

    "return 'false' if this scope is partially in given scope" in {
      Scope(Set("uid", "cn")).in(Scope(Set("uid"))) must beFalse
      Scope(Set("uid", "cn")).in(Scope(Set("cn", "foo"))) must beFalse
    }

    "return 'false' if this scope is not in given scope" in {
      Scope(Set("uid")).in(Scope(Set("cn"))) must beFalse
    }
  }

  "empty scope" should {

    "be in any scope" in {
      Scope.Empty.in(Scope.Empty) must beTrue
      Scope.Empty.in(Scope(Set("uid"))) must beTrue
      Scope.Empty.in(Scope(Set("uid", "another_scope"))) must beTrue
      Scope(Set("uid", "")).in(Scope(Set("uid"))) must beTrue
      Scope(Set("uid", "", "")).in(Scope(Set("uid", ""))) must beTrue
    }

  }

} 

package org.zalando.zhewbacca

import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import play.api.Configuration
import play.api.test.FakeRequest

import scala.concurrent.ExecutionContext

class SecurityRulesRepositorySpec extends Specification with Mockito {

  "SecurityRulesRepository" should {

    "load rules from default file" in {
      val provider = mock[AuthProvider]
      val repository = new SecurityRulesRepository(Configuration(), provider)
      val expectedRule = ValidateTokenRule(provider, "GET", "/foo", Scope(Set("uid", "entity.read")))

      repository.get(FakeRequest("GET", "/foo")) must beSome(expectedRule)
    }

    "load rules from custom file" in {
      val provider = mock[AuthProvider]
      val config = Configuration("authorisation.rules.file" -> "security_custom-security.conf")
      val repository = new SecurityRulesRepository(config, provider)
      val expectedRule = ValidateTokenRule(provider, "POST", "/bar.*", Scope(Set("uid")))

      repository.get(FakeRequest("POST", "/bar.*")) must beSome(expectedRule)
    }

    "raise an error when custom file is not available" in {
      val authProvider = mock[AuthProvider]
      val config = Configuration("authorisation.rules.file" -> "this-file-does-not-exist.conf")

      new SecurityRulesRepository(config, authProvider) must
        throwA[RuntimeException]("configuration file this-file-does-not-exist.conf for security rules not found")
    }

    "allow comments in security rules configuration file" in {
      val provider = mock[AuthProvider]
      val config = Configuration("authorisation.rules.file" -> "security_commented.conf")
      val repository = new SecurityRulesRepository(config, provider)
      val expectedRule = ValidateTokenRule(provider, "OPTIONS", "/", Scope(Set("app.resource.read")))

      repository.get(FakeRequest("OPTIONS", "/")) must beSome(expectedRule)
    }

    "raise an error when it cannot parse a configuration file" in {
      val authProvider = mock[AuthProvider]
        def config(fileName: String): Configuration = Configuration("authorisation.rules.file" -> fileName)

      new SecurityRulesRepository(config("security_unknown-http-method.conf"), authProvider) must throwA[RuntimeException]
      new SecurityRulesRepository(config("security_no-scopes.conf"), authProvider) must throwA[RuntimeException]
    }

    "return None if there is no configured rules for given request" in {
      val authProvider = mock[AuthProvider]
      val repository = new SecurityRulesRepository(Configuration(), authProvider)

      repository.get(FakeRequest("GET", "/unknown-uri")) must beNone
    }

    "allow explicitly to pass-through or deny a request for a specific URI" in {
      val authProvider = mock[AuthProvider]
      val configuration = Configuration("authorisation.rules.file" -> "security_pass-through.conf")
      val repository = new SecurityRulesRepository(configuration, authProvider)

      repository.get(FakeRequest("GET", "/foo")).get must beAnInstanceOf[ExplicitlyAllowedRule]
      repository.get(FakeRequest("GET", "/bar")).get must beAnInstanceOf[ExplicitlyDeniedRule]
    }

  }

} 

package org.zalando.zhewbacca

import org.specs2.mutable.Specification
import play.api.mvc._
import play.api.test.FakeRequest

import scala.concurrent.duration._
import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
class RequestValidatorSpec extends Specification {

  val testTokenInfo = TokenInfo("", Scope.Empty, "token type", "user uid", realm = "/employees")

  "Request Validator" should {
    "provide token information when token is valid" in {
      val authProvider = new AuthProvider {
        override def valid(token: Option[OAuth2Token], scope: Scope): Future[AuthResult] =
          Future.successful(AuthTokenValid(testTokenInfo))
      }

      val result = Await.result(RequestValidator.validate(Scope(Set("uid")), FakeRequest(), authProvider), 1.seconds)
      result must beEqualTo(Right(testTokenInfo))
    }

    "return HTTP status 401 (unauthorized) when token was not provided" in {
      val authProvider = new AuthProvider {
        override def valid(token: Option[OAuth2Token], scope: Scope): Future[AuthResult] =
          Future.successful(AuthTokenEmpty)
      }

      val result = Await.result(RequestValidator.validate(Scope(Set("uid")), FakeRequest(), authProvider), 1.seconds)
      result must beEqualTo(Left(Results.Unauthorized))
    }

    "return HTTP status 401 (unauthorized) when token is in valid" in {
      val authProvider = new AuthProvider {
        override def valid(token: Option[OAuth2Token], scope: Scope): Future[AuthResult] =
          Future.successful(AuthTokenInvalid)
      }

      val result = Await.result(RequestValidator.validate(Scope(Set("uid")), FakeRequest(), authProvider), 1.seconds)
      result must beEqualTo(Left(Results.Unauthorized))
    }

    "return HTTP status 401 (unauthorized) when Authorization provider has failed" in {
      val authProvider = new AuthProvider {
        override def valid(token: Option[OAuth2Token], scope: Scope): Future[AuthResult] =
          Future.failed(new RuntimeException)
      }

      val result = Await.result(RequestValidator.validate(Scope(Set("uid")), FakeRequest(), authProvider), 1.seconds)
      result must beEqualTo(Left(Results.Unauthorized))
    }

    "return HTTP status 403 (forbidden) in case insufficient scopes" in {
      val authProvider = new AuthProvider {
        override def valid(token: Option[OAuth2Token], scope: Scope): Future[AuthResult] =
          Future.successful(AuthTokenInsufficient)
      }

      val result = Await.result(RequestValidator.validate(Scope(Set("uid")), FakeRequest(), authProvider), 1.seconds)
      result must beEqualTo(Left(Results.Forbidden))
    }
  }
} 

package org.zalando.zhewbacca

import org.specs2.mutable.Specification
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._
import scala.concurrent.{Await, Future}

class OAuth2AuthProviderSpec extends Specification {

  "IAM Authorization Provider" should {

    "accept valid token with necessary scope" in {
      val tokenInfo = TokenInfo("311f3ab2-4116-45a0-8bb0-50c3bca0441d", Scope(Set("uid")), "Bearer", userUid = "1234", realm = "/employees")
      val request = new OAuth2AuthProvider((token: OAuth2Token) => Future.successful(Some(tokenInfo))).valid(
        Some(OAuth2Token("311f3ab2-4116-45a0-8bb0-50c3bca0441d")),
        Scope(Set("uid")))

      Await.result(request, 1.second) must beEqualTo(AuthTokenValid(tokenInfo))
    }

    "accept token which has many scopes" in {
      val tokenInfo = TokenInfo("311f3ab2-4116-45a0-8bb0-50c3bca0441d", Scope(Set("uid", "cn")), "Bearer", userUid = "1234", realm = "/employees")
      val request = new OAuth2AuthProvider((token: OAuth2Token) => Future.successful(Some(tokenInfo))).valid(
        Some(OAuth2Token("311f3ab2-4116-45a0-8bb0-50c3bca0441d")),
        Scope(Set("uid")))

      Await.result(request, 1.second) must beEqualTo(AuthTokenValid(tokenInfo))
    }

    "reject token when IAM reports it is not valid one" in {
      val request = new OAuth2AuthProvider((token: OAuth2Token) => Future.successful(None)).valid(
        Some(OAuth2Token("311f3ab2-4116-45a0-8bb0-50c3bca0441d")),
        Scope(Set("uid")))

      Await.result(request, 1.second) must beEqualTo(AuthTokenInvalid)
    }

    "reject token if IAM responses with Token Info for different token" in {
      val tokenInfo = TokenInfo("986c2946-c754-4e58-a0cb-7e86e3e9901b", Scope(Set("uid")), "Bearer", userUid = "1234", realm = "/employees")
      val request = new OAuth2AuthProvider((token: OAuth2Token) => Future.successful(Some(tokenInfo))).valid(
        Some(OAuth2Token("311f3ab2-4116-45a0-8bb0-50c3bca0441d")),
        Scope(Set("uid")))

      Await.result(request, 1.second) must beEqualTo(AuthTokenInsufficient)
    }

    "reject token with insufficient scopes" in {
      val tokenInfo = TokenInfo("311f3ab2-4116-45a0-8bb0-50c3bca0441d", Scope(Set("uid")), "Bearer", userUid = "1234", realm = "/employees")
      val request = new OAuth2AuthProvider((token: OAuth2Token) => Future.successful(Some(tokenInfo))).valid(
        Some(OAuth2Token("311f3ab2-4116-45a0-8bb0-50c3bca0441d")),
        Scope(Set("uid", "seo_description.write")))

      Await.result(request, 1.second) must beEqualTo(AuthTokenInsufficient)
    }

    "reject non 'Bearer' token" in {
      val tokenInfo = TokenInfo("311f3ab2-4116-45a0-8bb0-50c3bca0441d", Scope(Set("uid")), "Token", userUid = "1234", realm = "/employees")
      val request = new OAuth2AuthProvider((token: OAuth2Token) => Future.successful(Some(tokenInfo))).valid(
        Some(OAuth2Token("311f3ab2-4116-45a0-8bb0-50c3bca0441d")),
        Scope(Set("uid")))

      Await.result(request, 1.second) must beEqualTo(AuthTokenInsufficient)
    }

    "reject empty token" in {
      val request = new OAuth2AuthProvider((token: OAuth2Token) => Future.successful(None)).valid(
        None,
        Scope(Set("uid")))

      Await.result(request, 1.second) must beEqualTo(AuthTokenEmpty)
    }
  }
} 

package io.chrisdavenport.testcontainersspecs2

import java.util.UUID

import cats.effect._
import doobie._
import doobie.implicits._
import doobie.postgres.implicits._
import doobie.specs2._
import org.flywaydb.core.Flyway
import org.specs2.mutable.Specification

import scala.concurrent.ExecutionContext

class QueriesSpec[F[_]]
    extends Specification
    with IOChecker
    with ForAllTestContainer
    with UsesPostgreSQLMultipleDatabases {

  implicit val CS: ContextShift[IO] = IO.contextShift(ExecutionContext.global)

  override lazy val transactor: Transactor[IO] = Transactor.fromDriverManager[IO](
    driverName,
    jdbcUrl,
    dbUserName,
    dbPassword
  )

  sequential

  // afterStart / beforeStop available for actions at the begininning
  // and end of a particular container session.
  // In this case we make sure migrations have run before we check the sql statements.
  override def afterStart(): Unit = {
    Flyway
      .configure()
      .dataSource(jdbcUrl, dbUserName, dbPassword)
      .load()
      .migrate
    ()
  }

  private case class Person(person_id: UUID, firstName: String, lastName: String)

  check(sql"SELECT 1".query[Int])
  check(sql"SELECT person_id, first_name, last_name FROM persons".query[Person])

} 

package io.chrisdavenport.testcontainersspecs2

import cats.effect._
import org.flywaydb.core.Flyway
import org.specs2.mutable.Specification

class MigrationsSpec
    extends Specification
    with ForAllTestContainer
    with UsesPostgreSQLMultipleDatabases {

  "Migrations should run Correctly" in {
    IO {
      Flyway
        .configure()
        .dataSource(jdbcUrl, dbUserName, dbPassword)
        .load()
        .migrate
    }.attempt
      .map(_.isRight)
      .unsafeRunSync() must_=== true
  }

} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class DependenciesSpec extends Specification with JsonSpec {

  "dependencies draft 4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("dependencies", "draft4")
  }

  "dependencies draft 7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("dependencies", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class MinPropertiesSpec extends Specification with JsonSpec {

  "minProperties draft4" in {
    import Version4._
    implicit val validator = SchemaValidator(Some(Version4))
    validate("minProperties", "draft4")
  }

  "minProperties draft7" in {
    import Version7._
    implicit val validator = SchemaValidator(Some(Version7))
    validate("minProperties", "draft7")
  }
} 

package com.eclipsesource.schema

import java.net.URL

import com.eclipsesource.schema.drafts.Version4
import org.specs2.mutable.Specification
import play.api.libs.json.{JsValue, Json}

class SimplePerformanceSpec extends Specification {

  import Version4._

  def timed(name: String)(body: => Unit) {
    val start = System.currentTimeMillis()
    body
    println(name + ": " + (System.currentTimeMillis() - start) + " ms")
  }

  val validator = SchemaValidator(Some(Version4))
  val schemaUrl: URL = getClass.getResource("/issue-99-1.json")
  val schema: SchemaType = JsonSource.schemaFromUrl(schemaUrl).get

  val instance: JsValue = Json.parse("""{ "mything": "the thing" }""".stripMargin)

  timed("preloaded") {
    for (_ <- 1 to 1000) validator.validate(schema, instance)
  }
  timed("url based") {
    for (_ <- 1 to 1000) validator.validate(schemaUrl)(instance)
  }

} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.Version7
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class RefRemoteDraft7Spec extends Specification with JsonSpec {

  import Version7._

  implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    .addSchema(
      "http://localhost:1234/integer.json",
      JsonSource.schemaFromStream(
        getClass.getResourceAsStream("/remotes/integer.json")
      ).get
    )
    .addSchema(
      "http://localhost:1234/subSchemas.json",
      JsonSource.schemaFromStream(
        getClass.getResourceAsStream("/remotes/subSchemas.json")
      ).get
    )
    .addSchema(
      "http://localhost:1234/folder/folderInteger.json",
      JsonSource.schemaFromStream(
        getClass.getResourceAsStream("/remotes/folder/folderInteger.json")
      ).get
    )
    .addSchema(
      "http://localhost:1234/name.json",
      JsonSource.schemaFromStream(
        getClass.getResourceAsStream("/remotes/name.json")
      ).get
    )

  "refRemote draft7" in {
    validate("refRemote", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class NotSpec extends Specification with JsonSpec {

  "not draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("not", "draft4")
  }

  "not draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("not", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class MultipleOfSpec extends Specification with JsonSpec {

  "multipleOf draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("multipleOf", "draft4")
  }

  "multipleOf draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("multipleOf", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.internal.validators.DefaultFormats
import com.eclipsesource.schema.urlhandlers.ClasspathUrlHandler
import org.specs2.mutable.Specification
import play.api.libs.json.Json

class UrlHandlerSpec extends Specification with ErrorHelper { self =>

  "UrlHandlers" should {

    import Version4._

    val clazz = this.getClass

    // no handler at all
    "should fail to resolve absolute references on the classpath if not handler available" in {
      val validator = SchemaValidator(Some(Version4))
      val someJson = clazz.getResourceAsStream("/schemas/my-schema-with-protocol-ful-absolute-path.schema")
      val schema = JsonSource.schemaFromStream(someJson)
      validator.validate(schema.get, Json.obj("foo" -> Json.obj("bar" -> "Munich")))
        .isError must beTrue
    }

    // absolute protocol-ful handler
    "should resolve absolute references on the classpath with ClasspathUrlProtocolHandler" in {
      val validator = SchemaValidator(Some(Version4)).addUrlHandler(new ClasspathUrlHandler(), ClasspathUrlHandler.Scheme)
      val someJson = clazz.getResourceAsStream("/schemas/my-schema-with-protocol-ful-absolute-path.schema")
      val schema = JsonSource.schemaFromStream(someJson)
      val result = validator.validate(schema.get, Json.obj("foo" -> Json.obj("bar" -> "Munich")))
      result.isSuccess must beTrue
    }

    "should resolve absolute references on classpath with ClasspathUrlProtocolHandler (version 7)" in {
      import Version7._
      val validator = SchemaValidator(Some(Version7(new SchemaConfigOptions {
        override def formats: Map[String, SchemaFormat] = DefaultFormats.formats
        override def supportsExternalReferences: Boolean = true
      }))).addUrlHandler(new ClasspathUrlHandler(), ClasspathUrlHandler.Scheme)
      val schema = JsonSource.schemaFromString(
        """{
          |  "type": "object",
          |  "properties": {
          |     "schema": {
          |        "$ref": "classpath:///refs/json-schema-draft-07.json"
          |     }
          |  }
          |}
        """.stripMargin)
      val result = validator.validate(schema.get, Json.obj("schema" -> Json.obj()))
      result.isSuccess must beTrue
    }

    "should resolve relative references on classpath (valid instance)" in {
      val validator = SchemaValidator(Some(Version4))
      val url = clazz.getResource("/schemas/my-schema-with-protocol-less-relative-path.schema")
      validator.validate(url)(Json.obj("foo" -> Json.obj("bar" -> "Munich")))
        .isSuccess must beTrue
    }

    "should resolve relative references on the classpath (invalid instance)" in {
      val validator = SchemaValidator(Some(Version4))
      val url = clazz.getResource("/schemas/my-schema-with-protocol-less-relative-path.schema")
      val res = validator.validate(url)(Json.obj("foo" -> Json.obj("bar" -> 3)))
      firstErrorOf(res) must beEqualTo("Wrong type. Expected string, was number.")
    }
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class EnumSpec extends Specification with JsonSpec {

  "enum draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("enum", "draft4")
  }

  "enum draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("enum", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class UniqueItemsSpec extends Specification with JsonSpec {

  "uniqueItems draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("uniqueItems", "draft4")
  }

  "uniqueItems draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("uniqueItems", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class DefaultSpec extends Specification with JsonSpec {

  "validate draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("default", "draft4")
  }

  "validate draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("default", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class TypeSpec extends Specification with JsonSpec {

  "type draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("type", "draft4")
  }
  "type draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("type", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.Version4
import com.eclipsesource.schema.test.{Assets, JsonSpec}
import org.specs2.mutable.Specification
import org.specs2.specification.AfterAll
import org.specs2.specification.core.Fragments
import org.specs2.specification.dsl.Online
import play.api.Application
import play.api.inject.guice.GuiceApplicationBuilder
import play.api.mvc.DefaultActionBuilder
import play.api.test.TestServer

class RemoteSpecs extends Specification with JsonSpec with Online with AfterAll {

  import Version4._

  implicit val validator: SchemaValidator = {
    SchemaValidator(Some(Version4)).addSchema(
      "http://localhost:1234/scope_foo.json",
      JsonSource.schemaFromString(
        """{
          |  "definitions": {
          |    "bar": { "type": "string" }
          |  }
          |}""".stripMargin
      ).get
    )
  }

  def createApp: Application = new GuiceApplicationBuilder()
    .appRoutes(app => {
      val Action = app.injector.instanceOf[DefaultActionBuilder]
      Assets.routes(Action)(getClass, "remotes/")
    })
    .build()

  lazy val server = TestServer(port = 1234, createApp)

  def afterAll: Unit = {
    server.stop
    Thread.sleep(1000)
  }

  def validateAjv(testName: String): Fragments = validate(testName, "ajv_tests")

  sequential

  "Validation from remote resources is possible" >> {
    {
      server.start
      Thread.sleep(1000)
    } must not(throwAn[Exception]) continueWith {
      validateMultiple(
        "ajv_tests" -> Seq(
          "5_adding_dependency_after",
          "5_recursive_references",
          "12_restoring_root_after_resolve",
          "13_root_ref_in_ref_in_remote_ref",
          "14_ref_in_remote_ref_with_id",
          "62_resolution_scope_change"
        ),
        "draft4" -> Seq("refRemote")
      )
    }
  }

  validateAjv("1_ids_in_refs")
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class RequiredSpec extends Specification with JsonSpec {

  "required draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("required", "draft4")
  }

  "required draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("required", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class MaxItemsSpec extends Specification with JsonSpec {

  "maxItems draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("maxItems", "draft4")
  }

  "maxItems draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("maxItems", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification
import play.api.libs.json.{JsArray, JsNumber}

class AdditionalItemsSpec extends Specification with JsonSpec {

  "validate draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("additionalItems", "draft4")
  }

  "validate draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("additionalItems", "draft7")
  }

  "AdditionalItems" should {
    import Version7._
    val schema = JsonSource.schemaFromString(
      """{
        |  "items": [{}, {}, {}],
        |  "additionalItems": false
        |}""".stripMargin).get

    "no additional items present" in {
      val data = JsArray(Seq(JsNumber(1), JsNumber(2), JsNumber(3)))
      SchemaValidator(Some(Version4)).validate(schema, data).isSuccess must beTrue
    }
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class PatternPropertiesSpec extends Specification with JsonSpec {

  "patternProperties draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("patternProperties", "draft4")
  }

  "patternProperties draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("patternProperties", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class MaximumSpec extends Specification  with JsonSpec {

  "maximum draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("maximum", "draft4")
  }

  "maximum draft7" in {
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    import Version7._
    validate("maximum", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class AnyOfSpec extends Specification with JsonSpec {

  "anyOf draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("anyOf", "draft4")
    validate("anyOf", "ajv_tests")
  }

  "anyOf draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("anyOf", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class PatternSpec extends Specification with JsonSpec {

  "pattern draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("pattern", "draft4")
  }

  "pattern draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("pattern", "draft7")
  }
} 

package com.eclipsesource.schema.internal.serialization

import com.eclipsesource.schema._
import com.eclipsesource.schema.{JsonSource, SchemaType, SchemaValue}
import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.internal.draft7.constraints.{AnyConstraints7, NumberConstraints7, StringConstraints7}
import org.specs2.mutable.Specification
import play.api.libs.json.{JsArray, JsBoolean, JsString, Json}

class SchemaReadsSpec extends Specification {


  "Schema Reads for draft 4" should {

    import Version4._

    "not fail with match error (#104)" in {
      val schema = JsonSource.schemaFromString("""
        |{
        |  "someProp": {"type": "sting"}
        |}""".stripMargin)

      schema.isSuccess must beTrue
    }

    "not be able to read boolean schema" in {
      Json.fromJson[SchemaType](JsBoolean(true)).isError must beTrue
    }

    "fail if exclusiveMinimum is not a boolean" in {
      val result = JsonSource.schemaFromString(
        """{ "exclusiveMinimum": 3 }""".stripMargin
      )
      result.asEither must beLeft.like { case error => (error.toJson(0) \ "msgs").get.as[JsArray].value.head ==
        JsString("error.expected.jsboolean")
      }
    }
  }

  "Schema Reads for draft 7" should {

    import Version7._

    "read boolean schema" in {
      val booleanSchema = Json.fromJson[SchemaType](JsBoolean(true)).get
      booleanSchema must beEqualTo(SchemaValue(JsBoolean(true)))
    }

    "read compound type with error" in {
      val schema = JsonSource.schemaFromString("""
                                                 |{
                                                 |  "type": ["number", "string"]
                                                 |}""".stripMargin)

      schema.isSuccess must beTrue
      schema.asOpt must beSome.which(
        _ == CompoundSchemaType(
          Seq(
            SchemaNumber(NumberConstraints7().copy(any = AnyConstraints7().copy(schemaType = Some("number")))),
            SchemaString(StringConstraints7().copy(any = AnyConstraints7().copy(schemaType = Some("string"))))
          )
        )
      )
    }
  }
} 

package com.eclipsesource.schema.internal.refs

import org.specs2.mutable.Specification


class RefsSpec extends Specification {
  "Refs" should {
    "should define resolution scopes" in {

      Refs.mergeRefs(
        Ref("#foo"),
        Some(Ref("#bar"))
      ) must beEqualTo(Ref("#foo"))

      Refs.mergeRefs(
        Ref("#"), Some(Ref("http://x.y.z/rootschema.json#"))
      ) must beEqualTo(Ref("http://x.y.z/rootschema.json#"))

      Refs.mergeRefs(
        Ref("#foo"), Some(Ref("http://x.y.z/rootschema.json#"))
      ) must beEqualTo(Ref("http://x.y.z/rootschema.json#foo"))

      Refs.mergeRefs(
        Ref("otherschema.json"), Some(Ref("http://x.y.z/rootschema.json#"))
      ) must beEqualTo(Ref("http://x.y.z/otherschema.json#"))

      Refs.mergeRefs(
        Ref("#bar"), Some(Ref("http://x.y.z/otherschema.json"))
      ) must beEqualTo(Ref("http://x.y.z/otherschema.json#bar"))

      Refs.mergeRefs(
        Ref("t/inner.json#a"), Some(Ref("http://x.y.z/rootschema.json#"))
      ) must beEqualTo(Ref("http://x.y.z/t/inner.json#a"))

      Refs.mergeRefs(
        Ref("some://where.else/completely#"), Some(Ref("http://x.y.z/rootschema.json#"))
      ) must beEqualTo(Ref("some://where.else/completely#"))
    }
  }
} 

package com.eclipsesource.schema.internal.refs

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.{JsonSource, SchemaType, SchemaValue}
import org.specs2.mutable.Specification
import play.api.libs.json.JsNumber

class ResolveNumberConstraintsSpec extends Specification {

  "draft v4" should {

    import Version4._
    val resolver = SchemaRefResolver(Version4)

    "resolve number constraints" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "type": "integer",
          |  "minimum": 0,
          |  "maximum": 10,
          |  "multipleOf": 2
          |}""".stripMargin).get

      val scope = SchemaResolutionScope(schema)
      resolver.resolveFromRoot("#/minimum", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(0)))
      resolver.resolveFromRoot("#/maximum", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(10)))
      resolver.resolveFromRoot("#/multipleOf", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(2)))
    }
  }

  "draft v7" should {

    import Version7._
    val resolver = SchemaRefResolver(Version7)

    "resolve number constraints" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "type": "integer",
          |  "minimum": 0,
          |  "maximum": 10,
          |  "multipleOf": 2
          |}""".stripMargin).get

      val scope = SchemaResolutionScope(schema)
      resolver.resolveFromRoot("#/minimum", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(0)))
      resolver.resolveFromRoot("#/maximum", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(10)))
      resolver.resolveFromRoot("#/multipleOf", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(2)))
    }
  }
} 

package com.eclipsesource.schema.internal.refs

import com.eclipsesource.schema.{JsonSource, SchemaString, SchemaType}
import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.internal.draft7.constraints.StringConstraints7
import org.specs2.mutable.Specification
import play.api.libs.json.{JsBoolean, JsObject, JsString, JsValue}

class ResolveObjectConstraintsSpec extends Specification {

  "draft v4" should {

    import Version4._
    val resolver = SchemaRefResolver(Version4)

    "resolve dependencies constraint" in {
      val schema = JsonSource.schemaFromString(
        """{
          |"dependencies": {
          |    "a": "b",
          |    "c": ["d", "e"]
          |  }
          |}""".stripMargin).get

      val resolved = resolver.resolveFromRoot("#/dependencies/c/1", SchemaResolutionScope(schema))
      resolved.right.map(_.toJson) must beRight[JsValue](JsString("e"))
    }

    "resolve patternProperties constraint" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "patternProperties": {
          |        "^(/[^/]+)+$": {}
          |  }
          |}""".stripMargin).get
      val result = resolver.resolveFromRoot("#/patternProperties", SchemaResolutionScope(schema))
      result.map(_.toJson).right.get must beAnInstanceOf[JsObject]
    }

    "should resolve additionalProperties constraint" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "additionalProperties": false
          |}""".stripMargin).get

      val result = resolver.resolveFromRoot("#/additionalProperties", SchemaResolutionScope(schema))
      result.map(_.toJson) must beRight[JsValue](JsBoolean(false))
    }
  }

  "draft v7" should {

    import Version7._
    val resolver = SchemaRefResolver(Version7)

    "resolve dependencies constraint" in {
      val schema = JsonSource.schemaFromString(
        """{
          |"dependencies": {
          |    "a": "b",
          |    "c": ["d", "e"]
          |  }
          |}""".stripMargin).get

      val resolved = resolver.resolveFromRoot("#/dependencies/c/1", SchemaResolutionScope(schema))
      resolved.right.map(_.toJson) must beRight[JsValue](JsString("e"))
    }

    "resolve patternProperties constraint" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "patternProperties": {
          |        "^(/[^/]+)+$": {}
          |  }
          |}""".stripMargin).get
      val result = resolver.resolveFromRoot("#/patternProperties", SchemaResolutionScope(schema))
      result.map(_.toJson).right.get must beAnInstanceOf[JsObject]
    }

    "should resolve additionalProperties constraint" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "additionalProperties": false
          |}""".stripMargin).get

      val result = resolver.resolveFromRoot("#/additionalProperties", SchemaResolutionScope(schema))
      result.map(_.toJson) must beRight[JsValue](JsBoolean(false))
    }

    "should resolve additionalProperties constraint" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "propertyNames": {"maxLength": 3}
          |}""".stripMargin).get

      val result = resolver.resolveFromRoot("#/propertyNames", SchemaResolutionScope(schema))
      result.map(_.resolved) must beRight[SchemaType](SchemaString(StringConstraints7().copy(maxLength = Some(3))))
    }
  }
} 

package com.eclipsesource.schema.internal.refs

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.internal.constraints.Constraints.Minimum
import com.eclipsesource.schema.internal.draft7.constraints.NumberConstraints7
import com.eclipsesource.schema.{JsonSource, SchemaNumber, SchemaType, SchemaValue}
import org.specs2.mutable.Specification
import play.api.libs.json.{JsBoolean, JsNumber}

class ResolveArrayConstraintsSpec extends Specification {

  "draft v4" should {

    import Version4._
    val resolver = SchemaRefResolver(Version4)

    "resolve array constraints" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "items": {
          |    "type": "integer"
          |  },
          |  "minItems": 42,
          |  "maxItems": 99,
          |  "additionalItems": false,
          |  "uniqueItems": false
          |}""".stripMargin).get

      val scope = SchemaResolutionScope(schema)
      resolver.resolveFromRoot("#/minItems", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(42)))
      resolver.resolveFromRoot("#/maxItems", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(99)))
      resolver.resolveFromRoot("#/additionalItems", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsBoolean(false)))
      resolver.resolveFromRoot("#/uniqueItems", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsBoolean(false)))
    }
  }

  "draft v7" should {

    import Version7._
    val resolver = SchemaRefResolver(Version7)

    "resolve array constraints" in {
      val schema = JsonSource.schemaFromString(
        """{
          |  "items": {
          |    "type": "integer"
          |  },
          |  "minItems": 42,
          |  "maxItems": 99,
          |  "additionalItems": false,
          |  "uniqueItems": false,
          |  "contains": {
          |    "minimum": 55
          |  }
          |}""".stripMargin).get

      val scope = SchemaResolutionScope(schema)
      resolver.resolveFromRoot("#/minItems", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(42)))
      resolver.resolveFromRoot("#/maxItems", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(99)))
      resolver.resolveFromRoot("#/additionalItems", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsBoolean(false)))
      resolver.resolveFromRoot("#/uniqueItems", scope).map(_.resolved) must beRight[SchemaType](SchemaValue(JsBoolean(false)))
      resolver.resolveFromRoot("#/contains", scope).map(_.resolved) must beRight[SchemaType](
        SchemaNumber(NumberConstraints7(Some(Minimum(BigDecimal(55), Some(false)))))
      )
    }
  }
} 

package com.eclipsesource.schema.internal.refs

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.{JsonSource, SchemaType, SchemaValue}
import org.specs2.mutable.Specification
import play.api.libs.json.{JsNumber, JsString}

class ResolveStringConstraintsSpec extends Specification {

  "draft v4" should {

    import Version4._
    val resolver = SchemaRefResolver(Version4)

    "resolve string constraints" in {
      val schema =
        JsonSource.schemaFromString(
          """{
            |  "type": "string",
            |  "minLength": 1,
            |  "maxLength": 10,
            |  "pattern": "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"
            |}""".stripMargin).get

      val scope = SchemaResolutionScope(schema)
      resolver.resolveFromRoot("#/minLength", scope)
        .map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(1)))
      resolver.resolveFromRoot("#/maxLength", scope)
        .map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(10)))
      resolver.resolveFromRoot("#/pattern", scope)
        .map(_.resolved) must beRight[SchemaType](SchemaValue(JsString("^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$")))
    }
  }

  "draft v7" should {

    import Version7._
    val resolver = SchemaRefResolver(Version7)

    "resolve string constraints" in {
      val schema =
        JsonSource.schemaFromString(
          """{
            |  "type": "string",
            |  "minLength": 1,
            |  "maxLength": 10,
            |  "pattern": "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"
            |}""".stripMargin).get

      val scope = SchemaResolutionScope(schema)
      resolver.resolveFromRoot("#/minLength", scope)
        .map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(1)))
      resolver.resolveFromRoot("#/maxLength", scope)
        .map(_.resolved) must beRight[SchemaType](SchemaValue(JsNumber(10)))
      resolver.resolveFromRoot("#/pattern", scope)
        .map(_.resolved) must beRight[SchemaType](SchemaValue(JsString("^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$")))
    }
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class DefinitionsSpec extends Specification with JsonSpec { self =>

  "validate draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("definitions", "draft4")
  }

  "validate draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("definitions", "draft7")
  }

} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class MinimumSpec extends Specification with JsonSpec {

  "minimum draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("minimum", "draft4")
  }

  "minimum draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("minimum", "draft7")
  }
} 

package com.eclipsesource.schema

import org.specs2.mutable.Specification
import play.api.libs.json.{JsValue, Json}

import scala.util.Try

class TinCanSpec extends Specification { self =>

  import com.eclipsesource.schema.drafts.Version4

  val instance = JsonSource.fromString(
    """
      |{
      |  "actor": {
      |    "name": "Sally Glider",
      |    "mbox": "mailto:[email protected]"
      |  },
      |  "verb": {
      |    "id": "http://adlnet.gov/expapi/verbs/experienced",
      |    "display": { "en-US": "experienced" }
      |  },
      |  "object": {
      |    "id": "http://example.com/activities/solo-hang-gliding",
      |    "definition": {
      |      "name": { "en-US": "Solo Hang Gliding" }
      |    }
      |  }
      |}
    """.stripMargin).get


  "Tin Can Spec" should {

    import Version4._

    def readSchema(filename: String) =
      JsonSource.schemaFromStream(self.getClass.getResourceAsStream(s"/tincan/$filename.json")).get

    "validate basic statement object" in {

      val validator = SchemaValidator(Some(Version4))
        .addSchema("#agent", readSchema("agent"))
        .addSchema("#group", readSchema("group"))
        .addSchema("#inversefunctional", readSchema("inversefunctional"))
        .addSchema("#mbox", readSchema("mbox"))
        .addSchema("#statement_base", readSchema("statement_base"))
        .addSchema("#statement_object", readSchema("statement_object"))
        .addSchema("#verb", readSchema("verb"))
        .addSchema("#languagemap", readSchema("languagemap"))
        .addSchema("#activity", readSchema("activity"))
        .addSchema("#activity_definition", readSchema("activity_definition"))
        .addSchema("#activityid", readSchema("activityid"))

      val result = validator.validate(readSchema("statement_base"), instance)
      result.isSuccess must beTrue
    }
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.internal.refs.{SchemaRefResolver, SchemaResolutionScope}
import com.eclipsesource.schema.internal.validators.ArrayValidator
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification
import play.api.libs.json.{JsNumber, Json}

class ItemsSpec extends Specification with JsonSpec {

  "validate draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("items", "draft4")
  }

  "validate draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("items", "draft7")
  }

  "validate array with some invalid items" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    val schema = JsonSource.schemaFromString(
      """{
        |  "type": "array",
        |  "items": {
        |    "minimum": 3
        |  }
        |}""".stripMargin).get

    val instance = Json.arr(2, 3, 4, 1)

    val result = validator.validate(schema, instance)
    result.isError must beTrue
    result.asEither must beLeft.like { case error =>
      error.toJson.value must haveLength(2)
    }
  }

  "validate array with wrong json type" in {
    import Version4._
    val schema = JsonSource.schemaFromString(
      """{
        |  "type": "array",
        |  "items": {
        |    "minimum": 3
        |  }
        |}""".stripMargin).get.asInstanceOf[SchemaArray]
    val context = SchemaResolutionContext(SchemaRefResolver(Version4), SchemaResolutionScope(schema))
    val result = ArrayValidator.validate(schema, JsNumber(2), context)
    result.isFailure must beTrue
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.Version4
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification
import play.api.libs.json.JsNumber

class BigNumSpec extends Specification with JsonSpec {

  import Version4._
  implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
  validate("optional/bignum", "draft4")

  "Bignum" should {

    "be an integer" in {
      val schema = JsonSource.schemaFromString(""" {"type": "integer"} """).get
      val instance = JsNumber(BigDecimal("12345678910111213141516171819202122232425262728293031"))
      val result = SchemaValidator(Some(Version4)).validate(schema)(instance)
      result.asOpt must beSome.which(_ == JsNumber(BigDecimal("12345678910111213141516171819202122232425262728293031")))
    }

  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class AdditionalPropertiesSpec extends Specification with JsonSpec {

  "additionalProperties draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("additionalProperties", "draft4")
  }

  "additionalProperties draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("additionalProperties", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class MinItemsSpec extends Specification with JsonSpec {

  "minItems draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("minItems", "draft4")
  }

  "minItems draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("minItems", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.Version4
import org.specs2.mutable.Specification

class SchemaSpec extends Specification { self =>

  "Schema draft v7" should {
    "validate itself" in {
      import com.eclipsesource.schema.drafts.Version7._
      val schema = JsonSource.fromUrl(self.getClass.getResource("/refs/json-schema-draft-07.json")).get
      val jsonSchema = JsonSource.schemaFromStream(self.getClass.getResourceAsStream("/refs/json-schema-draft-07.json")).get
      implicit val validator: SchemaValidator = SchemaValidator()
      validator.validate(jsonSchema, schema).isSuccess must beTrue
    }
  }

  "Schema draft v4" should {
    "validate itself" in {
      import Version4._
      val schema = JsonSource.fromUrl(self.getClass.getResource("/refs/json-schema-draft-04.json")).get
      val jsonSchema = JsonSource.schemaFromStream(self.getClass.getResourceAsStream("/refs/json-schema-draft-04.json")).get
      implicit val validator: SchemaValidator = SchemaValidator()
      validator.validate(jsonSchema, schema).isSuccess must beTrue
    }
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.Version4
import org.specs2.mutable.Specification
import play.api.libs.json.Json

class Issue99Spec extends Specification { self =>

  "Issue 99 Spec" should {

    import Version4._

    "validate issue 99 test case" in {
      val schema = JsonSource.schemaFromString(
        """
          |{
          |  "type": "object",
          |  "properties": {
          |    "mything": { "$ref": "#thing" }
          |  },
          |  "definitions": {
          |    "thing": {
          |      "id": "#thing",
          |      "type": "string"
          |    }
          |  }
          |}
        """.stripMargin).get
      val validator = SchemaValidator(Some(Version4))
      validator.validate(schema, Json.obj(
        "mything" -> "test"
      )).isSuccess must beTrue
    }

    "validate issue 99-1 test case via URL" in {
      val schemaUrl = self.getClass.getResource("/issue-99-1.json")
      val validator = SchemaValidator(Some(Version4))
      val result = validator.validate(schemaUrl)(Json.obj(
        "mything" -> "test"
      ))
      result.isSuccess must beTrue
    }

    "not cause stack overflow for issue 99-5 test case via URL" in {
      val schemaUrl = self.getClass.getResource("/issue-99-5.json")
      val validator = SchemaValidator(Some(Version4))
      // must terminate
      validator.validate(schemaUrl)(Json.obj(
        "mything" -> "test"
      )).isError must beTrue
    }
  }

} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class OneOfSpec extends Specification with JsonSpec {

  import Version4._

  "oneOf draft4" in {
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("oneOf", "draft4")
    validate("oneOf", "ajv_tests")
  }

  "oneOf draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("oneOf", "draft7")
  }

  "oneOf must be array of objects (invalid)" in {
    val schema = JsonSource.schemaFromString(
      """{
        | "oneOf": [
        |  "#/definitions/foo"
        | ]
        |}""".stripMargin)
    schema.isError must beTrue
  }

  "oneOf must be array of objects (valid)" in {
    val schema = JsonSource.schemaFromString(
      """{
        | "oneOf": [{
        |  "$ref": "#/definitions/foo"
        | }]
        |}""".stripMargin)
    schema.isSuccess must beTrue
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class PropertiesSpec extends Specification with JsonSpec {

  "properties draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("properties", "draft4")
  }

  "properties draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("properties", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.Version4
import org.specs2.mutable.Specification

class ExamplesSpec extends Specification {

  val validator = SchemaValidator(Some(Version4))
  val swaggerSchemaUrl = "/test-schemas/swagger-2.0"

  private def validateExample(schema: String, url: String) = {
    val schemaUrl = getClass.getResource(url)
    val instanceUrl = getClass.getResource(url)
    val instance = JsonSource.fromUrl(instanceUrl)
    val result   = validator.validate(schemaUrl)(instance.get)
    result.isSuccess must beTrue
    result.get must beEqualTo(instance.get)
  }

  "Validator" should {
    "validate petstore-minimal" in {
      validateExample(swaggerSchemaUrl, "/test-schemas/petstore-minimal.json")
    }

    "validate petstore-simple" in {
      validateExample(swaggerSchemaUrl, "/test-schemas/petstore-simple.json")
    }

    "validate petstore-expanded" in {
      validateExample(swaggerSchemaUrl, "/test-schemas/petstore-expanded.json")
    }

    "validate petstore-with-external-docs" in {
      validateExample(swaggerSchemaUrl, "/test-schemas/petstore-with-external-docs.json")
    }

    "validate petstore" in {
      validateExample(swaggerSchemaUrl, "/test-schemas/petstore.json")
    }

    "validate core schema agsinst itself" in {
      validateExample("/test-schemas/schema", "/test-schemas/schema")
    }
  }

} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification
import play.api.libs.json.JsString

class MinLengthSpec extends Specification with JsonSpec {

  "validate draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("minLength", "draft4")
  }

  "validate draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("minLength", "draft7")
  }

  "MinLength" should {

    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))

    "validate against numeric strings that are long enough" in {
      val schema = JsonSource.schemaFromString(
        """{
          |"minLength": 3
        }""".stripMargin).get

      validator.validate(schema)(JsString("123")).isSuccess must beTrue
    }

    "not validate against numeric strings that are too short" in {
      val schema = JsonSource.schemaFromString(
        """{
          |"minLength": 3
        }""".stripMargin).get

      validator.validate(schema)(JsString("12")).isError must beTrue
    }

  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification

class MaxPropertiesSpec extends Specification with JsonSpec {

  "maxProperties draft4" in {
    import Version4._
    implicit val validator = SchemaValidator(Some(Version4))
    validate("maxProperties", "draft4")
  }

  "maxProperties draft7" in {
    import Version7._
    implicit val validator = SchemaValidator(Some(Version7))
    validate("maxProperties", "draft7")
  }
} 

package com.eclipsesource.schema

import com.eclipsesource.schema.drafts.{Version4, Version7}
import com.eclipsesource.schema.test.JsonSpec
import org.specs2.mutable.Specification
import play.api.libs.json._

class MaxLengthSpec extends Specification with JsonSpec {

  "maxLength draft4" in {
    import Version4._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version4))
    validate("maxLength", "draft4")
  }

  "maxLength draft7" in {
    import Version7._
    implicit val validator: SchemaValidator = SchemaValidator(Some(Version7))
    validate("maxLength", "draft7")
  }

  "MaxLength" should {
    import Version4._
    "fail with an error in case the string is too long" in {
      val schema = JsonSource.schemaFromString(
        """{
          |"maxLength": 2
        }""".stripMargin).get
      val json = JsString("foo")
      val result = SchemaValidator(Some(Version4)).validate(schema)(json)
      result.isError must beTrue
      result.asEither must beLeft.like {
        case error => (error.toJson(0) \ "msgs") == JsDefined(JsArray(Seq(JsString("'foo' exceeds maximum length of 2."))))
      }
    }
  }
} 

package com.decodified.scalassh

import org.specs2.mutable.Specification

class HostFileConfigSpec extends Specification {

  "Depending on the host file the HostFileConfig should produce a proper" >> {
    "PasswordLogin" ! {
      config("password.com") === Right(HostConfig(PasswordLogin("bob", "123"), "password.com", enableCompression = true))
    }
    "unencrypted PublicKeyLogin" ! {
      config("keyfile.com") === Right(HostConfig(PublicKeyLogin("alice", "/some/file"), "xyz.special.com", port = 30))
    }
    "encrypted PublicKeyLogin" ! {
      config("enc-keyfile.com") === Right(HostConfig(PublicKeyLogin("alice", "superSecure", "/some/file" :: Nil), "enc-keyfile.com"))
    }
    "AgentLogin" ! {
      config("agent.com") === Right(HostConfig(AgentLogin("bob"), "agent.com", enableCompression = true))
    }
    "error message if the file is missing" ! {
      config("non-existing.net").left.get === "Host resources 'non-existing.net', 'net' not found, either " +
        "provide one or use a concrete HostConfig, PasswordLogin, PublicKeyLogin or AgentLogin"
    }
    "error message if the login-type is invalid" ! {
      config("invalid-login-type.com").left.get must startingWith("Illegal login-type setting 'fancy pants'")
    }
    "error message if the username is missing" ! {
      config("missing-user.com").left.get must endWith("is missing required setting 'username'")
    }
    "error message if the host file contains an illegal line" ! {
      config("illegal-line.com").left.get must endWith("contains illegal line:\nthis line triggers an error!")
    }
  }

  "The sequence of searched config locations for host `node42.tier1.example.com`" should
    "be as described in the README" ! {
      HostFileConfig.searchLocations("node42.tier1.example.com").toList ===
        "node42.tier1.example.com" ::
        "node4X.tier1.example.com" ::
        "nodeXX.tier1.example.com" ::
        "tier1.example.com" ::
        "tierX.example.com" ::
        "example.com" ::
        "com" :: Nil
    }

  val config = HostResourceConfig()
} 

package sjsonnew
package support.spray

import spray.json.{ JsArray, JsNumber, JsString, JsObject }
import org.specs2.mutable.Specification

class IsoLListFormatSpec extends Specification with BasicJsonProtocol {
  sealed trait Contact
  case class Person(name: String, value: Option[Int]) extends Contact
  case class Organization(name: String, value: Option[Int]) extends Contact

  implicit val personIso: IsoLList.Aux[Person, String :*: Option[Int] :*: LNil] = LList.isoCurried(
    { p: Person => ("name", p.name) :*: ("value", p.value) :*: LNil })
    { in => Person(
      in.find[String]("name").get,
      in.find[Option[Int]]("value").flatten) }

  implicit val organizationIso: IsoLList.Aux[Organization, String :*: Option[Int] :*: LNil] = LList.isoCurried(
    { o: Organization => ("name", o.name) :*: ("value", o.value) :*: LNil })
    { in => Organization(
      in.find[String]("name").get,
      in.find[Option[Int]]("value").flatten) }

  implicit val ContactFormat: JsonFormat[Contact] = flatUnionFormat2[Contact, Person, Organization]("$type")

  val p1 = Person("Alice", Some(1))
  val personJs = JsObject("$fields" -> JsArray(JsString("name"), JsString("value")),
    "name" -> JsString("Alice"), "value" -> JsNumber(1))
  val c1: Contact = Organization("Company", None)
  val contactJs =
    JsObject(
      "$type" -> JsString("Organization"),
      "$fields" -> JsArray(JsString("name"), JsString("value")),
      "name" -> JsString("Company")
    )
  "The isomorphism from a custom type to LList" should {
    "convert from value to JObject" in {
      Converter.toJsonUnsafe(p1) mustEqual personJs
    }
    "convert from JObject to the same value" in {
      Converter.fromJsonUnsafe[Person](personJs) mustEqual p1
    }
    "convert from a union value to JObject" in {
      Converter.toJsonUnsafe(c1) mustEqual contactJs
    }
  }
} 

package stellar.sdk

import org.specs2.concurrent.ExecutionEnv
import org.specs2.mutable.Specification
import stellar.sdk.model.ledger.{LedgerEntryChange, TransactionLedgerEntries}
import stellar.sdk.model.{Desc, Now}

import scala.concurrent.Await
import scala.concurrent.duration._
import scala.util.Try

class TransactionLedgerEntriesSpec(ee: ExecutionEnv) extends Specification {

  import ee.ec

  val last100 = Await.result(PublicNetwork.transactions(cursor = Now, order = Desc), 1.minute).take(100).toList

  "transaction meta parsing" should {
    "parse the last 100 without any issues" >> {
      Try {
        last100.map(_.ledgerEntries)
      } must beSuccessfulTry[Seq[TransactionLedgerEntries]]
    }
  }

  "fee ledger entry parsing" should {
    "parse the last 100 without any issues" >> {
      Try {
        last100.flatMap(_.feeLedgerEntries)
      } must beSuccessfulTry[Seq[LedgerEntryChange]]
    }
  }
} 

package stellar.sdk

import org.specs2.concurrent.ExecutionEnv
import org.specs2.mutable.Specification
import stellar.sdk.model.op.AccountMergeOperation
import stellar.sdk.model.{Account, AccountId, NativeAmount, TimeBounds, Transaction}

import scala.concurrent.Await
import scala.concurrent.duration._
import scala.util.Try

class FriendBotSpec(implicit ee: ExecutionEnv) extends Specification {

  "the test network" should {
    "allow account funding via friendbot" >> {
      // #friendbot_example
      val kp = KeyPair.random
      val response = TestNetwork.fund(kp)
      // #friendbot_example

      val r = Await.result(response, 1 minute)

      // roll it back in, to be a good testnet citizen
      implicit val n = TestNetwork
      val giveItBack = for {
        accn <- n.account(kp)
        friendbot <- response.map(_.transaction.transaction.source)
        response <- Transaction(accn,
          maxFee = NativeAmount(100),
          timeBounds = TimeBounds.Unbounded
        ).add(AccountMergeOperation(friendbot.id)).sign(kp).submit()
      } yield response
      Await.result(giveItBack, 1 minute)

      r.isSuccess must beTrue
    }

    "be used to serialise a transaction" >> {
      val accn = KeyPair.fromPassphrase("an account")
      val sequence = 1
      val txn = {
        // #new_transaction_example
        implicit val network = TestNetwork
        val account = Account(AccountId(accn.publicKey), sequence)
        Transaction(account, maxFee = NativeAmount(100), timeBounds = TimeBounds.Unbounded)
        // #new_transaction_example
      }
      Try(txn.encodeXDR) must beASuccessfulTry[String]
    }
  }

} 

package stellar.sdk

import okhttp3.HttpUrl
import org.specs2.concurrent.ExecutionEnv
import org.specs2.mutable.Specification
import stellar.sdk.model.domain.{DomainInfo, IssuerDocumentation, Validator}

import scala.concurrent.duration._

class DomainInfoItSpec(implicit ee: ExecutionEnv) extends Specification {

  "known stellar.toml files" should {
    "parse correctly" >> {
      // #domain_info_example
      DomainInfo.forDomain("stellar.org") must beSome(
        DomainInfo(
          version = Some("2.0.0"),
          accounts = List(
            KeyPair.fromAccountId("GB6NVEN5HSUBKMYCE5ZOWSK5K23TBWRUQLZY3KNMXUZ3AQ2ESC4MY4AQ"),
            KeyPair.fromAccountId("GATL3ETTZ3XDGFXX2ELPIKCZL7S5D2HY3VK4T7LRPD6DW5JOLAEZSZBA"),
            KeyPair.fromAccountId("GCVLWV5B3L3YE6DSCCMHLCK7QIB365NYOLQLW3ZKHI5XINNMRLJ6YHVX"),
            KeyPair.fromAccountId("GCVJDBALC2RQFLD2HYGQGWNFZBCOD2CPOTN3LE7FWRZ44H2WRAVZLFCU"),
            KeyPair.fromAccountId("GAMGGUQKKJ637ILVDOSCT5X7HYSZDUPGXSUW67B2UKMG2HEN5TPWN3LQ"),
            KeyPair.fromAccountId("GDUY7J7A33TQWOSOQGDO776GGLM3UQERL4J3SPT56F6YS4ID7MLDERI4"),
            KeyPair.fromAccountId("GCPWKVQNLDPD4RNP5CAXME4BEDTKSSYRR4MMEL4KG65NEGCOGNJW7QI2"),
            KeyPair.fromAccountId("GDKIJJIKXLOM2NRMPNQZUUYK24ZPVFC6426GZAEP3KUK6KEJLACCWNMX"),
            KeyPair.fromAccountId("GAX3BRBNB5WTJ2GNEFFH7A4CZKT2FORYABDDBZR5FIIT3P7FLS2EFOZZ"),
            KeyPair.fromAccountId("GBEVKAYIPWC5AQT6D4N7FC3XGKRRBMPCAMTO3QZWMHHACLHTMAHAM2TP"),
            KeyPair.fromAccountId("GCKJZ2YVECFGLUDJ5T7NZMJPPWERBNYHCXT2MZPXKELFHUSYQR5TVHJQ"),
            KeyPair.fromAccountId("GBA6XT7YBQOERXT656T74LYUVJ6MEIOC5EUETGAQNHQHEPUFPKCW5GYM"),
            KeyPair.fromAccountId("GD2D6JG6D3V52ZMPIYSVHYFKVNIMXGYVLYJQ3HYHG5YDPGJ3DCRGPLTP"),
            KeyPair.fromAccountId("GA2VRL65L3ZFEDDJ357RGI3MAOKPJZ2Z3IJTPSC24I4KDTNFSVEQURRA")
          ),
          issuerDocumentation = Some(IssuerDocumentation(
            name = Some("Stellar Development Foundation"),
            url = Some(HttpUrl.parse("https://www.stellar.org")),
            github = Some("stellar"),
            twitter = Some("StellarOrg"),
          )),
          validators = List(
            Validator(
              alias = Some("sdf1"),
              displayName = Some("SDF 1"),
              host = Some("core-live-a.stellar.org:11625"),
              publicKey = Some(KeyPair.fromAccountId("GCGB2S2KGYARPVIA37HYZXVRM2YZUEXA6S33ZU5BUDC6THSB62LZSTYH")),
              history = Some(HttpUrl.parse("http://history.stellar.org/prd/core-live/core_live_001/"))
            ),
            Validator(
              alias = Some("sdf2"),
              displayName = Some("SDF 2"),
              host = Some("core-live-b.stellar.org:11625"),
              publicKey = Some(KeyPair.fromAccountId("GCM6QMP3DLRPTAZW2UZPCPX2LF3SXWXKPMP3GKFZBDSF3QZGV2G5QSTK")),
              history = Some(HttpUrl.parse("http://history.stellar.org/prd/core-live/core_live_002/"))
            ),
            Validator(
              alias = Some("sdf3"),
              displayName = Some("SDF 3"),
              host = Some("core-live-c.stellar.org:11625"),
              publicKey = Some(KeyPair.fromAccountId("GABMKJM6I25XI4K7U6XWMULOUQIQ27BCTMLS6BYYSOWKTBUXVRJSXHYQ")),
              history = Some(HttpUrl.parse("http://history.stellar.org/prd/core-live/core_live_003/"))
            ),
          )
        )
      )
      // #domain_info_example
      .awaitFor(30.seconds)
    }
  }
} 

package stellar.sdk

import org.specs2.concurrent.ExecutionEnv
import org.specs2.mutable.Specification
import org.specs2.specification.BeforeAfterAll
import stellar.sdk.model._
import stellar.sdk.model.op.PaymentOperation
import stellar.sdk.util.ByteArrays

import scala.concurrent.Await
import scala.concurrent.duration._

class TestNetworkJourney(implicit ee: ExecutionEnv) extends Specification with BeforeAfterAll {

  implicit val network = TestNetwork

  private val testAccounts = new TestAccounts(4)

  def beforeAll() = testAccounts.open()
  def afterAll() = testAccounts.close()

  "a client" should {
    "be able to send a payment" >> {
      val List(senderKey, recipientKey) = testAccounts.take(2)
      val response = for {
        sender <- network.account(senderKey)
        payment = PaymentOperation(recipientKey.toAccountId, Amount.lumens(2))
        txn = Transaction(sender, List(payment), NoMemo, TimeBounds.Unbounded, Amount.lumens(1))
        response <- txn.sign(senderKey).submit()
      } yield response

      response.map(_.isSuccess) must beTrue.await(0, 1.minute)
    }

    "be able to fee bump a v0 transaction" >> {
      val List(senderKey, recipientKey) = testAccounts.take(2)
      val sender = Await.result(network.account((senderKey)), 10.seconds)
      val payment = PaymentOperation(recipientKey.toAccountId, Amount.lumens(2))
      val signedTransaction = Transaction(sender, List(payment), NoMemo, TimeBounds.Unbounded, NativeAmount(100))
        .sign(senderKey)
      val parsedV0Txn: SignedTransaction = SignedTransaction.decode.run(signedTransaction.encodeV0).value._2

      val bumpedTxn = parsedV0Txn.bumpFee(NativeAmount(500), recipientKey)
      val response = Await.result(bumpedTxn.submit(), 20.seconds)
      response.isSuccess must beTrue
    }
  }
} 

package stellar.sdk

import org.specs2.concurrent.ExecutionEnv
import org.specs2.mutable.Specification
import stellar.sdk.model.response.FederationResponse

import scala.concurrent.duration._

class FederationLookupSpec(implicit ec: ExecutionEnv) extends Specification {

  "federation server lookup" should {
    "find result by name" >> {
      FederationServer("https://keybase.io/_/api/1.0/stellar/federation.json")
        .byName("jem*keybase.io") must beSome(
        FederationResponse(
          address = "jem*keybase.io",
          account = KeyPair.fromAccountId("GBRAZP7U3SPHZ2FWOJLHPBO3XABZLKHNF6V5PUIJEEK6JEBKGXWD2IIE")
        )).awaitFor(10.seconds)
    }
  }

} 

package stellar.sdk.model

import org.json4s.NoTypeHints
import org.json4s.native.{JsonMethods, Serialization}
import org.specs2.mutable.Specification
import stellar.sdk.ArbitraryInput

class PaymentPathSpec extends Specification with ArbitraryInput {

  implicit val formats = Serialization.formats(NoTypeHints) + PaymentPathDeserializer

  "a payment path response document" should {
    "parse to a payment path" >> prop { path: PaymentPath =>

      def amountJson(prefix: String, amount: Amount) =
        s"""
           |"${prefix}amount": "${amount.toDisplayUnits}",
           |${assetJson(prefix, amount.asset)}
         """.stripMargin

      def assetJson(prefix: String, asset: Asset) = {
        asset match {
          case NativeAsset => s""""${prefix}asset_type": "native""""
          case issuedAsset: NonNativeAsset =>
            s"""
               |"${prefix}asset_type": "${issuedAsset.typeString}",
               |"${prefix}asset_code": "${issuedAsset.code}",
               |"${prefix}asset_issuer": "${issuedAsset.issuer.accountId}"
            """.stripMargin
        }
      }

      val json =
        s"""
           |{
           |  ${amountJson("source_", path.source)},
           |  ${amountJson("destination_", path.destination)},
           |  "path": ${path.path.map(j => s"{${assetJson("", j)}}").mkString("[", ",", "]")}
           |}
         """.stripMargin

      JsonMethods.parse(json).extract[PaymentPath] mustEqual path
    }
  }

  "the underlying amount parser" should {
    "not parse unrecognised asset type" >> {
      val doc = """{"foo_asset_type":"bananas"}"""
      AmountParser.parseAsset("foo_", JsonMethods.parse(doc)) must throwA[RuntimeException]
    }
  }

} 

package stellar.sdk.model

import org.specs2.mutable.Specification
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class StrKeySpec extends Specification with ArbitraryInput with DomainMatchers {

  "strkey" should {
    "encode and decode to same" >> prop { key: StrKey =>
      val string = key.encodeToChars.mkString
      StrKey.decodeFromString(string) must beEquivalentTo(key)
    }

    "fail to decode if any char is > 127" >> {
      StrKey.decodeFromString("welcome to the 草叢") must throwAn[AssertionError]
    }
  }

} 

package stellar.sdk.model

import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.specs2.mutable.Specification
import stellar.sdk.ArbitraryInput
import stellar.sdk.model.op.JsonSnippets

class TradeSpec extends Specification with ArbitraryInput with JsonSnippets {

  implicit val formats = Serialization.formats(NoTypeHints) + TradeDeserializer

  "trade" should {
    "parse from json" >> prop { trade: Trade =>

      val doc =
        s"""
           |{
           |  "_links": {
           |    "self": {"href": ""},
           |    "base": {"href": "https://horizon.stellar.org/accounts/GCI7ILB37OFVHLLSA74UCXZFCTPEBJOZK7YCNBI7DKH7D76U4CRJBL2A"},
           |    "counter": {"href": "https://horizon.stellar.org/accounts/GDRFRGR2FDUFF2RI6PQE5KFSCJHGSEIOGET22R66XSATP3BYHZ46BPLO"},
           |    "operation": {"href": "https://horizon.stellar.org/operations/38583306127675393"}
           |  },
           |  "id": "${trade.id}",
           |  "paging_token": "38583306127675393-2",
           |  "ledger_close_time": "${formatter.format(trade.ledgerCloseTime)}",
           |  "offer_id": "${trade.offerId}",
           |  "base_offer_id": "${trade.baseOfferId}",
           |  "base_account": "${trade.baseAccount.accountId}",
           |  ${amountDocPortion(trade.baseAmount, "base_amount", "base_")}
           |  ${amountDocPortion(trade.counterAmount, "counter_amount", "counter_")}
           |  "counter_account": "${trade.counterAccount.accountId}",
           |  "counter_offer_id": "${trade.counterOfferId}",
           |  "base_is_seller": ${trade.baseIsSeller}
           |}
         """.stripMargin

      parse(doc).extract[Trade] mustEqual trade
    }
  }

} 

package stellar.sdk.model.ledger

import com.typesafe.scalalogging.LazyLogging
import org.specs2.mutable.Specification

import scala.util.{Failure, Try}

class TransactionLedgerEntriesSpec extends Specification with LedgerEntryGenerators with LazyLogging {

  "a ledger entry" should {
    "serde to/from XDR" >> prop { entries: TransactionLedgerEntries =>
      val triedEntries = Try(TransactionLedgerEntries.decode.run(entries.encode).value._2)
      triedEntries match {
        case Failure(_) => logger.error(s"Failed to decode $entries")
        case _ =>
      }
      triedEntries must beSuccessfulTry(entries)
    }
  }

} 

package stellar.sdk.model.ledger

import com.typesafe.scalalogging.LazyLogging
import org.specs2.mutable.Specification

import scala.util.{Failure, Try}

class LedgerEntrySpec extends Specification with LedgerEntryGenerators with LazyLogging {

  "a ledger entry" should {
    "serde to/from XDR" >> prop { entry: LedgerEntry =>
      val triedEntry = Try(LedgerEntry.decode.run(entry.encode).value._2)
      triedEntry match {
        case Failure(_) => logger.error(s"Failed to decode $entry")
        case _ =>
      }
      triedEntry must beSuccessfulTry(entry)
    }
  }

} 

package stellar.sdk.model.ledger

import com.typesafe.scalalogging.LazyLogging
import org.specs2.mutable.Specification

import scala.util.{Failure, Try}

class LedgerEntryChangeSpec extends Specification with LedgerEntryGenerators with LazyLogging {

  "a ledger entry change" should {
    "serde to/from XDR" >> prop { change: LedgerEntryChange =>
      val triedChange = Try(LedgerEntryChange.decode.run(change.encode).value._2)
      triedChange match {
        case Failure(_) => logger.error(s"Failed to decode $change")
        case _ =>
      }
      triedChange must beSuccessfulTry(change)
    }
  }

} 

package stellar.sdk.model.op

import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers, KeyPair}

class AccountMergeOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[AccountMergeOperation]] = Arbitrary(genTransacted(genAccountMergeOperation))
  implicit val formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "account merge operation" should {
    "serde via xdr string" >> prop { actual: AccountMergeOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: AccountMergeOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[AccountMergeOperation] =>
      val doc =
        s"""
           | {
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659144"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659144"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account":"${op.operation.sourceAccount.get.accountId}",
           |  "type_i": 8,
           |  "type": "account_merge"
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  "account": "${op.operation.sourceAccount.get.accountId}",
           |  "into": "${KeyPair.fromPublicKey(op.operation.destination.hash).accountId}",
           |}
         """.stripMargin

      parse(doc).extract[Transacted[AccountMergeOperation]] mustEqual op
    }.setGen(genTransacted(genAccountMergeOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

} 

package stellar.sdk.model.op

import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class SetOptionsOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[SetOptionsOperation]] = Arbitrary(genTransacted(genSetOptionsOperation))
  implicit val formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "set options operation" should {
    "serde via xdr string" >> prop { actual: SetOptionsOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: SetOptionsOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded must beEquivalentTo(actual)
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[SetOptionsOperation] =>
      val doc =
        s"""
           |{
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659137"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659137/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659137"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659137"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  ${opt("inflation_dest", op.operation.inflationDestination.map(_.accountId))}
           |  ${opt("home_domain", op.operation.homeDomain)}
           |  ${opt("master_key_weight", op.operation.masterKeyWeight)}
           |  ${opt("signer_key", op.operation.signer.map(_.key.encodeToChars.mkString))}
           |  ${opt("signer_weight", op.operation.signer.map(_.weight))}
           |  ${opt("set_flags", op.operation.setFlags.map(_.map(_.i)))}
           |  ${opt("set_flags_s", op.operation.setFlags.map(_.map(_.s)))}
           |  ${opt("clear_flags", op.operation.clearFlags.map(_.map(_.i)))}
           |  ${opt("clear_flags_s", op.operation.clearFlags.map(_.map(_.s)))}
           |  ${opt("low_threshold", op.operation.lowThreshold)}
           |  ${opt("med_threshold", op.operation.mediumThreshold)}
           |  ${opt("high_threshold", op.operation.highThreshold)}
           |  "type": "set_options",
           |  "type_i": 5,
           |}
         """.stripMargin

      parse(doc).extract[Transacted[SetOptionsOperation]] must beEquivalentTo(op)
    }.setGen(genTransacted(genSetOptionsOperation.suchThat(_.sourceAccount.nonEmpty)))
  }
} 

package stellar.sdk.model.op

import org.json4s.{Formats, NoTypeHints}
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class PathPaymentStrictReceiveOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[PathPaymentStrictReceiveOperation]] = Arbitrary(genTransacted(genPathPaymentStrictReceiveOperation))
  implicit val formats: Formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "path payment operation" should {
    "serde via xdr string" >> prop { actual: PathPaymentStrictReceiveOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: PathPaymentStrictReceiveOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[PathPaymentStrictReceiveOperation] =>
      val doc =
        s"""
           |{
           |  "_links":{
           |    "self":{"href":"https://horizon-testnet.stellar.org/operations/940258535411713"},
           |    "transaction":{"href":"https://horizon-testnet.stellar.org/transactions/a995af17837d1b53fb5782269250a36e9dbe74170260b46f2708e5f23f7c864a"},
           |    "effects":{"href":"https://horizon-testnet.stellar.org/operations/940258535411713/effects"},
           |    "succeeds":{"href":"https://horizon-testnet.stellar.org/effects?order=desc&cursor=940258535411713"},
           |    "precedes":{"href":"https://horizon-testnet.stellar.org/effects?order=asc&cursor=940258535411713"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type":"path_payment",
           |  "type_i":2,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  ${amountDocPortion(op.operation.destinationAmount)}
           |  ${amountDocPortion(op.operation.sendMax, "source_max", "source_")}
           |  "from":"${op.operation.sourceAccount.get.accountId}",
           |  "to":"${op.operation.destinationAccount.publicKey.accountId}",
           |  "path":[${if (op.operation.path.isEmpty) "" else op.operation.path.map(asset(_)).mkString("{", "},{", "}")}]
           |}
         """.stripMargin

      parse(doc).extract[Transacted[Operation]] mustEqual removeDestinationSubAccountId(op)
    }.setGen(genTransacted(genPathPaymentStrictReceiveOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

  // Because sub accounts are not yet supported in Horizon JSON.
  private def removeDestinationSubAccountId(op: Transacted[PathPaymentStrictReceiveOperation]): Transacted[PathPaymentStrictReceiveOperation] = {
    op.copy(operation = op.operation.copy(destinationAccount = op.operation.destinationAccount.copy(subAccountId = None)))
  }
} 

package stellar.sdk.model.op

import org.json4s.{Formats, NoTypeHints}
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class CreateAccountOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[CreateAccountOperation]] = Arbitrary(genTransacted(genCreateAccountOperation))
  implicit val formats: Formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer + OperationDeserializer

  "create account operation" should {
    "serde via xdr string" >> prop { actual: CreateAccountOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: CreateAccountOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "be parsed from json " >> prop { op: Transacted[CreateAccountOperation] =>
      val doc =
        s"""
           |{
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659137"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659137/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659137"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659137"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type": "create_account",
           |  "type_i": 0,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  "starting_balance": "${amountString(op.operation.startingBalance)}",
           |  "funder": "${op.operation.sourceAccount.get.accountId}",
           |  "account": "${op.operation.destinationAccount.publicKey.accountId}"
           |}
         """.stripMargin

      parse(doc).extract[Transacted[CreateAccountOperation]] mustEqual removeDestinationSubAccountId(op)
    }.setGen(genTransacted(genCreateAccountOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

  // Because sub accounts are not yet supported in Horizon JSON.
  private def removeDestinationSubAccountId(op: Transacted[CreateAccountOperation]): Transacted[CreateAccountOperation] = {
    op.copy(operation = op.operation.copy(destinationAccount = op.operation.destinationAccount.copy(subAccountId = None)))
  }
} 

package stellar.sdk.model.op

import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class InflationOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[InflationOperation]] = Arbitrary(genTransacted(genInflationOperation))
  implicit val formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "the inflation operation" should {
    "serde via xdr string" >> prop { actual: InflationOperation =>
      Operation.decodeXDR(base64(actual.encode)) mustEqual actual
    }

    "serde via xdr bytes" >> prop { actual: InflationOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[InflationOperation] =>
      val doc =
        s"""
           | {
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659144"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659144"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type": "inflation",
           |  "type_i": 9,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |}
         """.stripMargin

      parse(doc).extract[Transacted[InflationOperation]] mustEqual op
    }.setGen(genTransacted(genInflationOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

} 

package stellar.sdk.model.op

import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class BumpSequenceOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[BumpSequenceOperation]] = Arbitrary(genTransacted(genBumpSequenceOperation))
  implicit val formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "bump sequence operation" should {
    "serde via xdr bytes" >> prop { actual: BumpSequenceOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "serde via xdr string" >> prop { actual: BumpSequenceOperation =>
      Operation.decodeXDR(ByteArrays.base64(actual.encode)) mustEqual actual
    }

    "parse from json" >> prop { op: Transacted[BumpSequenceOperation] =>
      val doc =
        s"""
           | {
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659144"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659144"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type": "bump_sequence",
           |  "type_i": 11,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  "bump_to": ${op.operation.bumpTo}
           |}
         """.stripMargin

      parse(doc).extract[Transacted[BumpSequenceOperation]] mustEqual op
    }.setGen(genTransacted(genBumpSequenceOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

} 

package stellar.sdk.model.op

import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class CreatePassiveSellOfferOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[CreatePassiveSellOfferOperation]] = Arbitrary(genTransacted(genCreatePassiveSellOfferOperation))
  implicit val formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer + OperationDeserializer

  "create passive offer operation" should {
    "serde via xdr string" >> prop { actual: CreatePassiveSellOfferOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: CreatePassiveSellOfferOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[CreatePassiveSellOfferOperation] =>
      val doc =
        s"""
           |{
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659137"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659137/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659137"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659137"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type": "create_passive_sell_offer",
           |  "type_i": 4,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  ${amountDocPortion(op.operation.selling, assetPrefix = "selling_")},
           |  ${asset(op.operation.buying, "buying_")},
           |  "offer_id": 0,
           |  "price": "1.0",
           |  "price_r": {
           |    "d": ${op.operation.price.d},
           |    "n": ${op.operation.price.n}
           |  }
           |}
         """.stripMargin

      parse(doc).extract[Transacted[CreatePassiveSellOfferOperation]] mustEqual op
    }.setGen(genTransacted(genCreatePassiveSellOfferOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

} 

package stellar.sdk.model.op

import org.json4s.{Formats, NoTypeHints}
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class PathPaymentStrictSendOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[PathPaymentStrictSendOperation]] = Arbitrary(genTransacted(genPathPaymentStrictSendOperation))
  implicit val formats: Formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "path payment operation" should {
    "serde via xdr string" >> prop { actual: PathPaymentStrictSendOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: PathPaymentStrictSendOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[PathPaymentStrictSendOperation] =>
      val doc =
        s"""
           |{
           |  "_links":{
           |    "self":{"href":"https://horizon-testnet.stellar.org/operations/940258535411713"},
           |    "transaction":{"href":"https://horizon-testnet.stellar.org/transactions/a995af17837d1b53fb5782269250a36e9dbe74170260b46f2708e5f23f7c864a"},
           |    "effects":{"href":"https://horizon-testnet.stellar.org/operations/940258535411713/effects"},
           |    "succeeds":{"href":"https://horizon-testnet.stellar.org/effects?order=desc&cursor=940258535411713"},
           |    "precedes":{"href":"https://horizon-testnet.stellar.org/effects?order=asc&cursor=940258535411713"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type":"path_payment_strict_send",
           |  "type_i":13,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  ${amountDocPortion(op.operation.sendAmount, assetPrefix = "source_")}
           |  ${amountDocPortion(op.operation.destinationMin, "destination_min")}
           |  "from":"${op.operation.sourceAccount.get.accountId}",
           |  "to":"${op.operation.destinationAccount.publicKey.accountId}",
           |  "path":[${if (op.operation.path.isEmpty) "" else op.operation.path.map(asset(_)).mkString("{", "},{", "}")}]
           |}
         """.stripMargin

      parse(doc).extract[Transacted[Operation]] mustEqual removeDestinationSubAccountId(op)
    }.setGen(genTransacted(genPathPaymentStrictSendOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

  // Because sub accounts are not yet supported in Horizon JSON.
  private def removeDestinationSubAccountId(op: Transacted[PathPaymentStrictSendOperation]): Transacted[PathPaymentStrictSendOperation] = {
    op.copy(operation = op.operation.copy(destinationAccount = op.operation.destinationAccount.copy(subAccountId = None)))
  }
} 

package stellar.sdk.model.op

import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers, KeyPair}

class AllowTrustOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[AllowTrustOperation]] = Arbitrary(genTransacted(genAllowTrustOperation))
  implicit val formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "allow trust operation" should {
    "serde via xdr string" >> prop { actual: AllowTrustOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: AllowTrustOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[AllowTrustOperation] =>
      val doc =
        s"""
           | {
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659144"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659144"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type": "allow_trust",
           |  "type_i": 7,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  "asset_type": "${if (op.operation.assetCode.length <= 4) "credit_alphanum4" else "credit_alphanum12"}",
           |  "asset_code": "${op.operation.assetCode}",
           |  "asset_issuer": "${op.operation.sourceAccount.get.accountId}"
           |  "trustor": "${op.operation.trustor.accountId}",
           |  "trustee": "${op.operation.sourceAccount.get.accountId}",
           |  "authorize": ${op.operation.trustLineFlags.contains(TrustLineAuthorized)}
           |  "authorize_to_maintain_liabilities": ${op.operation.trustLineFlags.contains(TrustLineCanMaintainLiabilities)}
           |}
         """.stripMargin

      val parsed = parse(doc).extract[Transacted[AllowTrustOperation]]
      parsed mustEqual op
      parsed.operation.authorize mustEqual op.operation.authorize
      parsed.operation.authorizeToMaintainLiabilities mustEqual op.operation.authorizeToMaintainLiabilities
    }.setGen(genTransacted(genAllowTrustOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

} 

package stellar.sdk.model.op

import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class ChangeTrustOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[ChangeTrustOperation]] = Arbitrary(genTransacted(genChangeTrustOperation))
  implicit val formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "change trust operation" should {
    "serde via xdr string" >> prop { actual: ChangeTrustOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: ChangeTrustOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[ChangeTrustOperation] =>
      val doc =
        s"""
           | {
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659144"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659144"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type": "change_trust",
           |  "type_i": 6,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  ${amountDocPortion(op.operation.limit, "limit")},
           |  "trustee": "${op.operation.limit.asset.issuer.accountId}",
           |  "trustor": "${op.operation.sourceAccount.get.accountId}",
           |}
         """.stripMargin

      parse(doc).extract[Transacted[ChangeTrustOperation]] mustEqual op
    }.setGen(genTransacted(genChangeTrustOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

} 

package stellar.sdk.model.op

import org.apache.commons.codec.binary.Base64
import org.json4s.NoTypeHints
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.{Arbitrary, Gen}
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers, PublicKey}

class ManageDataOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arbDelete: Arbitrary[Transacted[DeleteDataOperation]] = Arbitrary(genTransacted(genDeleteDataOperation))
  implicit val arbWrite: Arbitrary[Transacted[WriteDataOperation]] = Arbitrary(genTransacted(genWriteDataOperation))
  implicit val formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  def doc[O <: ManageDataOperation](op: Transacted[O]) = {
    val dataValue = op.operation match {
      case WriteDataOperation(_, value, _) => Base64.encodeBase64String(value.toArray)
      case _ => ""
    }

    s"""
      |{
      |  "_links": {
      |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144"},
      |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
      |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144/effects"},
      |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659144"},
      |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659144"}
      |  },
      |  "id": "${op.id}",
      |  "paging_token": "10157597659137",
      |  "source_account": "${op.operation.sourceAccount.get.accountId}",
      |  "type": "manage_data",
      |  "type_i": 1,
      |  "created_at": "${formatter.format(op.createdAt)}",
      |  "transaction_hash": "${op.txnHash}",
      |  "name": "${op.operation.name}",
      |  "value": "$dataValue"
      |}""".stripMargin
  }

  "a write data operation" should {
    "serde via xdr string" >> prop { actual: WriteDataOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: WriteDataOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded must beEquivalentTo(actual)
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[WriteDataOperation] =>
      parse(doc(op)).extract[Transacted[ManageDataOperation]] must beEquivalentTo(op)
    }.setGen(genTransacted(genWriteDataOperation.suchThat(_.sourceAccount.nonEmpty)))

    "encode a string payload as UTF-8 in base64" >> prop { (s: String, source: PublicKey) =>
      val value = new String(s.take(64).getBytes("UTF-8").take(60), "UTF-8")
      WriteDataOperation("name", value).value.toSeq mustEqual value.getBytes("UTF-8").toSeq
      WriteDataOperation("name", value, None).value.toSeq mustEqual value.getBytes("UTF-8").toSeq
      WriteDataOperation("name", value, Some(source)).value.toSeq mustEqual value.getBytes("UTF-8").toSeq
    }.setGen1(Arbitrary.arbString.arbitrary.suchThat(_.nonEmpty))

    "fail if the key is greater than 64 bytes" >> prop { s: String =>
      WriteDataOperation(s, "value") must throwAn[IllegalArgumentException]
    }.setGen(Gen.identifier.suchThat(_.getBytes("UTF-8").length > 64))

    "fail if the value is greater than 64 bytes" >> prop { s: String =>
      WriteDataOperation("name", s) must throwAn[IllegalArgumentException]
    }.setGen(Gen.identifier.suchThat(_.getBytes("UTF-8").length > 64))
  }

  "a delete data operation" should {
    "serde via xdr string" >> prop { actual: DeleteDataOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: DeleteDataOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[DeleteDataOperation] =>
      parse(doc(op)).extract[Transacted[ManageDataOperation]] mustEqual op
    }.setGen(genTransacted(genDeleteDataOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

} 

package stellar.sdk.model.op

import org.json4s.{Formats, NoTypeHints}
import org.json4s.native.JsonMethods.parse
import org.json4s.native.Serialization
import org.scalacheck.Arbitrary
import org.specs2.mutable.Specification
import stellar.sdk.util.ByteArrays.base64
import stellar.sdk.{ArbitraryInput, DomainMatchers}

class PaymentOperationSpec extends Specification with ArbitraryInput with DomainMatchers with JsonSnippets {

  implicit val arb: Arbitrary[Transacted[PaymentOperation]] = Arbitrary(genTransacted(genPaymentOperation))
  implicit val formats: Formats = Serialization.formats(NoTypeHints) + TransactedOperationDeserializer

  "payment operation" should {
    "serde via xdr string" >> prop { actual: PaymentOperation =>
      Operation.decodeXDR(base64(actual.encode)) must beEquivalentTo(actual)
    }

    "serde via xdr bytes" >> prop { actual: PaymentOperation =>
      val (remaining, decoded) = Operation.decode.run(actual.encode).value
      decoded mustEqual actual
      remaining must beEmpty
    }

    "parse from json" >> prop { op: Transacted[PaymentOperation] =>
      val doc =
        s"""
           | {
           |  "_links": {
           |    "self": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144"},
           |    "transaction": {"href": "https://horizon-testnet.stellar.org/transactions/17a670bc424ff5ce3b386dbfaae9990b66a2a37b4fbe51547e8794962a3f9e6a"},
           |    "effects": {"href": "https://horizon-testnet.stellar.org/operations/10157597659144/effects"},
           |    "succeeds": {"href": "https://horizon-testnet.stellar.org/effects?order=desc\u0026cursor=10157597659144"},
           |    "precedes": {"href": "https://horizon-testnet.stellar.org/effects?order=asc\u0026cursor=10157597659144"}
           |  },
           |  "id": "${op.id}",
           |  "paging_token": "10157597659137",
           |  "source_account": "${op.operation.sourceAccount.get.accountId}",
           |  "type": "payment",
           |  "type_i": 1,
           |  "created_at": "${formatter.format(op.createdAt)}",
           |  "transaction_hash": "${op.txnHash}",
           |  ${amountDocPortion(op.operation.amount)},
           |  "from": "${op.operation.sourceAccount.get.accountId}",
           |  "to": "${op.operation.destinationAccount.publicKey.accountId}",
           |}
         """.stripMargin

      parse(doc).extract[Transacted[PaymentOperation]] mustEqual removeDestinationSubAccountId(op)
    }.setGen(genTransacted(genPaymentOperation.suchThat(_.sourceAccount.nonEmpty)))
  }

  // Because sub accounts are not yet supported in Horizon JSON.
  private def removeDestinationSubAccountId(op: Transacted[PaymentOperation]): Transacted[PaymentOperation] = {
    op.copy(operation = op.operation.copy(destinationAccount = op.operation.destinationAccount.copy(subAccountId = None)))
  }
}