removes doctrine cache bundle

Fusonic/RateLimitBundle/src/DependencyInjection/CacheProviderPass.php

@@ -10,11 +10,11 @@ class CacheProviderPass implements CompilerPassInterface
 {
     public function process(ContainerBuilder $container)
     {
-        $cacheProviderId = $container->getParameter('fusonic_rate_limit')['cache_provider'];
+        $cacheServiceId = $container->getParameter('fusonic_rate_limit')['cache_provider'];
 
-        $container->setAlias('fusonic_rate_limit.cache_provider', $cacheProviderId);
+        $container->setAlias('fusonic_rate_limit.cache_provider', $cacheServiceId);
 
         $definition = $container->getDefinition('fusonic_rate_limit.manager');
-        $definition->replaceArgument(1, new Reference($cacheProviderId));
+        $definition->replaceArgument(1, new Reference($cacheServiceId));
     }
 }

Fusonic/RateLimitBundle/src/Manager/RateLimitManager.php

@@ -2,10 +2,10 @@
 
 namespace Fusonic\RateLimitBundle\Manager;
 
-use Doctrine\Common\Cache\CacheProvider;
 use Fusonic\RateLimitBundle\Event\RateLimitAttemptsUpdatedEvent;
 use Fusonic\RateLimitBundle\Event\RateLimitExceededEvent;
 use Fusonic\RateLimitBundle\Model\RouteLimitConfig;
+use Psr\Cache\CacheItemPoolInterface;
 use Psr\Log\LoggerInterface;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\HttpKernel\Event\RequestEvent;
@@ -18,9 +18,9 @@ class RateLimitManager implements RateLimitManagerInterface
     private $rateLimitConfig;
 
     /**
-     * @var CacheProvider
+     * @var CacheItemPoolInterface
      */
-    private $cacheProvider;
+    private $cache;
 
     /**
      * @var LoggerInterface
@@ -34,21 +34,21 @@ class RateLimitManager implements RateLimitManagerInterface
 
     public function __construct(
         array $rateLimitConfig,
-        CacheProvider $cacheProvider,
+        CacheItemPoolInterface $cache,
         LoggerInterface $logger,
         EventDispatcherInterface $dispatcher
     ) {
         $this->rateLimitConfig = $rateLimitConfig;
-        $this->cacheProvider = $cacheProvider;
+        $this->cache = $cache;
         $this->logger = $logger;
         $this->dispatcher = $dispatcher;
     }
 
     public function resetAttemptsForIpAndRoute(string $ip, string $route): void
     {
         if ($this->isRateLimitEnabled() && $this->isRouteRateLimited($route)) {
-            $cacheId = $this->generateCacheId($ip, $route);
-            $this->cacheProvider->delete($cacheId);
+            $key = $this->generateCacheKey($ip, $route);
+            $this->cache->deleteItem($key);
         }
     }
 
@@ -63,10 +63,17 @@ public function handleRequest(RequestEvent $event): void
         }
 
         $routeConfig = RouteLimitConfig::fromRouteConfig($route, $this->getRouteConfig($route));
-        $cacheId = $this->generateCacheId($ip, $route);
+        $key = $this->generateCacheKey($ip, $route);
 
-        $attempts = $this->cacheProvider->fetch($cacheId) ?: 0;
-        $this->cacheProvider->save($cacheId, ++$attempts, $routeConfig->getPeriod());
+        $attempts = 1;
+        $item = $this->cache->getItem($key);
+        if ($item->isHit()) {
+            $attempts = $item->get() + 1;
+        }
+
+        $item->set($attempts);
+        $item->expiresAfter($routeConfig->getPeriod());
+        $this->cache->save($item);
 
         if ($attempts > $routeConfig->getLimit()) {
             $this->logger->critical(
@@ -103,7 +110,7 @@ protected function getRouteConfig(string $route): array
         return $this->rateLimitConfig['routes'][$route];
     }
 
-    protected function generateCacheId(string $ip, string $route): string
+    protected function generateCacheKey(string $ip, string $route): string
     {
         return sha1($ip.$route);
     }

Fusonic/RateLimitBundle/tests/BasicSetupTest.php

@@ -2,16 +2,16 @@
 
 namespace Fusonic\RateLimitBundle\Tests;
 
-use Doctrine\Common\Cache\CacheProvider;
 use Fusonic\RateLimitBundle\EventSubscriber\RateLimitEventSubscriber;
 use Fusonic\RateLimitBundle\Manager\RateLimitManager;
+use Psr\Cache\CacheItemPoolInterface;
 
 class BasicSetupTest extends TestCase
 {
     public function testServiceWiring(): void
     {
         $cacheProvider = $this->container->get('fusonic_rate_limit.cache_provider');
-        $this->assertInstanceOf(CacheProvider::class, $cacheProvider);
+        $this->assertInstanceOf(CacheItemPoolInterface::class, $cacheProvider);
 
         $manager = $this->container->get('fusonic_rate_limit.manager');
         $this->assertInstanceOf(RateLimitManager::class, $manager);

Fusonic/RateLimitBundle/tests/EventSubscriber/RateLimitEventSubscriberTest.php

@@ -4,6 +4,8 @@
 
 use Fusonic\RateLimitBundle\Event\RateLimitResetAttemptsEvent;
 use Fusonic\RateLimitBundle\Tests\TestCase;
+use Psr\Cache\CacheItemInterface;
+use Psr\Cache\CacheItemPoolInterface;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpKernel\Event\RequestEvent;
@@ -18,12 +20,13 @@ public function testResetRateLimitAttemptsEventHandling(): void
         $ip = '1.1.1.1';
         $id = sha1($ip.$route);
 
-        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
-        $cache->save($id, 5, 3600);
-        $this->assertTrue($cache->contains($id));
+        /** @var  $cache */
+        $cache = $this->getCache();
+        $this->createItem($id);
+        $this->assertTrue($cache->getItem($id)->isHit());
         $this->dispatchResetAttemptsEvent($route, $ip);
 
-        $this->assertFalse($cache->contains($id));
+        $this->assertFalse($cache->getItem($id)->isHit());
     }
 
     public function testRateLimitAttemptsUpdateEventHandling(): void
@@ -33,26 +36,26 @@ public function testRateLimitAttemptsUpdateEventHandling(): void
         $id = sha1($ip.$route);
 
         $request = Request::create('/foo', 'GET', ['_route' => $route]);
-        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
-        $this->assertFalse($cache->contains($id));
+        $cache = $this->getCache();
+        $this->assertFalse($cache->getItem($id)->isHit());
 
         $this->dispatchRequestEvent($request);
 
-        $this->assertTrue($cache->contains($id));
-        $cacheEntry = $cache->fetch($id);
-        $this->assertEquals(1, $cacheEntry);
+        $this->assertTrue($cache->getItem($id)->isHit());
+        $cacheEntry = $cache->getItem($id);
+        $this->assertEquals(1, $cacheEntry->get());
 
         $this->dispatchRequestEvent($request);
 
-        $this->assertTrue($cache->contains($id));
-        $cacheEntry = $cache->fetch($id);
-        $this->assertEquals(2, $cacheEntry);
+        $this->assertTrue($cache->getItem($id)->isHit());
+        $cacheEntry = $cache->getItem($id);
+        $this->assertEquals(2, $cacheEntry->get());
 
         $this->dispatchRequestEvent($request);
 
-        $this->assertTrue($cache->contains($id));
-        $cacheEntry = $cache->fetch($id);
-        $this->assertEquals(3, $cacheEntry);
+        $this->assertTrue($cache->getItem($id)->isHit());
+        $cacheEntry = $cache->getItem($id);
+        $this->assertEquals(3, $cacheEntry->get());
     }
 
     private function dispatchResetAttemptsEvent($route, $ip): void
@@ -71,4 +74,24 @@ private function dispatchRequestEvent(Request $request): void
             KernelEvents::REQUEST
         );
     }
+
+    private function getCache(): CacheItemPoolInterface
+    {
+        /** @var CacheItemPoolInterface $cache */
+        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
+
+        return $cache;
+    }
+
+    private function createItem(string $id, int $value = 5, int $ttl = 3600): CacheItemInterface
+    {
+        $cache = $this->getCache();
+
+        $item = $cache->getItem($id);
+        $item->set($value);
+        $item->expiresAfter($ttl);
+        $cache->save($item);
+
+        return $item;
+    }
 }

Fusonic/RateLimitBundle/tests/Manager/RateLimitManagerTest.php

@@ -3,6 +3,8 @@
 namespace Fusonic\RateLimitBundle\Tests\Manager;
 
 use Fusonic\RateLimitBundle\Tests\TestCase;
+use Psr\Cache\CacheItemInterface;
+use Psr\Cache\CacheItemPoolInterface;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpKernel\Event\RequestEvent;
 
@@ -14,13 +16,13 @@ public function testResetRateLimitForRoute(): void
         $ip = '1.1.1.1';
         $id = sha1($ip.$route);
 
-        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
-        $cache->save($id, 5, 3600);
-        $this->assertTrue($cache->contains($id));
+        $cache = $this->getCache();
+        $this->createItem($id);
+        $this->assertTrue($cache->getItem($id)->isHit());
 
         $manager = $this->container->get('fusonic_rate_limit.manager');
         $manager->resetAttemptsForIpAndRoute($ip, 'foo');
-        $this->assertFalse($cache->contains($id));
+        $this->assertFalse($cache->getItem($id)->isHit());
     }
 
     public function testResetRateLimitForNotExistingRoute(): void
@@ -29,13 +31,13 @@ public function testResetRateLimitForNotExistingRoute(): void
         $ip = '1.1.1.1';
         $id = sha1($ip.$route);
 
-        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
-        $cache->save($id, 5, 3600);
-        $this->assertTrue($cache->contains($id));
+        $cache = $this->getCache();
+        $this->createItem($id);
+        $this->assertTrue($cache->getItem($id)->isHit());
 
         $manager = $this->container->get('fusonic_rate_limit.manager');
         $manager->resetAttemptsForIpAndRoute($ip, 'foo2');
-        $this->assertTrue($cache->contains($id));
+        $this->assertTrue($cache->getItem($id)->isHit());
     }
 
     public function testResetRateLimitForDifferentIp(): void
@@ -44,13 +46,13 @@ public function testResetRateLimitForDifferentIp(): void
         $ip = '1.1.1.1';
         $id = sha1($ip.$route);
 
-        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
-        $cache->save($id, 5, 3600);
-        $this->assertTrue($cache->contains($id));
+        $cache = $this->getCache();
+        $this->createItem($id);
+        $this->assertTrue($cache->getItem($id)->isHit());
 
         $manager = $this->container->get('fusonic_rate_limit.manager');
         $manager->resetAttemptsForIpAndRoute('1.1.1.2', $route);
-        $this->assertTrue($cache->contains($id));
+        $this->assertTrue($cache->getItem($id)->isHit());
     }
 
     public function testHandlingRequestsForDefinedRoute(): void
@@ -64,27 +66,27 @@ public function testHandlingRequestsForDefinedRoute(): void
         $event->method('isMasterRequest')->willReturn(true);
         $event->method('getRequest')->willReturn($request);
 
-        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
-        $this->assertFalse($cache->contains($id));
+        $cache = $this->getCache();
+        $this->assertFalse($cache->getItem($id)->isHit());
 
         $manager = $this->container->get('fusonic_rate_limit.manager');
         $manager->handleRequest($event);
-        $this->assertTrue($cache->contains($id));
+        $this->assertTrue($cache->getItem($id)->isHit());
 
-        $cacheEntry = $cache->fetch($id);
-        $this->assertEquals(1, $cacheEntry);
+        $cacheEntry = $cache->getItem($id);
+        $this->assertEquals(1, $cacheEntry->get());
 
         $manager->handleRequest($event);
-        $this->assertTrue($cache->contains($id));
+        $this->assertTrue($cache->getItem($id)->isHit());
 
-        $cacheEntry = $cache->fetch($id);
-        $this->assertEquals(2, $cacheEntry);
+        $cacheEntry = $cache->getItem($id);
+        $this->assertEquals(2, $cacheEntry->get());
 
         $manager->handleRequest($event);
-        $this->assertTrue($cache->contains($id));
+        $this->assertTrue($cache->getItem($id)->isHit());
 
-        $cacheEntry = $cache->fetch($id);
-        $this->assertEquals(3, $cacheEntry);
+        $cacheEntry = $cache->getItem($id);
+        $this->assertEquals(3, $cacheEntry->get());
     }
 
     public function testHandlingRequestsForNotDefinedRoute(): void
@@ -98,11 +100,31 @@ public function testHandlingRequestsForNotDefinedRoute(): void
         $event->method('isMasterRequest')->willReturn(true);
         $event->method('getRequest')->willReturn($request);
 
-        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
-        $this->assertFalse($cache->contains($id));
+        $cache = $this->getCache();
+        $this->assertFalse($cache->getItem($id)->isHit());
 
         $manager = $this->container->get('fusonic_rate_limit.manager');
         $manager->handleRequest($event);
-        $this->assertFalse($cache->contains($id));
+        $this->assertFalse($cache->getItem($id)->isHit());
+    }
+
+    private function getCache(): CacheItemPoolInterface
+    {
+        /** @var CacheItemPoolInterface $cache */
+        $cache = $this->container->get('fusonic_rate_limit.cache_provider');
+
+        return $cache;
+    }
+
+    private function createItem(string $id, int $value = 5, int $ttl = 3600): CacheItemInterface
+    {
+        $cache = $this->getCache();
+
+        $item = $cache->getItem($id);
+        $item->set($value);
+        $item->expiresAfter($ttl);
+        $cache->save($item);
+
+        return $item;
     }
 }

Fusonic/RateLimitBundle/tests/TestCase.php

@@ -2,15 +2,15 @@
 
 namespace Fusonic\RateLimitBundle\Tests;
 
-use Doctrine\Common\Cache\CacheProvider;
+use Psr\Cache\CacheItemPoolInterface;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 use Symfony\Component\HttpKernel\KernelInterface;
 
 abstract class TestCase extends \PHPUnit\Framework\TestCase
 {
     protected const CONFIG = [
         'enabled' => true,
-        'cache_provider' => 'doctrine_cache.providers.rate_limit_cache',
+        'cache_provider' => 'cache.app',
         'routes' => [
             'foo' => [
                 'limit' => 2,
@@ -42,8 +42,8 @@ protected function setUp(): void
     {
         parent::setUp();
 
-        /** @var CacheProvider $cache */
+        /** @var  CacheItemPoolInterface $cache */
         $cache = $this->container->get('fusonic_rate_limit.cache_provider');
-        $cache->deleteAll();
+        $cache->clear();
     }
 }