fix methods with connection

Author: januabisconti

.gitignore

@@ -468,3 +468,4 @@ resources/frontend/default/js/components/clientComponents/*
 
 #escludo la cartella personal_scripts presente in utility così ognuno può avere i suoi script personali
 utility/personal_scripts
+/storage/logs/tests/.phpunit.cache/test-results

composer.json

@@ -20,13 +20,14 @@
         }
     ],
     "require": {
-        "php" : "^8.0",
-        "illuminate/support": "^9.0|^10.0|^11.0"    ,
+        "php": "^8.0",
+        "ext-redis": "*",
+        "illuminate/support": "^9.0|^10.0|^11.0",
         "laravel/framework": "^9.0|^10.0|^11.0",
-        "predis/predis": "^2.0",
-        "ext-redis": "*"
+        "predis/predis": "^2.0"
     },
     "require-dev": {
+        "m6web/redis-mock": "^5.6",
         "phpunit/phpunit": "^9.5|^10.0|^11.0",
         "orchestra/testbench": "^7.0|^8.0|^9.0",
         "mockery/mockery": "^1.5",

composer.lock

@@ -114,18 +114,16 @@ protected function processEvents(int $shardId, int $priority, int $limit, int $t
 
         // Prepare list of all identifiers to fetch last invalidation times
         $allIdentifiers = [];
-
         foreach ($eventsByIdentifier as $key => $eventsGroup) {
             $allIdentifiers[] = $key;
             foreach ($eventsGroup as $event) {
-                $eventAssociations = $associations->get($event->id, collect());
+                $eventAssociations = $associations->where('event_id', '=', $event->id);
                 foreach ($eventAssociations as $assoc) {
                     $assocKey = $assoc->associated_type . ':' . $assoc->associated_identifier;
                     $allIdentifiers[] = $assocKey;
                 }
             }
         }
-
         // Fetch last invalidation times in bulk
         $lastInvalidationTimes = $this->getLastInvalidationTimes(array_unique($allIdentifiers));
 
@@ -136,7 +134,7 @@ protected function processEvents(int $shardId, int $priority, int $limit, int $t
             // Get associated identifiers for the events
             $associatedIdentifiers = [];
             foreach ($eventsGroup as $event) {
-                $eventAssociations = $associations->get($event->id, collect());
+                $eventAssociations = $associations->where('event_id', '=', $event->id);
                 foreach ($eventAssociations as $assoc) {
                     $assocKey = $assoc->associated_type . ':' . $assoc->associated_identifier;
                     $associatedIdentifiers[$assocKey] = [
@@ -150,7 +148,6 @@ protected function processEvents(int $shardId, int $priority, int $limit, int $t
             // Build a list of all identifiers to check
             $identifiersToCheck = [$key];
             $identifiersToCheck = array_merge($identifiersToCheck, array_keys($associatedIdentifiers));
-
             $lastInvalidationTimesSubset = array_intersect_key($lastInvalidationTimes, array_flip($identifiersToCheck));
 
             $shouldInvalidate = $this->shouldInvalidateMultiple($identifiersToCheck, $lastInvalidationTimesSubset, $invalidationWindow);
@@ -314,13 +311,15 @@ protected function updateLastInvalidationTimes(array $identifiers): void
      */
     protected function processBatch(array $batchIdentifiers, array $eventsToUpdate): void
     {
+
         // Begin transaction for the batch
         DB::beginTransaction();
 
         try {
             // Separate keys and tags
             $keys = [];
             $tags = [];
+
             foreach ($batchIdentifiers as $item) {
                 switch ($item['type']) {
                     case 'key':
@@ -386,6 +385,7 @@ protected function invalidateKeys(array $keys): void
     {
         $callback = config('super_cache_invalidate.key_invalidation_callback');
 
+
         // Anche in questo caso va fatto un loop perchè le chiavi potrebbero stare in database diversi
         foreach ($keys as $keyAndConnectionName) {
             [$key, $connection_name] = explode('§', $keyAndConnectionName);
@@ -398,6 +398,7 @@ protected function invalidateKeys(array $keys): void
 
             // oppure di default uso Laravel
             $storeName =  $this->getStoreFromConnectionName($connection_name);
+
             if ($storeName === null) {
                 return;
             }

src/Console/ProcessCacheInvalidationEventsCommand.php

@@ -28,10 +28,10 @@ class PruneCacheInvalidationDataCommand extends Command
      * @param string $tableName             The name of the table
      * @param int    $retentionPartitionKey The partition key cutoff
      */
-    protected function pruneTable(string $tableName, int $retentionPartitionKey): void
+    protected function pruneTable(string $tableName, int $retentionPartitionKey, ?int $minPartitionValueToExclude = 0): void
     {
         // Fetch partition names
-        $partitions = $this->getPartitionsFromDb($tableName, $retentionPartitionKey);
+        $partitions = $this->getPartitionsFromDb($tableName, $retentionPartitionKey, $minPartitionValueToExclude);
 
         if (empty($partitions)) {
             $this->info("No partitions to prune for table {$tableName}.");
@@ -55,37 +55,47 @@ public function handle(): void
     {
         $months = (int) $this->option('months');
         $retentionDate = now()->subMonths($months);
-        $retentionPartitionKey = $retentionDate->year * 100 + $retentionDate->week();
 
         // Prune tables
-        $tables = [
-            'cache_invalidation_events',
-            'cache_invalidation_timestamps',
-            'cache_invalidation_event_associations',
-        ];
+        $this->pruneTable('cache_invalidation_timestamps', ($retentionDate->year * 100 + $retentionDate->week) + 1);
+        $this->pruneTable('cache_invalidation_event_associations', ($retentionDate->year * 100 + $retentionDate->week) + 1);
 
-        foreach ($tables as $tableName) {
-            $this->pruneTable($tableName, $retentionPartitionKey);
+        $shards = config('super_cache_invalidate.total_shards', 10);
+        $priorities = [0, 1];
+
+        $minPartitionValueToExclude = 0;
+        foreach ($priorities as $priority) {
+            for ($shard = 0; $shard < $shards; $shard++) {
+                $minPartitionValueToExclude = ($priority * $shards) + $shard + 1;
+            }
+        }
+        $arrPartitionValues = [];
+        foreach ($priorities as $priority) {
+            for ($shard = 0; $shard < $shards; $shard++) {
+                $arrPartitionValues[] = (($retentionDate->year * 10000) + ($retentionDate->week * 100) + ($priority * $shards) + $shard) + 1;
+            }
         }
+        $maxPartitionValueToInclude = max($arrPartitionValues);
+        $this->pruneTable('cache_invalidation_events', $maxPartitionValueToInclude, $minPartitionValueToExclude);
 
         $this->info('Old cache invalidation data has been pruned.');
     }
 
     /**
      * @param string $tableName
-     * @param int $retentionPartitionKey
+     * @param int $maxPartitionValueToInclude
      * @return array
      */
-    protected function getPartitionsFromDb(string $tableName, int $retentionPartitionKey): array
+    protected function getPartitionsFromDb(string $tableName, int $maxPartitionValueToInclude, $minPartitionValueToExclude): array
     {
         $partitions = DB::select('
             SELECT PARTITION_NAME, PARTITION_DESCRIPTION
             FROM INFORMATION_SCHEMA.PARTITIONS
             WHERE TABLE_SCHEMA = DATABASE()
             AND TABLE_NAME = ?
             AND PARTITION_NAME IS NOT NULL
-            AND PARTITION_DESCRIPTION < ?
-        ', [$tableName, $retentionPartitionKey]);
+            AND PARTITION_DESCRIPTION < ? AND PARTITION_DESCRIPTION > ?
+        ', [$tableName, $maxPartitionValueToInclude, $minPartitionValueToExclude]);
         return $partitions;
     }
 }

src/Console/PruneCacheInvalidationDataCommand.php

@@ -2,22 +2,20 @@
 
 namespace Padosoft\SuperCacheInvalidate\Test\Unit;
 
-use PHPUnit\Framework\TestCase;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Cache;
-use Padosoft\SuperCacheInvalidate\Console\ProcessCacheInvalidationEventsCommand;
-use Padosoft\SuperCacheInvalidate\Helpers\SuperCacheInvalidationHelper;
 use Carbon\Carbon;
+use Mockery;
+use Padosoft\SuperCacheInvalidate\Helpers\SuperCacheInvalidationHelper;
 
 class ProcessCacheInvalidationEventsTest extends TestCase
 {
-    protected ProcessCacheInvalidationEventsCommand $command;
+    protected SuperCacheInvalidationHelper $helper;
 
     protected function setUp(): void
     {
         parent::setUp();
-        $helper = new SuperCacheInvalidationHelper();
-        $this->command = new ProcessCacheInvalidationEventsCommand($helper);
+        $this->helper = new SuperCacheInvalidationHelper();
     }
 
     public function testProcessEventsWithAssociatedIdentifiersWithinWindow(): void
@@ -26,9 +24,12 @@ public function testProcessEventsWithAssociatedIdentifiersWithinWindow(): void
         $events = collect([
             (object)[
                 'id' => 1,
-                'type' => 'tag',
+                'type' => 'key',
                 'identifier' => 'article_ID:7',
-                'event_time' => Carbon::now()->subSeconds(10),
+                'reason' => 'Article 7 removed',
+                'connection_name' => 'default',
+                'shard' => 1,
+                'priority' => 1
             ],
         ]);
 
@@ -37,44 +38,90 @@ public function testProcessEventsWithAssociatedIdentifiersWithinWindow(): void
                 'event_id' => 1,
                 'associated_type' => 'tag',
                 'associated_identifier' => 'plp:sport',
+                'connection_name' => 'default',
             ],
         ]);
 
         // Mock DB queries
-        DB::shouldReceive('table->where->where->where->where->orderBy->limit->get')
+        DB::shouldReceive('table->where->where->where->where->where->orderBy->limit->get')
             ->andReturn($events)
         ;
 
-        DB::shouldReceive('table->whereIn->get')
+        DB::shouldReceive('table->whereIn->get->groupBy')
             ->andReturn($associations)
         ;
 
         // Mock last invalidation times
-        DB::shouldReceive('select')->andReturn([
+        DB::shouldReceive('select')
+            ->andReturn([
             (object)[
-                'identifier_type' => 'tag',
+                'identifier_type' => 'key',
                 'identifier' => 'article_ID:7',
-                'last_invalidated' => Carbon::now()->subSeconds(40)->toDateTimeString(),
+                'last_invalidated' => Carbon::now()->subSeconds(120)->toDateTimeString(),
             ],
             (object)[
                 'identifier_type' => 'tag',
                 'identifier' => 'plp:sport',
-                'last_invalidated' => Carbon::now()->subSeconds(20)->toDateTimeString(),
+                'last_invalidated' => Carbon::now()->subSeconds(180)->toDateTimeString(),
             ],
         ]);
 
+        // Mock update or insert
+        DB::shouldReceive('table->updateOrInsert')->twice(); //1 per la chiave e 1 per il tag
+
+        DB::shouldReceive('beginTransaction')->once();
+
+        // CHIAVE
         // Mock Cache
-        Cache::shouldReceive('tags->flush')->never();
+        Cache::shouldReceive('store')
+             ->with('redis-store-1') // Nome dello store
+             ->once()
+             ->andReturn(Mockery::mock(\Illuminate\Contracts\Cache\Repository::class, function ($mock) {
+                 // Mockiamo il comportamento del repository cache
+                 $mock->shouldReceive('forget')
+                      ->withArgs(function ($key) {
+                          // controllo che la chiave sia proprio quella
+                          $this->assertEquals('article_ID:7', $key);
+                          return true; // Indica che l'argomento è accettabile
+                      })
+                      ->once()
+                      ->andReturn(true);
+             }));
 
-        // Mock update or insert
-        DB::shouldReceive('table->updateOrInsert')->never();
+        // TAG
+        // Mock Cache
+        Cache::shouldReceive('store')
+             ->with('redis-store-1') // Nome dello store
+             ->once()
+             ->andReturn(Mockery::mock(\Illuminate\Contracts\Cache\Repository::class, function ($mock) {
+                 // Mockiamo il comportamento del repository cache
+                 $mock->shouldReceive('tags')
+                      ->withArgs(function ($tags) {
+                          // controllo che la chiave sia proprio quella
+                          $this->assertEquals(['plp:sport'], $tags);
+                          return true; // Indica che l'argomento è accettabile
+                      })
+                      ->once()
+                     ->andReturn(Mockery::mock(\Illuminate\Cache\TaggedCache::class, function ($taggedCacheMock) {
+                         $taggedCacheMock->shouldReceive('flush')
+                                         ->once()
+                                         ->andReturn(true);
+                     }));
+             }));
 
         // Mock event update
         DB::shouldReceive('table->whereIn->update')->once();
 
-        // Run the command
-        $this->command->handle();
+        DB::shouldReceive('commit')->once();
 
-        // Assertions are handled by Mockery expectations
+        // Run the command
+        // Run the command
+        $this->artisan('supercache:process-invalidation', [
+            '--shard' => 0,
+            '--priority' => 0,
+            '--limit' => 1,
+            '--tag-batch-size' => 1,
+            '--connection_name' => 'default',
+        ]);
     }
 }