DEV Community: jcfrane

Testing / Mocking Laravel HTTP Client Response / Request

jcfrane — Fri, 29 Dec 2023 11:45:29 +0000

In my recent coding endeavors, I unexpectedly found myself immersed in the world of writing tests—a departure from my usual programming routine. The particular challenge that caught me off guard was the intricacy of mocking objects, especially when dealing with Laravel Http Client requests and responses.
Let me walk you through a recent scenario. I've been working on a BlockchainService class with a critical function: getConfirmations(string $hash): int. This function interacts with other microservices by making HTTP requests and handling responses.
Here's a snippet of the function's definition:

public function getConfirmations(string $hash, array $context = []): int
    {
        try {
            $token = $this->authServiceV2->getClientCredentialsToken();
            $response = $this->request
                ->throw()
                ->get('/api/internal/v2/blockchain/confirmations/' .  $hash);

            $json = $response->json();
            $json = [];

            return $json['confirmations'];
        } catch (RequestException $exception) {
            throw new InternalCallException($exception);
        }
    }

Now, the challenges I faced were multi-faceted:

1. Mocking Illuminate\Http\Client\PendingRequest:

I crafted a utility function in my TestCase class to create a mock object for PendingRequest. This involved setting up the expected behavior for the get method and creating a mock response using Guzzle.

use Illuminate\Http\Client\PendingRequest;
use Illuminate\Http\Client\Response as LaravelResponse;
use PHPUnit\Framework\MockObject\MockObject;

abstract class TestCase extends BaseTestCase
{
  protected \Exception $exceptionToThrow;

  public function getHttpResponseMock($status, $headers = [], $body = [])
  {
      $mock = \Mockery::mock(PendingRequest::class)->makePartial();

      $laravelResponse = $this->createLaravelHttpResponse($status, $headers, $body);

      $mock->shouldReceive('withMiddleware')
          ->andReturn($mock);

      $mock->shouldReceive('get')
          ->andReturnUsing(function () use ($laravelResponse) {
              if (isset($this->exceptionToThrow)) {
                  throw $this->exceptionToThrow;
              }
              return $laravelResponse;
          })
          ->once();

      return $mock;
  }


  public function createLaravelHttpResponse($status, $headers = [], $body = []): LaravelResponse
  {
      $guzzleResponse = new \GuzzleHttp\Psr7\Response($status, $headers, json_encode($body));

      return new LaravelResponse($guzzleResponse);
  }
}

2. Mocking AuthServiceV2:

To mock the AuthServiceV2, I created a partial mock with expectations for the getClientCredentialsToken method.

use App\Services\AuthServiceV2;
use PHPUnit\Framework\MockObject\MockObject;

public function createAuthServiceV2PartialMock(): MockObject
{
    $authService = $this->createMock(AuthServiceV2::class);
    $authService
        ->expects($this->once())
        ->method('getClientCredentialsToken')
        ->willReturn('mocked_token');

    return $authService;
}

3. Making Assertions on the Function:

Bringing it all together in a test method, I validated that the getConfirmations function behaves as expected by asserting the result against the expected confirmations.

public function it_can_get_confirmations()
{
    $expectedConfirmations = 10;
    $hash = 'example_hash';

    $pendingRequest = $this->getHttpResponseMock(200, [], [ 'confirmations' => $expectedConfirmations ]);
    $authService = $this->createAuthServiceV2PartialMock();

    // Create instance
    $blockchainService = new BlockchainService($pendingRequest, $authService);

    // Act
    $confirmations = $blockchainService->getConfirmations($hash);

    // Assert
    $this->assertEquals($expectedConfirmations, $confirmations);

This cohesive approach ensured a comprehensive testing environment, covering the intricacies of HTTP client mocking and service authentication. The utilization of mock objects and thoughtful assertions allowed for robust validation of the getConfirmations function, providing confidence in its functionality.

In the ever-evolving landscape of software development, navigating testing complexities becomes an integral part of ensuring the reliability and robustness of our code. Embracing challenges and employing effective testing strategies are key steps toward code excellence and maintainability. Here's to conquering the testing terrain! 🚀✨

Originally posted at: https://jcfrane.com

Laravel Queue: archiving PDF Files

jcfrane — Fri, 13 Aug 2021 10:48:34 +0000

I’ve been working with Laravel Queues lately and it is indeed a pleasant experience. If you are not yet familiar with Laravel Queue you can read more about it here.

Queues are typically used in tasks that require an intensive amount of resources. For example, generating a large CSV report might take a while to finish. You can delegate the task in a queue that runs as a background task (managed by Supervisor) and just give the users feedback over time. This way, end-users will not wait for a long time for the report to finish. Most, users will even think that your application might be crashing.

In one of my projects I need to create a Zip Archive of PDF Files for about hundreds of users. Generating PDF Files usually takes time and resource. As such, I do it via Queue. Each Job not only generates PDF File it also updates the Zip Archive.

GeneratePDFResult.php:

<?php

namespace App\Jobs;

use App\Models\Result;
use App\ResultCheckers\NISResultChecker;
use Illuminate\Bus\Batchable;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Storage;
use PDF;
use ZipArchive;

// Supports local driver, for now.
class GeneratePDFResult implements ShouldQueue
{
    use Batchable, Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    private const CACHE_TTL = 31556926;
    public $tries = 1;
    public $result;

    public function __construct(Result $result)
    {
        $this->result = $result;
    }

    public function handle()
    {
        $payload = [
            'scores' => $this->result->scores,
            'details' => $this->result->details,
        ];

        $batchId = $this->batch()->id;
        $pdf = PDF::loadView('neuro_report', [ 'payload' => $payload ])->setPaper('legal', 'portrait');
        $fileName =  sprintf('%s %s %s.pdf',
            $payload['details']['exam_date'],
            $payload['details']['first_name'],
            $payload['details']['last_name'],
        );

        $pdfFilePath = '/results/' . $batchId . '/' . $fileName;
        Storage::disk('local')->put($pdfFilePath, $pdf->output());

        $this->updateZipArchive($batchId, $pdfFilePath, $fileName);
    }

    private function updateZipArchive($batchId, $pdfFilePath, $fileName)
    {
        $zip = new ZipArchive();
        $zipFilePath = Storage::disk('local')->path('/results/' . $this->batchId . '/' . $this->batchId . '.zip');
        $pdfLocalFilePath = Storage::disk('local')->path($pdfFilePath);

        if ($zip->open($zipFilePath, ZipArchive::CREATE) === TRUE) {
            $zip->addFromString($fileName, Storage::disk('local')->get($pdfFilePath));
            $zip->close();
        } else {
            logger('Failed opening zip file:' . $zipFilePath);
        }
    }
}

As you’ve noticed, I used a 3rd party library called laravel-dompdf to generate PDF Files from HTML. I’ve used the ZipArchive class of PHP for creating and updating the Zip Archives. I’ve batched the jobs so that they are logically grouped and I can monitor them as a whole. Also you can notice how the Storage facade works perfectly with these two.

That’s it! I hope you learn something new that you can apply on your backend applications.

Originally posted at jcfrane.com

call vs apply vs bind

jcfrane — Fri, 06 Aug 2021 07:01:02 +0000

If you started your career as a javascript developer using frameworks such as vue and angular, javascript native functions might be unfamiliar to you. If you stumbled upon functions like call, apply, and bind and seems you can’t wrap your head around them, this article is for you.

All these 3 methods allow you to change the this context of a function.

Suppose you have the following code:

function sayName() {
  console.log(this.name)
}

sayName()

The output of this call is undefined. Because this refers to Window(if you are running the code in a browser) object and it has no name property. Thus, the undefined.

The call() method

call() basically calls a function with the given lexical context as parameter like so:

let human = { name: 'JC' }
function sayName() {
  console.log(this.name)
}

sayName.call(human); // Outputs JC

Another thing you can do is to supply argument/s to the function like so:

let human = { name: 'JC' }
function sayName(greeting) {
  console.log(greeting + ' ' + this.name)
}
sayName.call(human, 'Hi!') // Outputs Hi! JC

The apply() method

apply() is just like call() except that it accepts arguments in array like so:

let human = { name: ‘JC’ }
function sayName(greeting, city) {
  console.log(greeting + ' ' + this.name + ' from ' + city)
}
sayName.apply(human, ['Hi', 'Taguig']) // Outputs Hi! JC from Taguig

with call() you have to supply the arguments individually like so:

console.log(sayName.call(human, 'Hi!', 'Taguig')) // Outputs Hi! JC from Taguig

The bind() method

The bind() is somewhat special. It is a higher-order function which means it returns another function when you invoke it. The function returned is curried, meaning you can call it multiple times to provide different arguments in each call. It is a complex topic you can read more about it on the internet. For now, let’s apply it on our example:

let human = { name: 'JC' }
function sayName(greeting, city) {
   console.log(greeting + ' ' +     this.name + ' from ' + city)
}

let greet = sayName.bind(human)
greet('Hi!', 'Taguig') // Outputs Hi! JC from Taguig
greet('Hello!', 'Makati') // Outputs Hello! JC from Makati

That’s it! I hope I was able to demistified these 3 methods for you. Thanks for reading my article!

Originally posted at jcfrane.com