Chain of responsibility 

     
How could I explain the Chain of Responsibility pattern to myself?

# What is the Chain of Responsibility?

A series of classes or functions that are capable of handing certain requests.These handlers are connected in a linked list where each handler is aware of the next handler in the list, or chain. If a handler is not capable of handling the request then it calls the next providing the request.
The chain may be implemented such that multiple handlers can contribute to the completion of a single request. In this the request will need to be updated before being passed to the next handler.

# Why is that a good idea?
* It allows handers to be added or removed with minimal change to existing code.
* It allows handlers to be re-ordered without editing the handlers or making large code changes.
* Allows handling logic to be decoupled from other handling logic and tested independently.

# Where would you use it?
* At times where the execution order is likely to be changed often or dynamically.
* At times when methods of processing a request need to be added or removed with minimal code changes or dynamically 
* To simplify complex if, else logic chains and decouple them into testable components.

# ATM example. 
The canonical example for explaining how the Chain of Responsibility works is using an ATM. Each denomination of money is provided as a handler. Ordered from largest to smallest.
 
To return $125
The $50 note handler run first scheduling 2 $50 notes to be given to the user and passes the request to the next handler. 
The $20 note handler runs second scheduling 1 $20 note to be given to the user and passes the request on again. 
The $10 note handler is not able to process the request and passes the request on.
The $5 note handler schedules 1 $5 note.
With nothing left to return the recursion completes and the scheduled money is given to the user.

# What could go wrong?

* No fall back handler. 
If no handler is specified to handle a command that is is unknown or not capable of being processed then there is a chance that the system will throw a null reference exception or complete without having finished processing the request.

* Can be implemented in a way that tightly couples the order of the strategies
Each handler should not be hard coded to know what is next in the chain. This creates unnecessary and undesirable coupling between the handlers. The next handler in the chain should be passed in as part of the constructor or be set by a higher order class.  
In the above example if the machine is out of $20 notes it should be able to dynamically remove the $20 handler without having to be re-coded.

Comments

Post a Comment

Popular posts from this blog

Solving `Empty reply from server` in DotNet Core

tldr; If you’re getting  curl: (52) Empty reply from server  check that you’ve configured Kestrel correctly. Long version I’ve started playing with Dotnet Core and Docker and have had a few issues getting started. I’ve had a little bit of experience with Docker, though only a little. I’ve worked with DotNet previously but never with Core. Environment The setup I’m using is a Windows laptop running Vagrant. Via Vagrant I’m running an Ubuntu Virtual Machine with the Docker run time installed. Feels a litle like inception. Key Problem The key problem that I’ve had getting started was having my Docker container not responding correctly to my curl commands. I get this: curl: (56) Recv failure: Connection reset by peer curl: (52) Empty reply from server Given that I’m not all that familliar with Docker or Dotnet Core I decided to remove one of the variables and set up a simple Express app in a different docker container. This validated that the commmand I was using to run
Read more

Testing functions that use local storage with Jest

Testing functions that use the browsers local storage API seems easy when you know how. Here's a quick run down on how to mock it out with Jest if, like me, you're not familiar with how to test it. In the end it's very little code. Consider the following TypeScript code. import { get, save, key } from "./storage"; describe(save, () => { let setItem: jest.Mock; beforeEach(() => { setItem = jest.fn(); Storage.prototype.setItem = setItem; }); it("should call set item with predefined key and json object", () => { const valueToStore = { value: "toStore" }; save(valueToStore); expect(setItem).toHaveBeenCalledWith(key, JSON.stringify(valueToStore)); }); }); The key lines are in the beforeEach call where the setItem function of the Storage prototype is assigned to an instance of jest.fn() . This allows us to make assertions on what is passed to the local storage setItem API.
Read more

Building a verify JWT function in TypeScript

# Verifying an RS232 signed JWT JSON Web Tokens (JWT) are used as a way to verify the identity of the caller of an API. **The best way to verify a JWT is to use a verification library.** I wanted to have a look at some of what those libraries are doing under the hood by putting together a function that will return if a given token is valid. In this blog I'll go through what I have done to get a validation function working. To simplify things assume: - That the signing algorithm is RS232 all others are considered invalid. - That the public keys are available on a JWKS url provided to the function eg [https://klee-test.au.auth0.com/.well-known/jwks.json](https://klee-test.au.auth0.com/.well-known/jwks.json) - I only want to know if the token was signed by a key available at the above url. I wont be checking if the token has expired, if the scopes or other claims are valid. # Break up the token A JWT is made up to 3 parts. The first thing to do in validating the token is to brea
Read more