DEV Community: Muhammad MP

How to test the die() function?

Muhammad MP — Fri, 16 Feb 2024 20:01:21 +0000

I'd written a PHP package for those who develop Telegram bots, to make it easier and cleaner.

Look at the third argument that is false:

$tg->listen('/start', function () use ($tg) {
    $tg->sendMessage([
        'chat_id' => $tg->user->id,
        'text' => 'Hello, world!',
    ]);
}, false);

It's $thenDie to terminate the script after running the command, so the rest of the code won't be executed. How does it do that? By calling the dieIf() method:

return $this->dieIf($thenDie);

And this is the dieIf() method implementation that's just simple:

private function dieIf(bool $condition)
{
    if ($condition) {
        die();
    }
}

Okay, so we use the die() function to terminate the script and say goodbye to the request. Where's the problem?

The problem is that I wanted to write some tests for the package and the die() function not only terminates the script, but also prevents the tests from working too! Surprising, huh?

What can we do here?
I searched the whole Stackoverflow for find a sufficient answer, and I list the best solutions provided by some smart guys:

A. Move it to another class then mock it, bruh!
The problem with this solution is that we don't want to create another class and make an instance of that, just because we need to test one line of code.

B. Check the environment
You can use constants to ensure if the code is running tests. You may have done this in Laravel before:

if (!app()->runningUnitTests()) {
    // Doing things we're not gonna test
}

It's certainly sensible to use the die() function there, and write an else for the testing environment, right? Not really! Testable code, is code that don't need using these tricks to get tested. Moreover, this plan is similar to the previous one and adds unjustifiable complexity to the project.

If it’s hard to test your code, consider changing the design.

C. Use something other than the die() function
I've adopted this approach, and replaced the die() function with throwing an exception:

private function dieIf(bool $condition)
{
    if ($condition) {
        throw new TerminationException();
    }
}

According to the documentation, the die() function is an equivalent to the exit() function.

exit — Output a message and terminate the current script

By throwing an exception, you have more control on what happens; you can catch the exception and do whatever you want; reporting to Sentry, writing logs, showing error pages and so on. Using the die() function doesn't provide these advantages at all, and above that you can't test it like exceptions!

This is one of my test cases after that significant change:

public function test_terminates_if_secret_token_didnt_match()
{
    $_SERVER['HTTP_X_TELEGRAM_BOT_API_SECRET_TOKEN'] = 'password';

    $this->expectException(TerminationException::class);

    (new TeleBot('some-token', 'indeedpassword'));
}

Thanks for reading. Now it does the same, and I can test it. There are some links for further reading:

Dynamic API Versioning in Laravel

Muhammad MP — Wed, 31 Jan 2024 16:06:08 +0000

Recently, I applied for a software engineering job, and at first, I was too excited about it. Yes, there were some tasks to do that finally made me give up because I didn't have much time to do all of what was wanted in the description, and I also had another interviews. So I didn't get through the tasks. Believe me or not, it was like an actual backlog!

The problem

But, one of the tasks impressed me to do some stuff and write this post. I tell you about the question and clarify the problem:

We build an API (v1).
Then we have another version (v2) with some new features.
Not every feature has changed, let's keep it DRY!



Controllers/
├─ v1/
│  ├─ PostController.php
├─ v2/
│  ├─ PostController.php

Let's suppose that we don't have the show() method in the v2/PostController.php because we don't need it. But the first version's index() method has a totally different implementation than the second version. Consider that the boss doesn't like any duplication!

How do you implement it?

Solution #1: Inheritance

I assume that you know what inheritance is and get directly into my first solution to the problem.

In the first version, we implement everything we need normally. When we start building the second version's endpoints, we just implement what's changed. I demonstrate the idea with this example:

api.php



Route::get('/v1/posts', [V1PostController::class, 'index']);
Route::get('/v1/posts/{id}', [V1PostController::class, 'show']);

Route::get('/v2/posts', [V2PostController::class, 'show']);
Route::get('/v2/posts/{id}', [V2PostController::class, 'show']);

V1/PostController.php



<?php

namespace App\Http\Controllers\API\V1;

use App\Http\Controllers\Controller;

class PostController extends Controller
{
    public function index()
    {
        return 'V1 index';
    }

    public function show($id)
    {
        return "V1 show: {$id}";
    }
}

V2/PostController.php



<?php

namespace App\Http\Controllers\API\V2;

use App\Http\Controllers\API\V1\PostController as V1PostController;

class PostController extends V1PostController
{
    public function index()
    {
        return 'V2 index';
    }
}

As we haven't overridden the show() method, the second version's controller provides the first version's functionality and opening https://localhost/api/v2/posts/1 shows us:

V1 show: 1

Solution #2: handleVersion()

The problem with the previous solution is that we need to define all the routes, even if they do the same thing in the previous version. What's the point of defining the /v2/posts/{id} route if it's not actually implemented? Are we supposed to repeat a hundred routes per version? Of course not!

Another fix came into my head! How does router work? Let's take a glance:



Route::get('uri here', ['controller namespace', 'method name']);

So I wrote such a function:
helpers.php



function handleVersion(string $controller, string $method)
{
    $latestApiVersion = config('app.latest_api_version');
    preg_match("/api\/v(\\d+)/i", request()->path(), $apiVersion);
    $apiVersion = $apiVersion[1] ?? $latestApiVersion;

    if ($apiVersion > $latestApiVersion) {
        abort(404);
    }

    $namespace = "App\Http\Controllers\API\V{$apiVersion}\\{$controller}";

    while (! method_exists(app($namespace), $method)) {
        if ($apiVersion === 0) {
            abort(404);
        }

        $apiVersion--;
        $namespace = "App\Http\Controllers\API\V{$apiVersion}\\{$controller}";
    }

    return [$namespace, $method];
}

And used it as bellow:
api.php



Route::get('{version}/posts', handleVersion('PostController', 'index'));
Route::get('{version}/posts/{id}', handleVersion('PostController', 'show'));

Now, I don't have to define plenty of pointless routes anymore!

Solution #3: A combination of my two solutions

I liked the idea of extending the previous version controllers; hence, I decided to combine the two solutions! If you're going to create empty controllers, you can get rid of the while() loop in the handleVersion().

Last words!

I truly enjoyed facing this challenge, and this post is about two ideas I'd thought about. If you have a better idea, please feel free to share it with us in the comments.

JS Plays With Emojis!

Muhammad MP — Wed, 26 Apr 2023 17:45:09 +0000

Do you see the cover image? I saw that in a post, someone wondered about why it happens as if he had suddenly discovered one of Javascript's hidden features. But what is really happening there?

Let's have some fun with emojis:

const family = '👨‍👩‍👧‍👦'
console.log([...family])
// ['👨', '‍', '👩', '‍', '👧', '‍', '👦']

As you see, we have seven elements in the array, not only the member families; We got some emojis glued together with the zero with joiner character.

console.log(family.includes('👦'))
// do they have a son? returns true!

let familyWithTwoDoughters = family.replace('👦', '👧')
// we get this: 👨‍👩‍👧‍👧

Happily this is true not only about family emojis, but also for many emojies we may never use. Here is the technologist emoji (👨‍💻) that is made of 👨 and 💻! After googling some stuff, I explored this file on Github:
https://github.com/unicode-org/icu/blob/main/icu4c/source/data/unidata/emoji-zwj-sequences.txt
that contains a long list of them.

An Emoji ZWJ Sequence is a combination of multiple emojis which display as a single emoji on supported platforms.

The formula is to combine multiple emojis using the zero width joiner character:
👨 + ZWJ + 🔬 = 👨‍🔬
🐻 + ZWJ + ❄ = 🐻‍❄️
🐈 + ZWJ + ⬛ = 🐈‍⬛

You can play with them in Telegram or any other application that supports them. It is not as magical as some people may think and has nothing to do with JS. We can do all of this using PHP, and any programming language supports strings:

$family = '👨‍👩‍👧‍👦';
var_dump(mb_str_split($family));

Thank you.

Create a feed reader bot with PHP (2)

Muhammad MP — Sat, 30 Jul 2022 19:25:00 +0000

In the previous part, we thought about the main functionality of our bot and implemented three commands to see a list of feeds, add a new feed and remove an added feed.

In this part, we create another file that reads the feeds. Consider that we have created bot.php to be called by Telegram server, but there is another part that should be called by a job scheduler (take cron as an example) every five minutes (or any time interval that you prefer). I use cron-job.org for doing that; it is free and easy to use.

Creating `cron.php`

Create a file named cron.php in the project directory, import autoload.php and our configuration files and create an instance of TeleBot:



<?php

use TeleBot\TeleBot;

require_once __DIR__ . '/vendor/autoload.php';

$config = require_once __DIR__ . '/config/bot.php';
$feeds = json_decode(file_get_contents(__DIR__ . '/config/feeds.json'))->feeds;

$tg = new TeleBot($config['bot_token']);

Reading the feeds

Next, we add the following code:



$links = "<b>🆕 New posts:</b>\n\n";
$linkCount = 0;
foreach ($feeds as $feed) {    
    $context = stream_context_create([
        "http" => [
            "method" => "GET",
            "header" => "User-Agent: FeedReaderBot",
        ],
    ]);

    $feedContent = new SimpleXMLElement(file_get_contents($feed->url, false, $context));

    foreach ($feedContent->channel->item as $item) {
        $links .= "<a href=\"{$item->link}\">▪️ {$item->title}</a>\n";
        $linkCount++;
    }
}

if ($linkCount === 0) {
    die();
}

$tg->sendMessage([
    'chat_id' => $config['owner_user_id'],
    'text' => $links,
    'parse_mode' => 'html',
    'disable_web_page_preview' => true,
]);

Dev.to prevents us from loading the feeds; we add User-Agent header and we do not look like the bots anymore. 😎
We parse the XML content using the SimpleXMLElement class; this is an internal feature in PHP, as we parse JSON with ease and we do not need to install any packages.
We create the list in a foreach loop.
After the first loop that iterates all of the feed objects, we send a message; using HTML format (because we have had <a> tag) and disabling the embedded links.

Now, enter the address of cron.php in your web browser; you should see an elegant list:

Oh, wait! If I refresh the page, it sends the same list! It is unacceptable, because we only want the new posts, not the latest posts!

Only new posts!

Yes, you are completely right! For avoiding this problem, we must save the last link in our feed object:



{
    "url": "feed-url-here",
    "reader": "dev.to",
+    "last_item_url": "some-url-here"
}

Add the new field in bot.php:



$feeds[] = [
    'url' => $url,
    'reader' => 'dev.to',
    'last_item_url' => '',
];

We also need some changes in cron.php:



$links = "<b>🆕 New posts:</b>\n\n";
$linkCount = 0;
foreach ($feeds as $feed) {
    $context = stream_context_create([
        "http" => [
            "method" => "GET",
            "header" => "User-Agent: FeedReaderBot",
        ],
    ]);

    $feedContent = new SimpleXMLElement(file_get_contents($feed->url, false, $context));

    $latestPostLink = (string) $feedContent->channel->item[0]->link;

    if ($latestPostLink === $feed->last_item_url) {
        break;
    }

    foreach ($feedContent->channel->item as $item) {
        if ((string) $item->link === $feed->last_item_url) {
            break;
        }

        $links .= "<a href=\"{$item->link}\">▪️ {$item->title}</a>\n";
        $linkCount++;
    }

    $feed->last_item_url = $latestPostLink;
}

if ($linkCount === 0) {
    die();
}

file_put_contents(__DIR__ . '/config/feeds.json', json_encode(['feeds' => $feeds]));

$tg->sendMessage([
    'chat_id' => $config['owner_user_id'],
    'text' => $links,
    'parse_mode' => 'html',
    'disable_web_page_preview' => true,
]);

If the last post link is the same as the one already stored in feeds.json, we will skip the current feed object and check for the next. Otherwise, we add to the end of the list until we reach the last post link that is saved. Finally, we assign $latestPostLink to the last_item_url property of the feed object and save the $feeds array (that involves the updated objects) in the feeds.json outside the loop.

Add a cron-job

We do not want to enter the URL every five minutes, because if we had that much time, we would not need RSS/Atom/JSON feeds! So you should create a cron-job to send a request to our script every five minutes.

Hooray! Wait for the updates...
Thank you for following the tutorial and I hope you enjoyed it.

We used TeleBot to build this bot; you can support me by staring the repository:
https://github.com/muhammadmp97/TeleBot

And here is what we have done by now:
https://github.com/muhammadmp97/FeedReaderBot/tree/d238ac8429db6777b24a51f8618d17c2547a7254

Create a feed reader bot with PHP (1)

Muhammad MP — Thu, 28 Jul 2022 19:11:00 +0000

In this series, we will build a Telegram bot together! Follow the posts if you are familiar with PHP and interested in Telegram bots. I try to explain what I do and make it easy for you to understand how we can build bots and implement the features that we need.

I also have created a repository for this series on Github. You may star it and see the commits:
https://github.com/WebPajooh/FeedReaderBot

What we want to build

We will build a bot that reads website feeds and sends us the new posts. Suppose that we do not have enough time to check many websites, blogs and twitter accounts to see if they have published something new. Hence, our bot fetches them and makes a list of links for us. In the beginning, we just support dev.to feeds, but we will extend it in the future; Keeping it as clean as possible.

Hello, Composer!

My experience says that building a bot without using a library is like running with no shoes! You can write some functions to avoid duplication and other problems, but I prefer using my TeleBot.

Create a directory for our bot, get inside and run this command:
composer init
After answering some questions, it is time to install TeleBot:
composer require webpajooh/telebot
Now we have a composer.json file, including:



{
    "name": "webpajooh/feedreaderbot",
    "type": "project",
    "authors": [
        {
            "name": "WebPajooh",
            "email": "webpajooh@gmail.com"
        }
    ],
    "require": {
        "webpajooh/telebot": "^1.5"
    }
}

Creating a telegram bot

There is an official bot called @BotFather and people manage their bots there. Just start a conversation and use /newbot command to create yours.
Now, you have an access token; such a string for communicating with the bot and run methods:

2472141014:AAGJdPk3Vv9vjQ1TfKa2JT58AtiDPZa-yXT

What is the plan?

Let's summarize our goals:

A command for adding a feed.
A command that shows a list of followed feeds.
A command for removing a feed from the list.
Checking every minute if there is a new post.
Making a list of new posts and sent it to the developer id.

Of course, we are still a few steps away from implementing these features. We must save the mandatory configurations somewhere because we do not want to hardcode everything.

Configurations

In the root directory, create a config folder (look at the structure):



.
├── config
│   ├── bot.php
│   └── feeds.json
├── vendor
├── bot.php
├── composer.json
└── composer.lock

We use config/bot.php to store information such as token and user id, and feeds.json is a JSON file (is it too hard to guess this?) that keeps the feed links. Why do not we use MySQL or SQLite? Because it is extremely easier to work with JSON files and we do not need features that relational databases provide.

config/bot.php returns an array:



<?php

return [
    'bot_token' => 'your token here',
    'owner_user_id' => 'your user id here',
];

And this is how our bot.php looks like:



<?php

require_once __DIR__ . '/vendor/autoload.php';

$config = require_once __DIR__ . '/config/bot.php';

This file is the start point that receives the Telegram incoming updates and responds our commands.

Setting the webhook address

When you send messages to bots, Telegram sends an update to some URL that processes the update and responds:

Currently, we have a token and our files are on a server. So we can connect the bot to the script by using setWebhook method:
https://api.telegram.org/bot[token]/setWebhook?url=[https://example.com/feedreader]/bot.php

The next step is to implement the first feature!

The `/add` command

We decided to store the feeds in a JSON file and it should have such a structure:



{
    "feeds": [
        {
            "url": "https://example.com/feed",
            "reader": "example"
        }
    ]
}

Now, we can write the first command in bot.php:



<?php

use TeleBot\TeleBot;

require_once __DIR__ . '/vendor/autoload.php';

$config = require_once __DIR__ . '/config/bot.php';
$feeds = json_decode(file_get_contents(__DIR__ . '/config/feeds.json'))->feeds;

$tg = new TeleBot($config['bot_token']);

try {
    $tg->listen('/add %p', function ($url) use ($tg, $config, $feeds) {
        foreach ($feeds as $feed) {
            if ($url === $feed->url) {
                return $tg->sendMessage([
                    'chat_id' => $config['owner_user_id'],
                    'reply_to_message_id' => $tg->message->message_id,
                    'text' => '❗️ Feed exists!',
                ]);
            }
        }

        $feeds[] = [
            'url' => $url,
            'reader' => 'dev.to',
        ];

        file_put_contents(__DIR__ . '/config/feeds.json', json_encode(['feeds' => $feeds]));

        $tg->sendMessage([
            'chat_id' => $config['owner_user_id'],
            'reply_to_message_id' => $tg->message->message_id,
            'text' => '✅ Feed added successfully!',
        ]);
    });
} catch (Throwable $th) {
    $tg->sendMessage([
        'chat_id' => $config['owner_user_id'],
        'text' => $th->getMessage(),
    ]);
}

It is ready to test:

What happened?

The listen() method, gets a string as command and a callback function to run, if the user message matches the command.
If the URL has been added before, we return an error message to the user. I know this part is buggy and unreliable, but is it fine for now!
If the URL does not exist in our array, we put it into the array (we also store a reader field for the future features), save the JSON file and inform the user that things go well.

The `/remove` command

By now, the user can add a URL to follow, but we need a /remove command as well to unfollow URLs. We should filter the feeds array and remove the entered URL:



$tg->listen('/remove %p', function ($url) use ($tg, $config, $feeds) {
    $newFeeds = array_filter($feeds, function ($feed) use ($url) {
        return $feed->url !== $url;
    });

    if (count($newFeeds) === count($feeds)) {
        return $tg->sendMessage([
            'chat_id' => $config['owner_user_id'],
            'reply_to_message_id' => $tg->message->message_id,
            'text' => '❗️ Feed not found!',
        ]);
    }

    file_put_contents(__DIR__ . '/config/feeds.json', json_encode(['feeds' => $newFeeds]));

    $tg->sendMessage([
        'chat_id' => $config['owner_user_id'],
        'reply_to_message_id' => $tg->message->message_id,
        'text' => '✅ Feed removed successfully!',
    ]);
});

I think it is very clear, we will continue...

The `/list` command

This is the last feature that we implement in this part of the article. We should show a list of followed URLs to the user:



$tg->listen('/list', function () use ($tg, $config, $feeds) {
    $links = "<b>Followed feeds:</b>\n";
    foreach ($feeds as $feed) {
        $links .=  "🔗 <code>{$feed->url}</code>\n";
    }

    $tg->sendMessage([
        'chat_id' => $config['owner_user_id'],
        'reply_to_message_id' => $tg->message->message_id,
        'text' => $links,
        'parse_mode' => 'html',
    ]);
});

It is clever to use the <code> tag and let the user copy the URL.

Okay, it is time to say goodbye! In the next part, we will fetch the links after finding new posts. Like the post if you liked it, and feel free to write a comment or ask questions.

This is what we built:
https://github.com/muhammadmp97/FeedReaderBot/tree/374b8e2af020e48c5ad7bddc2f45417a88e246f9

Hello, world!

Muhammad MP — Tue, 26 Jul 2022 11:02:00 +0000

Hello, world!
This is my first post on Dev.to and I have a few reasons for being here:

Making connections with other developers and using their experiences.
Improving my English writing. It' so bad and I have to make it better by over-writing.
I still consider myself a beginner, but sometimes I have an idea for writing about and it may help beginners like me! I'm interested in building things by PHP/Javscript and crave learning new stuff.
Finding a new challenging job! Who hates better opportunities? 😁
Not everyone writes here and the network is more technical.

So... I'm here!
Thinking about a subject for the next post...