archtechx/tenancy
1
0
Fork 0
mirror of https://github.com/archtechx/tenancy.git synced 2025-12-12 11:14:04 +00:00
Code Activity

[4.x] Resolve testing todos (#1361)

Browse source 
* Test encrypted cookie identification

* Add Fortify bootstrapper custom query param passing test

* Correct Fortify route bootstrapper test (todo  refactor, convoluted)

* Clarify Fortify bootstrapper test

* Fix encrypted cookie identification test

* Move encrypted cookie assertion to "cookie identification works"

* Cover configured tenant model columns in cached resolver tests

* Refactor testing resolver with default vs custom tenant model name config

* Delete resolved todo

* Make code more concise

* Keep initial formatting (minimize diff noise)

* Make dataset/helper method parameter clearer

* Clarify fortify test

* Clarify assertions, improve comments

* Delete excessive comments, make existing comments consistent and clearer

* Make cached resolver test file clearer, update outdated comments

* Use the tenant model column term consistently

* FIx inconsistencies

* Provide more info in comment

* make comment more clear

* static property reset

---------

Co-authored-by: Samuel Štancl <samuel@archte.ch>
This commit is contained in:
lukinovec 2025-08-03 23:21:03 +02:00 • committed by GitHub
parent 81fff15afe
commit f308e2f84d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 157 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

133
tests/CachedTenantResolverTest.php
View file

@ -17,59 +17,72 @@ use Stancl\Tenancy\Middleware\InitializeTenancyByPath;
use Stancl\Tenancy\Resolvers\RequestDataTenantResolver;
use function Stancl\Tenancy\Tests\pest;
test('tenants can be resolved using cached resolvers', function (string $resolver) {
$tenant = Tenant::create(['id' => $tenantKey = 'acme']);
beforeEach($cleanup = function () {
Tenant::$extraCustomColumns = [];
});
$tenant->domains()->create(['domain' => $tenantKey]);
afterEach($cleanup);
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
test('tenants can be resolved using cached resolvers', function (string $resolver, bool $configureTenantModelColumn) {
$tenant = Tenant::create([$tenantModelColumn = tenantModelColumn($configureTenantModelColumn) => 'acme']);
$tenant->createDomain($tenant->{$tenantModelColumn});
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
})->with([
DomainTenantResolver::class,
PathTenantResolver::class,
RequestDataTenantResolver::class,
])->with([
'tenant model column is id (default)' => false,
'tenant model column is name (custom)' => true,
]);
test('the underlying resolver is not touched when using the cached resolver', function (string $resolver) {
$tenant = Tenant::create(['id' => $tenantKey = 'acme']);
test('the underlying resolver is not touched when using the cached resolver', function (string $resolver, bool $configureTenantModelColumn) {
$tenant = Tenant::create([$tenantModelColumn = tenantModelColumn($configureTenantModelColumn) => 'acme']);
$tenant->createDomain($tenantKey);
$tenant->createDomain($tenant->{$tenantModelColumn});
DB::enableQueryLog();
config(['tenancy.identification.resolvers.' . $resolver . '.cache' => false]);
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
DB::flushQueryLog();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
pest()->assertNotEmpty(DB::getQueryLog()); // not empty
config(['tenancy.identification.resolvers.' . $resolver . '.cache' => true]);
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
DB::flushQueryLog();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
expect(DB::getQueryLog())->toBeEmpty(); // empty
})->with([
DomainTenantResolver::class,
PathTenantResolver::class,
RequestDataTenantResolver::class,
])->with([
'tenant model column is id (default)' => false,
'tenant model column is name (custom)' => true,
]);
test('cache is invalidated when the tenant is updated', function (string $resolver) {
$tenant = Tenant::create(['id' => $tenantKey = 'acme']);
$tenant->createDomain($tenantKey);
test('cache is invalidated when the tenant is updated', function (string $resolver, bool $configureTenantModelColumn) {
$tenant = Tenant::create([$tenantModelColumn = tenantModelColumn($configureTenantModelColumn) => 'acme']);
$tenant->createDomain($tenant->{$tenantModelColumn});
DB::enableQueryLog();
config(['tenancy.identification.resolvers.' . $resolver . '.cache' => true]);
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
expect(DB::getQueryLog())->not()->toBeEmpty();
DB::flushQueryLog();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
expect(DB::getQueryLog())->toBeEmpty();
// Tenant cache gets invalidated when the tenant is updated
@ -77,41 +90,47 @@ test('cache is invalidated when the tenant is updated', function (string $resolv
DB::flushQueryLog();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
expect(DB::getQueryLog())->not()->toBeEmpty(); // Cache was invalidated, so the tenant was retrieved from the DB
})->with([
DomainTenantResolver::class,
PathTenantResolver::class,
RequestDataTenantResolver::class,
])->with([
'tenant model column is id (default)' => false,
'tenant model column is name (custom)' => true,
]);
test('cache is invalidated when the tenant is deleted', function (string $resolver) {
test('cache is invalidated when the tenant is deleted', function (string $resolver, bool $configureTenantModelColumn) {
DB::statement('SET FOREIGN_KEY_CHECKS=0;'); // allow deleting the tenant
$tenant = Tenant::create(['id' => $tenantKey = 'acme']);
$tenant->createDomain($tenantKey);
$tenant = Tenant::create([$tenantModelColumn = tenantModelColumn($configureTenantModelColumn) => 'acme']);
$tenant->createDomain($tenant->{$tenantModelColumn});
DB::enableQueryLog();
config(['tenancy.identification.resolvers.' . $resolver . '.cache' => true]);
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
expect(DB::getQueryLog())->not()->toBeEmpty();
DB::flushQueryLog();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenantKey))))->toBeTrue();
expect($tenant->is(app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn))))->toBeTrue();
expect(DB::getQueryLog())->toBeEmpty();
$tenant->delete();
DB::flushQueryLog();
expect(fn () => app($resolver)->resolve(getResolverArgument($resolver, $tenantKey)))->toThrow(TenantCouldNotBeIdentifiedException::class);
expect(fn () => app($resolver)->resolve(getResolverArgument($resolver, $tenant, $tenantModelColumn)))->toThrow(TenantCouldNotBeIdentifiedException::class);
expect(DB::getQueryLog())->not()->toBeEmpty(); // Cache was invalidated, so the DB was queried
})->with([
DomainTenantResolver::class,
PathTenantResolver::class,
RequestDataTenantResolver::class,
])->with([
'tenant model column is id (default)' => false,
'tenant model column is name (custom)' => true,
]);
test('cache is invalidated when a tenants domain is changed', function () {
@ -307,23 +326,49 @@ test('PathTenantResolver properly separates cache for each tenant column', funct
pest()->get("/x/bar/b")->assertSee('foo');
expect(count(DB::getRawQueryLog()))->toBe(4); // unchanged
expect(count($redisKeys()))->toBe(4); // unchanged
Tenant::$extraCustomColumns = []; // reset
});
/**
* Return the argument for the resolver – tenant key, or a route instance with the tenant parameter.
* This method is used in generic tests to ensure that caching works correctly both with default and custom resolver config.
*
* PathTenantResolver uses a route instance with the tenant parameter as the argument,
* unlike other resolvers which use a tenant key as the argument.
*
* This method is used in the tests where we test all the resolvers
* to make getting the resolver arguments less repetitive (primarily because of the PathTenantResolver).
* If $configureTenantModelColumn is false, the tenant model column is 'id' (default) -- don't configure anything, keep the defaults.
* If $configureTenantModelColumn is true, the tenant model column should be 'name' (custom) -- configure tenant_model_column in the resolvers.
*/
function getResolverArgument(string $resolver, string $tenantKey): string|Route
function tenantModelColumn(bool $configureTenantModelColumn): string {
// Default tenant model column is 'id'
$tenantModelColumn = 'id';
if ($configureTenantModelColumn) {
// Use 'name' as the custom tenant model column
$tenantModelColumn = 'name';
Tenant::$extraCustomColumns = [$tenantModelColumn];
Schema::table('tenants', function (Blueprint $table) use ($tenantModelColumn) {
$table->string($tenantModelColumn)->unique();
});
config(['tenancy.identification.resolvers.' . PathTenantResolver::class . '.tenant_model_column' => $tenantModelColumn]);
config(['tenancy.identification.resolvers.' . RequestDataTenantResolver::class . '.tenant_model_column' => $tenantModelColumn]);
}
return $tenantModelColumn;
}
/**
* This method is used in generic tests where we test all the resolvers
* to make getting the resolver arguments less repetitive (primarily because of PathTenantResolver).
*
* For PathTenantResolver, return a route instance with the value retrieved using $tenant->{$parameterColumn} as the parameter.
* For RequestDataTenantResolver and DomainTenantResolver, return the value retrieved using $tenant->{$parameterColumn}.
*
* Tenant model column is 'id' by default, but in the generic tests,
* we also configure that to 'name' to ensure everything works both with default and custom config.
*/
function getResolverArgument(string $resolver, Tenant $tenant, string $parameterColumn = 'id'): string|Route
{
// PathTenantResolver uses a route instance as the argument
if ($resolver === PathTenantResolver::class) {
// PathTenantResolver uses a route instance as the argument
$routeName = 'tenant-route';
// Find or create a route instance for the resolver
@ -332,17 +377,21 @@ function getResolverArgument(string $resolver, string $tenantKey): string|Route
->prefix('{tenant}')
->middleware(InitializeTenancyByPath::class);
// To make the tenant available on the route instance
// Make the 'tenant' route parameter the tenant key
// Setting the parameter on the $route->parameters property is required
// Because $route->setParameter() throws an exception when $route->parameters is not set yet
$route->parameters[PathTenantResolver::tenantParameterName()] = $tenantKey;
/**
* To make the tenant available on the route instance,
* set the 'tenant' route parameter to the tenant model column value ('id' or 'name').
*
* Setting the parameter on the $route->parameters property is required
* because $route->setParameter() throws an exception when $route->parameters isn't set yet.
*/
$route->parameters['tenant'] = $tenant->{$parameterColumn};
// Return the route instance with the tenant key as the 'tenant' parameter
// Return the route instance with 'id' or 'name' as the 'tenant' parameter
return $route;
}
// Resolvers other than PathTenantResolver use the tenant key as the argument
// Return the tenant key
return $tenantKey;
// Assuming that:
// - with RequestDataTenantResolver, the tenant model column value is the payload value
// - with DomainTenantResolver, the tenant has a domain with name equal to the tenant model column value (see the createDomain() calls in various tests)
return $tenant->{$parameterColumn};
}