From e8eb38748f644c88411fb13fe6fe12ee32b95a1d Mon Sep 17 00:00:00 2001 From: lukinovec Date: Fri, 16 May 2025 16:52:13 +0200 Subject: [PATCH] Refactor cloning action, update tests --- src/Actions/CloneRoutesAsTenant.php | 153 ++++++--------- tests/CloneActionTest.php | 289 ++++++---------------------- 2 files changed, 116 insertions(+), 326 deletions(-) diff --git a/src/Actions/CloneRoutesAsTenant.php b/src/Actions/CloneRoutesAsTenant.php index 86c3df9d..2e5f58e8 100644 --- a/src/Actions/CloneRoutesAsTenant.php +++ b/src/Actions/CloneRoutesAsTenant.php @@ -9,38 +9,32 @@ use Illuminate\Routing\Route; use Illuminate\Routing\Router; use Illuminate\Support\Collection; use Illuminate\Support\Str; -use Stancl\Tenancy\Enums\RouteMode; use Stancl\Tenancy\Resolvers\PathTenantResolver; /** - * The CloneRoutesAsTenant action clones - * routes flagged with the 'universal' middleware, - * all routes without a flag if the default route mode is universal, - * and routes that directly use the InitializeTenancyByPath middleware. + * Clones routes manually added to $routesToClone, or if $routesToClone is empty, + * clones all existing routes for which shouldBeCloned returns true (by default, this means all routes + * with any middleware that's present in $cloneRoutesWithMiddleware). + * Cloned routes are prefixed with '/{tenant}', flagged with 'tenant' middleware, + * and have their names prefixed with 'tenant.'. * * The main purpose of this action is to make the integration * of packages (e.g., Jetstream or Livewire) easier with path-based tenant identification. * - * By default, universal routes are cloned as tenant routes (= they get flagged with the 'tenant' middleware) - * and prefixed with the '/{tenant}' path prefix. Their name also gets prefixed with the tenant name prefix. - * - * Routes with the path identification middleware get cloned similarly, but only if they're not universal at the same time. - * Unlike universal routes, these routes don't get the tenant flag, - * because they don't need it (they're not universal, and they have the identification MW, so they're already considered tenant). - * - * You can use the `cloneUsing()` hook to customize the route definitions, - * and the `skipRoute()` method to skip cloning of specific routes. - * You can also use the $tenantParameterName and $tenantRouteNamePrefix - * static properties to customize the tenant parameter name or the route name prefix. + * Customization: + * - Use cloneRoutesWithMiddleware() to change the middleware in $cloneRoutesWithMiddleware + * - Use shouldClone() to change which routes should be cloned + * - Use cloneUsing() to customize route definitions + * - Adjust PathTenantResolver's $tenantParameterName and $tenantRouteNamePrefix as needed * * Note that routes already containing the tenant parameter or prefix won't be cloned. */ class CloneRoutesAsTenant { - protected array $cloneRouteUsing = []; - protected array $skippedRoutes = [ - 'stancl.tenancy.asset', - ]; + protected array $routesToClone = []; + protected Closure|null $cloneUsing = null; + protected Closure|null $shouldBeCloned = null; + protected array $cloneRoutesWithMiddleware = ['clone']; public function __construct( protected Router $router, @@ -48,100 +42,69 @@ class CloneRoutesAsTenant public function handle(): void { - $this->getRoutesToClone()->each(fn (Route $route) => $this->cloneRoute($route)); + // If no routes were specified using cloneRoute(), get all routes that should be cloned + if (! $this->routesToClone) { + $this->routesToClone = collect($this->router->getRoutes()->get()) + ->filter(fn (Route $route) => $this->shouldBeCloned($route)) + ->all(); + } + + foreach ($this->routesToClone as $route) { + // If the cloneUsing callback is set, + // use the callback to clone the route instead of the default + if ($this->cloneUsing) { + ($this->cloneUsing)($route); + + continue; + } + + $this->copyMiscRouteProperties($route, $this->createNewRoute($route)); + } $this->router->getRoutes()->refreshNameLookups(); } - /** - * Make the action clone a specific route using the provided callback instead of the default one. - */ - public function cloneUsing(string $routeName, Closure $callback): static + public function cloneUsing(Closure|null $cloneUsing): static { - $this->cloneRouteUsing[$routeName] = $callback; + $this->cloneUsing = $cloneUsing; return $this; } - /** - * Skip a route's cloning. - */ - public function skipRoute(string $routeName): static + public function cloneRoutesWithMiddleware(array $middleware): static { - $this->skippedRoutes[] = $routeName; + $this->cloneRoutesWithMiddleware = $middleware; return $this; } - /** - * @return Collection - */ - protected function getRoutesToClone(): Collection + public function shouldClone(Closure|null $shouldClone): static { - $tenantParameterName = PathTenantResolver::tenantParameterName(); + $this->shouldBeCloned = $shouldClone; - /** - * Clone all routes that: - * - don't have the tenant parameter - * - aren't in the $skippedRoutes array - * - are using path identification (kernel or route-level). - * - * Non-universal cloned routes will only be available in the tenant context, - * universal routes will be available in both contexts. - */ - return collect($this->router->getRoutes()->get())->filter(function (Route $route) use ($tenantParameterName) { - if ( - tenancy()->routeHasMiddleware($route, 'tenant') || - in_array($route->getName(), $this->skippedRoutes, true) || - in_array($tenantParameterName, $route->parameterNames(), true) - ) { - return false; - } - - $pathIdentificationMiddleware = config('tenancy.identification.path_identification_middleware'); - $routeHasPathIdentificationMiddleware = tenancy()->routeHasMiddleware($route, $pathIdentificationMiddleware); - $routeHasNonPathIdentificationMiddleware = tenancy()->routeHasIdentificationMiddleware($route) && ! $routeHasPathIdentificationMiddleware; - $pathIdentificationMiddlewareInGlobalStack = tenancy()->globalStackHasMiddleware($pathIdentificationMiddleware); - - /** - * The route should get cloned if: - * - it has route-level path identification middleware, OR - * - it uses kernel path identification (it doesn't have any route-level identification middleware) and the route is tenant or universal. - * - * The route is considered tenant if: - * - it's flagged as tenant, OR - * - it's not flagged as tenant or universal, but it has the identification middleware - * - * The route is considered universal if it's flagged as universal, and it doesn't have the tenant flag - * (it's still considered universal if it has route-level path identification middleware + the universal flag). - * - * If the route isn't flagged, the context is determined using the default route mode. - */ - $pathIdentificationUsed = (! $routeHasNonPathIdentificationMiddleware) && - ($routeHasPathIdentificationMiddleware || $pathIdentificationMiddlewareInGlobalStack); - - return $pathIdentificationUsed && - (tenancy()->getRouteMode($route) === RouteMode::UNIVERSAL || tenancy()->routeHasMiddleware($route, 'clone')); - }); + return $this; } - /** - * Clone a route using a callback specified in the $cloneRouteUsing property (using the cloneUsing method). - * If there's no callback specified for the route, use the default way of cloning routes. - */ - protected function cloneRoute(Route $route): void + public function cloneRoute(Route $route): static { - $routeName = $route->getName(); + $this->routesToClone[] = $route; - // If the route's cloning callback exists - // Use the callback to clone the route instead of the default way of cloning routes - if ($routeName && $customRouteCallback = data_get($this->cloneRouteUsing, $routeName)) { - $customRouteCallback($route); + return $this; + } - return; + // todo@rename + protected function shouldBeCloned(Route $route): bool + { + if ($this->shouldBeCloned) { + return ($this->shouldBeCloned)($route); } - $this->copyMiscRouteProperties($route, $this->createNewRoute($route)); + if (Str::startsWith($route->getName(), PathTenantResolver::tenantRouteNamePrefix())) { + // The route already has the tenant route name prefix, so we don't need to clone it + return false; + } + + return tenancy()->routeHasMiddleware($route, $this->cloneRoutesWithMiddleware); } protected function createNewRoute(Route $route): Route @@ -156,21 +119,21 @@ class CloneRoutesAsTenant // Make the new route have the same middleware as the original route // Add the 'tenant' middleware to the new route - // Exclude `universal` and `clone` middleware from the new route (it should only be flagged as tenant) + // Exclude $this->cloneRoutesWithMiddleware MW from the new route (it should only be flagged as tenant) $newRouteMiddleware = collect($routeMiddleware) ->merge(['tenant']) // Add 'tenant' flag - ->filter(fn (string $middleware) => ! in_array($middleware, ['universal', 'clone'])) + ->filter(fn (string $middleware) => ! in_array($middleware, $this->cloneRoutesWithMiddleware)) ->toArray(); $tenantRouteNamePrefix = PathTenantResolver::tenantRouteNamePrefix(); // Make sure the route name has the tenant route name prefix - $newRouteNamePrefix = $route->getName() + $newRouteName = $route->getName() ? $tenantRouteNamePrefix . Str::after($route->getName(), $tenantRouteNamePrefix) : null; return $action - ->put('as', $newRouteNamePrefix) + ->put('as', $newRouteName) ->put('middleware', $newRouteMiddleware) ->put('prefix', $prefix . '/{' . PathTenantResolver::tenantParameterName() . '}'); })->toArray(); diff --git a/tests/CloneActionTest.php b/tests/CloneActionTest.php index 3706f31e..33646346 100644 --- a/tests/CloneActionTest.php +++ b/tests/CloneActionTest.php @@ -1,270 +1,121 @@ 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; - } - +test('CloneRoutesAsTenant registers prefixed duplicates of routes correctly', function () { 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'); + $route = RouteFacade::get('/home', fn () => true)->middleware(['clone'])->name('home'); - 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); + expect($routes = RouteFacade::getRoutes()->get())->toContain($route); /** @var CloneRoutesAsTenant $cloneRoutesAction */ $cloneRoutesAction = app(CloneRoutesAsTenant::class); $cloneRoutesAction->handle(); - expect($routesAfterRegisteringDuplicates = RouteFacade::getRoutes()->get()) - ->toContain($universalRoute) - ->toContain($centralRoute); + $newRoutes = collect(RouteFacade::getRoutes()->get())->filter(fn ($route) => ! in_array($route, $routes)); - $newRoutes = collect($routesAfterRegisteringDuplicates)->filter(fn ($route) => ! in_array($route, $routes)); + expect($newRoutes->first()->uri())->toBe('{' . $tenantParameterName . '}' . '/' . $route->uri()); - expect($newRoutes->first()->uri())->toBe('{' . $tenantParameterName . '}' . '/' . $universalRoute->uri()); - expect($newRoutes->last()->uri())->toBe('{' . $tenantParameterName . '}' . '/' . $universalRoute2->uri()); - - // Universal flag is excluded from the route middleware + // The 'clone' flag is excluded from the route middleware expect(tenancy()->getRouteMiddleware($newRoutes->first())) ->toEqualCanonicalizing( - array_values(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_values(array_merge(tenancy()->getRouteMiddleware($universalRoute2), ['tenant'])) + array_values(array_filter(array_merge(tenancy()->getRouteMiddleware($route), ['tenant']), + fn($middleware) => $middleware !== 'clone')) ); $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.'); + pest()->get(route($tenantRouteName = $newRoutes->first()->getName(), [$tenantParameterName => $tenant->getTenantKey()]))->assertOk(); - 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); + expect($tenantRouteName)->toBe($tenantRouteNamePrefix . $route->getName()); }); -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'); +test('custom callback can be used for determining if a route should be cloned', function () { + RouteFacade::get('/home', fn () => true)->name('home'); /** @var CloneRoutesAsTenant $cloneRoutesAction */ $cloneRoutesAction = app(CloneRoutesAsTenant::class); $currentRouteCount = fn () => count(RouteFacade::getRoutes()->get()); $initialRouteCount = $currentRouteCount(); - $cloneRoutesAction; + // No routes should be cloned + $cloneRoutesAction + ->shouldClone(fn (Route $route) => false) + ->handle(); - // 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 route count to stay the same because cloning essentially gets turned off 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(); + // Only the 'home' route should be cloned + $cloneRoutesAction + ->shouldClone(fn (Route $route) => $route->getName() === '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'); +test('custom callbacks can be used for customizing the creation of the cloned routes', function () { + RouteFacade::get('/foo', fn () => true)->name('foo')->middleware(['clone']); + RouteFacade::get('/bar', fn () => true)->name('bar')->middleware(['clone']); /** @var CloneRoutesAsTenant $cloneRoutesAction */ $cloneRoutesAction = app(CloneRoutesAsTenant::class); + + $cloneRoutesAction + ->cloneUsing(function (Route $route) { + RouteFacade::get('/cloned/' . $route->uri(), fn () => 'cloned route')->name('cloned.' . $route->getName()); + })->handle(); + + pest()->get(route('cloned.foo'))->assertSee('cloned route'); + pest()->get(route('cloned.bar'))->assertSee('cloned route'); +}); + +test('the clone action can clone specific routes', function() { + RouteFacade::get('/foo', fn () => true)->name('foo')->middleware(['clone']); + $barRoute = RouteFacade::get('/bar', fn () => true)->name('bar')->middleware(['clone']); + $currentRouteCount = fn () => count(RouteFacade::getRoutes()->get()); $initialRouteCount = $currentRouteCount(); - // Skip cloning the 'home' route - $cloneRoutesAction->skipRoute($routeName); + /** @var CloneRoutesAsTenant $cloneRoutesAction */ + $cloneRoutesAction = app(CloneRoutesAsTenant::class); - $cloneRoutesAction->handle(); + $cloneRoutesAction->cloneRoute($barRoute)->handle(); - // Expect route count to stay the same because the 'home' route cloning gets skipped - expect($initialRouteCount)->toEqual($currentRouteCount()); + // Exactly one route should be cloned + expect($currentRouteCount())->toEqual($initialRouteCount + 1); + + expect(RouteFacade::getRoutes()->getByName('tenant.bar'))->not()->toBeNull(); }); -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(array_values($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]); - test('the clone action prefixes already prefixed routes correctly', function () { $routes = [ - RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.') - ->middleware(['universal', InitializeTenancyByPath::class]) + RouteFacade::get('/home', fn () => true) + ->middleware(['clone']) ->name('home') ->prefix('prefix'), - RouteFacade::get('/leadingAndTrailingSlash', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.') - ->middleware(['universal', InitializeTenancyByPath::class]) + RouteFacade::get('/leadingAndTrailingSlash', fn () => true) + ->middleware(['clone']) ->name('leadingAndTrailingSlash') ->prefix('/prefix/'), - RouteFacade::get('/leadingSlash', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.') - ->middleware(['universal', InitializeTenancyByPath::class]) + RouteFacade::get('/leadingSlash', fn () => true) + ->middleware(['clone']) ->name('leadingSlash') ->prefix('/prefix'), - RouteFacade::get('/trailingSlash', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.') - ->middleware(['universal', InitializeTenancyByPath::class]) + RouteFacade::get('/trailingSlash', fn () => true) + ->middleware(['clone']) ->name('trailingSlash') ->prefix('prefix/'), ]; @@ -293,7 +144,7 @@ test('the clone action prefixes already prefixed routes correctly', function () ->toBe("http://localhost/prefix/{$tenant->getTenantKey()}/{$routes[$key]->getName()}"); // The cloned route is accessible - pest()->get($clonedRouteUrl)->assertSee('Tenancy initialized.'); + pest()->get($clonedRouteUrl)->assertOk(); } }); @@ -301,12 +152,12 @@ test('clone action trims trailing slashes from prefixes given to nested route gr RouteFacade::prefix('prefix')->group(function () { RouteFacade::prefix('')->group(function () { // This issue seems to only happen when there's a group with a prefix, then a group with an empty prefix, and then a / route - RouteFacade::get('/', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.') - ->middleware(['universal', InitializeTenancyByPath::class]) + RouteFacade::get('/', fn () => true) + ->middleware(['clone']) ->name('landing'); - RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.') - ->middleware(['universal', InitializeTenancyByPath::class]) + RouteFacade::get('/home', fn () => true) + ->middleware(['clone']) ->name('home'); }); }); @@ -324,27 +175,3 @@ test('clone action trims trailing slashes from prefixes given to nested route gr ->not()->toContain("prefix//") ->toBe("http://localhost/prefix/{$tenant->getTenantKey()}/home"); }); - -class CustomInitializeTenancyByPath extends InitializeTenancyByPath -{ - -} - -dataset('path identification types', [ - 'kernel identification' => [ - ['universal'], // Route middleware - [InitializeTenancyByPath::class], // Global Global middleware - ], - 'route-level identification' => [ - ['universal', InitializeTenancyByPath::class], // Route middleware - [], // Global middleware - ], - 'kernel identification + defaulting to universal routes' => [ - [], // Route middleware - ['universal', InitializeTenancyByPath::class], // Global middleware - ], - 'route-level identification + defaulting to universal routes' => [ - [InitializeTenancyByPath::class], // Route middleware - ['universal'], // Global middleware - ], -]);