ldc-boutique-cnc-sable/tests/Unit/App/Policies/Frontend/OrderTunnelStepPolicyTest.php

<?php

declare(strict_types=1);

use App\Models\Customer;
use App\Models\User;
use App\Policies\Frontend\OrderTunnelStepPolicy;
use Domain\Enums\OrderTunnelStep;
use Domain\Services\OrderTunnelService;
use Illuminate\Support\Facades\Gate;

covers(OrderTunnelStepPolicy::class);

function createFakeGate(bool $returns): object
{
    return new class ($returns)
    {
        public function __construct(private bool $returns)
        {
        }

        public function allows($ability, $arguments = [])
        {
            return $this->returns;
        }
    };
}

describe('OrderTunnelStepPolicy', function () {
    describe('canReviewBasketSummary', function () {
        it('returns false when user is a User instance', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $user               = new User();

            // WHEN
            $result = $policy->canReviewBasketSummary($user);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns false when gate denies customerPassOrders', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(false));

            // WHEN
            $result = $policy->canReviewBasketSummary($customer);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns false when orderTunnelService denies access to REVIEW step', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(true));

            $orderTunnelService->shouldReceive('canAccessStep')
                ->once()
                ->with(OrderTunnelStep::REVIEW)
                ->andReturn(false);

            // WHEN
            $result = $policy->canReviewBasketSummary($customer);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns true when gate allows and orderTunnelService allows', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(true));

            $orderTunnelService->shouldReceive('canAccessStep')
                ->once()
                ->with(OrderTunnelStep::REVIEW)
                ->andReturn(true);

            // WHEN
            $result = $policy->canReviewBasketSummary($customer);

            // THEN
            expect($result)->toBeTrue();
        });
    });

    describe('canPickTimeSlot', function () {
        it('returns false when user is a User instance', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $user               = new User();

            // WHEN
            $result = $policy->canPickTimeSlot($user);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns false when gate denies customerPassOrders', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(false));

            // WHEN
            $result = $policy->canPickTimeSlot($customer);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns false when orderTunnelService denies access to BOOKING step', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(true));

            $orderTunnelService->shouldReceive('canAccessStep')
                ->once()
                ->with(OrderTunnelStep::BOOKING)
                ->andReturn(false);

            // WHEN
            $result = $policy->canPickTimeSlot($customer);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns true when gate allows and orderTunnelService allows', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(true));

            $orderTunnelService->shouldReceive('canAccessStep')
                ->once()
                ->with(OrderTunnelStep::BOOKING)
                ->andReturn(true);

            // WHEN
            $result = $policy->canPickTimeSlot($customer);

            // THEN
            expect($result)->toBeTrue();
        });
    });

    describe('canFinalizeOrder', function () {
        it('returns false when user is a User instance', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $user               = new User();

            // WHEN
            $result = $policy->canFinalizeOrder($user);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns false when gate denies customerPassOrders', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(false));

            // WHEN
            $result = $policy->canFinalizeOrder($customer);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns false when orderTunnelService denies access to CONFIRMATION step', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(true));

            $orderTunnelService->shouldReceive('canAccessStep')
                ->once()
                ->with(OrderTunnelStep::CONFIRMATION)
                ->andReturn(false);

            // WHEN
            $result = $policy->canFinalizeOrder($customer);

            // THEN
            expect($result)->toBeFalse();
        });

        it('returns true when gate allows and orderTunnelService allows', function () {
            // GIVEN
            $orderTunnelService = \Mockery::mock(OrderTunnelService::class);
            $policy             = new OrderTunnelStepPolicy($orderTunnelService);
            $customer           = new Customer();

            Gate::swap(createFakeGate(true));

            $orderTunnelService->shouldReceive('canAccessStep')
                ->once()
                ->with(OrderTunnelStep::CONFIRMATION)
                ->andReturn(true);

            // WHEN
            $result = $policy->canFinalizeOrder($customer);

            // THEN
            expect($result)->toBeTrue();
        });
    });
});