mirror of
https://github.com/archtechx/tenancy.git
synced 2025-12-12 17:24:03 +00:00
Central routes without Route::domain(), configurable tenant/central routes by default for domain/subdomain identification, allow accessing central routes in early identification for path & request data middleware (#3)
* Update url binding bootstrapper test * Fix parent::temporarySignedRoute() call * Add universal route tests for all identification types * Improve determineContextFromRequest() * Add setting `TenancyUrlGenerator::$prefixRouteNames` to true in TSP stub * Delete seemingly redundant test (making one route universal won't make all routes universal in any case) * Use collection syntax in ReregisterUniversalRoutes * Improve comments * Add domain identification MW annotation * Update condition in GloballyUsable * Set `tenancy.bootstrappers` instead of adding the bootstrappers using `tenancy.bootstrappers.x`, move test * Revert GloballyUsable condition change * Delete assigning bootstrappers to tenancy.bootstrappers.x * Exclude cache prefixing bootstrapper from the initial configuration * Fix test * Unset bypass parameter * Set static kernel identification-related properties in TestCase * Update bootstrapper name in annotation * Move unset() into a condition * Update TenancyUrlGenerator condition * Set static properties without instantiating Tenancy * Fix unsetting bypass parameter * formatting changes * add a comment * improve docblock * add docblock to TenancyUrlGenerator [ci skip] * docblock changes [ci skip] * Update TenancyUrlGenerator (rename variable, allow bypassing prefixing temporarySignedRoute name) * Improve determineContextFromRequest * Only return the new url generator instance when extending 'url' in UrlBindingBootstrapper * Check route's MW groups for the path ID MW * Remove extra imports from config * Rename MiddlewareContext to Context, add condition for skipping ID MW * Set only the needed bootstrappers in TestCase * Fix code style (php-cs-fixer) * Remove condition * Use correct return type * Fix PHPStan issue * Update comment * Check for tenant parameter instead of prefix * Update shouldBeSkipped condition for universal routes * Don't remove the 'universal' MW group after route re-registration, update test * Fix code style (php-cs-fixer) * Fix typo * Add test for mixing placement of access prevention and identification MW * Add test for mixing placement of access prevention and identification MW * Update docblock * Add setting the session and key resolvers in UrlBindingBootstrapper (required with LW file uploads) * Update stub * Update variable name in route reregistering action * Add trailing comma * Fix code style (php-cs-fixer) * Require routes using path identification to be flagged as tenant in order to be recognized as tenant routes * Add tenant flag while re-registering routes * Update determineContextFromRequest condition (wip) * Fix code style (php-cs-fixer) * Update the middleware context logic so that universal routes have to be flagged as tenant instead of just having ID MW * Update path identification condition * Fix re-registering the LW localized route (add 'tenant' MW) * Update docblock * Simplify LW route re-registration * Add comment * Update comment * Simplify determineContextFromRequest, add comment * Improve stub * Add skipRoute method + test * Fix typo * Update assets/TenancyServiceProvider.stub.php * Update src/Concerns/DealsWithEarlyIdentification.php * Fix typo Co-authored-by: Samuel Štancl <samuel.stancl@gmail.com> * Improve comment * Update test structure * Restructure Fortify test * code style * Fix typo * Update ReregisterUniversalRoutes annotation * Only prefix route name if it wasn't already prefixed * Add todo@docs * Delete `Tenancy::$kernelAccessPreventionSkipped` and related logic * Delete test tenant cleanup * Test MW group unpacking, restructure and improve test * Test that tenancy isn't initialized after visiting a central route with the tenant parameter * Delete "in both central and tenant contexts" from test names * Test that re-registering works with controllers too * Set misc route properties during re-registering * Determine context instead of guessing, update universal route tests * Use randomly generated tenant ID instead of hardcoding `acme` * Remove setting route validators * Rename and update determine context method, add comments * Update ForgetTenantParameter annotation * Add comment * Delete comment, delete variable assignment * Update early domain identification test * Improve domain identification tests (test defaulting accurately) * Improve readability * Simplify domain early ID test * Use randomly generated tenant instead of 'acme' * Simplify request data ID test, use random tenant instead of 'acme' * Simplify defaulting domain identification test * Use RouteFacade alias for the Route facade, improve test code * Add defaulting to the request data and path ID tests * Merge path identification tenant parameter removal tests, clean up * Correct wording Co-authored-by: Samuel Štancl <samuel.stancl@gmail.com> * Delete debugging things from UniversalRouteTest * Update annotation * Add `// Creates a matrix` * Improve comment wording * Add MiddlewareUsableWithUniversalRoutes, refactor code accordingly * Fix code style (php-cs-fixer) * Delete debugging leftovers * Delete unused import * Update universal route GloballyUsable condition * Don't implement the universal route interface in access prevention MW * Check if request host is in the central domains in domain ID MW * Test universal routes with domain identification without access prevent MW * Test that universal routes work only with identification MW implementing the universal route interface * Fix code style (php-cs-fixer) * Rename GloballyUsable to UsableWithEarlyIdentification * Fix annotation * Update requestHasTenant annotations * Update comment * Add `with()` comments * Add with() comments where missing * Rename interface, update/add comments * Rename exception, update its default message * Fix code style (php-cs-fixer) * Fix interface name * Delete redundant code from subdomain ID MW * Change domainOrSubdomain ID MW so that instead of passing the identification to other MWs, it happens in the domainOrSubdomain MW * Test domainOrSubdomain identification with universal routes * Fix code style (php-cs-fixer) * Rename universal routes interface * Fix code style (php-cs-fixer) * Try explaining forgetting the tenant parameter better * update interface name reference * uncouple example from query parameters * Update ForgetTenantParameter.php * Update ForgetTenantParameter annotation * Check both routeHasMiddleware and routeHasIdentificationMiddleware in the route MW detection test * Hardcode tenant subdomain * Delete redundant event listening code * Delete unused imports * Delete misuse of `tenancy()->getMiddlewareContext()` from conditions * Delete unused variable * Update comment * Correct request data identification test (defaulting) * Fix defaulting in path id test * Move default route context configuration in domian id test * Rename and update the tenant parameter test * Delete extra tenant parameter test * Use `tenant-domain.test` instead of `127.0.0.2` * Add `default_to_universal_routes` config key * Deal with defaulting to universal routes in the reregistering action * Update logic to make defaulting to universal routes possible * Test defaulting to universal routes * Fix code style (php-cs-fixer) * Delete extra tests * Delete "without access prevention" from datasets * Add defaulting to universal routes to datasets * Override universal flag by central/tenant flag * Add universal flag overriding test * Update "a route can be universal in both route modes" so that the name corresponds with the tested thing * Ignore the PHPStan error * Reset `InitializeTenancyByPath::$onFail` in PathIdentificationTest * Simplify expression * Use 'Tenancy (not) initialized.' in instead of `tenant()?->getTenantKey()` for better assertions * Properly test removing tenant parameter * Reset static properties in tests * Correct comments in EarlyIdentificationTest * Add comment * Add detail to annotation * Throw exception if payload isn't string or null in request data ID MW * Fix code style (php-cs-fixer) * Delete static `$kernelIdentificationSkipped` property, use `$request->attributes` instead * Use 'default_route_mode' instead of 'default_to_tenant/universal_routes' * Fix code style (php-cs-fixer) * Make path identification MW, tenantParameterName and tenantRouteNamePrefix configurable in ReregisterUniversalRoutes * Delete unused import * Add `$passTenantParameterToRoute` to TenancyUrlGenerator * Use `$passTenantParameterToRoute` in BootstrapperTest * Bypass tenant parameter passing * Improve TenancyUrlGenerator so that both ID methods work * Fix code style (php-cs-fixer) * Improve TenancyUrlGenerator readability * Add modifyBehavior() to TenancyUrlGenerator * Fix code style (php-cs-fixer) * Improve comment * Toggle route name prefixing in path/request data ID MW (route-level identification) * Fix code style (php-cs-fixer) * Add path identification MW config key, add `getTenantParameterName()` to ForgetTenantParameter * Fix code style (php-cs-fixer) * Fix modifyBehavior and routeBehaviorModificationBypassed * Add type to `$parameters` parameter * Split modifyBehavior into two methods, don't pass name and parameters by reference * Update UrlBindingBootstrapper annotation * Correct naming in tests (request data -> query string identification) * Add info to annotation * Pass arrays to the behavior modification methods instead of `mixed` * Fix default value of static property in Fortify bootstrapper * Fix code style (php-cs-fixer) * Correct annotation * Enable prefixing routes directly using path identification MW * Test re-registration of routes with path ID MW * Prefix names of routes directly using path ID MW * Fix code style (php-cs-fixer) * Add Livewire v3 integration example to TSP stub * Prefix route name only if it's not prefixed already * Rename ReregisterUniversalRoutes to ReregisterRoutesAsTenant * Fix code style (php-cs-fixer) * Improve ReregisterRoutesAsTenant * Add/update TenancyUrlGenerator docblocks * Update action name in comments/test names * Update reregister action annotation * Delete unused imports * Improve comments * Make method protected * Improve TenancyUrlGenerator code * Test bypass parameter removal * Fix comment * Update annotation * Improve shouldReregisterRoute * Fix typo, delete redundant comment * Improve skipRoute * Improve shouldBeSkipped * Add and test `$passTenantParameterToRoutes` * add a comment * Fix typo in comment * Pass array as $parameters in prepareRouteInputs * Make path_identification_middleware an array * Fix code style (php-cs-fixer) * Fix ReregisterRouteAsTenant * Move tenantParameterName and tenantRouteNamePrefix getting to PathIdentificationManager * Make PathIdentificationManager properties `Closure|null` * Fix code style (php-cs-fixer) * Fix PathIdentificationManager * Update comments * Use foreach for dataset definition * Extract repetitive inGlobalStack and routeHasMiddleware calls * Refactor PathIdentificationManager * Update TenancyUrlGenerator annotation * Add $skippedRoutes, refactor ReregisterRoutesAsTenant * Improve reregisterRoute * Update re-register action annotation * update test name * Make PathIdentificationManager methods static again, update comments * Add test comment * Update ForgetTenantParameter annotation * Improve route re-registration condition, add comment * Change "re-register" to "clone" * minor code improvements --------- Co-authored-by: lukinovec <lukinovec@gmail.com> Co-authored-by: Samuel Štancl <samuel.stancl@gmail.com> Co-authored-by: PHP CS Fixer <phpcsfixer@example.com>
This commit is contained in:
Abrar Ahmad
GitHub
parent
bd9bbe8b41
commit
1d0ca27bc8
53 changed files with 2668 additions and 271 deletions
|
|
@ -2,119 +2,532 @@
|
|||
|
||||
declare(strict_types=1);
|
||||
|
||||
use Illuminate\Support\Facades\Route;
|
||||
use Stancl\Tenancy\Exceptions\TenantCouldNotBeIdentifiedOnDomainException;
|
||||
use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
|
||||
use Stancl\Tenancy\Middleware\PreventAccessFromUnwantedDomains;
|
||||
use Stancl\Tenancy\Tenancy;
|
||||
use Illuminate\Http\Request;
|
||||
use Illuminate\Routing\Route;
|
||||
use Stancl\Tenancy\Tests\Etc\Tenant;
|
||||
use Illuminate\Contracts\Http\Kernel;
|
||||
use Stancl\Tenancy\Resolvers\PathTenantResolver;
|
||||
use Illuminate\Routing\Controller as BaseController;
|
||||
use Illuminate\Support\Facades\Route as RouteFacade;
|
||||
use Stancl\Tenancy\Actions\CloneRoutesAsTenant;
|
||||
use Stancl\Tenancy\Middleware\InitializeTenancyByPath;
|
||||
use Stancl\Tenancy\Middleware\IdentificationMiddleware;
|
||||
use Stancl\Tenancy\Resolvers\RequestDataTenantResolver;
|
||||
use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
|
||||
use Stancl\Tenancy\Concerns\UsableWithEarlyIdentification;
|
||||
use Stancl\Tenancy\Middleware\InitializeTenancyBySubdomain;
|
||||
use Stancl\Tenancy\Middleware\InitializeTenancyByRequestData;
|
||||
use Stancl\Tenancy\Middleware\PreventAccessFromUnwantedDomains;
|
||||
use Stancl\Tenancy\Middleware\InitializeTenancyByDomainOrSubdomain;
|
||||
use Stancl\Tenancy\Exceptions\TenantCouldNotBeIdentifiedByPathException;
|
||||
use Stancl\Tenancy\Exceptions\TenantCouldNotBeIdentifiedOnDomainException;
|
||||
use Stancl\Tenancy\Exceptions\MiddlewareNotUsableWithUniversalRoutesException;
|
||||
use Stancl\Tenancy\Exceptions\TenantCouldNotBeIdentifiedByRequestDataException;
|
||||
use Stancl\Tenancy\RouteMode;
|
||||
|
||||
test('a route can work in both central and tenant context', function (array $routeMiddleware, string|null $globalMiddleware) {
|
||||
if ($globalMiddleware) {
|
||||
app(Kernel::class)->pushMiddleware($globalMiddleware);
|
||||
test('a route can be universal using domain identification', function (array $routeMiddleware, array $globalMiddleware) {
|
||||
foreach ($globalMiddleware as $middleware) {
|
||||
// Instead of a global 'universal' MW, we use the default_route_mode config key to make routes universal by default
|
||||
if ($middleware === 'universal') {
|
||||
config(['tenancy.default_route_mode' => RouteMode::UNIVERSAL]);
|
||||
} else {
|
||||
app(Kernel::class)->pushMiddleware($middleware);
|
||||
}
|
||||
}
|
||||
|
||||
Route::middlewareGroup('universal', []);
|
||||
|
||||
Route::get('/foo', function () {
|
||||
RouteFacade::get('/foo', function () {
|
||||
return tenancy()->initialized
|
||||
? 'Tenancy is initialized.'
|
||||
: 'Tenancy is not initialized.';
|
||||
})->middleware($routeMiddleware);
|
||||
|
||||
$tenant = Tenant::create([
|
||||
'id' => 'acme',
|
||||
]);
|
||||
$tenant = Tenant::create();
|
||||
|
||||
$tenant->domains()->create([
|
||||
'domain' => 'acme.localhost',
|
||||
'domain' => $tenantDomain = $tenant->getTenantKey() . '.localhost',
|
||||
]);
|
||||
|
||||
pest()->get("http://localhost/foo")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is not initialized.');
|
||||
|
||||
pest()->get("http://acme.localhost/foo")
|
||||
pest()->get("http://{$tenantDomain}/foo")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is initialized.');
|
||||
})->with('identification types');
|
||||
})->with('domain identification types');
|
||||
|
||||
test('making one route universal doesnt make all routes universal', function (array $routeMiddleware, string|null $globalMiddleware) {
|
||||
if ($globalMiddleware) {
|
||||
app(Kernel::class)->pushMiddleware($globalMiddleware);
|
||||
test('a route can be universal using subdomain 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);
|
||||
}
|
||||
}
|
||||
|
||||
Route::middlewareGroup('universal', []);
|
||||
RouteFacade::get('/foo', function () {
|
||||
return tenancy()->initialized
|
||||
? 'Tenancy is initialized.'
|
||||
: 'Tenancy is not initialized.';
|
||||
})->middleware($routeMiddleware);
|
||||
|
||||
Route::middleware($routeMiddleware)->group(function () {
|
||||
Route::get('/nonuniversal', function () {
|
||||
return tenant('id');
|
||||
});
|
||||
$tenant = Tenant::create();
|
||||
$tenantKey = $tenant->getTenantKey();
|
||||
|
||||
Route::get('/universal', function () {
|
||||
return tenancy()->initialized
|
||||
? 'Tenancy is initialized.'
|
||||
: 'Tenancy is not initialized.';
|
||||
})->middleware('universal');
|
||||
});
|
||||
|
||||
$tenant = Tenant::create([
|
||||
'id' => 'acme',
|
||||
]);
|
||||
$tenant->domains()->create([
|
||||
'domain' => 'acme.localhost',
|
||||
'domain' => $tenantKey,
|
||||
]);
|
||||
|
||||
pest()->get("http://localhost/universal")
|
||||
pest()->get("http://localhost/foo")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is not initialized.');
|
||||
|
||||
pest()->get("http://acme.localhost/universal")
|
||||
pest()->get("http://{$tenantKey}.localhost/foo")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is initialized.');
|
||||
})->with('subdomain identification types');
|
||||
|
||||
test('a route can be universal using domainOrSubdomain 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);
|
||||
|
||||
$tenant = Tenant::create();
|
||||
|
||||
$tenant->domains()->create([
|
||||
'domain' => $tenantDomain = 'tenant-domain.test',
|
||||
]);
|
||||
|
||||
$tenant->domains()->create([
|
||||
'domain' => $tenantSubdomain = 'tenant-subdomain',
|
||||
]);
|
||||
|
||||
pest()->get("http://localhost/foo")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is not initialized.');
|
||||
|
||||
// Domain identification
|
||||
pest()->get("http://{$tenantDomain}/foo")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is initialized.');
|
||||
|
||||
tenancy()->end();
|
||||
|
||||
pest()->get('http://localhost/nonuniversal')
|
||||
->assertStatus(404);
|
||||
|
||||
pest()->get('http://acme.localhost/nonuniversal')
|
||||
// Subdomain identification
|
||||
pest()->get("http://{$tenantSubdomain}.localhost/foo")
|
||||
->assertSuccessful()
|
||||
->assertSee('acme');
|
||||
})->with([
|
||||
'early identification' => [
|
||||
'route_middleware' => [PreventAccessFromUnwantedDomains::class],
|
||||
'global_middleware' => InitializeTenancyByDomain::class,
|
||||
],
|
||||
'route-level identification' => [
|
||||
'route_middleware' => [PreventAccessFromUnwantedDomains::class, InitializeTenancyByDomain::class],
|
||||
'global_middleware' => null,
|
||||
]
|
||||
]);
|
||||
->assertSee('Tenancy is initialized.');
|
||||
})->with('domainOrSubdomain identification types');
|
||||
|
||||
test('it throws correct exception when route is universal and tenant does not exist', function (array $routeMiddleware, string|null $globalMiddleware) {
|
||||
if ($globalMiddleware) {
|
||||
app(Kernel::class)->pushMiddleware($globalMiddleware);
|
||||
test('a route can be universal using request data 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);
|
||||
}
|
||||
}
|
||||
|
||||
Route::middlewareGroup('universal', []);
|
||||
RouteFacade::get('/foo', function () {
|
||||
return tenancy()->initialized
|
||||
? 'Tenancy is initialized.'
|
||||
: 'Tenancy is not initialized.';
|
||||
})->middleware($routeMiddleware);
|
||||
|
||||
Route::get('/foo', function () {
|
||||
$tenantKey = Tenant::create()->getTenantKey();
|
||||
|
||||
pest()->get("http://localhost/foo")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is not initialized.');
|
||||
|
||||
pest()->get("http://localhost/foo?tenant={$tenantKey}")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is initialized.');
|
||||
})->with('request data identification types');
|
||||
|
||||
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);
|
||||
|
||||
/** @var CloneRoutesAsTenant $reregisterRoutesAction */
|
||||
$reregisterRoutesAction = app(CloneRoutesAsTenant::class);
|
||||
|
||||
$reregisterRoutesAction->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.');
|
||||
})->with('path identification types');
|
||||
|
||||
test('correct exception is thrown when route is universal and tenant could not be identified using domain 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);
|
||||
|
||||
pest()->expectException(TenantCouldNotBeIdentifiedOnDomainException::class);
|
||||
$this->withoutExceptionHandling()->get('http://acme.localhost/foo');
|
||||
})->with('identification types');
|
||||
$this->withoutExceptionHandling()->get('http://nonexistent_domain.localhost/foo');
|
||||
})->with('domain identification types');
|
||||
|
||||
dataset('identification types', [
|
||||
'early identification' => [
|
||||
'route_middleware' => ['universal', PreventAccessFromUnwantedDomains::class],
|
||||
'global_middleware' => InitializeTenancyByDomain::class,
|
||||
],
|
||||
'route-level identification' => [
|
||||
'route_middleware' => ['universal', PreventAccessFromUnwantedDomains::class, InitializeTenancyByDomain::class],
|
||||
'global_middleware' => null,
|
||||
]
|
||||
test('correct exception is thrown when route is universal and tenant could not be identified using subdomain 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);
|
||||
|
||||
pest()->expectException(TenantCouldNotBeIdentifiedOnDomainException::class);
|
||||
$this->withoutExceptionHandling()->get('http://nonexistent_subdomain.localhost/foo');
|
||||
})->with('subdomain identification types');
|
||||
|
||||
test('correct exception is thrown when route is universal and tenant could not be identified 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', fn () => tenant() ? 'Tenancy is initialized.' : 'Tenancy is not initialized.')->middleware($routeMiddleware)->name('foo');
|
||||
|
||||
/** @var CloneRoutesAsTenant $reregisterRoutesAction */
|
||||
$reregisterRoutesAction = app(CloneRoutesAsTenant::class);
|
||||
|
||||
$reregisterRoutesAction->handle();
|
||||
|
||||
pest()->expectException(TenantCouldNotBeIdentifiedByPathException::class);
|
||||
$this->withoutExceptionHandling()->get('http://localhost/non_existent/foo');
|
||||
})->with('path identification types');
|
||||
|
||||
test('correct exception is thrown when route is universal and tenant could not be identified using request data 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);
|
||||
|
||||
pest()->expectException(TenantCouldNotBeIdentifiedByRequestDataException::class);
|
||||
$this->withoutExceptionHandling()->get('http://localhost/foo?tenant=nonexistent_tenant');
|
||||
})->with('request data identification types');
|
||||
|
||||
test('tenant and central flags override the universal flag', function () {
|
||||
app(Kernel::class)->pushMiddleware(InitializeTenancyByRequestData::class);
|
||||
$tenant = Tenant::create();
|
||||
|
||||
$route = RouteFacade::get('/route', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')->middleware('universal');
|
||||
|
||||
// Route is universal
|
||||
pest()->get('/route')->assertOk()->assertSee('Tenancy not initialized.');
|
||||
pest()->get('/route?tenant=' . $tenant->getTenantKey())->assertOk()->assertSee('Tenancy initialized.');
|
||||
tenancy()->end();
|
||||
|
||||
// Route is in tenant context
|
||||
$route->action['middleware'] = ['universal', 'tenant'];
|
||||
|
||||
pest()->get('/route')->assertServerError(); // "Tenant could not be identified by request data with payload..."
|
||||
pest()->get('/route?tenant=' . $tenant->getTenantKey())->assertOk()->assertSee('Tenancy initialized.');
|
||||
tenancy()->end();
|
||||
|
||||
// Route is in central context
|
||||
$route->action['middleware'] = ['universal', 'central'];
|
||||
|
||||
pest()->get('/route')->assertOk()->assertSee('Tenancy not initialized.');
|
||||
pest()->get('/route?tenant=' . $tenant->getTenantKey())->assertOk()->assertSee('Tenancy not initialized.'); // Route is accessible, but the context is central
|
||||
});
|
||||
|
||||
test('a route can be flagged as universal in both route modes', function (RouteMode $defaultRouteMode) {
|
||||
app(Kernel::class)->pushMiddleware(InitializeTenancyBySubdomain::class);
|
||||
app(Kernel::class)->pushMiddleware(PreventAccessFromUnwantedDomains::class);
|
||||
|
||||
config(['tenancy.default_route_mode' => $defaultRouteMode]);
|
||||
|
||||
RouteFacade::get('/universal', fn () => tenant() ? 'Tenancy is initialized.' : 'Tenancy is not initialized.')->middleware('universal');
|
||||
|
||||
Tenant::create()->domains()->create(['domain' => $tenantSubdomain = 'tenant-subdomain']);
|
||||
|
||||
pest()->get("http://localhost/universal")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is not initialized.');
|
||||
|
||||
pest()->get("http://{$tenantSubdomain}.localhost/universal")
|
||||
->assertSuccessful()
|
||||
->assertSee('Tenancy is initialized.');
|
||||
})->with([
|
||||
'default to tenant routes' => RouteMode::TENANT,
|
||||
'default to central routes' => RouteMode::CENTRAL,
|
||||
]);
|
||||
|
||||
test('ReregisterRoutesAsTenant registers prefixed duplicates of universal routes correctly', function (bool $kernelIdentification, bool $useController) {
|
||||
$routeMiddleware = ['universal'];
|
||||
|
||||
if ($kernelIdentification) {
|
||||
app(Kernel::class)->pushMiddleware(InitializeTenancyByPath::class);
|
||||
} else {
|
||||
$routeMiddleware[] = InitializeTenancyByPath::class;
|
||||
}
|
||||
|
||||
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 re-registered correctly
|
||||
$universalRoute = RouteFacade::get('/home', $useController ? Controller::class : fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')->middleware($routeMiddleware)->name('home');
|
||||
$centralRoute = RouteFacade::get('/central', fn () => true)->name('central');
|
||||
|
||||
expect($routes = RouteFacade::getRoutes()->get())->toContain($universalRoute);
|
||||
expect($routes)->toContain($centralRoute);
|
||||
|
||||
/** @var CloneRoutesAsTenant $reregisterRoutesAction */
|
||||
$reregisterRoutesAction = app(CloneRoutesAsTenant::class);
|
||||
|
||||
$reregisterRoutesAction->handle();
|
||||
|
||||
expect($routesAfterRegisteringDuplicates = RouteFacade::getRoutes()->get())
|
||||
->toContain($universalRoute)
|
||||
->toContain($centralRoute);
|
||||
|
||||
$newRoute = collect($routesAfterRegisteringDuplicates)->filter(fn ($route) => ! in_array($route, $routes))->first();
|
||||
|
||||
expect($newRoute->uri())->toBe('{' . $tenantParameterName . '}' . '/' . $universalRoute->uri());
|
||||
expect(tenancy()->getRouteMiddleware($newRoute))->toBe(array_merge(tenancy()->getRouteMiddleware($universalRoute), ['tenant']));
|
||||
|
||||
$tenant = Tenant::create();
|
||||
|
||||
pest()->get(route($centralRouteName = $universalRoute->getName()))->assertSee('Tenancy not initialized.');
|
||||
pest()->get(route($tenantRouteName = $newRoute->getName(), [$tenantParameterName => $tenant->getTenantKey()]))->assertSee('Tenancy initialized.');
|
||||
|
||||
expect($tenantRouteName)->toBe($tenantRouteNamePrefix . $universalRoute->getName());
|
||||
expect($centralRouteName)->toBe($universalRoute->getName());
|
||||
})->with([
|
||||
'kernel identification' => true,
|
||||
'route-level identification' => false,
|
||||
// Creates a matrix (multiple with())
|
||||
])->with([
|
||||
'use controller' => true,
|
||||
'use closure' => false
|
||||
]);
|
||||
|
||||
test('tenant resolver methods return the correct names for configured values', function (string $configurableParameter, string $value) {
|
||||
$configurableParameterConfigKey = 'tenancy.identification.resolvers.' . PathTenantResolver::class . '.' . $configurableParameter;
|
||||
|
||||
config([$configurableParameterConfigKey => $value]);
|
||||
|
||||
// Note: The names of the methods are NOT dynamic (PathTenantResolver::tenantParameterName(), PathTenantResolver::tenantRouteNamePrefix())
|
||||
$resolverMethodName = str($configurableParameter)->camel()->toString();
|
||||
|
||||
expect(PathTenantResolver::$resolverMethodName())->toBe($value);
|
||||
})->with([
|
||||
['tenant_parameter_name', 'parameter'],
|
||||
['tenant_route_name_prefix', 'prefix']
|
||||
]);
|
||||
|
||||
test('ReregisterRoutesAsTenant only re-registers 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 re-registered
|
||||
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 re-registered
|
||||
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 $reregisterRoutesAction */
|
||||
$reregisterRoutesAction = app(CloneRoutesAsTenant::class);
|
||||
|
||||
$reregisterRoutesAction->handle();
|
||||
|
||||
// Only one of the two routes gets re-registered
|
||||
expect($currentRouteCount())->toBe($newRouteCount + 1);
|
||||
});
|
||||
|
||||
test('custom callbacks can be used for reregistering universal routes', function () {
|
||||
RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')->middleware('universal')->name($routeName = 'home');
|
||||
|
||||
/** @var CloneRoutesAsTenant $reregisterRoutesAction */
|
||||
$reregisterRoutesAction = app(CloneRoutesAsTenant::class);
|
||||
$currentRouteCount = fn () => count(RouteFacade::getRoutes()->get());
|
||||
$initialRouteCount = $currentRouteCount();
|
||||
|
||||
// Skip re-registering the 'home' route
|
||||
$reregisterRoutesAction->cloneUsing($routeName, function (Route $route) {
|
||||
return;
|
||||
})->handle();
|
||||
|
||||
// Expect route count to stay the same because the 'home' route re-registration gets skipped
|
||||
expect($initialRouteCount)->toEqual($currentRouteCount());
|
||||
|
||||
// Modify the 'home' route re-registration so that a different route is registered
|
||||
$reregisterRoutesAction->cloneUsing($routeName, function (Route $route) {
|
||||
RouteFacade::get('/newly-registered-route', fn() => true)->name('new.home');
|
||||
})->handle();
|
||||
|
||||
expect($currentRouteCount())->toEqual($initialRouteCount + 1);
|
||||
});
|
||||
|
||||
test('reregistration of specific routes can get skipped', function () {
|
||||
RouteFacade::get('/home', fn () => tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.')->middleware('universal')->name($routeName = 'home');
|
||||
|
||||
/** @var CloneRoutesAsTenant $reregisterRoutesAction */
|
||||
$reregisterRoutesAction = app(CloneRoutesAsTenant::class);
|
||||
$currentRouteCount = fn () => count(RouteFacade::getRoutes()->get());
|
||||
$initialRouteCount = $currentRouteCount();
|
||||
|
||||
// Skip re-registering the 'home' route
|
||||
$reregisterRoutesAction->skipRoute($routeName)->handle();
|
||||
|
||||
// Expect route count to stay the same because the 'home' route re-registration gets skipped
|
||||
expect($initialRouteCount)->toEqual($currentRouteCount());
|
||||
});
|
||||
|
||||
|
||||
test('identification middleware works with universal routes only when it implements MiddlewareUsableWithUniversalRoutes', function () {
|
||||
$tenantKey = Tenant::create()->getTenantKey();
|
||||
$routeAction = fn () => tenancy()->initialized ? $tenantKey : 'Tenancy is not initialized.';
|
||||
|
||||
// Route with the package's request data identification middleware – implements MiddlewareUsableWithUniversalRoutes
|
||||
RouteFacade::get('/universal-route', $routeAction)->middleware(['universal', InitializeTenancyByRequestData::class]);
|
||||
|
||||
// Routes with custom request data identification middleware – does not implement MiddlewareUsableWithUniversalRoutes
|
||||
RouteFacade::get('/custom-mw-universal-route', $routeAction)->middleware(['universal', CustomMiddleware::class]);
|
||||
RouteFacade::get('/custom-mw-tenant-route', $routeAction)->middleware(['tenant', CustomMiddleware::class]);
|
||||
|
||||
// Ensure the custom identification middleware works with non-universal routes
|
||||
// This is tested here because this is the only test where the custom MW is used
|
||||
// No exception is thrown for this request since the route uses the TENANT middleware, not the UNIVERSAL middleware
|
||||
pest()->get('http://localhost/custom-mw-tenant-route?tenant=' . $tenantKey)->assertOk()->assertSee($tenantKey);
|
||||
|
||||
pest()->get('http://localhost/universal-route')->assertOk();
|
||||
pest()->get('http://localhost/universal-route?tenant=' . $tenantKey)->assertOk()->assertSee($tenantKey);
|
||||
|
||||
pest()->expectException(MiddlewareNotUsableWithUniversalRoutesException::class);
|
||||
$this->withoutExceptionHandling()->get('http://localhost/custom-mw-universal-route');
|
||||
});
|
||||
|
||||
foreach ([
|
||||
'domain identification types' => [PreventAccessFromUnwantedDomains::class, InitializeTenancyByDomain::class],
|
||||
'subdomain identification types' => [PreventAccessFromUnwantedDomains::class, InitializeTenancyBySubdomain::class],
|
||||
'domainOrSubdomain identification types' => [PreventAccessFromUnwantedDomains::class, InitializeTenancyByDomainOrSubdomain::class],
|
||||
'path identification types' => [InitializeTenancyByPath::class],
|
||||
'request data identification types' => [InitializeTenancyByRequestData::class],
|
||||
] as $datasetName => $middleware) {
|
||||
dataset($datasetName, [
|
||||
'kernel identification' => [
|
||||
'route_middleware' => ['universal'],
|
||||
'global_middleware' => $middleware,
|
||||
],
|
||||
'route-level identification' => [
|
||||
'route_middleware' => ['universal', ...$middleware],
|
||||
'global_middleware' => [],
|
||||
],
|
||||
'kernel identification + defaulting to universal routes' => [
|
||||
'route_middleware' => [],
|
||||
'global_middleware' => ['universal', ...$middleware],
|
||||
],
|
||||
'route-level identification + defaulting to universal routes' => [
|
||||
'route_middleware' => $middleware,
|
||||
'global_middleware' => ['universal'],
|
||||
],
|
||||
]);
|
||||
}
|
||||
|
||||
class Controller extends BaseController
|
||||
{
|
||||
public function __invoke()
|
||||
{
|
||||
return tenant() ? 'Tenancy initialized.' : 'Tenancy not initialized.';
|
||||
}
|
||||
}
|
||||
|
||||
class CustomMiddleware extends IdentificationMiddleware
|
||||
{
|
||||
use UsableWithEarlyIdentification;
|
||||
|
||||
public static string $header = 'X-Tenant';
|
||||
public static string $cookie = 'X-Tenant';
|
||||
public static string $queryParameter = 'tenant';
|
||||
|
||||
public function __construct(
|
||||
protected Tenancy $tenancy,
|
||||
protected RequestDataTenantResolver $resolver,
|
||||
) {
|
||||
}
|
||||
|
||||
/** @return \Illuminate\Http\Response|mixed */
|
||||
public function handle(Request $request, Closure $next): mixed
|
||||
{
|
||||
if ($this->shouldBeSkipped(tenancy()->getRoute($request))) {
|
||||
// Allow accessing central route in kernel identification
|
||||
return $next($request);
|
||||
}
|
||||
|
||||
return $this->initializeTenancy($request, $next, $this->getPayload($request));
|
||||
}
|
||||
|
||||
protected function getPayload(Request $request): string|array|null
|
||||
{
|
||||
if (static::$header && $request->hasHeader(static::$header)) {
|
||||
return $request->header(static::$header);
|
||||
} elseif (static::$queryParameter && $request->has(static::$queryParameter)) {
|
||||
return $request->get(static::$queryParameter);
|
||||
} elseif (static::$cookie && $request->hasCookie(static::$cookie)) {
|
||||
return $request->cookie(static::$cookie);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue