//设置package包名称以及导入依赖的类
import akka.actor.{ActorRef, ActorSystem, Props}
import akka.cluster.sharding.ShardRegion._
import akka.testkit.TestActor.AutoPilot
import akka.testkit.{TestActor, TestProbe}

class FakeCluster(
                   name: String,
                   system: ActorSystem,
                   propsFactory: Unit => Props,
                   extractEntityId: Msg => (EntityId, Msg)
                 ) {
  private implicit val s = system

  private val probe = TestProbe(name)
  private val refs = scala.collection.mutable.Map.empty[String, ActorRef]

  probe.setAutoPilot(new AutoPilot {
    override def run(sender: ActorRef, msg: Any): AutoPilot = {
      val (id, _) = extractEntityId(msg)
      val item = refs.getOrElseUpdate(id, system.actorOf(propsFactory(()), id))
      item.tell(msg, sender)
      TestActor.KeepRunning
    }
  })

  def ref = probe.ref
}

object FakeCluster {
  def apply(
             name: String,
             propsFactory: Unit => Props,
             extractEntityId: Msg => (EntityId, Msg)
           )(implicit system: ActorSystem) = new FakeCluster(name, system, propsFactory, extractEntityId)
} 

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

import org.scalatest.FunSpec
import org.scalatest.Matchers
import org.scalatest.BeforeAndAfterEach
import akka.actor.ActorSystem
import akka.testkit.TestActor
import akka.testkit.TestActorRef
import com.chapter1.StringStoreActor

class StringStoreActorTest extends FunSpec with Matchers with BeforeAndAfterEach{
  describe("StringStoreActor") {
    it("should store the last string it received") {
      implicit val system = ActorSystem()
      val actorRef = TestActorRef(new StringStoreActor)
      actorRef ! "Hello"
      actorRef ! "Bye"
      val realActor = actorRef.underlyingActor;
      realActor.lastStringReceived should(equal("Bye"))
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.ganchurin.currency.rest

import akka.actor.ActorRef
import akka.testkit.TestActor.AutoPilot
import akka.testkit.{TestActor, TestProbe}
import com.ganchurin.currency.domain.Quote
import com.ganchurin.currency.message.QuoteRequest
import org.specs2.mutable.Specification
import spray.testkit.Specs2RouteTest

class RoutingServiceSpec extends Specification with Specs2RouteTest {

	"Rest service" should {

		"Print empty json when quote is not available" in {
			val service = new TestService()

			Get("/quote/USD") ~> service.route ~> check {
				responseAs[String] must contain("{}")
			}
		}

		"Print json when quote is available" in {
			val service = new TestService()

			Get("/quote/EUR") ~> service.route ~> check {
				responseAs[String] must contain("""{"code":"EUR","bid":75.0,"offer":85.0}""")
			}
		}
	}

	class TestService extends RoutingService {
		def actorRefFactory = system
		val currencyBoardActor = TestProbe("currency-board")
		val autoPilot = new AutoPilot {
			def run(sender: ActorRef, msg: Any): AutoPilot = msg match {
				case QuoteRequest("USD") =>
					sender ! Option.empty[Quote]
					TestActor.KeepRunning
				case QuoteRequest("EUR") =>
					sender ! Some(Quote("EUR", 75.0, 85.0))
					TestActor.NoAutoPilot
			}
		}
		currencyBoardActor setAutoPilot autoPilot
		val quoteBoard = currencyBoardActor.ref
	}

}