//设置package包名称以及导入依赖的类
package name.mikulskibartosz.demo.akka.actors

import akka.actor.ActorSystem
import akka.testkit.{ImplicitSender, DefaultTimeout, TestKit}
import name.mikulskibartosz.demo.akka.service.Service
import org.mockito.Mockito._
import org.scalatest.mock.MockitoSugar
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

import scala.util.Try


abstract class AbstractActorSpec extends TestKit(ActorSystem()) with DefaultTimeout with ImplicitSender
with WordSpecLike with Matchers with BeforeAndAfterAll with MockitoSugar {
  override def afterAll() = {
    super.afterAll()
    shutdown()
  }

  def createServiceReturning(value: Try[Int]) = {
    val service = mock[Service]
    when(service.generate()).thenReturn(value)
    service
  }
} 

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

import akka.testkit.{DefaultTimeout, ImplicitSender, TestKitBase}
import core.{Core, CoreActors}
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

trait ActorSpecBase
  extends ImplicitSender
  with Core
  with WordSpecLike
  with Matchers
  with BeforeAndAfterAll
  with AwaitHelper
  with DefaultTimeout {
  self: TestKitBase =>
} 

//设置package包名称以及导入依赖的类
package com.github.mijicd.waes.domain

import akka.actor.ActorSystem
import akka.testkit.{DefaultTimeout, ImplicitSender, TestKit}
import com.github.mijicd.waes.TestSpec
import com.github.mijicd.waes.domain.DataKeeper.{Compare, StoreLeft, StoreRight}
import org.junit.runner.RunWith
import org.scalatest.junit.JUnitRunner

@RunWith(classOf[JUnitRunner])
class DataKeeperSpec extends TestKit(ActorSystem())
  with DefaultTimeout with ImplicitSender with TestSpec {

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

  val actor = system.actorOf(DataKeeper.props())

  trait TestValues {
    val id = "test-id"
    val test = "test"
    val text = "text"
    val empty = ""
  }

  "DataKeeper" should "respond with 'EQUAL' when comparing same values" in {
    new TestValues {
      actor ! StoreLeft(id, test)
      actor ! StoreRight(id, test)

      actor ! Compare(id)
      expectMsg(DiffResult.forEqual)
    }
  }

  it should "respond with 'DIFFERENT_LENGTHS' when comparing non-empty with an empty value" in {
    new TestValues {
      actor ! StoreLeft(id, test)
      actor ! StoreRight(id, empty)

      actor ! Compare(id)
      expectMsg(DiffResult.forDifferentLengths)
    }
  }

  it should "respond with 'DIFFERENT_AT' and a list of diffs when comparing different values" in {
    new TestValues {
      actor ! StoreLeft(id, test)
      actor ! StoreRight(id, text)

      actor ! Compare(id)
      expectMsg(DiffResult.forDifferences(Seq(2)))
    }
  }

  it should "treat non-existent values as empty ones" in {
    val id = "empty-id"
    actor ! Compare(id)
    expectMsg(DiffResult.forEqual)
  }
} 

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

import akka.actor.{Props, ActorSystem}
import akka.pattern.AskSupport
import akka.stream.ActorMaterializer
import akka.testkit.{ImplicitSender, DefaultTimeout, TestKit}
import mandrillclient.api.JsonFormats
import mandrillclient.core.{MandrillAPIActor, MandrillClientSettings, Settings}
import org.scalatest._
import scala.concurrent.duration._

class MandrillClientSpec extends TestKit(ActorSystem("mandrill")) with DefaultTimeout with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll with AskSupport with EitherValues with OptionValues {

  implicit val materializer = ActorMaterializer()

  override def afterAll() = {
    info.apply("shutdown actor system")
    system.shutdown()
    super.afterAll()
  }

  val settings = new Settings with MandrillClientSettings with MandrillClientTestSettings
  val apiKey = settings.testKey

  val duration = 5 seconds
  val apiActor = system.actorOf(Props(classOf[MandrillAPIActor], settings, system, JsonFormats.formats), "Test-MandrillAPIActor")

} 

//设置package包名称以及导入依赖的类
import akka.actor.ActorSystem
import akka.testkit.{DefaultTimeout, ImplicitSender, TestActors, TestKit}
import com.typesafe.config.ConfigFactory
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

import scala.concurrent.duration._


class EchoUsageSpec extends TestKit(ActorSystem(
  "EchoUsageSpec",
  ConfigFactory.parseString(EchoUsageSpec.config))) with DefaultTimeout with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {


  val echoRef = system.actorOf(TestActors.echoActorProps)

  override def afterAll {
    shutdown()
  }

  "An EchoActor" should {
    "Respond with the same message it receives" in {
      within(50 millis) {
        echoRef ! "test"
        expectMsg("test")
      }
    }
  }
}


object EchoUsageSpec {
  // Define your test specific configuration here
  val config =
  """
    akka {
      loglevel = "WARNING"
    }
  """

} 

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

import akka.actor.{ ActorRef, Props, ActorSystem }

import akka.testkit.{ TestKit, ImplicitSender, DefaultTimeout }

import org.scalatest.{ WordSpecLike, MustMatchers }

class BoxOfficeSpec extends TestKit(ActorSystem("testBoxOffice"))
    with WordSpecLike
    with MustMatchers
    with ImplicitSender
    with DefaultTimeout
    with StopSystemAfterAll {
  "The BoxOffice" must {

    "Create an event and get tickets from the correct Ticket Seller" in {
      import BoxOffice._
      import TicketSeller._

      val boxOffice = system.actorOf(BoxOffice.props)
      val eventName = "RHCP"
      boxOffice ! CreateEvent(eventName, 10)
      expectMsg(EventCreated(Event(eventName, 10)))

      boxOffice ! GetTickets(eventName, 1)
      expectMsg(Tickets(eventName, Vector(Ticket(1))))

      boxOffice ! GetTickets("DavidBowie", 1)
      expectMsg(Tickets("DavidBowie"))
    }

    "Create a child actor when an event is created and sends it a Tickets message" in {
      import BoxOffice._
      import TicketSeller._

      val boxOffice = system.actorOf(Props(
          new BoxOffice  {
            override def createTicketSeller(name: String): ActorRef = testActor
          }
        )
      )

      val tickets = 3
      val eventName = "RHCP"
      val expectedTickets = (1 to tickets).map(Ticket).toVector
      boxOffice ! CreateEvent(eventName, tickets)
      expectMsg(Add(expectedTickets))
      expectMsg(EventCreated(Event(eventName, tickets)))
    }
  }
} 

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

import akka.actor.ActorSystem
import akka.testkit.{DefaultTimeout, ImplicitSender, TestKit}
import com.typesafe.config.ConfigFactory
import org.scalatest._

class Base extends TestKit(ActorSystem("changestream_test", ConfigFactory.load("test.conf")))
    with DefaultTimeout
    with ImplicitSender
    with Matchers
    with Inside
    with WordSpecLike
    with BeforeAndAfterAll
    with BeforeAndAfter {
  implicit val ec = system.dispatcher

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

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

import akka.TestDummyActorRef
import akka.actor.{ActorRef, Address, ChildActorPath, RootActorPath}
import akka.testkit.DefaultTimeout
import com.evolutiongaming.util.ActorSpec
import org.scalatest.{FlatSpec, Matchers, OptionValues}
import org.scalatest.concurrent.{Eventually, PatienceConfiguration, ScalaFutures}
import org.scalatest.mockito.MockitoSugar

import scala.concurrent.duration._

trait AllocationStrategySpec extends FlatSpec
  with ActorSpec
  with Matchers
  with MockitoSugar
  with OptionValues
  with ScalaFutures
  with Eventually
  with PatienceConfiguration {

  override implicit val patienceConfig: PatienceConfig = PatienceConfig(5.seconds, 500.millis)

  trait AllocationStrategyScope extends ActorScope with DefaultTimeout {

    implicit val ec = system.dispatcher

    def mockedAddressRef(addr: Address): ActorRef = {
      val rootPath = RootActorPath(addr)
      val path = new ChildActorPath(rootPath, "test")
      new TestDummyActorRef(path)
    }

    def mockedHostRef(host: String): ActorRef =
      mockedAddressRef(testAddress(host))

    def testAddress(host: String): Address = Address(
      protocol = "http",
      system = "System",
      host = host,
      port = 2552)
  }
} 

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

import akka.testkit.TestKit
import akka.testkit.ImplicitSender
import akka.actor.Props
import com.contact.email.successEmail
import org.scalatest.BeforeAndAfterAll
import com.contact.email.EmailActor
import akka.testkit.DefaultTimeout
import org.scalatest.Matchers
import scala.util.Try
import scala.io.Source
import org.scalatest.WordSpecLike
import akka.actor.ActorSystem
import com.contact.email.sendGMail
import scala.concurrent.duration._

class EmailSpec extends TestKit(ActorSystem("TestKitUsageSpec")) with DefaultTimeout with ImplicitSender with WordSpecLike with BeforeAndAfterAll with Matchers {
  //You didn't think I was silly enough to put my password here did you?
  lazy val passwordFile = "/home/ra41p/workspace/TusharContact/ContactTusharLib/password"
  val emailActor = system.actorOf(Props(classOf[EmailActor], "testEmailActor"))
  val password =
    Try(Source.fromFile(passwordFile)
      .getLines()
      .toList(0))
      .toOption
      .getOrElse(throw new Exception("Create a non-empty password file noob"))

  override def afterAll = shutdown()
  
  "An EmailActor" should {
    "Respond with the a success message after sending e-mail" in {
      within(15 seconds) {
        emailActor ! sendGMail("[email protected]",
          password,
          "ramith.honeypot",
          "Hey, trying to contact you via contact-lib",
          "Test Email from contact-lib. I can contact you via e-mail now :D. -Ramith")
        expectMsg(successEmail)
      }
    }
  }
}