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

import actors.TestKitSpec
import akka.stream.ActorMaterializer
import akka.stream.scaladsl.Keep
import akka.stream.testkit.scaladsl.{TestSink, TestSource}
import akka.testkit.TestProbe
import org.scalatest.MustMatchers
import play.api.libs.json.{JsValue, Json}

import scala.concurrent.ExecutionContext

class HomeControllerSpec extends TestKitSpec with MustMatchers {

  "createWebSocketFlow" should {

    "create a websocket flow and send a message through" in {
      implicit val materializer = ActorMaterializer()(system)
      implicit val ec: ExecutionContext = system.dispatcher

      val stocksActor = TestProbe("stocksActor")
      val userParentActor = TestProbe("userParentActor")
      val userActor = TestProbe("userActor")

      // http://doc.akka.io/docs/akka/2.4.4/scala/stream/stream-testkit.html
      val publisher = akka.stream.testkit.TestPublisher.probe[JsValue]()

      // instantiate the controller...
      val controller = new HomeController(stocksActor.ref, userParentActor.ref)

      // call method under test...
      val flowUnderTest = controller.createWebSocketFlow(publisher, userActor.ref)

      // create a test source and sink around the flow
      val (pub, sub) = TestSource.probe[JsValue]
        .via(flowUnderTest)
        .toMat(TestSink.probe[JsValue])(Keep.both)
        .run()

      val jsvalue = Json.obj("herp" -> "derp")

      // check that a message sent in will come out the other end
      sub.request(n = 1)
      publisher.sendNext(jsvalue)
      sub.expectNext(jsvalue)
    }

  }


} 

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

import java.time.Instant

import akka.NotUsed
import akka.actor.ActorSystem
import akka.http.scaladsl.model.ResponseEntity
import akka.stream.scaladsl.{Flow, Keep}
import akka.stream.testkit.scaladsl.{TestSink, TestSource}
import akka.testkit.TestKit
import org.json4s.JsonAST.JValue
import org.scalatest.{BeforeAndAfterAll, FlatSpecLike}


class HTTPPollingActorSpec(_system: ActorSystem) extends TestKit(_system)
  with FlatSpecLike with BeforeAndAfterAll {

  override def afterAll = {
    TestKit.shutdownActorSystem(system)
  }

  def testExchangeFlowPubSub(flow: Flow[(Instant, ResponseEntity), (String, JValue), NotUsed]) =
    TestSource.probe[(Instant, ResponseEntity)]
      .via(flow)
      .toMat(TestSink.probe[(String, JValue)])(Keep.both)
} 

//设置package包名称以及导入依赖的类
package akka.stream.contrib

import akka.stream.scaladsl.{ Keep, Source }
import akka.stream.testkit.scaladsl.{ TestSink, TestSource }

class AccumulateSpecAutoFusingOn extends { val autoFusing = true } with AccumulateSpec
class AccumulateSpecAutoFusingOff extends { val autoFusing = false } with AccumulateSpec

trait AccumulateSpec extends BaseStreamSpec {

  "Accumulate" should {
    "emit folded vaules starting with the result of applying the given function to the given zero and the first pushed element" in {
      val (source, sink) = TestSource.probe[Int]
        .via(Accumulate(0)(_ + _))
        .toMat(TestSink.probe)(Keep.both)
        .run()
      sink.request(99)
      source.sendNext(1)
      source.sendNext(2)
      source.sendNext(3)
      sink.expectNext(1, 3, 6)
      source.sendComplete()
      sink.expectComplete()
    }

    "not emit any value for an empty source" in {
      Source(Vector.empty[Int])
        .via(Accumulate(0)(_ + _))
        .runWith(TestSink.probe)
        .request(99)
        .expectComplete()
    }

    "fail on upstream failure" in {
      val (source, sink) = TestSource.probe[Int]
        .via(Accumulate(0)(_ + _))
        .toMat(TestSink.probe)(Keep.both)
        .run()
      sink.request(99)
      source.sendError(new Exception)
      sink.expectError()
    }
  }
} 

//设置package包名称以及导入依赖的类
package akka.stream.contrib

import akka.stream.scaladsl.Keep
import akka.stream.testkit.scaladsl.{ TestSink, TestSource }
import akka.testkit.TestDuration
import org.scalatest.concurrent.ScalaFutures

import scala.concurrent.duration._


class TimeWindowSpecAutoFusingOn extends { val autoFusing = true } with TimeWindowSpec

trait TimeWindowSpec extends BaseStreamSpec with ScalaFutures {
  private val timeWindow = 100.milliseconds

  "TimeWindow flow" should {
    "aggregate data for predefined amount of time" in {
      val summingWindow = TimeWindow(timeWindow.dilated, eager = false)(identity[Int])(_ + _)

      val (pub, sub) = TestSource.probe[Int]
        .via(summingWindow)
        .toMat(TestSink.probe)(Keep.both)
        .run

      sub.request(2)

      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      sub.expectNext(timeWindow * 2, 5)
      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      sub.expectNext(timeWindow * 2, 5)
    }

    "emit the first seed if eager" in {
      val summingWindow = TimeWindow(timeWindow.dilated, eager = true)(identity[Int])(_ + _)

      val (pub, sub) = TestSource.probe[Int]
        .via(summingWindow)
        .toMat(TestSink.probe)(Keep.both)
        .run

      sub.request(2)

      pub.sendNext(1)
      sub.expectNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      pub.sendNext(1)
      sub.expectNext(5)
    }
  }
}