Give universal flag highest priority (#27)

* Give universal flag the highest priority (wip) * Stop forgetting tenant parameter when route-level path ID is used * Fix PHPStan errors * Simplify annotation * Fix comment * Correct annotations * Improve requestHasTenant comment * Make cloning logic only clone universal routes, delete the universal flag from the new (tenant) route * Delete APP_DEBUG * make if condition easier to read * Update DealsWithRouteContexts.php * Fix test * Fix code style (php-cs-fixer) * Move tests * Delete incorrectly committed file * Cloning routes update wip * Route cloning rework WIP * Add todo to clone routes * Fix code style (php-cs-fixer) * Route cloning fix WIP * Set CloneRoutesAsTenant::$tenantMiddleware to ID MW * Revert CloneRoutesAsTenant::$tenantMiddleware-related changes * Simplify requestHasTenant * Add and test 'ckone' flag * Delete setting $skippedRoutes from CloneRoutesAsTenant * Fix code style (php-cs-fixer) * make config key used for testing distinct from normal tenancy config keys * Update src/Actions/CloneRoutesAsTenant.php * Move 'path identification types' dataset to CloneActionTest --------- Co-authored-by: Samuel Štancl <samuel.stancl@gmail.com> Co-authored-by: Samuel Štancl <samuel@archte.ch> Co-authored-by: PHP CS Fixer <phpcsfixer@example.com>
2025-12-12 09:54:03 +00:00 · 2024-01-25 15:27:17 +01:00 · 2024-01-25 15:27:17 +01:00 · c312156c18
commit c312156c18
parent 070828a81e
10 changed files with 315 additions and 296 deletions
--- a/tests/CloneActionTest.php
+++ b/tests/CloneActionTest.php
@ -0,0 +1,269 @@
+<?php
+
+use Illuminate\Routing\Route;
+use Stancl\Tenancy\Enums\RouteMode;
+use Illuminate\Contracts\Http\Kernel;
+use Stancl\Tenancy\Actions\CloneRoutesAsTenant;
+use Stancl\Tenancy\Resolvers\PathTenantResolver;
+use Illuminate\Support\Facades\Route as RouteFacade;
+use Stancl\Tenancy\Tests\Etc\HasMiddlewareController;
+use Stancl\Tenancy\Middleware\InitializeTenancyByPath;
+use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
+
+test('a route can be universal using path identification', function (array $routeMiddleware, array $globalMiddleware) {
+    foreach ($globalMiddleware as $middleware) {
+        if ($middleware === 'universal') {
+            config(['tenancy.default_route_mode' => RouteMode::UNIVERSAL]);
+        } else {
+            app(Kernel::class)->pushMiddleware($middleware);
+        }
+    }
+
+    RouteFacade::get('/foo', function () {
+        return tenancy()->initialized
+            ? 'Tenancy is initialized.'
+            : 'Tenancy is not initialized.';
+    })->middleware($routeMiddleware);
+
+    config(['tenancy._tests.static_identification_middleware' => $routeMiddleware]);
+
+    RouteFacade::get('/bar', [HasMiddlewareController::class, 'index']);
+
+    /** @var CloneRoutesAsTenant $cloneRoutesAction */
+    $cloneRoutesAction = app(CloneRoutesAsTenant::class);
+
+    $cloneRoutesAction->handle();
+
+    $tenantKey = Tenant::create()->getTenantKey();
+
+    pest()->get("http://localhost/foo")
+        ->assertSuccessful()
+        ->assertSee('Tenancy is not initialized.');
+
+    pest()->get("http://localhost/{$tenantKey}/foo")
+        ->assertSuccessful()
+        ->assertSee('Tenancy is initialized.');
+
+    tenancy()->end();
+
+    pest()->get("http://localhost/bar")
+        ->assertSuccessful()
+        ->assertSee('Tenancy is not initialized.');
+
+    pest()->get("http://localhost/{$tenantKey}/bar")
+        ->assertSuccessful()
+        ->assertSee('Tenancy is initialized.');
+})->with('path identification types');
+
+test('CloneRoutesAsTenant registers prefixed duplicates of universal routes correctly', function (bool $kernelIdentification, bool $useController, string $tenantMiddleware) {
+    $routeMiddleware = ['universal'];
+    config(['tenancy.identification.path_identification_middleware' => [$tenantMiddleware]]);
+
+    if ($kernelIdentification) {
+        app(Kernel::class)->pushMiddleware($tenantMiddleware);
+    } else {
+        $routeMiddleware[] = $tenantMiddleware;
+    }
+
+    config(['tenancy.identification.resolvers.' . PathTenantResolver::class . '.tenant_parameter_name' => $tenantParameterName = 'team']);
+    config(['tenancy.identification.resolvers.' . PathTenantResolver::class . '.tenant_route_name_prefix' => $tenantRouteNamePrefix = 'team-route.']);
+
+    // Test that routes with controllers as well as routes with closure actions get cloned correctly
+    $universalRoute = RouteFacade::get('/home', $useController ? Controller::class : fn () => tenant() ? 'Tenancy is initialized.' : 'Tenancy is not initialized.')->middleware($routeMiddleware)->name('home');
+    $centralRoute = RouteFacade::get('/central', fn () => true)->name('central');
+
+    config(['tenancy._tests.static_identification_middleware' => $routeMiddleware]);
+
+    $universalRoute2 = RouteFacade::get('/bar', [HasMiddlewareController::class, 'index'])->name('second-home');
+
+    expect($routes = RouteFacade::getRoutes()->get())->toContain($universalRoute)
+        ->toContain($universalRoute2)
+        ->toContain($centralRoute);
+
+    /** @var CloneRoutesAsTenant $cloneRoutesAction */
+    $cloneRoutesAction = app(CloneRoutesAsTenant::class);
+
+    $cloneRoutesAction->handle();
+
+    expect($routesAfterRegisteringDuplicates = RouteFacade::getRoutes()->get())
+        ->toContain($universalRoute)
+        ->toContain($centralRoute);
+
+    $newRoutes = collect($routesAfterRegisteringDuplicates)->filter(fn ($route) => ! in_array($route, $routes));
+
+    expect($newRoutes->first()->uri())->toBe('{' . $tenantParameterName . '}' . '/' . $universalRoute->uri());
+    expect($newRoutes->last()->uri())->toBe('{' . $tenantParameterName . '}' . '/' . $universalRoute2->uri());
+
+    // Universal flag is excluded from the route middleware
+    expect(tenancy()->getRouteMiddleware($newRoutes->first()))
+        ->toEqualCanonicalizing(
+            array_filter(array_merge(tenancy()->getRouteMiddleware($universalRoute), ['tenant']),
+            fn($middleware) => $middleware !== 'universal')
+        );
+
+    // Universal flag is provided statically in the route's controller, so we cannot exclude it
+    expect(tenancy()->getRouteMiddleware($newRoutes->last()))
+        ->toEqualCanonicalizing(
+            array_merge(tenancy()->getRouteMiddleware($universalRoute2), ['tenant'])
+        );
+
+    $tenant = Tenant::create();
+
+    pest()->get(route($centralRouteName = $universalRoute->getName()))->assertSee('Tenancy is not initialized.');
+    pest()->get(route($centralRouteName2 = $universalRoute2->getName()))->assertSee('Tenancy is not initialized.');
+    pest()->get(route($tenantRouteName = $newRoutes->first()->getName(), [$tenantParameterName => $tenant->getTenantKey()]))->assertSee('Tenancy is initialized.');
+    tenancy()->end();
+    pest()->get(route($tenantRouteName2 = $newRoutes->last()->getName(), [$tenantParameterName => $tenant->getTenantKey()]))->assertSee('Tenancy is initialized.');
+
+    expect($tenantRouteName)->toBe($tenantRouteNamePrefix . $universalRoute->getName());
+    expect($tenantRouteName2)->toBe($tenantRouteNamePrefix . $universalRoute2->getName());
+    expect($centralRouteName)->toBe($universalRoute->getName());
+    expect($centralRouteName2)->toBe($universalRoute2->getName());
+})->with([
+    'kernel identification' => true,
+    'route-level identification' => false,
+// Creates a matrix (multiple with())
+])->with([
+    'use controller' => true,
+    'use closure' => false
+])->with([
+    'path identification middleware' => InitializeTenancyByPath::class,
+    'custom path identification middleware' => CustomInitializeTenancyByPath::class,
+]);
+
+test('CloneRoutesAsTenant only clones routes with path identification by default', function () {
+    app(Kernel::class)->pushMiddleware(InitializeTenancyByPath::class);
+
+    $currentRouteCount = fn () => count(RouteFacade::getRoutes()->get());
+
+    $initialRouteCount = $currentRouteCount();
+
+    // Path identification is used globally, and this route doesn't use a specific identification middleware, meaning path identification is used and the route should get cloned
+    RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')->middleware('universal')->name('home');
+    // The route uses a specific identification middleware other than InitializeTenancyByPath – the route shouldn't get cloned
+    RouteFacade::get('/home-domain-id', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')->middleware(['universal', InitializeTenancyByDomain::class])->name('home-domain-id');
+
+    expect($currentRouteCount())->toBe($newRouteCount = $initialRouteCount + 2);
+
+    /** @var CloneRoutesAsTenant $cloneRoutesAction */
+    $cloneRoutesAction = app(CloneRoutesAsTenant::class);
+
+    $cloneRoutesAction->handle();
+
+    // Only one of the two routes gets cloned
+    expect($currentRouteCount())->toBe($newRouteCount + 1);
+});
+
+test('custom callbacks can be used for cloning universal routes', function () {
+    RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')->middleware(['universal', InitializeTenancyByPath::class])->name($routeName = 'home');
+
+    /** @var CloneRoutesAsTenant $cloneRoutesAction */
+    $cloneRoutesAction = app(CloneRoutesAsTenant::class);
+    $currentRouteCount = fn () => count(RouteFacade::getRoutes()->get());
+    $initialRouteCount = $currentRouteCount();
+
+    $cloneRoutesAction;
+
+    // Skip cloning the 'home' route
+    $cloneRoutesAction->cloneUsing($routeName, function (Route $route) {
+        return;
+    })->handle();
+
+    // Expect route count to stay the same because the 'home' route cloning gets skipped
+    expect($initialRouteCount)->toEqual($currentRouteCount());
+
+    // Modify the 'home' route cloning so that a different route is cloned
+    $cloneRoutesAction->cloneUsing($routeName, function (Route $route) {
+        RouteFacade::get('/cloned-route', fn () => true)->name('new.home');
+    })->handle();
+
+    expect($currentRouteCount())->toEqual($initialRouteCount + 1);
+});
+
+test('cloning of specific routes can get skipped', function () {
+    RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')->middleware('universal')->name($routeName = 'home');
+
+    /** @var CloneRoutesAsTenant $cloneRoutesAction */
+    $cloneRoutesAction = app(CloneRoutesAsTenant::class);
+    $currentRouteCount = fn () => count(RouteFacade::getRoutes()->get());
+    $initialRouteCount = $currentRouteCount();
+
+    // Skip cloning the 'home' route
+    $cloneRoutesAction->skipRoute($routeName);
+
+    $cloneRoutesAction->handle();
+
+    // Expect route count to stay the same because the 'home' route cloning gets skipped
+    expect($initialRouteCount)->toEqual($currentRouteCount());
+});
+
+test('routes except nonuniversal routes with path id mw are given the tenant flag after cloning', function (array $routeMiddleware, array $globalMiddleware) {
+    foreach ($globalMiddleware as $middleware) {
+        if ($middleware === 'universal') {
+            config(['tenancy.default_route_mode' => RouteMode::UNIVERSAL]);
+        } else {
+            app(Kernel::class)->pushMiddleware($middleware);
+        }
+    }
+
+    $route = RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')
+        ->middleware($routeMiddleware)
+        ->name($routeName = 'home');
+
+    app(CloneRoutesAsTenant::class)->handle();
+
+    $clonedRoute = RouteFacade::getRoutes()->getByName('tenant.' . $routeName);
+
+    // Non-universal routes with identification middleware are already considered tenant, so they don't get the tenant flag
+    if (! tenancy()->routeIsUniversal($route) && tenancy()->routeHasIdentificationMiddleware($clonedRoute)) {
+        expect($clonedRoute->middleware())->not()->toContain('tenant');
+    } else {
+        expect($clonedRoute->middleware())->toContain('tenant');
+    }
+})->with('path identification types');
+
+test('routes with the clone flag get cloned without making the routes universal', function ($identificationMiddleware) {
+    config(['tenancy.identification.path_identification_middleware' => [$identificationMiddleware]]);
+
+    RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')
+        ->middleware(['clone', $identificationMiddleware])
+        ->name($routeName = 'home');
+
+    $tenant = Tenant::create();
+
+    app(CloneRoutesAsTenant::class)->handle();
+
+    $clonedRoute = RouteFacade::getRoutes()->getByName('tenant.' . $routeName);
+
+    expect($clonedRoute->middleware())->toEqualCanonicalizing(['tenant', $identificationMiddleware]);
+
+    // The original route is not accessible
+    pest()->get(route($routeName))->assertServerError();
+    pest()->get(route($routeName, ['tenant' => $tenant]))->assertServerError();
+    // The cloned route is a tenant route
+    pest()->get(route('tenant.' . $routeName, ['tenant' => $tenant]))->assertSee('Tenancy initialized.');
+})->with([InitializeTenancyByPath::class, CustomInitializeTenancyByPath::class]);
+
+class CustomInitializeTenancyByPath extends InitializeTenancyByPath
+{
+
+}
+
+dataset('path identification types', [
+    'kernel identification' => [
+        'route_middleware' => ['universal'],
+        'global_middleware' => [InitializeTenancyByPath::class],
+    ],
+    'route-level identification' => [
+        'route_middleware' => ['universal', InitializeTenancyByPath::class],
+        'global_middleware' => [],
+    ],
+    'kernel identification + defaulting to universal routes' => [
+        'route_middleware' => [],
+        'global_middleware' => ['universal', InitializeTenancyByPath::class],
+    ],
+    'route-level identification + defaulting to universal routes' => [
+        'route_middleware' => [InitializeTenancyByPath::class],
+        'global_middleware' => ['universal'],
+    ],
+]);