Cache prefix mode for separating tenant caches (#1014)

* cache prefix * prefix cache bootstrapper and tests * remove comment * DI app * cache prefix base from config * Create PrefixCacheBootstrapperTest.php * remove `null` check * fix phpstan error * Update PrefixCacheTenancyBootstrapper.php * Update PrefixCacheBootstrapperTest.php * add comments * Update PrefixCacheTenancyBootstrapper.php * Update PrefixCacheBootstrapperTest.php * Update config.php * test names grammar * user `getTenantKey` method * assert tenants' data is accessible using the prefix from the central context * remove unused line * use proper DI * build prefix using original prefix * fix prefix test according to prefix changes * fix test * CacheManager dependency injection test * CacheService class as singleton * introduce second tenant in test * use Repository in service class DI * Update CacheAction.php * Rename CacheAction to CacheService * Update prefix bootstrapper and test (`setStore()` in CacheManager and Repository needed) * Add macro * Fix code style (php-cs-fixer) * Simplify cache store refreshing * Make Tenancy override CacheManager * Update CacheManager, add refreshStore() * Fix code style (php-cs-fixer) * Uncomment cache tagging * Revert condition in CacheManager to avoid excessive nesting * Move `Cache::macro()` to a slightly more appropriate place * Fix code style (php-cs-fixer) * Use better class for the macro * Toggle cache tags * Make CacheManager::$addTags default to `true` * Add changes to PR to Laravel * Fix code style (php-cs-fixer) * Revert changes, add comment * Add test * Make `$cache` non-nullable Co-authored-by: Samuel Štancl <samuel@archte.ch> * Add and test `nonTenantCacheDrivers` * Add nonTenantCacheDrivers check * Test that the prefix stays the same * Change nonTenantCacheDrivers to tenantCacheStores * Remove redundant CacheManager extend() call * Make 'redis' the only tenant cache store in beforeEach, test that tenantCacheStores works * Remove unused import, change word * Make CacheService a singleton in a test * Update test name * Remove group('prefix') * Rename CacheManagerService * Improve specific cache store in a service test * Improve comment * Improve tests * Use my Laravel fork * Fix code style (php-cs-fixer) * Downgrade Laravel * Upgrade Laravel * Hint Repository implementation instead of contract * Fix types * Fix code style (php-cs-fixer) * Fix test * Use Laravel fork in ci.yml * use dev-master before our changes are released in L10 * remove laravel fork from repositories * use 10.x-dev instead of master * remove L9 support * 10.x-dev (fix conflict resolution) * use the laravel version from the ci matrix for the phpstan job as well * Revert "use the laravel version from the ci matrix for the phpstan job as well" This reverts commit 5f3079d2ff. * Test that non-default stores get prefixed too * Use new Laravel release, remove L9 support * Complete L9 support removal * Specify 10.1.1 as the minimal Laravel version in ci.yml * Use 10.x-dev * Prefix all cache stores specified in `$tenantCacheStores` * Update Laravel * Use tmpfs in docker-compose * Add customizing cache store prefixes * Test cache prefixing customization * Fix code style (php-cs-fixer) * Update ci.yml * Delete tmpfs from docker-compose.yml (there were no benefits) * Use default prefix generator inline, delete the 'default' key logic * Fix original prefix logic * Update tests * Delete CacheTenancyBootstrapper * Reset static properties in afterEach * Use `$this->config` instead of `config()` * Disable cache tagging by default, add CacheTagBootstrapper * Fix code style (php-cs-fixer) * Rename bootstrapper * Improve CacheManager * Move logic from separate method to __call * Make original prefixes customizable * Add info in comment * Add defaultPrefix property * Use `$this->app` instead of `app()` * Rename bootstrapper * Fix code style (php-cs-fixer) * Use a single original prefix * Update prefix generator logic + tests * Correct `$addTags` reset in a test * Update cache tests so that both prefixing and tagging is covered * Simplify cache tests * Delete afterEach * Small testing improvements * Set `cache.default` in beforeEach * Update cache prefixing and tests * Add assertion * Refactor assertion * Refactor assertions * Delete TTL from cache put calls * Add re-initialization cache assertion * Assert that cache is null from the beginning * Merge the tenantCacheStores tests * Fix formatting * Improve test name * Improve tests * Add cache manager config key * Fix code style (php-cs-fixer) * Update defaulting test * Add todo * Update comments * Extract duplicate assertions into a closure * Update comment * Add assertions + comment * Delete redundant config put calls * Use `tenancy.cache.manager` config instead of `Stancl\Tenancy\CacheManager` * Change setting to assertion, add comment * Inline variable & config key assignment * Delete `cache.default` assertion * Override cache manager only in CacheTagsBootstrapper * Fix code style (php-cs-fixer) * Prefix both drivers by default, add assertions for the second driver where missing * Clean up global state (static properties) in before/afterEach * Add docblock to tags bootstrapper * Delete extra dependency * Add `illuminate/support` dependency back * Use `$addTags` approach again * Fix code style (php-cs-fixer) * Revert "Fix code style (php-cs-fixer)" This reverts commit ea805fa231. * Revert "Use `$addTags` approach again" This reverts commit 8f5a4e4eb6. * Add commented CacheTagsBootstrapper with info to the bootstrappers config * Delete legacy bootstrapper from the bootstrappers config, add info to the bootstrapper's docblock * Delete "?" from `tenant()?->getTenantKey() * call generatePrefix() on $bootstrapper * misc improvements --------- Co-authored-by: lukinovec <lukinovec@gmail.com> Co-authored-by: PHP CS Fixer <phpcsfixer@example.com> Co-authored-by: Samuel Štancl <samuel@archte.ch> Co-authored-by: Samuel Štancl <samuel.stancl@gmail.com>
2025-12-12 08:24:04 +00:00 · 2023-04-24 19:25:51 +05:00 · 2023-04-24 19:25:51 +05:00 · bd9bbe8b41
commit bd9bbe8b41
parent 6a26f712e7
15 changed files with 549 additions and 39 deletions
--- a/tests/PrefixCacheBootstrapperTest.php
+++ b/tests/PrefixCacheBootstrapperTest.php
@ -0,0 +1,324 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Cache\CacheManager;
+use Illuminate\Support\Facades\Event;
+use Stancl\Tenancy\Events\TenancyEnded;
+use Stancl\Tenancy\Tests\Etc\CacheService;
+use Stancl\Tenancy\Events\TenancyInitialized;
+use Stancl\Tenancy\Listeners\BootstrapTenancy;
+use Stancl\Tenancy\Listeners\RevertToCentralContext;
+use Stancl\Tenancy\Tests\Etc\SpecificCacheStoreService;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
+
+beforeEach(function () {
+    config([
+        'tenancy.bootstrappers' => [
+            PrefixCacheTenancyBootstrapper::class
+        ],
+        'cache.default' => $cacheDriver = 'redis',
+        'cache.stores.' . $secondCacheDriver = 'redis2' => config('cache.stores.redis'),
+    ]);
+
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [$cacheDriver, $secondCacheDriver];
+    PrefixCacheTenancyBootstrapper::$prefixGenerator = null;
+
+    Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
+    Event::listen(TenancyEnded::class, RevertToCentralContext::class);
+});
+
+afterEach(function () {
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [];
+    PrefixCacheTenancyBootstrapper::$prefixGenerator = null;
+});
+
+test('correct cache prefix is used in all contexts', function () {
+    $originalPrefix = config('cache.prefix');
+    $prefixBase = config('tenancy.cache.prefix_base');
+    $getDefaultPrefixForTenant = fn (Tenant $tenant) => $originalPrefix . $prefixBase . $tenant->getTenantKey();
+    $bootstrapper = app(PrefixCacheTenancyBootstrapper::class);
+
+    $expectCachePrefixToBe = function (string $prefix) {
+        expect($prefix . ':') // RedisStore suffixes prefix with ':'
+            ->toBe(app('cache')->getPrefix())
+            ->toBe(app('cache.store')->getPrefix())
+            ->toBe(cache()->getPrefix())
+            ->toBe(cache()->store('redis2')->getPrefix()); // Non-default cache stores specified in $tenantCacheStores are prefixed too
+    };
+
+    $expectCachePrefixToBe($originalPrefix);
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+
+    tenancy()->initialize($tenant1);
+    cache()->set('key', 'tenantone-value');
+    $tenantOnePrefix = $getDefaultPrefixForTenant($tenant1);
+    $expectCachePrefixToBe($tenantOnePrefix);
+    expect($bootstrapper->generatePrefix($tenant1))->toBe($tenantOnePrefix);
+
+    tenancy()->initialize($tenant2);
+    cache()->set('key', 'tenanttwo-value');
+    $tenantTwoPrefix = $getDefaultPrefixForTenant($tenant2);
+    $expectCachePrefixToBe($tenantTwoPrefix);
+    expect($bootstrapper->generatePrefix($tenant2))->toBe($tenantTwoPrefix);
+
+    // Prefix gets reverted to default after ending tenancy
+    tenancy()->end();
+    $expectCachePrefixToBe($originalPrefix);
+
+    // Assert tenant's data is accessible using the prefix from the central context
+    config(['cache.prefix' => null]); // stop prefixing cache keys in central so we can provide prefix manually
+    app('cache')->forgetDriver(config('cache.default'));
+
+    expect(cache($tenantOnePrefix . ':key'))->toBe('tenantone-value');
+    expect(cache($tenantTwoPrefix . ':key'))->toBe('tenanttwo-value');
+});
+
+test('cache is persisted when reidentification is used', function () {
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    cache(['foo' => 'bar']);
+    expect(cache('foo'))->toBe('bar');
+
+    tenancy()->initialize($tenant2);
+    expect(cache('foo'))->toBeNull();
+    tenancy()->end();
+
+    tenancy()->initialize($tenant1);
+    expect(cache('foo'))->toBe('bar');
+});
+
+test('prefixing separates the cache', function () {
+    $tenant1 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    cache()->put('foo', 'bar');
+    expect(cache()->get('foo'))->toBe('bar');
+
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant2);
+
+    expect(cache()->get('foo'))->toBeNull();
+
+    cache()->put('foo', 'xyz');
+    expect(cache()->get('foo'))->toBe('xyz');
+
+    tenancy()->initialize($tenant1);
+    expect(cache()->get('foo'))->toBe('bar');
+});
+
+test('central cache is persisted', function () {
+    cache()->put('key', 'central');
+
+    $tenant1 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    expect(cache('key'))->toBeNull();
+    cache()->put('key', 'tenant');
+
+    expect(cache()->get('key'))->toBe('tenant');
+
+    tenancy()->end();
+    cache()->put('key2', 'central-two');
+
+    expect(cache()->get('key'))->toBe('central');
+    expect(cache()->get('key2'))->toBe('central-two');
+    
+    tenancy()->initialize($tenant1);
+    expect(cache()->get('key'))->toBe('tenant');
+    expect(cache()->get('key2'))->toBeNull();
+});
+
+test('cache base prefix is customizable', function () {
+    config([
+        'tenancy.cache.prefix_base' => $prefixBase = 'custom_'
+    ]);
+
+    $originalPrefix = config('cache.prefix');
+    $tenant1 = Tenant::create();
+
+    tenancy()->initialize($tenant1);
+
+    expect($originalPrefix . $prefixBase . $tenant1->getTenantKey() . ':')
+        ->toBe(cache()->getPrefix())
+        ->toBe(cache()->store('redis2')->getPrefix()) // Non-default store gets prefixed correctly too
+        ->toBe(app('cache')->getPrefix())
+        ->toBe(app('cache.store')->getPrefix());
+});
+
+test('cache is prefixed correctly when using a repository injected in a singleton', function () {
+    $this->app->singleton(CacheService::class);
+
+    expect(cache('key'))->toBeNull();
+
+    $this->app->make(CacheService::class)->handle();
+
+    expect(cache('key'))->toBe('central-value');
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    expect(cache('key'))->toBeNull();
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($tenant1->getTenantKey());
+
+    tenancy()->initialize($tenant2);
+
+    expect(cache('key'))->toBeNull();
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($tenant2->getTenantKey());
+
+    tenancy()->end();
+
+    expect(cache('key'))->toBe('central-value');
+});
+
+test('specific central cache store can be used inside a service', function () {
+    // Make sure 'redis' (the default store) is the only prefixed store
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = ['redis'];
+    // Name of the non-default, central cache store that we'll use using cache()->store($cacheStore)
+    $cacheStore = 'redis2';
+
+    // Service uses the 'redis2' store which is central/not prefixed (not present in PrefixCacheTenancyBootstrapper::$tenantCacheStores)
+    // The service's handle() method sets the value of the cache key 'key' to the current tenant key
+    // Or to 'central-value' if tenancy isn't initialized
+    $this->app->singleton(SpecificCacheStoreService::class, function() use ($cacheStore) {
+        return new SpecificCacheStoreService($this->app->make(CacheManager::class), $cacheStore);
+    });
+
+    $this->app->make(SpecificCacheStoreService::class)->handle();
+    expect(cache()->store($cacheStore)->get('key'))->toBe('central-value');
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    // The store isn't prefixed, so the cache isn't separated – the values persist from one context to another
+    // Also assert that the value of 'key' is set correctly inside SpecificCacheStoreService according to the current context
+    expect(cache()->store($cacheStore)->get('key'))->toBe('central-value');
+    $this->app->make(SpecificCacheStoreService::class)->handle();
+    expect(cache()->store($cacheStore)->get('key'))->toBe($tenant1->getTenantKey());
+
+    tenancy()->initialize($tenant2);
+
+    expect(cache()->store($cacheStore)->get('key'))->toBe($tenant1->getTenantKey());
+    $this->app->make(SpecificCacheStoreService::class)->handle();
+    expect(cache()->store($cacheStore)->get('key'))->toBe($tenant2->getTenantKey());
+
+    tenancy()->end();
+    // We last executed handle() in tenant2's context, so the value should persist as tenant2's id
+    expect(cache()->store($cacheStore)->get('key'))->toBe($tenant2->getTenantKey());
+});
+
+test('only the stores specified in tenantCacheStores get prefixed', function () {
+    // Make sure the currently used store ('redis') is the only store in $tenantCacheStores
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [$prefixedStore = 'redis'];
+
+    $centralValue = 'central-value';
+    $assertStoreIsNotPrefixed = function (string $unprefixedStore) use ($prefixedStore, $centralValue) {
+        // Switch to the unprefixed store
+        config(['cache.default' => $unprefixedStore]);
+        expect(cache('key'))->toBe($centralValue);
+        // Switch back to the prefixed store
+        config(['cache.default' => $prefixedStore]);
+    };
+
+    $this->app->singleton(CacheService::class);
+
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($centralValue);
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+
+    tenancy()->initialize($tenant1);
+
+    expect(cache('key'))->toBeNull();
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($tenant1->getTenantKey());
+
+    $assertStoreIsNotPrefixed('redis2');
+
+    tenancy()->initialize($tenant2);
+
+    expect(cache('key'))->toBeNull();
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($tenant2->getTenantKey());
+
+    $assertStoreIsNotPrefixed('redis2');
+
+    tenancy()->end();
+    expect(cache('key'))->toBe($centralValue);
+
+    $this->app->make(CacheService::class)->handle();
+    expect(cache('key'))->toBe($centralValue);
+});
+
+test('non default stores get prefixed too when specified in tenantCacheStores', function () {
+    // In beforeEach, we set $tenantCacheStores to ['redis', 'redis2']
+    // Make 'redis' the default cache driver
+    config(['cache.default' => 'redis']);
+
+    $tenant = Tenant::create();
+    $defaultPrefix = cache()->store()->getPrefix();
+    $bootstrapper = app(PrefixCacheTenancyBootstrapper::class);
+
+    // The prefix is the same for both drivers in the central context
+    expect(cache()->store('redis')->getPrefix())->toBe($defaultPrefix);
+    expect(cache()->store('redis2')->getPrefix())->toBe($defaultPrefix);
+
+    tenancy()->initialize($tenant);
+
+    // We didn't add a prefix generator for our 'redis2' driver, so we expect the prefix to be generated using the 'default' generator
+    expect($bootstrapper->generatePrefix($tenant) . ':')
+        ->toBe(cache()->getPrefix())
+        ->toBe(cache()->store('redis2')->getPrefix()); // Non-default store
+
+    tenancy()->end();
+});
+
+test('cache store prefix generation can be customized', function() {
+    // Use custom prefix generator
+    PrefixCacheTenancyBootstrapper::generatePrefixUsing($customPrefixGenerator = function (Tenant $tenant) {
+        return 'redis_tenant_cache_' . $tenant->getTenantKey();
+    });
+
+    expect(PrefixCacheTenancyBootstrapper::$prefixGenerator)->toBe($customPrefixGenerator);
+    expect(app(PrefixCacheTenancyBootstrapper::class)->generatePrefix($tenant = Tenant::create()))
+        ->toBe($customPrefixGenerator($tenant));
+
+    tenancy()->initialize($tenant = Tenant::create());
+
+    // Expect the 'redis' store to use the prefix generated by the custom generator
+    expect($customPrefixGenerator($tenant) . ':')
+        ->toBe(cache()->getPrefix())
+        ->toBe(cache()->store('redis2')->getPrefix()) // Non-default cache stores specified in $tenantCacheStores are prefixed too
+        ->toBe(app('cache')->getPrefix())
+        ->toBe(app('cache.store')->getPrefix());
+
+    tenancy()->end();
+});
+
+test('stores get prefixed using the default way if no prefix generator is specified', function() {
+    $originalPrefix = config('cache.prefix');
+    $prefixBase = config('tenancy.cache.prefix_base');
+    $tenant = Tenant::create();
+    $defaultPrefix = $originalPrefix . $prefixBase . $tenant->getTenantKey();
+
+    // Don't specify a prefix generator
+    // Let the prefix get created using the default approach
+    tenancy()->initialize($tenant);
+
+    // All stores use the default way of generating the prefix when the prefix generator isn't specified
+    expect($defaultPrefix . ':')
+        ->toBe(app(PrefixCacheTenancyBootstrapper::class)->generatePrefix($tenant) . ':')
+        ->toBe(cache()->getPrefix()) // Get prefix of the default store ('redis')
+        ->toBe(cache()->store('redis2')->getPrefix());
+
+    tenancy()->end();
+});