Refactor cloning action, update tests

tests/CloneActionTest.php

@@ -1,270 +1,121 @@
 <?php
 
 use Illuminate\Routing\Route;
-use Stancl\Tenancy\Enums\RouteMode;
 use Stancl\Tenancy\Tests\Etc\Tenant;
-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;
 use function Stancl\Tenancy\Tests\pest;
 
-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;
-    }
-
+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
-    ],
-]);