DEV Community: Serhii

A Guide to Testing Middleware in Laravel

Serhii — Sun, 30 Jul 2023 10:57:16 +0000

Greetings, fellow developers! 🌟

Today, we're diving into the exciting world of Laravel middleware testing. Middleware plays a vital role in filtering and securing HTTP requests before they reach your application's routes. Ensuring that your middleware works flawlessly is crucial for building robust and secure web applications. In this article, we'll explore how to create a simple middleware in Laravel and write tests to cover both successful and failed authorization scenarios.

Are you ready to bolster your testing skills and secure your routes with confidence? Let's get started on this middleware testing adventure! 🚀

Creating the Middleware:

Our first step is to create a simple middleware that will handle authorization for a secret area of our application. We'll call it RequiredHeaderMiddleware, responsible for checking a specific header in incoming requests.

Open your terminal and run the following command to create the middleware:

php artisan make:middleware RequiredHeaderMiddleware

Now, navigate to the app/Http/Middleware directory and open it and replace the content with the following code:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class RequiredHeaderMiddleware
{
    public const SECRET_ACCESS_HEADER = 'Secret-Access-Header';

    public function handle(Request $request, Closure $next): Response
    {
        $requestedHeader = $request->header(self::SECRET_ACCESS_HEADER);
        if (empty($requestedHeader)) {
            return response('This area needs authorization header', Response::HTTP_UNAUTHORIZED);
        }

        return $next($request);
    }
}

In this middleware, we check for the presence of a Secret-Access-Header in the incoming request. If the header is missing, we return an unauthorized response, securing our secret area effectively.

Creating a Test Case:

Now, let's write some test cases to ensure our middleware behaves as expected in different scenarios.

Create a new test:

php artisan make:test RequiredHeaderMiddlewareTest

Copy the following test code into the newly created file:

<?php

namespace Tests\Feature;

use App\Http\Middleware\RequiredHeaderMiddleware;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;
use Tests\TestCase;

class RequiredHeaderMiddlewareTest extends TestCase
{
    public function testEndpointWithoutHeader(): void
    {
        // Given
        $request = Request::create(route('secret-place'));

        $next = function () {
            return response('This is a secret place');
        };

        // When
        $middleware = new RequiredHeaderMiddleware();
        $response = $middleware->handle($request, $next);

        // Then
        $this->assertEquals(Response::HTTP_UNAUTHORIZED, $response->getStatusCode());
        $this->assertEquals('This area needs authorization header', $response->getContent());
    }

    public function testWithCorrectHeader(): void
    {
        // Given
        $request = Request::create(route('secret-place'));
        $request->headers->set(RequiredHeaderMiddleware::SECRET_ACCESS_HEADER, 'foo-bar');

        $next = function () {
            return response('This is a secret place');
        };

        // When
        $middleware = new RequiredHeaderMiddleware();
        $response = $middleware->handle($request, $next);

        // Then
        $this->assertEquals(Response::HTTP_OK, $response->getStatusCode());
        $this->assertEquals('This is a secret place', $response->getContent());
    }
}

In the test cases, we simulate two scenarios: one without the required header (which should return an unauthorized response), and one with the correct header (which should return the content of our secret place).

Conclusion:

Congratulations! 🎉 You've successfully created a custom middleware in Laravel and written test cases to ensure its proper functioning. Middleware testing is essential for securing your routes and guaranteeing smooth operations within your application.

P.S. If you found this article helpful, stay tuned for more exciting Laravel and testing content. I'll be sharing more tips and tricks to level up your development skills. Don't forget to follow me here on dev.to for updates! 🚀

How to display two fields with same name in BackPack For Laravel

Serhii — Wed, 15 Jan 2020 16:29:48 +0000

Real case
What need to do?
Bad solution (wrong way)
Wrong result
Better solution (Accessors & Mutators)
Do not forget about Storing!
Works!

Have you ever heard anything about BackPack for Laravel?
It's Laravel Admin Panel. Fast & easy to integrate. But then could be some issues... For example:

Real case

You have a two tables (order and person):

Schema::create('orders', function (Blueprint $table) {
    $table->bigIncrements('id');
    $table->unsignedBigInteger('primary_person');
    $table->unsignedBigInteger('secondary_person');
});

Schema::create('persons', function (Blueprint $table) {
    $table->bigIncrements('id');
    $table->string('first_name', 255);
    $table->string('last_name', 255);
});

Each order has relation to primary and secondary persons by ID:

class Order extends Model
{
    use CrudTrait;

    protected $table = 'orders';
    protected $fillable = [
        'primary_person',
        'secondary_person',
    ];

    public function primaryPerson()
    {
        return $this->hasOne(Person::class, 'id', 'primary_person');
    }

    public function secondaryPerson()
    {
        return $this->hasOne(Person::class, 'id', 'secondary_person');
    }
}

What need to do?

BackPackForLaravel provides possibility to quickly generate CRUD pages. In our case we need to edit order page.
So, let's create text inputs for:

First name of Primary person
Last name of Primary person
First name of Secondary person
Last name of Secondary person

Bad solution (wrong way)

According to documentation in OrderCrudController.php need to add:

$this->crud->addFields([
    [
       'label' => 'First Name of Primary person',
       'type' => 'text',
       'name' => 'first_name',
       'entity' => 'primaryPerson',
       'model' => 'App\Models\Person',
    ],
    [
        'label' => 'Last Name of Primary person',
        'type' => 'text',
        'name' => 'last_name',
        'entity' => 'primaryPerson',
        'model' => 'App\Models\Person',
    ],
    [
        'label' => 'First Name of Secondary person',
        'type' => 'text',
        'name' => 'first_name',
        'entity' => 'secondaryPerson',
        'model' => 'App\Models\Person',
    ],
    [
        'label' => 'Last Name of Secondary person',
        'type' => 'text',
        'name' => 'last_name',
        'entity' => 'secondaryPerson',
        'model' => 'App\Models\Person',
    ]
]);

Wrong result

Attribute name in controller it's also name in text input.
It have to be uniq!
So, we get only latest two inputs:

Let's think how to cheat.

Better solution (Accessors & Mutators)

Go to Laravel's documentation and read about accessors and mutators.

We could define new names of same field.
For example,

Primary person fields become:
primary_first_name
primary_last_name

Secondary person fields become:
secondary_first_name
secondary_last_name

Let's create two models. PrimaryPerson:

namespace App\Models;

class PrimaryPerson extends Person
{
    public function getPrimaryFirstNameAttribute()
    {
        return $this->attributes['first_name'];
    }

    public function setPrimaryFirstNameAttribute($value)
    {
        $this->attributes['first_name'] = $value;
    }

    public function getPrimaryLastNameAttribute()
    {
        return $this->attributes['last_name'];
    }

    public function setPrimaryLastNameAttribute($value)
    {
        $this->attributes['last_name'] = $value;
    }
}

and SecondaryPerson:

namespace App\Models;

class SecondaryPerson extends Person
{
    public function getSecondaryFirstNameAttribute()
    {
        return $this->attributes['first_name'];
    }

    public function setSecondaryFirstNameAttribute($value)
    {
        $this->attributes['first_name'] = $value;
    }

    public function getSecondaryLastNameAttribute()
    {
        return $this->attributes['last_name'];
    }

    public function setSecondaryLastNameAttribute($value)
    {
        $this->attributes['last_name'] = $value;
    }
}

New we can change Fields in OrderCrudController.php

$this->crud->addFields([
    [
       'label' => 'First Name of Primary person',
       'type' => 'text',
       'name' => 'primary_first_name',
       'entity' => 'primaryPerson',
    ],
    [
        'label' => 'Last Name of Primary person',
        'type' => 'text',
        'name' => 'primary_last_name',
        'entity' => 'primaryPerson',
    ],
    [
        'label' => 'First Name of Secondary person',
        'type' => 'text',
        'name' => 'secondary_first_name',
        'entity' => 'secondaryPerson',
    ],
    [
        'label' => 'Last Name of Secondary person',
        'type' => 'text',
        'name' => 'secondary_last_name',
        'entity' => 'secondaryPerson',
    ]
]);

Do not forget about Storing!

Fetching works good, but we broke store action. Need to implement custom one.

public function update(UpdateRequest $request)
{
    $this->crud->hasAccessOrFail('update');
    $this->crud->setOperation('update');

    if (is_null($request)) {
        $request = \Request::instance();
    }

    /* Storing main object
    $item = $this->crud->update($request->get($this->crud->model->getKeyName()),
        $request->only([
            'primary_person',
            'secondary_person',
        ])
    );
    $this->data['entry'] = $this->crud->entry = $item;
    */

    $this->updatePrimaryPerson($request);
    $this->updateSecondaryPerson($request);

    \Alert::success(trans('backpack::crud.update_success'))->flash();
    $this->setSaveAction();
    return $this->performSaveAction($item->getKey());
}

private function updatePrimaryPerson(UpdateRequest $request)
{
    $person = PrimaryPerson::find($this->crud->entry->primary_person);
    $person->primary_first_name = $request->get('primary_first_name');
    $person->primary_last_name = $request->get('primary_last_name');
    $person->save();
}

private function updateSecondaryPerson(UpdateRequest $request)
{
    $person = SecondaryPerson::find($this->crud->entry->secondary_person);
    $person->secondary_first_name = $request->get('secondary_first_name');
    $person->secondary_last_name = $request->get('secondary_last_name');
    $person->save();
}

Works!

Good luck folk!