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

//#plain-spec
import akka.actor.ActorSystem
import akka.actor.Actor
import akka.actor.Props
import akka.testkit.{ TestActors, TestKit, ImplicitSender }
import org.scalatest.WordSpecLike
import org.scalatest.Matchers
import org.scalatest.BeforeAndAfterAll

//#implicit-sender
class MySpec(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {
  //#implicit-sender

  def this() = this(ActorSystem("MySpec"))

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  "An Echo actor" must {

    "send back messages unchanged" in {
      val echo = system.actorOf(TestActors.echoActorProps)
      echo ! "hello world"
      expectMsg("hello world")
    }

  }
}
//#plain-spec 

//设置package包名称以及导入依赖的类
import akka.actor.{Props, ActorSystem}
import akka.testkit.TestActors.EchoActor
import akka.testkit.{ ImplicitSender, TestActors, TestKit }
import org.scalatest.{ BeforeAndAfterAll, Matchers, WordSpecLike }
import wipro.crawler.actors.Crawler


class CrawlerActorSpec() extends TestKit(ActorSystem("Crawler")) with ImplicitSender
with WordSpecLike with Matchers with BeforeAndAfterAll {

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  "An Crawler actor" must {

    "start creating other actors on start " in {
      val crawlerRef = system.actorOf(Props(new Crawler("http://wiprodigital.com",1)))
      crawlerRef ! "start"
      expectNoMsg()
    }

  }
} 

//设置package包名称以及导入依赖的类
import akka.actor.{ActorSystem, Props}
import akka.testkit.{ImplicitSender, TestActors, TestKit}
import hu.bme.mit.ire.messages.ChangeSet
import hu.bme.mit.ire.nodes.unary.MinNode
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

class MinNodeTest(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {

  def this() = this(ActorSystem("MySpec"))

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  import hu.bme.mit.ire.util.TestUtil._

  "Min" must {
    "do simple min 0" in {
      val changeSet = ChangeSet(
        positive = Vector(
          tuple("a", 1),
          tuple("a", 2),
          tuple("a", 1.1),
          tuple("b", 3)
        )
      )
      val echoActor = system.actorOf(TestActors.echoActorProps)
      val min = system.actorOf(Props(new MinNode(echoActor ! _,Vector(0), 1)))

      min ! changeSet
      expectMsg(ChangeSet(positive = Vector(
        tuple("a", 1), tuple("b", 3)
      )))

      min ! ChangeSet(negative = Vector(tuple("a", 1)))
      expectMsg(ChangeSet(
        positive = Vector(tuple("a", 1.1)),
        negative = Vector(tuple("a", 1))
      ))
    }
  }
} 

//设置package包名称以及导入依赖的类
import akka.actor.{ActorSystem, Props}
import akka.testkit.{ImplicitSender, TestActors, TestKit}
import hu.bme.mit.ire.messages.{ChangeSet, Primary, Secondary}
import hu.bme.mit.ire.nodes.binary.UnionNode
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

class UnionNodeTest(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {

  def this() = this(ActorSystem("MySpec"))

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  import hu.bme.mit.ire.util.TestUtil._

  "Union" must {
    "do simple unions 0" in {
      val prim = ChangeSet(
        positive = Vector(tuple(1, 2), tuple(1, 3))
      )
      val sec = ChangeSet(
        positive = Vector(tuple(1, 2), tuple(1, 4))
      )
      val echoActor = system.actorOf(TestActors.echoActorProps)
      val union = system.actorOf(Props(new UnionNode(echoActor ! _)))

      union ! Primary(prim)
      expectMsg(ChangeSet(positive = Vector(tuple(1, 2), tuple(1, 3))))
      union ! Secondary(sec)
      expectMsg(ChangeSet(positive = Vector(tuple(1, 4))))
    }
  }
} 

//设置package包名称以及导入依赖的类
import akka.actor.{ActorSystem, Props}
import akka.testkit.{ImplicitSender, TestActors, TestKit}
import hu.bme.mit.ire.messages.ChangeSet
import hu.bme.mit.ire.nodes.unary.MapperNode
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

class ListSelectorNodeTest(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {

  def this() = this(ActorSystem("MySpec"))

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  import hu.bme.mit.ire.util.TestUtil._

  "ListSelector" must {
    "do select items in lists 0" in {
      val changeSet = ChangeSet(
        positive = Vector(
          tuple(List("a","b","c"))
        )
      )

      val function = (n: Any) => n match {
        case s: List[Any] => s(1)
      }
      val echoActor = system.actorOf(TestActors.echoActorProps)
      val listSelector = system.actorOf(Props(new MapperNode(echoActor ! _, function, 0)))

      listSelector ! changeSet
      expectMsg(ChangeSet(positive = Vector(tuple("b"))))
    }
  }
} 

//设置package包名称以及导入依赖的类
import akka.actor.{ActorSystem, Props}
import akka.testkit.{ImplicitSender, TestActors, TestKit}
import hu.bme.mit.ire.datatypes.Tuple
import hu.bme.mit.ire.messages.ChangeSet
import hu.bme.mit.ire.nodes.unary.{EqualityNode, InequalityNode, SelectionNode}
import hu.bme.mit.ire.util.TestUtil._
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

class SelectionTest(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {

  def this() = this(ActorSystem("MySpec"))

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  "Selection" must {
    "check the condition properly" in {
      val changeSet = ChangeSet(Vector(tuple(0, "something"), tuple(0, "something else")))
      val echoActor = system.actorOf(TestActors.echoActorProps)
      val condition = (n: Tuple) => {
        n(1) == "something"
      }
      val checker = system.actorOf(Props(new SelectionNode(echoActor ! _, condition)))

      checker ! changeSet
      expectMsg(ChangeSet(positive = Vector(tuple(0, "something"))))
    }
  }
  "EqualityChecker" must {
    "check equality properly" in {
      val changeSet = ChangeSet(Vector(tuple(0, 2, 1), tuple(0, 0, 0), tuple(0, 2, 0)))
      val echoActor = system.actorOf(TestActors.echoActorProps)
      val equalityChecker = system.actorOf(Props(new EqualityNode(echoActor ! _, 0, Vector(1, 2))))

      equalityChecker ! changeSet
      expectMsg(ChangeSet(Vector(tuple(0, 0, 0))))
    }
  }
  "InequalityChecker" must {
    "check inequality properly" in {
      val changeSet = ChangeSet(Vector(tuple(0, 2, 1), tuple(0, 3, 0), tuple(0, 0, 0)))
      val echoActor = system.actorOf(TestActors.echoActorProps)
      val inequalityChecker = system.actorOf(Props(new InequalityNode(echoActor ! _, 0, Vector(1, 2))))

      inequalityChecker ! changeSet
      expectMsg(ChangeSet(Vector(tuple(0, 2, 1))))
    }
  }
} 

//设置package包名称以及导入依赖的类
import akka.actor.{ActorSystem, Props}
import akka.testkit.{ImplicitSender, TestActors, TestKit}
import hu.bme.mit.ire.messages.ChangeSet
import hu.bme.mit.ire.nodes.unary.MaxNode
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

class MaxNodeTest(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {

  def this() = this(ActorSystem("MySpec"))

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  import hu.bme.mit.ire.util.TestUtil._

  "Max" must {
    "do simple max 0" in {
      val changeSet = ChangeSet(
        positive = Vector(
          tuple("a", 1),
          tuple("a", 2),
          tuple("a", 1.1),
          tuple("b", 3)
        )
      )
      val echoActor = system.actorOf(TestActors.echoActorProps)
      val max = system.actorOf(Props(new MaxNode(echoActor ! _,Vector(0), 1)))

      max ! changeSet
      expectMsg(ChangeSet(positive = Vector(
        tuple("a", 2), tuple("b", 3)
      )))

      max ! ChangeSet(negative = Vector(tuple("a", 2)))
      expectMsg(ChangeSet(
        positive = Vector(tuple("a", 1.1)),
        negative = Vector(tuple("a", 2))
      ))
    }
  }
} 

//设置package包名称以及导入依赖的类
import akka.actor.{ActorSystem, Props}
import akka.testkit.{ImplicitSender, TestActors, TestKit}
import hu.bme.mit.ire.messages.ChangeSet
import hu.bme.mit.ire.nodes.unary.MapperNode
import hu.bme.mit.ire.util.TestUtil._
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

class MapperTest(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {

  def this() = this(ActorSystem("MySpec"))

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  "MapperNode" must {
    "map values" in {
      val changeSet = ChangeSet(positive=Vector(tuple(0, "something")), negative=Vector(tuple(0, "something else")))
      val echoActor = system.actorOf(TestActors.echoActorProps)
      val function = (n: Any) => n match {
        case s: String => s.length
      }
      val checker = system.actorOf(Props(new MapperNode(echoActor ! _, function, 1)))

      checker ! changeSet
      expectMsg(ChangeSet(
        positive = Vector(tuple(0, "something".length)),
        negative = Vector(tuple(0, "something else".length))
      ))
    }
  }
} 

//设置package包名称以及导入依赖的类
import akka.actor.{ActorSystem, actorRef2Scala}
import akka.testkit.{ImplicitSender, TestActors, TestKit}
import hu.bme.mit.ire.TransactionFactory
import hu.bme.mit.ire.messages.ChangeSet
import hu.bme.mit.ire.util.TestUtil._
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

class TransactionFactoryTest(_system: ActorSystem) extends TestKit(_system) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {
  def this() = this(ActorSystem("MySpec"))

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  "TransactionFactory" must {

    "send incoming data after subscription" in {
      val input = new TransactionFactory(messageSize = 4)
      val echoActor = system.actorOf(TestActors.echoActorProps)
      input.subscribe(Map("test" -> (echoActor ! _)))
      val tran = input.newBatchTransaction()
      tran.add("test", tuple(6, 1L))
      tran.add("test", tuple(6, 2L))
      tran.close()
      expectMsg(ChangeSet(positive = Vector(tuple(6, 2), tuple(6, 1))))
    }

    "do no splitting in batch" in {
      val input = new TransactionFactory(messageSize = 2)
      val echoActor = system.actorOf(TestActors.echoActorProps)
      input.subscribe(Map("test" -> (echoActor ! _)))
      val tran = input.newBatchTransaction()
      for (i <- 1 to 3) {
        tran.add("test", tuple(6, i))
      }
      tran.close()
      expectMsg(ChangeSet(positive = Vector(tuple(6, 3), tuple(6, 2), tuple(6, 1))))
    }
    "send messageSize sized messages when using continuous transactions" in {
      val input = new TransactionFactory(messageSize = 2)
      val echoActor = system.actorOf(TestActors.echoActorProps)
      input.subscribe(Map("test" -> (echoActor ! _)))
      val tran = input.newContinousTransaction()
      for (i <- 1 to 3) {
        tran.add("test", tuple(6, i))
      }
      tran.close()
      expectMsg(ChangeSet(positive = Vector(tuple(6, 2), tuple(6, 1))))
      expectMsg(ChangeSet(positive = Vector(tuple(6, 3))))
    }
  }
} 

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

class EchoActorSpec extends TestKit(ActorSystem("MySpec")) //the actor system passed here is exposed via system in the test
  with ImplicitSender // provides a TestActor that will be receiving all the msg send to sender() which can be checked via expectMsg() assertions
  with WordSpecLike
  with Matchers
  with BeforeAndAfterAll {

  override def afterAll {
    TestKit.shutdownActorSystem(system) // Mus be done!
  }

  "An Echo actor" must {

    "send back messages unchanged" in {
      val echo = system.actorOf(TestActors.echoActorProps)
      echo ! "hello world"
      expectMsg("hello world")
      // see http://doc.akka.io/docs/akka/current/scala/testing.html#built-in-assertions for the list of available assertions
      //as with actors we deal with asynchronous calls, we always operate within limits of timeouts -> if not defined explicitly
      //we always have a timeout of 3sec
    }

  }
} 

//设置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.shashank.akka.testing

import akka.actor.{Actor, ActorSystem, PoisonPill, Props}
import akka.testkit.{ImplicitSender, TestActors, TestKit, TestProbe}
import org.scalatest.WordSpecLike
import org.scalatest.Matchers
import org.scalatest.BeforeAndAfterAll


class AsynchronousTest extends TestKit(ActorSystem("MySpec")) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {

  override def afterAll {
    TestKit.shutdownActorSystem(system)
  }

  "Testing actors" must {

    "echo actor" in {
      val echo = system.actorOf(TestActors.echoActorProps)
      echo ! "hello world"
      expectMsg("hello world")
    }

    "buffer actor adds values to buffer" in {
      val bufferActor = system.actorOf(Props[ActorBasedBuffer], "bufferactor")
      bufferActor ! (10)
      expectNoMsg()
      bufferActor ! (20)
      expectNoMsg()

      bufferActor ! ("sum")
      expectMsg(30)

      println(bufferActor.path.name)
      bufferActor.path.name shouldEqual "bufferactor"
    }

    "killing actor" in {
      val echo = system.actorOf(TestActors.echoActorProps)
      val probe = TestProbe()
      probe watch echo
      echo ! PoisonPill
      probe.expectTerminated(echo)

    }

  }
} 

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

import akka.actor.ActorSystem
import akka.testkit.{ImplicitSender, TestActors, TestKit}
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}


class ProcessingActorTest extends TestKit(ActorSystem("testActorSystem")) with ImplicitSender
  with WordSpecLike with Matchers with BeforeAndAfterAll {

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

  "Processing actors" must {
    "Kick off Extracting Actor" in {
      val processingActor = system.actorOf(TestActors.echoActorProps)
      processingActor ! "echo"
    }
  }

}