pekko/supervisor/test-code/test/scala/GenericServerContainerSuite.scala

/**
 * Copyright (C) 2009 Scalable Solutions.
 */

package com.scalablesolutions.akka.supervisor

import org.specs.runner.JUnit4
import org.specs.Specification

import scala.actors._
import scala.actors.Actor._

/**
 * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
 */
class GenericServerContainerTest extends JUnit4(genericServerContainerSpec) // for JUnit4 and Maven
object genericServerContainerSpec extends Specification {

  var inner: GenericServerContainerActor = null
  var server: GenericServerContainer = null
  def createProxy(f: () => GenericServer) = { 
    val server = new GenericServerContainer("server", f)
    server.setTimeout(100)
    server 
  }

  inner = new GenericServerContainerActor
  server = createProxy(() => inner)
  server.newServer
  server.start

  "server should be initialized" in {
    server.init("testInit")
    Thread.sleep(100)
    expect("initializing: testInit") {
      inner.log
    }
  }

  "server should terminate with a reason " in {
    server.terminate("testTerminateWithReason", 100)
    Thread.sleep(100)
    expect("terminating: testTerminateWithReason") {
      inner.log
    }
  }

  "server respond to async oneway message" in {
    server ! OneWay
    Thread.sleep(100)
    expect("got a oneway") {
      inner.log
    }
  }

  "server respond to async ping message" in {
    server ! Ping
    Thread.sleep(100)
    expect("got a ping") {
      inner.log
    }
  }

  "server respond to !!!" in {
    expect("pong") {
      (server !!! Ping).getOrElse("nil")
    }
    expect("got a ping") {
      inner.log
    }
  }

  "server respond to !?" in {
    expect("pong") {
      val res: String = server !? Ping
      res
    }
    expect("got a ping") {
      inner.log
    }
  }

  "server respond to !!! with timeout" in {
    expect("pong") {
      (server !!! Ping).getOrElse("nil")
    }
    expect("got a ping") {
      inner.log
    }
  }

  "server respond to !!! with timeout" in {
    expect("error handler") {
      server !!! (OneWay, "error handler")
    }
    expect("got a oneway") {
      inner.log
    }
  }

  "server respond to !!! and return future with timeout" in {
    val future = server !! Ping
    future.receiveWithin(100) match {
      case None => fail("timed out") // timed out
      case Some(reply) =>
        expect("got a ping") {
          inner.log
        }
        assert("pong" === reply)
    }
  }

  "server respond to !!! and return future with timeout" in {
    val future = server !! OneWay
    future.receiveWithin(100) match {
      case None =>
        expect("got a oneway") {
          inner.log
        }
      case Some(reply) =>
        fail("expected a timeout, got Some(reply)")
    }
  }

  "server respond do hotswap" in {
    // using base
    expect("pong") {
      (server !!! Ping).getOrElse("nil")
    }

    // hotswapping
    server.hotswap(Some({
      case Ping => reply("hotswapped pong")
    }))
    expect("hotswapped pong") {
      (server !!! Ping).getOrElse("nil")
    }
  }

  "server respond do double hotswap" in {
    // using base
    expect("pong") {
      (server !!! Ping).getOrElse("nil")
    }

    // hotswapping
    server.hotswap(Some({
      case Ping => reply("hotswapped pong")
    }))
    expect("hotswapped pong") {
      (server !!! Ping).getOrElse("nil")
    }

    // hotswapping again
    server.hotswap(Some({
      case Ping => reply("hotswapped pong again")
    }))
    expect("hotswapped pong again") {
      (server !!! Ping).getOrElse("nil")
    }
  }

  "server respond do hotswap and then revert" in {
    // using base
    expect("pong") {
      (server !!! Ping).getOrElse("nil")
    }

    // hotswapping
    server.hotswap(Some({
      case Ping => reply("hotswapped pong")
    }))
    expect("hotswapped pong") {
      (server !!! Ping).getOrElse("nil")
    }

    // restoring original base
    server.hotswap(None)
    expect("pong") {
      (server !!! Ping).getOrElse("nil")
    }
  }
}


class GenericServerContainerActor extends GenericServer  {
  var log = ""

  override def body: PartialFunction[Any, Unit] = {
    case Ping =>
      log = "got a ping"
      reply("pong")

    case OneWay =>
      log = "got a oneway"
  }

  override def init(config: AnyRef) = log = "initializing: " + config
  override def shutdown(reason: AnyRef) = log = "terminating: " + reason
}