php-tenant/tests/Feature/WorkspaceCacheTest.php

<?php

declare(strict_types=1);

namespace Core\Mod\Tenant\Tests\Feature;

use Core\Mod\Social\Models\Account;
use Core\Mod\Tenant\Concerns\BelongsToWorkspace;
use Core\Mod\Tenant\Concerns\HasWorkspaceCache;
use Core\Mod\Tenant\Models\User;
use Core\Mod\Tenant\Models\Workspace;
use Core\Mod\Tenant\Scopes\WorkspaceScope;
use Core\Mod\Tenant\Services\WorkspaceCacheManager;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Cache;
use Tests\TestCase;

/**
 * Test workspace-scoped caching functionality.
 *
 * These tests verify that the team-scoped caching feature works correctly,
 * including cache hit/miss behavior, auto-invalidation, TTL expiration,
 * and multi-workspace isolation.
 */
class WorkspaceCacheTest extends TestCase
{
    use RefreshDatabase;

    protected User $user;

    protected Workspace $workspace;

    protected Workspace $otherWorkspace;

    protected WorkspaceCacheManager $cacheManager;

    protected function setUp(): void
    {
        parent::setUp();

        // Reset cache manager state
        WorkspaceCacheManager::resetKeyRegistry();

        // Configure the cache manager for testing
        $this->cacheManager = app(WorkspaceCacheManager::class);
        $this->cacheManager->setConfig([
            'enabled' => true,
            'ttl' => 300,
            'prefix' => 'test_workspace_cache',
            'use_tags' => false, // Use non-tagged mode for tests (array driver doesn't support tags)
        ]);

        // Enable strict mode for tests
        WorkspaceScope::enableStrictMode();

        // Create test data
        $this->user = User::factory()->create(['name' => 'Test User']);
        $this->workspace = Workspace::factory()->create(['name' => 'Test Workspace']);
        $this->otherWorkspace = Workspace::factory()->create(['name' => 'Other Workspace']);

        $this->user->hostWorkspaces()->attach($this->workspace, ['role' => 'owner', 'is_default' => true]);
        $this->user->hostWorkspaces()->attach($this->otherWorkspace, ['role' => 'member', 'is_default' => false]);

        // Clear any existing cache
        Cache::flush();
    }

    protected function tearDown(): void
    {
        WorkspaceScope::enableStrictMode();
        WorkspaceCacheManager::resetKeyRegistry();
        parent::tearDown();
    }

    // -------------------------------------------------------------------------
    // WorkspaceCacheManager Basic Tests
    // -------------------------------------------------------------------------

    public function test_cache_manager_can_be_resolved(): void
    {
        $manager = app(WorkspaceCacheManager::class);

        $this->assertInstanceOf(WorkspaceCacheManager::class, $manager);
    }

    public function test_cache_manager_generates_correct_keys(): void
    {
        $key = $this->cacheManager->key($this->workspace, 'test_key');

        $this->assertStringContainsString((string) $this->workspace->id, $key);
        $this->assertStringContainsString('test_key', $key);
        $this->assertStringContainsString('test_workspace_cache', $key);
    }

    public function test_cache_manager_workspace_tag_generation(): void
    {
        $tag = $this->cacheManager->workspaceTag($this->workspace);

        $this->assertStringContainsString((string) $this->workspace->id, $tag);
        $this->assertStringContainsString('workspace', $tag);
    }

    public function test_cache_manager_model_tag_generation(): void
    {
        $tag = $this->cacheManager->modelTag(Account::class);

        $this->assertStringContainsString('Account', $tag);
        $this->assertStringContainsString('model', $tag);
    }

    // -------------------------------------------------------------------------
    // Cache Hit/Miss Tests
    // -------------------------------------------------------------------------

    public function test_cache_remember_stores_and_retrieves_value(): void
    {
        $callCount = 0;

        // First call - should execute callback
        $result1 = $this->cacheManager->remember($this->workspace, 'test', 300, function () use (&$callCount) {
            $callCount++;

            return 'cached_value';
        });

        // Second call - should use cache
        $result2 = $this->cacheManager->remember($this->workspace, 'test', 300, function () use (&$callCount) {
            $callCount++;

            return 'new_value';
        });

        $this->assertEquals('cached_value', $result1);
        $this->assertEquals('cached_value', $result2);
        $this->assertEquals(1, $callCount, 'Callback should only be called once');
    }

    public function test_cache_miss_executes_callback(): void
    {
        $callCount = 0;

        $result = $this->cacheManager->remember($this->workspace, 'new_key', 300, function () use (&$callCount) {
            $callCount++;

            return 'fresh_value';
        });

        $this->assertEquals('fresh_value', $result);
        $this->assertEquals(1, $callCount);
    }

    public function test_cache_can_store_collections(): void
    {
        $collection = collect(['item1', 'item2', 'item3']);

        $this->cacheManager->put($this->workspace, 'collection_test', $collection, 300);

        $retrieved = $this->cacheManager->get($this->workspace, 'collection_test');

        $this->assertInstanceOf(Collection::class, $retrieved);
        $this->assertEquals($collection->toArray(), $retrieved->toArray());
    }

    public function test_cache_has_returns_correct_boolean(): void
    {
        $this->assertFalse($this->cacheManager->has($this->workspace, 'nonexistent'));

        $this->cacheManager->put($this->workspace, 'exists', 'value', 300);

        $this->assertTrue($this->cacheManager->has($this->workspace, 'exists'));
    }

    // -------------------------------------------------------------------------
    // Cache Invalidation Tests
    // -------------------------------------------------------------------------

    public function test_cache_forget_removes_key(): void
    {
        $this->cacheManager->put($this->workspace, 'to_forget', 'value', 300);
        $this->assertTrue($this->cacheManager->has($this->workspace, 'to_forget'));

        $result = $this->cacheManager->forget($this->workspace, 'to_forget');

        $this->assertTrue($result);
        $this->assertFalse($this->cacheManager->has($this->workspace, 'to_forget'));
    }

    public function test_cache_flush_clears_all_workspace_keys(): void
    {
        // Store multiple keys
        $this->cacheManager->put($this->workspace, 'key1', 'value1', 300);
        $this->cacheManager->put($this->workspace, 'key2', 'value2', 300);
        $this->cacheManager->put($this->workspace, 'key3', 'value3', 300);

        // Verify keys exist
        $this->assertTrue($this->cacheManager->has($this->workspace, 'key1'));
        $this->assertTrue($this->cacheManager->has($this->workspace, 'key2'));
        $this->assertTrue($this->cacheManager->has($this->workspace, 'key3'));

        // Flush all keys for workspace
        $this->cacheManager->flush($this->workspace);

        // Verify keys are gone
        $this->assertFalse($this->cacheManager->has($this->workspace, 'key1'));
        $this->assertFalse($this->cacheManager->has($this->workspace, 'key2'));
        $this->assertFalse($this->cacheManager->has($this->workspace, 'key3'));
    }

    public function test_model_save_clears_workspace_cache(): void
    {
        $this->actingAs($this->user);
        request()->attributes->set('workspace_model', $this->workspace);

        // Create an account (bypassing strict mode for setup)
        WorkspaceScope::withoutStrictMode(function () {
            Account::factory()->create(['workspace_id' => $this->workspace->id]);
        });

        // Cache the collection
        $cached = Account::ownedByCurrentWorkspaceCached();
        $this->assertCount(1, $cached);

        // Create another account - this should clear the cache
        WorkspaceScope::withoutStrictMode(function () {
            Account::factory()->create(['workspace_id' => $this->workspace->id]);
        });

        // Get the collection again - should reflect the new data
        $refreshed = Account::ownedByCurrentWorkspaceCached();
        $this->assertCount(2, $refreshed);
    }

    public function test_model_delete_clears_workspace_cache(): void
    {
        $this->actingAs($this->user);
        request()->attributes->set('workspace_model', $this->workspace);

        // Create accounts
        $account = null;
        WorkspaceScope::withoutStrictMode(function () use (&$account) {
            $account = Account::factory()->create(['workspace_id' => $this->workspace->id]);
            Account::factory()->create(['workspace_id' => $this->workspace->id]);
        });

        // Cache the collection
        $cached = Account::ownedByCurrentWorkspaceCached();
        $this->assertCount(2, $cached);

        // Delete one account - this should clear the cache
        WorkspaceScope::withoutStrictMode(function () use ($account) {
            $account->delete();
        });

        // Get the collection again - should reflect the deletion
        $refreshed = Account::ownedByCurrentWorkspaceCached();
        $this->assertCount(1, $refreshed);
    }

    // -------------------------------------------------------------------------
    // Multi-Workspace Isolation Tests
    // -------------------------------------------------------------------------

    public function test_cache_is_isolated_between_workspaces(): void
    {
        // Store different values in different workspaces
        $this->cacheManager->put($this->workspace, 'shared_key', 'workspace1_value', 300);
        $this->cacheManager->put($this->otherWorkspace, 'shared_key', 'workspace2_value', 300);

        // Retrieve values
        $value1 = $this->cacheManager->get($this->workspace, 'shared_key');
        $value2 = $this->cacheManager->get($this->otherWorkspace, 'shared_key');

        $this->assertEquals('workspace1_value', $value1);
        $this->assertEquals('workspace2_value', $value2);
    }

    public function test_flush_only_affects_target_workspace(): void
    {
        // Store values in both workspaces
        $this->cacheManager->put($this->workspace, 'key', 'value1', 300);
        $this->cacheManager->put($this->otherWorkspace, 'key', 'value2', 300);

        // Flush only the first workspace
        $this->cacheManager->flush($this->workspace);

        // First workspace key should be gone
        $this->assertFalse($this->cacheManager->has($this->workspace, 'key'));

        // Other workspace key should still exist
        $this->assertTrue($this->cacheManager->has($this->otherWorkspace, 'key'));
        $this->assertEquals('value2', $this->cacheManager->get($this->otherWorkspace, 'key'));
    }

    public function test_model_caching_respects_workspace_context(): void
    {
        $this->actingAs($this->user);

        // Create accounts in different workspaces
        WorkspaceScope::withoutStrictMode(function () {
            Account::factory()->create(['workspace_id' => $this->workspace->id, 'name' => 'Account 1']);
            Account::factory()->create(['workspace_id' => $this->workspace->id, 'name' => 'Account 2']);
            Account::factory()->create(['workspace_id' => $this->otherWorkspace->id, 'name' => 'Other Account']);
        });

        // Set context to first workspace
        request()->attributes->set('workspace_model', $this->workspace);

        // Cache should only contain first workspace's accounts
        $cached = Account::ownedByCurrentWorkspaceCached();
        $this->assertCount(2, $cached);
        $this->assertTrue($cached->pluck('name')->contains('Account 1'));
        $this->assertTrue($cached->pluck('name')->contains('Account 2'));
        $this->assertFalse($cached->pluck('name')->contains('Other Account'));

        // Switch context to other workspace
        request()->attributes->set('workspace_model', $this->otherWorkspace);

        // Cache should only contain other workspace's accounts
        $otherCached = Account::ownedByCurrentWorkspaceCached();
        $this->assertCount(1, $otherCached);
        $this->assertTrue($otherCached->pluck('name')->contains('Other Account'));
    }

    // -------------------------------------------------------------------------
    // Configuration Tests
    // -------------------------------------------------------------------------

    public function test_cache_disabled_when_config_disabled(): void
    {
        $this->cacheManager->setConfig([
            'enabled' => false,
            'ttl' => 300,
            'prefix' => 'test',
            'use_tags' => false,
        ]);

        $callCount = 0;

        // Both calls should execute the callback because caching is disabled
        $this->cacheManager->remember($this->workspace, 'test', 300, function () use (&$callCount) {
            $callCount++;

            return 'value';
        });

        $this->cacheManager->remember($this->workspace, 'test', 300, function () use (&$callCount) {
            $callCount++;

            return 'value';
        });

        $this->assertEquals(2, $callCount, 'Both calls should execute callback when cache is disabled');
    }

    public function test_default_ttl_used_when_null_passed(): void
    {
        $this->cacheManager->setConfig([
            'enabled' => true,
            'ttl' => 600,
            'prefix' => 'test',
            'use_tags' => false,
        ]);

        $this->assertEquals(600, $this->cacheManager->defaultTtl());
    }

    public function test_custom_prefix_used_in_keys(): void
    {
        $this->cacheManager->setConfig([
            'enabled' => true,
            'ttl' => 300,
            'prefix' => 'custom_prefix',
            'use_tags' => false,
        ]);

        $key = $this->cacheManager->key($this->workspace, 'test');

        $this->assertStringContainsString('custom_prefix', $key);
    }

    // -------------------------------------------------------------------------
    // Cache Statistics Tests
    // -------------------------------------------------------------------------

    public function test_stats_returns_workspace_cache_info(): void
    {
        $this->cacheManager->put($this->workspace, 'key1', 'value1', 300);
        $this->cacheManager->put($this->workspace, 'key2', 'value2', 300);

        $stats = $this->cacheManager->stats($this->workspace);

        $this->assertEquals($this->workspace->id, $stats['workspace_id']);
        $this->assertTrue($stats['enabled']);
        $this->assertIsInt($stats['registered_keys']);
        $this->assertIsArray($stats['keys']);
    }

    public function test_get_registered_keys_returns_workspace_keys(): void
    {
        $this->cacheManager->put($this->workspace, 'key1', 'value1', 300);
        $this->cacheManager->put($this->workspace, 'key2', 'value2', 300);

        $keys = $this->cacheManager->getRegisteredKeys($this->workspace);

        $this->assertCount(2, $keys);
    }

    // -------------------------------------------------------------------------
    // HasWorkspaceCache Trait Tests
    // -------------------------------------------------------------------------

    public function test_has_workspace_cache_remember_for_workspace(): void
    {
        $this->actingAs($this->user);
        request()->attributes->set('workspace_model', $this->workspace);

        // Create a model class that uses HasWorkspaceCache
        $testModel = new class extends Model
        {
            use BelongsToWorkspace;
            use HasWorkspaceCache;

            protected $table = 'test_cache_models';
        };

        $callCount = 0;

        // First call - should execute callback
        $result1 = $testModel::rememberForWorkspace('custom_key', 300, function () use (&$callCount) {
            $callCount++;

            return collect(['item1', 'item2']);
        });

        // Second call - should use cache
        $result2 = $testModel::rememberForWorkspace('custom_key', 300, function () use (&$callCount) {
            $callCount++;

            return collect(['different']);
        });

        $this->assertEquals(['item1', 'item2'], $result1->toArray());
        $this->assertEquals(['item1', 'item2'], $result2->toArray());
        $this->assertEquals(1, $callCount);
    }

    public function test_has_workspace_cache_forget_for_workspace(): void
    {
        $this->actingAs($this->user);
        request()->attributes->set('workspace_model', $this->workspace);

        $testModel = new class extends Model
        {
            use BelongsToWorkspace;
            use HasWorkspaceCache;

            protected $table = 'test_cache_models';
        };

        // Store a value
        $testModel::putForWorkspace('to_forget', 'value', 300);
        $this->assertTrue($testModel::hasInWorkspaceCache('to_forget'));

        // Forget it
        $testModel::forgetForWorkspace('to_forget');
        $this->assertFalse($testModel::hasInWorkspaceCache('to_forget'));
    }

    public function test_has_workspace_cache_without_context_returns_callback_result(): void
    {
        // Ensure no workspace context
        request()->attributes->remove('workspace_model');
        WorkspaceScope::disableStrictMode();

        $testModel = new class extends Model
        {
            use BelongsToWorkspace;
            use HasWorkspaceCache;

            protected $table = 'test_cache_models';

            protected bool $workspaceContextRequired = false;
        };

        $callCount = 0;

        // Without context, should always execute callback (no caching)
        $result = $testModel::rememberForWorkspace('key', 300, function () use (&$callCount) {
            $callCount++;

            return 'uncached_value';
        });

        $this->assertEquals('uncached_value', $result);
        $this->assertEquals(1, $callCount);

        WorkspaceScope::enableStrictMode();
    }

    // -------------------------------------------------------------------------
    // BelongsToWorkspace Caching Tests
    // -------------------------------------------------------------------------

    public function test_owned_by_current_workspace_cached_uses_cache_manager(): void
    {
        $this->actingAs($this->user);
        request()->attributes->set('workspace_model', $this->workspace);

        // Create an account
        WorkspaceScope::withoutStrictMode(function () {
            Account::factory()->create(['workspace_id' => $this->workspace->id]);
        });

        // First call - should cache
        $result1 = Account::ownedByCurrentWorkspaceCached();

        // Verify result
        $this->assertCount(1, $result1);

        // Check that cache key was registered
        $keys = $this->cacheManager->getRegisteredKeys($this->workspace);
        $this->assertNotEmpty($keys);
    }

    public function test_for_workspace_cached_caches_for_specific_workspace(): void
    {
        // Create accounts in the workspace
        WorkspaceScope::withoutStrictMode(function () {
            Account::factory()->count(3)->create(['workspace_id' => $this->workspace->id]);
        });

        $callCount = 0;

        // Manually test caching behavior
        $firstCall = Account::forWorkspaceCached($this->workspace, 300);
        $this->assertCount(3, $firstCall);

        // Second call should use cache (we can't easily verify this without mocking,
        // but we can verify the result is consistent)
        $secondCall = Account::forWorkspaceCached($this->workspace, 300);
        $this->assertCount(3, $secondCall);
    }

    public function test_workspace_cache_key_includes_model_name(): void
    {
        $key = Account::workspaceCacheKey($this->workspace->id);

        $this->assertStringContainsString('Account', $key);
        $this->assertStringContainsString((string) $this->workspace->id, $key);
    }

    public function test_clear_all_workspace_caches_clears_user_workspaces(): void
    {
        $this->actingAs($this->user);

        // Cache data in both workspaces
        request()->attributes->set('workspace_model', $this->workspace);
        WorkspaceScope::withoutStrictMode(function () {
            Account::factory()->create(['workspace_id' => $this->workspace->id]);
        });
        Account::ownedByCurrentWorkspaceCached();

        request()->attributes->set('workspace_model', $this->otherWorkspace);
        WorkspaceScope::withoutStrictMode(function () {
            Account::factory()->create(['workspace_id' => $this->otherWorkspace->id]);
        });
        Account::ownedByCurrentWorkspaceCached();

        // Clear all caches for the model
        Account::clearAllWorkspaceCaches();

        // Note: Without tags, this clears cache for all workspaces the user has access to
        // The cache should be empty for both workspaces now
        $keys1 = $this->cacheManager->getRegisteredKeys($this->workspace);
        $keys2 = $this->cacheManager->getRegisteredKeys($this->otherWorkspace);

        // After clearing, the registered keys should be empty or the cache values should be missing
        // (depending on implementation details)
        $this->assertCount(0, $keys1);
        $this->assertCount(0, $keys2);
    }
}