单元测试scala演员

Question

有人知道单元测试Scala演员的好方法吗？ 在一般意义上，我有一个接收消息的演员，并会发出其他消息作为回应。 这是在多个线程上完成的，并且不正确的actor可能发送错误的消息或根本不发送消息。 我需要一种简单的方法来创建一个模拟actor，它向正在测试的actor发送和接收消息。 这方面有什么经验吗？

Answer 1

由于演员风格的消息传递的动态性，模拟演员通常没有任何麻烦。 只需创建一个接收所需消息的演员即可免费回家。 您当然需要确保这个模拟actor是传递消息的那个，但只要您尝试测试的actor是可重入的 ，这应该不是问题。

Answer 2

我认为复杂性取决于几个因素......

1. 演员是多么有状态？

如果它的行为类似于幂等函数，只是异步，那么它应该是一个简单的事情，即模拟发送消息的actor，然后检查它是否收到了预期的消息。 您可能希望在模拟actor上使用react / receiveWithin，以防在合理的时间段内出现响应而您可能会失败而不是挂起。

但是，如果消息不是彼此独立的，那么您应该使用各种消息序列和预期结果对其进行测试。

2. 被测试的演员将与多少演员互动？

如果期望演员与许多其他演员互动，并且它是有状态的，则应该与几个演员发送/接收消息进行测试。 由于您可能无法保证消息的到达顺序，因此您应确保置换演员发送消息的顺序，或者在演员生成消息时引入随机暂停并多次运行测试。

我不知道有任何用于测试演员的预构建框架，但你可能会想到Erlang的灵感。

http://svn.process-one.net/contribs/trunk/eunit/doc/overview-summary.html

Answer 3

我一直想知道如何自己测试演员。

以下是我提出的问题，是否有人看到这种方法存在问题？

而不是直接发送消息，如果您的actor委托发送给函数的消息怎么办？

然后，您的测试可以将该函数替换为跟踪调用次数和/或调用该方法的参数的函数：

class MyActor extends Actor {

  var sendMessage:(Actor, ContactMsg) => Unit = {
    (contactActor, msg) => {
      Log.trace("real sendMessage called")
      contactActor ! msg 
    }
  }

  var reactImpl:PartialFunction(Any, Unit) = {
      case INCOMING(otherActor1, otherActor2, args) => {

        /* logic to test */
        if(args){
          sendMessage(otherActor1, OUTGOING_1("foo"))

        } else {
          sendMessage(otherActor2, OUTGOING_2("bar"))
        }
      }
  }

  final def act = loop {
    react {
      reactImpl
    }
  }

您的测试用例可能包含以下代码：

// setup the test
var myActor = new MyActor
var target1 = new MyActor
var target2 = new MyActor
var sendMessageCalls:List[(Actor, String)] = Nil

/*
* Create a fake implementation of sendMessage
* that tracks the arguments it was called with
* in the sendMessageCalls list:
*/
myActor.sendMessage = (actor, message) => {
  Log.trace("fake sendMessage called")
  message match {
    case OUTGOING_1(payload) => { 
      sendMessageCalls = (actor, payload) :: sendMessageCalls
    }
    case _ => { fail("Unexpected Message sent:"+message) }
  }
}

// run the test
myActor.start
myActor.reactImpl(Incoming(target1, target2, true))

// assert the results
assertEquals(1, sendMessageCalls.size)
val(sentActor, sentPayload) = sendMessageCalls(0)
assertSame(target1, sentActor)
assertEquals("foo", sentPayload)
// .. etc.

Answer 4

我试图对一个演员进行单元测试（它有效）。 我正在使用Specs作为框架。

object ControllerSpec extends Specification {
  "ChatController" should{
    "add a listener and respond SendFriends" in{
        var res = false
        val a = actor{}
        val mos = {ChatController !? AddListener(a)}
        mos match{
             case SendFriends => res = true
             case _ => res = false
        }
        res must beTrue
    }

这是如何工作的，通过向单例ChatController发送同步调用。 ChatController通过使用reply（）进行响应 。 响应作为被调用函数的返回发送，并存储到mos中。 然后匹配应用于mos获取从ChatController发送的案例类。 如果结果是预期的（SendFriends），则将res设置为true。 res必须是True断言决定测试的成败。

我正在测试的演员单身人士

import ldc.socialirc.model._

import scala.collection.mutable.{HashMap, HashSet}
import scala.actors.Actor
import scala.actors.Actor._

import net.liftweb.util.Helpers._

//Message types
case class AddListener(listener: Actor)
case class RemoveListener(listener: Actor)
case class SendFriends
//Data Types
case class Authority(usr: Actor, role: String)
case class Channel(channelName: String, password: String, creator: String, motd:   String, users: HashSet[Authority])

object ChatController extends Actor {
    // The Channel List  - Shows what actors are in each Chan
    val chanList = new HashMap[String, Channel]
    // The Actor List - Shows what channels its in
    val actorList = new HashMap[Actor, HashSet[String]]

    def notifyListeners = {

    }

    def act = {
        loop {
            react {
                case AddListener(listener: Actor)=>
                    actorList += listener -> new HashSet[String]
                    reply(SendFriends)

            }
        }
    }
    start //Dont forget to start
}

虽然它不完整但它会按预期返回Sendfriends案例类。

Answer 5

最近， Akka增加了Actors单元测试套件。 您可以在此博文中找到一些信息和代码段。