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>

.github/workflows/ci.yml

@@ -16,8 +16,6 @@ jobs:
     strategy:
       matrix:
         include:
-        - laravel: "^9.0"
-          php: "8.0"
         - laravel: "^10.0"
           php: "8.2"
 

assets/config.php

@@ -2,6 +2,7 @@
 
 declare(strict_types=1);
 
+use Stancl\Tenancy\CacheManager;
 use Stancl\Tenancy\Middleware;
 use Stancl\Tenancy\Resolvers;
 
@@ -98,10 +99,10 @@ return [
      */
     'bootstrappers' => [
         Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper::class,
-        Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper::class,
         Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper::class,
         Stancl\Tenancy\Bootstrappers\QueueTenancyBootstrapper::class,
         Stancl\Tenancy\Bootstrappers\BatchTenancyBootstrapper::class,
+        // Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper::class,
         // Stancl\Tenancy\Bootstrappers\UrlTenancyBootstrapper::class,
         // Stancl\Tenancy\Bootstrappers\SessionTenancyBootstrapper::class,
         // Stancl\Tenancy\Bootstrappers\MailTenancyBootstrapper::class, // Queueing mail requires using QueueTenancyBootstrapper with $forceRefresh set to true
@@ -178,7 +179,7 @@ return [
     ],
 
     /**
-     * Cache tenancy config. Used by CacheTenancyBootstrapper.
+     * Cache tenancy config. Used by the custom CacheManager and the PrefixCacheTenancyBootstrapper.
      *
      * This works for all Cache facade calls, cache() helper
      * calls and direct calls to injected cache stores.
@@ -190,6 +191,7 @@ return [
      */
     'cache' => [
         'tag_base' => 'tenant', // This tag_base, followed by the tenant_id, will form a tag that will be applied on each cache call.
+        'prefix_base' => 'tenant_', // This prefix_base, followed by the tenant_id, will form a cache prefix that will be used for every cache key.
     ],
 
     /**

composer.json

@@ -17,7 +17,7 @@
     "require": {
         "php": "^8.2",
         "ext-json": "*",
-        "illuminate/support": "^9.38|^10.0",
+        "illuminate/support": "^10.1",
         "facade/ignition-contracts": "^1.0.2",
         "spatie/ignition": "^1.4",
         "ramsey/uuid": "^4.7.3",
@@ -26,8 +26,8 @@
         "spatie/invade": "^1.1"
     },
     "require-dev": {
-        "laravel/framework": "^9.38|^10.0",
-        "orchestra/testbench": "^7.0|^8.0",
+        "laravel/framework": "^10.1",
+        "orchestra/testbench": "^8.0",
         "league/flysystem-aws-s3-v3": "^3.12.2",
         "doctrine/dbal": "^3.6.0",
         "spatie/valuestore": "^1.2.5",

src/Bootstrappers/CacheTagsBootstrapper.php

@@ -7,13 +7,20 @@ namespace Stancl\Tenancy\Bootstrappers;
 use Illuminate\Cache\CacheManager;
 use Illuminate\Contracts\Foundation\Application;
 use Illuminate\Support\Facades\Cache;
-use Stancl\Tenancy\CacheManager as TenantCacheManager;
 use Stancl\Tenancy\Contracts\TenancyBootstrapper;
 use Stancl\Tenancy\Contracts\Tenant;
 
-class CacheTenancyBootstrapper implements TenancyBootstrapper
+/**
+ * todo name.
+ *
+ * Separate tenant cache using tagging.
+ * This is the legacy approach. Some things, like dependency injection, won't work properly with this bootstrapper.
+ * PrefixCacheTenancyBootstrapper is the recommended bootstrapper for cache separation.
+ */
+class CacheTagsBootstrapper implements TenancyBootstrapper
 {
     protected ?CacheManager $originalCache = null;
+    public static string $cacheManagerWithTags = \Stancl\Tenancy\CacheManager::class;
 
     public function __construct(
         protected Application $app
@@ -24,9 +31,9 @@ class CacheTenancyBootstrapper implements TenancyBootstrapper
     {
         $this->resetFacadeCache();
 
-        $this->originalCache = $this->originalCache ?? $this->app['cache'];
+        $this->originalCache ??= $this->app['cache'];
         $this->app->extend('cache', function () {
-            return new TenantCacheManager($this->app);
+            return new static::$cacheManagerWithTags($this->app);
         });
     }
 

src/Bootstrappers/PrefixCacheTenancyBootstrapper.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Stancl\Tenancy\Bootstrappers;
+
+use Closure;
+use Illuminate\Cache\CacheManager;
+use Illuminate\Cache\Repository;
+use Illuminate\Contracts\Config\Repository as ConfigRepository;
+use Illuminate\Support\Facades\Cache;
+use Stancl\Tenancy\Contracts\TenancyBootstrapper;
+use Stancl\Tenancy\Contracts\Tenant;
+
+class PrefixCacheTenancyBootstrapper implements TenancyBootstrapper
+{
+    protected string|null $originalPrefix = null;
+    public static array $tenantCacheStores = []; // E.g. ['redis']
+    public static Closure|null $prefixGenerator = null;
+
+    public function __construct(
+        protected ConfigRepository $config,
+        protected CacheManager $cacheManager,
+    ) {
+    }
+
+    public function bootstrap(Tenant $tenant): void
+    {
+        $this->originalPrefix = $this->config->get('cache.prefix');
+
+        $prefix = $this->generatePrefix($tenant);
+
+        foreach (static::$tenantCacheStores as $store) {
+            $this->setCachePrefix($store, $prefix);
+
+            // Now that the store uses the passed prefix
+            // Set the configured prefix back to the default one
+            $this->config->set('cache.prefix', $this->originalPrefix);
+        }
+    }
+
+    public function revert(): void
+    {
+        foreach (static::$tenantCacheStores as $store) {
+            $this->setCachePrefix($store, $this->originalPrefix);
+        }
+    }
+
+    protected function setCachePrefix(string $driver, string|null $prefix): void
+    {
+        $this->config->set('cache.prefix', $prefix);
+
+        // Refresh driver's store to make the driver use the current prefix
+        $this->refreshStore($driver);
+
+        // It is needed when a call to the facade has been made before bootstrapping tenancy
+        // The facade has its own cache, separate from the container
+        Cache::clearResolvedInstances();
+    }
+
+    public function generatePrefix(Tenant $tenant): string
+    {
+        $defaultPrefix = $this->originalPrefix . $this->config->get('tenancy.cache.prefix_base') . $tenant->getTenantKey();
+
+        return static::$prefixGenerator ? (static::$prefixGenerator)($tenant) : $defaultPrefix;
+    }
+
+    public static function generatePrefixUsing(Closure $prefixGenerator): void
+    {
+        static::$prefixGenerator = $prefixGenerator;
+    }
+
+    /**
+     * Refresh cache driver's store.
+     */
+    protected function refreshStore(string $driver): void
+    {
+        $newStore = $this->cacheManager->resolve($driver)->getStore();
+        /** @var Repository $repository */
+        $repository = $this->cacheManager->driver($driver);
+
+        $repository->setStore($newStore);
+    }
+}

tests/BootstrapperTest.php

@@ -28,18 +28,26 @@ use Stancl\Tenancy\Listeners\BootstrapTenancy;
 use Stancl\Tenancy\Tests\Etc\TestingBroadcaster;
 use Stancl\Tenancy\Listeners\DeleteTenantStorage;
 use Stancl\Tenancy\Listeners\RevertToCentralContext;
+use Stancl\Tenancy\Bootstrappers\CacheTagsBootstrapper;
 use Stancl\Tenancy\Bootstrappers\UrlTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\MailTenancyBootstrapper;
-use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\RedisTenancyBootstrapper;
 use Stancl\Tenancy\Middleware\InitializeTenancyBySubdomain;
 use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\BroadcastTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
 
 beforeEach(function () {
     $this->mockConsoleOutput = false;
 
+    config(['cache.default' => $cacheDriver = 'redis']);
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [$cacheDriver];
+    // Reset static properties of classes used in this test file to their default values
+    BroadcastTenancyBootstrapper::$credentialsMap = [];
+    TenancyBroadcastManager::$tenantBroadcasters = ['pusher', 'ably'];
+    UrlTenancyBootstrapper::$rootUrlOverride = null;
+
     Event::listen(
         TenantCreated::class,
         JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
@@ -51,6 +59,14 @@ beforeEach(function () {
     Event::listen(TenancyEnded::class, RevertToCentralContext::class);
 });
 
+afterEach(function () {
+    // Reset static properties of classes used in this test file to their default values
+    UrlTenancyBootstrapper::$rootUrlOverride = null;
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [];
+    TenancyBroadcastManager::$tenantBroadcasters = ['pusher', 'ably'];
+    BroadcastTenancyBootstrapper::$credentialsMap = [];
+});
+
 test('database data is separated', function () {
     config(['tenancy.bootstrappers' => [
         DatabaseTenancyBootstrapper::class,
@@ -82,12 +98,9 @@ test('database data is separated', function () {
     expect(DB::table('users')->first()->name)->toBe('Foo');
 });
 
-test('cache data is separated', function () {
+test('cache data is separated', function (string $bootstrapper) {
     config([
-        'tenancy.bootstrappers' => [
-            CacheTenancyBootstrapper::class,
-        ],
-        'cache.default' => 'redis',
+        'tenancy.bootstrappers' => [$bootstrapper],
     ]);
 
     $tenant1 = Tenant::create();
@@ -121,7 +134,10 @@ test('cache data is separated', function () {
 
     // Asset central is still the same
     expect(Cache::get('foo'))->toBe('central');
-});
+})->with([
+    CacheTagsBootstrapper::class,
+    PrefixCacheTenancyBootstrapper::class,
+]);
 
 test('redis data is separated', function () {
     config(['tenancy.bootstrappers' => [

tests/BroadcastingTest.php

@@ -13,12 +13,17 @@ use Stancl\Tenancy\Tests\Etc\TestingBroadcaster;
 use Stancl\Tenancy\Listeners\RevertToCentralContext;
 use Illuminate\Contracts\Broadcasting\Broadcaster as BroadcasterContract;
 
-beforeEach(function() {
+beforeEach(function () {
     withTenantDatabases();
+    TenancyBroadcastManager::$tenantBroadcasters = ['pusher', 'ably'];
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
     Event::listen(TenancyEnded::class, RevertToCentralContext::class);
 });
 
+afterEach(function () {
+    TenancyBroadcastManager::$tenantBroadcasters = ['pusher', 'ably'];
+});
+
 test('bound broadcaster instance is the same before initializing tenancy and after ending it', function() {
     config(['broadcasting.default' => 'null']);
     TenancyBroadcastManager::$tenantBroadcasters[] = 'null';

tests/CacheManagerTest.php

@@ -2,16 +2,14 @@
 
 declare(strict_types=1);
 
+use Stancl\Tenancy\Tests\Etc\Tenant;
 use Illuminate\Support\Facades\Event;
-use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
 use Stancl\Tenancy\Events\TenancyInitialized;
 use Stancl\Tenancy\Listeners\BootstrapTenancy;
-use Stancl\Tenancy\Tests\Etc\Tenant;
+use Stancl\Tenancy\Bootstrappers\CacheTagsBootstrapper;
 
 beforeEach(function () {
-    config(['tenancy.bootstrappers' => [
-        CacheTenancyBootstrapper::class,
-    ]]);
+    config(['tenancy.bootstrappers' => [CacheTagsBootstrapper::class]]);
 
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
 });
@@ -60,7 +58,7 @@ test('tags separate cache well enough', function () {
     $tenant2 = Tenant::create();
     tenancy()->initialize($tenant2);
 
-    pest()->assertNotSame('bar', cache()->get('foo'));
+    expect(cache('foo'))->not()->toBe('bar');
 
     cache()->put('foo', 'xyz', 1);
     expect(cache()->get('foo'))->toBe('xyz');
@@ -76,7 +74,7 @@ test('invoking the cache helper works', function () {
     $tenant2 = Tenant::create();
     tenancy()->initialize($tenant2);
 
-    pest()->assertNotSame('bar', cache('foo'));
+    expect(cache('foo'))->not()->toBe('bar');
 
     cache(['foo' => 'xyz'], 1);
     expect(cache('foo'))->toBe('xyz');

tests/DomainTest.php

@@ -12,6 +12,8 @@ use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
 use Stancl\Tenancy\Resolvers\DomainTenantResolver;
 
 beforeEach(function () {
+    InitializeTenancyByDomain::$onFail = null;
+
     Route::group([
         'middleware' => InitializeTenancyByDomain::class,
     ], function () {
@@ -23,6 +25,10 @@ beforeEach(function () {
     config(['tenancy.models.tenant' => DomainTenant::class]);
 });
 
+afterEach(function () {
+    InitializeTenancyByDomain::$onFail = null;
+});
+
 test('tenant can be identified using hostname', function () {
     $tenant = DomainTenant::create();
 
@@ -89,9 +95,6 @@ test('onfail logic can be customized', function () {
 });
 
 test('throw correct exception when onFail is null and universal routes are enabled', function () {
-    // un-define onFail logic
-    InitializeTenancyByDomain::$onFail = null;
-
     // Enable UniversalRoute feature
     Route::middlewareGroup('universal', []);
 

tests/Etc/CacheService.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Stancl\Tenancy\Tests\Etc;
+
+use Illuminate\Cache\Repository;
+
+class CacheService
+{
+    public function __construct(
+       protected Repository $cache
+    ) {
+    }
+
+    public function handle(): void
+    {
+        if (tenancy()->initialized) {
+            $this->cache->put('key', tenant()->getTenantKey());
+        } else {
+            $this->cache->put('key', 'central-value');
+        }
+    }
+}

tests/Etc/SpecificCacheStoreService.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Stancl\Tenancy\Tests\Etc;
+
+use Illuminate\Cache\CacheManager;
+use Illuminate\Cache\Repository;
+
+class SpecificCacheStoreService
+{
+    public Repository $cache;
+
+    public function __construct(CacheManager $cacheManager, string $cacheStoreName)
+    {
+        $this->cache = $cacheManager->store($cacheStoreName);
+    }
+
+    public function handle(): void
+    {
+        if (tenancy()->initialized) {
+            $this->cache->put('key', tenant()->getTenantKey());
+        } else {
+            $this->cache->put('key', 'central-value');
+        }
+    }
+}

tests/GlobalCacheTest.php

@@ -2,25 +2,32 @@
 
 declare(strict_types=1);
 
+use Stancl\Tenancy\CacheManager;
+use Stancl\Tenancy\Tests\Etc\Tenant;
 use Illuminate\Support\Facades\Event;
-use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
 use Stancl\Tenancy\Events\TenancyEnded;
-use Stancl\Tenancy\Events\TenancyInitialized;
 use Stancl\Tenancy\Facades\GlobalCache;
+use Stancl\Tenancy\Events\TenancyInitialized;
 use Stancl\Tenancy\Listeners\BootstrapTenancy;
 use Stancl\Tenancy\Listeners\RevertToCentralContext;
-use Stancl\Tenancy\Tests\Etc\Tenant;
+use Stancl\Tenancy\Bootstrappers\CacheTagsBootstrapper;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
 
 beforeEach(function () {
-    config(['tenancy.bootstrappers' => [
-        CacheTenancyBootstrapper::class,
-    ]]);
+    config(['cache.default' => $cacheDriver = 'redis']);
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [$cacheDriver];
 
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
     Event::listen(TenancyEnded::class, RevertToCentralContext::class);
 });
 
-test('global cache manager stores data in global cache', function () {
+afterEach(function () {
+    PrefixCacheTenancyBootstrapper::$tenantCacheStores = [];
+});
+
+test('global cache manager stores data in global cache', function (string $bootstrapper) {
+    config(['tenancy.bootstrappers' => [$bootstrapper]]);
+
     expect(cache('foo'))->toBe(null);
     GlobalCache::put(['foo' => 'bar'], 1);
     expect(GlobalCache::get('foo'))->toBe('bar');
@@ -48,9 +55,14 @@ test('global cache manager stores data in global cache', function () {
 
     tenancy()->initialize($tenant1);
     expect(cache('def'))->toBe('ghi');
-});
+})->with([
+    CacheTagsBootstrapper::class,
+    PrefixCacheTenancyBootstrapper::class,
+]);
+
+test('the global_cache helper supports the same syntax as the cache helper', function (string $bootstrapper) {
+    config(['tenancy.bootstrappers' => [$bootstrapper]]);
 
-test('the global_cache helper supports the same syntax as the cache helper', function () {
     $tenant = Tenant::create();
     $tenant->enter();
 
@@ -63,4 +75,7 @@ test('the global_cache helper supports the same syntax as the cache helper', fun
     expect(global_cache()->get('foo'))->toBe('baz');
 
     expect(cache('foo'))->toBe(null); // tenant cache is not affected
-});
+})->with([
+    CacheTagsBootstrapper::class,
+    PrefixCacheTenancyBootstrapper::class,
+]);

tests/MailTest.php

@@ -12,11 +12,16 @@ use Stancl\Tenancy\Bootstrappers\MailTenancyBootstrapper;
 
 beforeEach(function() {
     config(['mail.default' => 'smtp']);
+    MailTenancyBootstrapper::$credentialsMap = [];
 
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
     Event::listen(TenancyEnded::class, RevertToCentralContext::class);
 });
 
+afterEach(function () {
+    MailTenancyBootstrapper::$credentialsMap = [];
+});
+
 // Initialize tenancy as $tenant and assert that the smtp mailer's transport has the correct password
 function assertMailerTransportUsesPassword(string|null $password) {
     $manager = app(MailManager::class);

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();
+});

tests/TestCase.php

@@ -9,6 +9,7 @@ use Dotenv\Dotenv;
 use Stancl\Tenancy\Facades\Tenancy;
 use Stancl\Tenancy\Tests\Etc\Tenant;
 use Illuminate\Support\Facades\Redis;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
 use Illuminate\Foundation\Application;
 use Stancl\Tenancy\Facades\GlobalCache;
 use Stancl\Tenancy\TenancyServiceProvider;
@@ -118,6 +119,7 @@ abstract class TestCase extends \Orchestra\Testbench\TestCase
         ]);
 
         $app->singleton(RedisTenancyBootstrapper::class); // todo (Samuel) use proper approach eg config for singleton registration
+        $app->singleton(PrefixCacheTenancyBootstrapper::class); // todo (Samuel) use proper approach eg config for singleton registration
         $app->singleton(BroadcastTenancyBootstrapper::class);
         $app->singleton(MailTenancyBootstrapper::class);
         $app->singleton(UrlTenancyBootstrapper::class);