Chapter 3 Test-driven development with actors Akka in Action

Failure is a normal part of any application, and can be a result of a wide variety of causes. With actors, the failures can happen during startup, message processing, or other lifecycle events. More precisely, Akka HTTP will automatically deserialize your query parameters to their corresponding types, as specified by the .as notation. Therefore, you no longer need to maintain redundant parsing methods in your code base, such as, the parsing of a given String into an Int, Double, etc. We then define an implicit val for the ExceptionHandler, and pass-through a Partial Function to trap any exceptions of type RuntimeException.

Using TestActorRef will allow you to read internal actor state without having to send the actor a message, which is normally not possible. It will not allow you to directly modify internal actor state, or access private fields. The EventFilter is a tool to verify that actors write certain log messages. Let’s assume that we have an IdentityManagerActor that creates new users. IdentityManagerActor collaborates with an AuthenticationActor to get CreateUser requests validated. If the AuthenticationActor times out, the IdentityManager should fail the CreateUserRequest.

Monitor Your Akka.NET Applications with Ease

The processing of the StopBaking event will trigger the unbecome() method to signal the actor to switch back to its previous state. Similar to our previous examples, we create a DonutStockActor which extends the akka.actor.Actor trait. Instead of DonutStockActor forwarding messages to a single DonutStockWorkActor, it will use a ScatterGatherFirstCompletedPool to fan-out the requests to a bunch of DonutStockWorkerActor. It will, however, only accept the reply from the first DonutStockWorkerActor . Similar to the Tell Pattern example, creating an Akka actor is as easy as extending the Actor trait, and implementing the receivemethod.

We then create the DonutStockActor, which internally defines a TailChoppingPool router. On receipt of CheckStock messages, the DonutStockActor will forward the request to a TailChoppingPool of DonutStockWorkerActors. This means that DonutStockActor will incrementally fan-out CheckStock messages to DonutStockWorkerActors, as per the configuration intervals of the TailChoppingPool. As a reminder, only the first request will be accepted, and all others will be discarded. We expand our DonutStoreProtocol and, add a CheckStock() case class, in addition to the previous Info() case class, which we’ll use for message passing with our Actors. Moreover, we’ll create a custom exception , that we will use to show how to isolate failures by following the Error Kernel Approach.

What is Use Case Testing? (Example)

Following on the Error Kernel Approach, DonutStockActor will supervise the child actor DonutStockWorkerActor. In this simple example, our actor will react to exceptions of type WorkerFailedException, and attempt to restart the child actor DonutStockWorkerActor. For all other exceptions, we assume that DonutStockActor is unable to handle those and, in turn, it will escalate those exceptions up the actor hierarchy. But, we would rather work with a more appropriate Case Class as opposed to an HttpResponse. To this end, let’s start by passing through the HttpResponse, that is, the donutsResponse value, to the Unmarshal class from the akka.http.scaladsl.unmarshalling package.

For now, let’s not focus on the supervision, as we will discuss Akka Actor supervision strategies in upcoming tutorials. In this step, we create a DonutInfoActor by extending the akka.actor trait. In this tutorial, we will continue our discussion onActor Hierarchy, and show how we can use an actor’s path to find it within an actor system. For the purpose of this example, we will reuse the code snippets from our Tell Pattern tutorial. You can find additional information on Actor paths from the official Akka documentation on Actor Paths and Addressing.

Learn production best practices, operations and deployment approaches for using Akka.NET.

They often use the language and terms of the business rather than technical terms, especially when the actor is a business user. Stop wasting time in complicated workflows and start solving problems today with Kamon APM. Finally, take into account that auto-grouping will only pick up actors that are not being explicitly tracked in any other way (e.g. the actor is not explicitly tracked nor included in an explicit group). Short lived actors that perform support work for other bigger pieces of the system.

• If you prefer to avoid modifying the parent or child constructor you can create a fabricated parent in your test.
• To this end, let’s start by passing through the HttpResponse, that is, the donutsResponse value, to the Unmarshal class from the akka.http.scaladsl.unmarshalling package.
• Since the trait just returns an Actor, when testing this actor we can inject a factory that returns any actor, for example this allows us to inject a mocked child actor, instead of the actual one.
• Sending a BakeDonut event using Akka’s Tell Pattern willtransition DonutBakingActor into the Start state.
• When they complete, the remaining 5 requests will execute as shown below.
• The number of expected messages defaults to Int.MaxValue, which effectively disables this limit.
• However, the TailChoppingPool fans-out request to additional routees incrementally according to the configuration you specify.

There is a whole set of examination methods, e.g. receiving all consecutive messages matching certain criteria, receiving a whole sequence of fixed messages or classes, receiving nothing for some time, etc. Akka.group.processing-time timer Tracks the time taken for a member actor to process the receive function. Akka.actor.processing-time timer Tracks the time taken for the actor to process the receive function.

Get Underlying Actor

If you are not familiar with registering future callbacks, feel free to review our tutorial on Future onComplete(). As the name implies, this module is typically best suited for middle-tier applications which require an HTTP https://globalcloudteam.com/ endpoint. As an example, you could use Akka HTTP to expose a REST endpoint that interfaces with a storage layer such as a database. For additional information, you can refer to the official Akka documentation on Akka HTTP.

You can think of it as the “top-most” actor which monitors the entire actor system. Next is the system guardian, which is the “top-level” actor in charge of any system level actors. On the left hand side, you will notice the user guardian, and this is the “top-level” actor hierarchy for actors that we create in our actor system. Note also that you can nest hierarchies as shown by the someChild actor.

Adding some UI bling

Inside its get directive, we make use of the built-in extractRequest directive, which will provide you with an . With the httpRequest value in scope, you can access the HTTP headers section using the httpRequest.headers notation. For the purpose of illustration, we simply produce a comma delimited String for all the HTTP headers using the mkString(“, “) method.

To create the DonutInfoActor within our DonutStoreActorSystem, we use the actorOf() method as shown below. Let’s go ahead and use the actorOf() method to create our DonutInfoActor. For completeness, we’ll also register a Future onComplete()callback to know that our actor system was successfully shutdown.

References

Understanding actor hierarchies is important to help us design systems which follow the Fail-Fast principle. In upcoming tutorials, we will show how to design actor systems to isolate failures, and plan ahead with recovery options. What we’ve learned on actor hierarchies will be the foundation https://globalcloudteam.com/glossary/actor/ to design resilient actor systems that can deal with failures. The diagram below from the official Akka documentationprovides a good visual overview of the actor hierarchy as supported by Akka. We create the DonutStockActor into our DonutStoreActorSystem by calling the actorOf() method.