laravel-json-api / testing Goto Github PK

JsonApiRoute::server('v1')
    ->middleware('auth:api')
    ->prefix($api_prefix)
    ->namespace('Api\V1')
    ->resources(function ($server) {
        $server->resource('users')->actions('-actions', function ($actions) {
            $actions->get('profile');
        })->only('profile');
    });

<?php

declare(strict_types=1);

namespace App\Traits;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Redis;
use LaravelJsonApi\Core\Server\Concerns\ServerAware;

trait Publishable
{
    use ServerAware;

    public function publish(): void
    {
        // retrieve the resources which are registered inside the server.
        $resources = $this->server()->resources();

        // check if the model exists and exists inside the resources.
        if (! is_object($this) || ! $resources->exists($this)) {
            return;
        }

        // Create the resource from model
        $model = $resources->create($this);

        // Create response from the resource and get the content to send through Redis.P
        $message = $model->toResponse(new Request())->content();

        // Publish the serialized model to the default Redis channel
        Redis::publish('default', $message);
    }
}

<?php

declare(strict_types=1);

namespace Tests\Feature;

use App\Http\Middleware\Keycloak\CheckRoles;
use App\Http\Middleware\Keycloak\CheckSession;
use App\Models\File;
use App\Models\Permission;
use App\Models\User;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use LaravelJsonApi\Core\Server\Concerns\ServerAware;
use LaravelJsonApi\Testing\MakesJsonApiRequests;
use Symfony\Component\HttpFoundation\Response as ResponseAlias;
use Tests\TestCase;

class FilesTest extends TestCase
{
    use DatabaseTransactions;
    use MakesJsonApiRequests;
    use ServerAware;

    public const BASEURL = '/api/v1/'.File::JSON_API_TYPE;

    public function setUp(): void
    {
        parent::setUp();
        $this->withoutMiddleware(CheckSession::class);
        $this->withoutMiddleware(CheckRoles::class);
    }

    public function testIndexWithPermission(): void
    {
        // GIVEN
        File::factory()->count(10)->create();

        $user = User::factory()->create();
        $user->givePermissionTo(Permission::PERMISSION_FILE_INDEX);

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->get(self::BASEURL);
        // THEN
        $response->assertJsonStructure([
            'data' => [
                [
                    'type',
                    'id',
                    'attributes' => [
                        'name',
                        'path',
                        'mime_type',
                        'createdAt',
                        'updatedAt',
                    ],
                ],
            ],
        ]);

        $response->assertJsonCount(10, 'data');
    }

    public function testIndexWithoutPermission(): void
    {
        // GIVEN
        File::factory()->count(10)->create();

        $user = User::factory()->create();
        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->get(self::BASEURL);
        // THEN
        $response->assertStatus(ResponseAlias::HTTP_FORBIDDEN);
    }

    public function testCreateWithPermission(): void
    {
        // GIVEN
        $user = User::factory()->create();
        $user->givePermissionTo(Permission::PERMISSION_FILE_CREATE);

        $file = File::factory()->make();

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->withData([
            'type' => File::JSON_API_TYPE,
            'attributes' => [
                'name' => $file->name,
                'mime_type' => $file->mime_type,
            ],
        ])->post(self::BASEURL);

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_CREATED);
        $response->assertSessionHasNoErrors();
        $response->assertJsonStructure([
            'data' => [
                'type',
                'id',
                'attributes' => [
                    'name',
                    'path',
                    'mime_type',
                    'createdAt',
                    'updatedAt',
                ],
            ],
        ]);
    }

    public function testCreateWithInvalidData(): void
    {
        // GIVEN
        $user = User::factory()->create();
        $user->givePermissionTo(Permission::PERMISSION_FILE_CREATE);

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->withData([
            'type' => File::JSON_API_TYPE,
            'attributes' => [
                'name' => null,
                'mime_type' => null,
            ],
        ])->post(self::BASEURL);

        // THEN
        $response->assertStatusCode(ResponseAlias::HTTP_UNPROCESSABLE_ENTITY);
    }

    public function testCreateWithoutPermission(): void
    {
        // GIVEN
        $user = User::factory()->create();

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->withData([
            'type' => File::JSON_API_TYPE,
            'attributes' => [
                'name' => 'test',
                'mime_type' => 'txt',
            ],
        ])->post(self::BASEURL);

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_FORBIDDEN);
    }

    public function testShowWithPermission(): void
    {
        // GIVEN
        $user = User::factory()->create();
        $user->givePermissionTo(Permission::PERMISSION_FILE_SHOW);
        $user->givePermissionTo(Permission::PERMISSION_FILE_CREATE);

        $file = File::factory()->create(
            [
                'id' => 1,
                'name' => 'test',
                'mime_type' => 'txt',
            ]
        );

        $this->actingAs($user, 'api')->jsonApi()->withData([
            'type' => File::JSON_API_TYPE,
            'attributes' => [
                'name' => $file->name,
                'mime_type' => $file->mime_type,
            ],
        ])->post(self::BASEURL);

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->get(self::BASEURL.'/1');

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_OK);
        $response->assertJsonStructure([
            'data' => [
                'type',
                'id',
                'attributes' => [
                    'name',
                    'path',
                    'mime_type',
                    'createdAt',
                    'updatedAt',
                ],
            ],
        ]);
    }

    public function testShowWithoutPermission(): void
    {
        // GIVEN
        $user = User::factory()->create();

        $file = File::factory()->create();

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->get(self::BASEURL.'/'.$file->id);

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_FORBIDDEN);
    }

    public function testUpdateWithPermission(): void
    {
        // GIVEN
        $user = User::factory()->create();
        $user->givePermissionTo(Permission::PERMISSION_FILE_UPDATE);

        $file = File::factory()->create();

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->withData([
            'type' => File::JSON_API_TYPE,
            'id' => (string) $file->id,
            'attributes' => [
                'name' => 'file',
                'mime_type' => 'txt',
            ],
        ])->patch(self::BASEURL.'/'.$file->id);

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_OK);
        $response->assertSessionHasNoErrors();
        $response->assertJsonStructure([
            'data' => [
                'type',
                'id',
                'attributes' => [
                    'name',
                    'path',
                    'mime_type',
                    'createdAt',
                    'updatedAt',
                ],
            ],
        ]);
    }

    public function testUpdateWithInvalidData(): void
    {
        // GIVEN
        $user = User::factory()->create();
        $user->givePermissionTo(Permission::PERMISSION_FILE_UPDATE);

        $file = File::factory()->create();

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->withData([
            'type' => File::JSON_API_TYPE,
            'id' => (string) $file->id,
            'attributes' => [
                'name' => null,
                'mime_type' => null,
            ],
        ])->patch(self::BASEURL.'/'.$file->id);

        // THEN
        $response->assertStatusCode(ResponseAlias::HTTP_UNPROCESSABLE_ENTITY);
    }

    public function testUpdateWithoutPermission(): void
    {
        // GIVEN
        $user = User::factory()->create();

        $file = File::factory()->create();

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->withData([
            'type' => File::JSON_API_TYPE,
            'id' => (string) $file->id,
            'attributes' => [
                'name' => 'test',
                'mime_type' => 'txt',
            ],
        ])->patch(self::BASEURL.'/'.$file->id);

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_FORBIDDEN);
    }

    public function testDeleteWithPermission(): void
    {
        // GIVEN
        $user = User::factory()->create();
        $user->givePermissionTo(Permission::PERMISSION_FILE_DELETE);

        $file = File::factory()->create();

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->delete(self::BASEURL.'/'.$file->id);

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_NO_CONTENT);
    }

    public function testDeleteWithoutPermission(): void
    {
        // GIVEN
        $user = User::factory()->create();

        $file = File::factory()->create();

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->delete(self::BASEURL.'/'.$file->id);

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_FORBIDDEN);
    }

    public function testUpdateObjectThatDoesntExist(): void
    {
        // GIVEN
        $user = User::factory()->create();
        $user->givePermissionTo(Permission::PERMISSION_FILE_UPDATE);

        // WHEN
        $response = $this->actingAs($user, 'api')->jsonApi()->withData([
            'type' => File::JSON_API_TYPE,
            'id' => '1',
            'attributes' => [
                'name' => 'test',
                'mime_type' => 'txt',
            ],
        ])->patch(self::BASEURL.'/1');

        // THEN
        $response->assertStatus(ResponseAlias::HTTP_NOT_FOUND);
    }
}