Testing Actor Systems

      Comments Off on Testing Actor Systems

Adding new features and evolving the application will be much more pleasant this way. The second strategy is a Black Box approach, where you can talk to the actor and check only the response. To get the response from the actor, you need to use something called a testing probe, which will emulate a sender actor. A persistent actor (also known as an event sourced actor) from Akka, additionally, is able to persist its state in a form of events.

For the purpose of illustrating handling of timeouts, our previous event, states and mutable data remain unchanged. The events, states and mutable data have clear separations as mandated by the LoggingFSM trait. Next, we send a BakeDonut event which is a subtype of our new DonutProtocol trait.

Message-passing semantics

Next, we create an instance for our Akka HTTP Routes, which are encapsulated within the class DonutRoutes and exposed via its route() method. That is why you should primarily aim to enclose your relevant Akka HTTP APIs or Routes using, say, a class or a trait, such that it is easier to bring them into scope in your production code or for testing purposes. Thus far, we’ve used Akka’s LoggingFSM trait to provide better closures around events, states and mutable data within our Finite State Machines. Consequently, we’ve implemented when(Stop) and when(Start), as well as capturing events that cannot be processed through the whenUnhandled() partial function.
This is fine for a standard system with a moderate load, but we are building a reactive solution that should be easy to scale. Also, you are limited to databases that support such locking, which is not always the case. It’s time to introduce our main guest which is the Actor and Akka stack that implements the Actor Model. The TestKit contains an actor named testActor which is the entry point for messages to be examined with the various expectMsg…

  • Yet, Akka provides further refinements around closures for states, events and internal data via the LoggingFSM trait.
  • As such, it is important to note that the actors within our Actor System exist in a hierarchy.
  • A packaged task allows deferring the calculation of an asynchronous result while holding a reference to the eventual (potential) result.
  • Akka further refines the receive() method by providing Finite State Machine semantics (short for FSM).
  • This will get Guice to automatically bind an instance of ConfiguredChildActor.Factory, which will provide an instance of Configuration to ConfiguredChildActor when it’s instantiated.

A consequence of the above theorem is that a finite actor can nondeterministically respond with an uncountable[clarify] number of different outputs. This is similar to the everything is an object philosophy used by some object-oriented programming languages. To dive even deeper, check out the Serenity/JS repository

Testing it out

and explore the examples. Actors demonstrate how to accomplish a goal by performing activities at multiple levels of abstraction.
Testing Actor Systems
But you can override / manipulate whatever config settings you need to. This is another place it’s easy to focus too much on the implementation of your code. You want to focus on testing the intended effects of your code, not testing the framework itself. This is one case where Akka.NET’s commitment to providing simple abstractions makes testing harder. First as a stand-in for another actor, and in the second example as a a more programmable TestActor.

As we learned in the Hello World example, each actor defines the type of messages it will accept. Our device actor has the responsibility to use the same ID parameter for the response of a given query, which would make it look like the following. If we were working with objects, we would typically design the API as interfaces, a collection of abstract methods to be filled out by the actual implementation. While it is not possible to formalize general protocols in the programming language, we can compose their most basic element, messages.

Akka LoggingFSM provides a nice closure over unhandled event using whenUnhandled. In the previous example, we showed the enhanced semantics provided when using Akka’s LoggingFSM for designing Finite State Machines. LoggingFSM provides much better closures around events, states, and what is actor mutable data. We extend the previous state machine, and implement the events to be handled while in the start state and, as a result, we add another event named StopBaking. Sequencing these events into actors which have a single thread pool would be nice in such circumstances.

In this post we will focus on the core pieces you need to know that are shared across all of the above testing frameworks. Each framework has its own specific extensions to the core TestKit API (assertions, etc.). Or alternatively, you could make mainActor an ActorRef by sending an Identify message to the ActorSelection. I would inject the mainActor actor selection into the client, and create that using Akka TestKits.
Testing Actor Systems
What if a value of the wrong type was passed-through to, say, the priceLevel query parameter? For instance, a String value with the “cheap” literal is being passed-through to the priceLevel query parameter below. Without any surprise, this would trigger an exception that will bubble up our given Akka HTTP hierarchy. In order to verify the appropriate exception, we first need to make use of the Route.seal method for the donutRoutes, such that the given exception can be forwarded to akka-testkit’s check method.