DEV Community: Rafael Acioly

Understanding Chain of Responsability pattern

Rafael Acioly — Tue, 08 Dec 2020 15:25:05 +0000

Introduction

On many occasions on our projects, we find ourselves writing pieces of code that stop entirely the program or to continue given a specific condition, it can be a validation of data that was sent, a query on the database, or a logic validation of our business rules, to solve each validation we tend to write simple ifs, in many cases it fits well but it also starts to generate a bigger problem that is having a bunch of ifs on the same place will make the code harder to debug and read.

The Problem

I'm going to use as an example an e-commerce that is selling a product with a discount on a specific date, the steps that we need to validate are:
Is the product still in stock?
Is the discount still valid (valid period)?
Does the discount value exceed the product price?

To solve this issue we usually write many ifs, like this:

def show_discount(product):
    if product.stock == 0:
        return f"there's no stock for {product}"

    discount = Discount.find(product.id)
    if discount.expire_at < today:
        return f"discount for {product} is expired"

    product_price = product.price - discount_amount.value
    if product_price <= 0:
        return "cannot apply discount, discount value is greater than the product price"

    return f"total with discount: {product_price}"

The code above looks fine, but as time pass we will need to change some rule or add new ones, the problems with this approach may include:

Coupling
Complexity
Organization

Now let's say that by accident someone applied a discount for a product that shouldn't be applied and from now on we need to create a mechanism to block those certain products to get a discount

blocked_brands = ("apple",)
def show_discount(product):
    if product.stock == 0:
        return f"there's no stock for {product}"

    if product.brand in blocked_brands:
        return "cannot apply discount for blocked brands"

    # + previous code...

Add a new if can solve the problem in the quickest and easiest way but it will start to create another problem of "code smell", our function is now even longer and more complex, this situation can make the code harder to maintain, but if the "simplest" solution is not the right solution, how can we improve/fix this situation?

Chain of Responsiability

Chain of Responsibility is a behavioral design pattern that lets you pass requests along a chain of handlers. Upon receiving a call, each handler decides either to process the request or to pass it to the next handler in the chain.

Benefits

We can control the order of the validation easier
Single responsibility principle
Easy to maintain
Open/Closed principle, we can add a new handler without changing the ones that already work

How to implement

Declare the handler interface and describe the signature of a method for handling requests. To remove duplicated code we can write abstract classes derived from the handler interface.

class Handler(ABC):
    @abstractmethod
    def set_next(self, handler: Handler) -> Handler:
        pass

    @abstractmethod
    def handle(self, request) -> Optional[str]:
        pass


class AbstractHandler(Handler):
    _next_handler: Handler = None

    def set_next(self, handler: Handler) -> Handler:
        self._next_handler = handler
        # Returning a handler from here will let us link handlers in a
        # convenient way:
        # product.set_next(brand).set_next(discount)
        return handler

    @abstractmethod
    def handle(self, product: Any) -> str:
        if self._next_handler:
            return self._next_handler.handle(product)
        return None

For each handler, we create a subclass handler that implements the interface methods. Each handler should make their own decisions separately.

class ProductHandler(AbstractHandler):
    def handle(product) -> str:
        if product.stock == 0:
            return "there's no stock for {product}"

        return super().handle(product)

class BrandHandler(AbstractHandler):
    _blocked_brands = ("apple",)

    def handle(product) -> str:
        if product.brand in self._blocked_brands:
            return f"{product.name} is not allowed to have discount, blocked by brand"

        return super().handle(product)

class DiscountHandler(AbstractHandler):
    def handle(product) -> str:
        discount = Discount.find(product.id)
        if not has_valid_period(discount):
            return "the discount is expired"

        if has_valid_amount(product.price, discount_amount.value):
            return "cannot apply discount, discount value is greater than the product price"

        return super().handle(product)

    def has_valid_period(discount):
        return discount.expires_at < datetime.now()

    def has_valid_amount(product_price, discount_value):
        return discount_value < product_price

What's happening?

Every class handler has an attribute that tells what is the next step

ProductHandler._next_handler will be BrandHandler 
BrandHandler._next_handler will be DiscountHandler 
DiscountHandler.next_handler will be None

Refactoring

Now that we've separated the responsibilities using classes that implement the interface we can change our code:

product_handler = ProductHandler()
brand_handler = BrandHandler()
discount_handler = DiscountHandler()

product_handler.set_next(brand_handler).set_next(discount_handler)

# product sample
product = Product(id=1, name="mobile phone", stock=0, brand="sansumg", price=1000)

print(product_handler.handle(product))

After the change, the code is simpler to change because every class has his own responsibility and is also more flexible because if we need to change the handler order or add a new one we just need to change the set_next order, we can also start the chain from any point

# will execute only BrandHandler and DiscountHandler
print(brand_handler.handle(product))

If we need to add a new handler we can simply create another class and add another set_next method.

class NotificationHandler(AbstractHandler):
    def handle(product) -> str:
        if product.stock <= 10 and product.price >= 1000:
            logger.info(f"{product.name} is running out of stock, current stock: {product.stock}")

        return super().handle(product)


product_handler = ProductHandler()
brand_handler = BrandHandler()
discount_handler = DiscountHandler()
notification_handler = NotificationHandler()

product_handler.set_next(
    brand_handler
).set_next(
    discount_handler
).set_next(
    notification_handler
)

References

https://refactoring.guru/pt-br/design-patterns/chain-of-responsibility

Using mock on Golang tests

Rafael Acioly — Wed, 02 Jan 2019 12:43:43 +0000

I was studying golang these days and needed to write some tests.
I'm new at golang and i was not familiar with testing and stuffs like that so it was a little "hard" to me to get into it, this post is to make this easy for you as I wish it had been easy for me, i'll cover the basic principles to write tests with sql mock using the main golang structure (interfaces) to keep it simple.

I'm assuming that you're already familiar with golang

Golang interfaces

If you come from a language like java, PHP or any other OOP language you must be familiar with interfaces, in short an interface is a contract used to guarantee that a specific class implements determined method/attributes.
Go has interfaces too and is very simple to write it:

type repository interface {}

I'll use as example the Error interface that are built-in in go, as we know errors in go are a type or like some people say a first class citizen.
we can return a error, create a new type of error, pass error as parameter, store a error in a variable and so on...checkout the error interface
as you can see the Error interface only requires a single method called Error that returns a string, so if we do;

type MyCustomError struct {
    message string
}

func (e MyCustomError) Error() string {
    return e.message
}

we can use MyCustomError as an error type.


func myMethod() error {
    return MyCustomError{message: "my custom error"}
}

you see that our myMethod declares that the return of this method is a built-in error type and the method return a MyCustomError, this is possible because MyCustomError implements all methods required by the Error interface this way we can say that MyCustomError is a error type.

This is the main principle to write mocks in go, we create a custom struct that implementes the needed methods that provide all methods of a specific resource.

We'll not write an entire struct for sql.DB, thanks to ~~God~~ DATA-DOG we already have the package to do this job

Hands on

In the follow examples i'll let some TODOS in the code so you can see what is missing, i let you a challenge at the end, good luck.

Ok, know that we know a little about interfaces/structs let's dive in mocks, first create a new project with these files: database.go and test_database.go

the database.go file:

package database

import "database/sql"

type Repository interface {
    Find(id int) error
}

type repository struct {
    // the db field is of type `DB` from the `database` package
    // that provides the method to interact with our real database
    db *sql.DB
}

func NewRepository(db *sql.DB) Repository {
    return &repository{db: db}
}

// Find retrieves a single record from database
// based on id column
func (r repository) Find(id int) error {}

Notes:
The NewRepository method declares that will return a Repository interface and accept the sql.DB struct as parameter, this interface is only for learning propose, we do not have to write it in this example.

Let's start with the Find method, in your database_test file write the follow code:

package database

import (
    "gopkg.in/DATA-DOG/go-sqlmock.v1"
    "testing"
)

func TestFindDatabaseRecord(t *testing.T) {
    // the db satisfy the sql.DB struct
    db, mock, err := sqlmock.New()
    if err != nil {
        t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
    }
    defer db.Close()

    // our sql.DB must exec the follow query
    mock.ExpectQuery("SELECT \\* FROM my_table").
        // the number 3 must be on the query like "where id = 3"
        WithArgs(3)
        // TODO: define the values that need to be returned from the database

    myDB := NewRepository(db) // passes the mock to our code

    // run the code with the database mock
    if err = myDB.Find(3); err != nil {
        t.Errorf("something went wrong: %s", err.Error())
    }
}

Resume:
The code above create a mock of sql.DB struct and passes it as parameter to our code, the mock says that the query SELECT * FROM my_table must be executed with the argument 3, the DATA-DOG package provides a lot of methods like ExpectExec, WillReturnResult and ExpectRollback, the package is smart enough to know when you run a specific method and will compare your expectations if needed.

the Find method:


func (r repository) Find(id int) error {
    // r is the reference to our struct and db is the mock that we passed
    stmt, err := r.db.Prepare("SELECT * from my_table WHERE id = $1")
    if err != nil {
        return err
    }
    defer stmt.Close()

    // change the placeholder $1 to use the id parameter
    _, err = stmt.Exec(id) // should be result, err = stmt.Exec(id)
    if err != nil {
        return err
    }

    // TODO: we need to fill a struct with the database result
    // and return it with nil

    return nil // should be mystruct, nil
}

You have noted that the Find method doesn't return any database information, the examples of this code is very generic with the purpose of you implement it, can you handle this?

What you have to todo from here:

return the data on the Find method along with the error
compare the returned values

hints:

take a look at the method NewRows and the WillReturnRows.
create a struct to hold the database values and return this struct on Find method

when are finished share with me what you have done! :)

Thank you for reading till here, if you have any advice, questions or suggestion i'll be glad to talk about it.

Working with Queues and Stacks in PHP

Rafael Acioly — Tue, 13 Mar 2018 14:26:33 +0000

The content of this post was inspired by the post To Queue Or Not To Queue by Vaidehi Joshi and from the Base CS Series Video Stacks and Queues

To Queue Or Not To Queue

Vaidehi Joshi ・ Feb 14 '17 ・ 9 min read

#backgroundjobs #queues #computerscience #datastructures

On the post made by Vaidehi she explain how queues work and show some "functions/methods" to enqueue and dequeue something, this is a simple and direct examples to show you how it works in PHP (i'm assuming that you already have seeing the CS video).

PHP comes with a standard library called SplQueue, (Spl stands for Standard PHP Library)

SplQueue inherits from SplDoublyLinkedList. So, objects of SplQueue support methods push() and pop(). But please be advised that if you use push() and pop() methods on a SplQueue object, it behaves like a stack rather than a queue

Manu Manjunath (original explanation from PHP official documentation)

long short story, SplDoublyLinkedList means that the same library works both for queue and stacks.

Stacks

As mentioned above, if you use push() and pop() on a SplQueue object the behave will be of a stack and not a queue, see:

$stack = new SplQueue();
$stack->push(1);
$stack->push(2);
$stack->push(3);
$stack->pop(); // remove the last one

print_r($stack);
/*
OUTPUT

SplQueue Object
(
    [flags:SplDoublyLinkedList:private] => 4
    [dllist:SplDoublyLinkedList:private] => Array
        (
            [0] => 1
            [1] => 2
        )
)

*/

Note that 3 got popped and not 1.

Queues

Methods to use SplQueue as a queue are: enqueue() and dequeue(), see:

$queue = new SplQueue();
$queue->enqueue('A');
$queue->enqueue('B');
$queue->enqueue('C');
$queue->dequeue(); // remove the first one

print_r($q);
/*
OUTPUT

SplQueue Object
(
    [flags:SplDoublyLinkedList:private] => 4
    [dllist:SplDoublyLinkedList:private] => Array
        (
            [0] => B
            [1] => C
        )
)

*/

`Queue` and `Stack` helper methods:

$queue->enqueue('dev'); // or $stack->push('dev');
$queue->enqueue('.to'); // or $stack->push('.to');

$queue->count(); // (int) 2
$queue->isEmpty(); // false

$queue->valid(); // false because right now the pointer is in the last position

// move the cursor to the first position, if you run valid() again after this it will be true
$queue->rewind();

$queue->current(); // "dev", current() just work if you rewind() before call it


$queue->unshift(3); // add the value to the beginning
$queue->current(); // "dev", because we need to move the cursor back to the first position
$queue->rewind();
$queue->current(); // 3

$queue->add(2, 'random-text'); // Add/insert a new value at the specified index

print_r($queue); // Show only 3, "dev" and "to" because we don't rewind() yet.

$queue->rewind(); // move the cursor back to the first position

print_r($queue);
/* 
OUTPUT

SplQueue Object
(
    [flags:SplDoublyLinkedList:private] => 4
    [dllist:SplDoublyLinkedList:private] => Array
        (
            [0] => 3
            [1] => dev
            [2] => random-text
            [3] => .to
        )
)

*/

Iterating over the queue and stack:

$queue = new SplQueue();
$queue->enqueue('dev');
$queue->enqueue('.to');
$queue->unshift('https://');
$queue->rewind(); // always rewind the queue/stack, so PHP can start from the beginning.

while($queue->valid()){
    echo $queue->current()."\n"; // Show the first one
    $queue->next(); // move the cursor to the next element
}

/* 
OUTPUT

https://
dev
.to

*/

There is a bunch of methods that you can use and i cannot show all of it here, you can see every method in the official documentation about SplQueue

So, what programming language are you working right now? do this have queue and stack built-in? if so, how can i use it? if not how do you do it? write a post and show to us how to work with queues and stacks in your favorite programming language! 😄

--
Thanks for reading out, I'm working on my English and if there is any misspelling please let me know.