Extract ConsentHashServiceInterface

Extracting this interface from the existing service is allowing us to
more easily test the service. As mocking a final class is not possible.

Author: MKodde

library/EngineBlock/Corto/Model/Consent.php

@@ -18,7 +18,7 @@
 
 use OpenConext\EngineBlock\Metadata\Entity\ServiceProvider;
 use OpenConext\EngineBlock\Authentication\Value\ConsentType;
-use OpenConext\EngineBlock\Service\Consent\ConsentHashService;
+use OpenConext\EngineBlock\Service\ConsentHashServiceInterface;
 
 class EngineBlock_Corto_Model_Consent
 {
@@ -41,11 +41,6 @@ class EngineBlock_Corto_Model_Consent
      */
     private $_responseAttributes;
 
-    /**
-     * @var EngineBlock_Database_ConnectionFactory
-     */
-    private $_databaseConnectionFactory;
-
     /**
      * A reflection of the eb.run_all_manipulations_prior_to_consent feature flag
      *
@@ -61,7 +56,7 @@ class EngineBlock_Corto_Model_Consent
     private $_consentEnabled;
 
     /**
-     * @var ConsentHashService
+     * @var ConsentHashServiceInterface
      */
     private $_hashService;
 
@@ -73,16 +68,14 @@ public function __construct(
         bool $mustStoreValues,
         EngineBlock_Saml2_ResponseAnnotationDecorator $response,
         array $responseAttributes,
-        EngineBlock_Database_ConnectionFactory $databaseConnectionFactory,
         bool $amPriorToConsentEnabled,
         bool $consentEnabled,
-        ConsentHashService $hashService
+        ConsentHashServiceInterface $hashService
     ) {
         $this->_tableName = $tableName;
         $this->_mustStoreValues = $mustStoreValues;
         $this->_response = $response;
         $this->_responseAttributes = $responseAttributes;
-        $this->_databaseConnectionFactory = $databaseConnectionFactory;
         $this->_amPriorToConsentEnabled = $amPriorToConsentEnabled;
         $this->_hashService = $hashService;
         $this->_consentEnabled = $consentEnabled;
@@ -114,21 +107,8 @@ public function giveImplicitConsentFor(ServiceProvider $serviceProvider): bool
 
     public function countTotalConsent(): int
     {
-        $dbh = $this->_getConsentDatabaseConnection();
-        if (!$dbh) {
-            return 0;
-        }
-
         $consentUid = $this->_getConsentUid();
-        return $this->_hashService->countTotalConsent($dbh, $consentUid);
-    }
-
-    /**
-     * @return bool|PDO
-     */
-    protected function _getConsentDatabaseConnection()
-    {
-        return $this->_databaseConnectionFactory->create();
+        return $this->_hashService->countTotalConsent($consentUid);
     }
 
     protected function _getConsentUid()
@@ -152,36 +132,26 @@ protected function _getStableAttributesHash($attributes): string
 
     private function _storeConsent(ServiceProvider $serviceProvider, $consentType): bool
     {
-        $dbh = $this->_getConsentDatabaseConnection();
-        if (!$dbh) {
-            return false;
-        }
-
         $parameters = array(
             sha1($this->_getConsentUid()),
             $serviceProvider->entityId,
             $this->_getStableAttributesHash($this->_responseAttributes),
             $consentType,
         );
 
-        return $this->_hashService->storeConsentHashInDb($dbh, $parameters);
+        return $this->_hashService->storeConsentHash($parameters);
     }
 
     private function _hasStoredConsent(ServiceProvider $serviceProvider, $consentType): bool
     {
-        $dbh = $this->_getConsentDatabaseConnection();
-        if (!$dbh) {
-            return false;
-        }
-
         $parameters = array(
             sha1($this->_getConsentUid()),
             $serviceProvider->entityId,
             $this->_getAttributesHash($this->_responseAttributes),
             $consentType,
         );
 
-        $hasUnstableConsentHash = $this->_hashService->retrieveConsentHashFromDb($dbh, $parameters);
+        $hasUnstableConsentHash = $this->_hashService->retrieveConsentHash($parameters);
 
         if ($hasUnstableConsentHash) {
             return true;
@@ -194,6 +164,6 @@ private function _hasStoredConsent(ServiceProvider $serviceProvider, $consentTyp
             $consentType,
         );
 
-        return $this->_hashService->retrieveConsentHashFromDb($dbh, $parameters);
+        return $this->_hashService->retrieveConsentHash($parameters);
     }
 }

library/EngineBlock/Corto/Model/Consent/Factory.php

@@ -26,26 +26,19 @@ class EngineBlock_Corto_Model_Consent_Factory
     /** @var EngineBlock_Corto_Filter_Command_Factory */
     private $_filterCommandFactory;
 
-    /** @var EngineBlock_Database_ConnectionFactory */
-    private $_databaseConnectionFactory;
-
     /**
      * @var ConsentHashService
      */
     private $_hashService;
 
     /**
       * @param EngineBlock_Corto_Filter_Command_Factory $filterCommandFactory
-      * @param EngineBlock_Database_ConnectionFactory $databaseConnectionFactory
       */
     public function __construct(
         EngineBlock_Corto_Filter_Command_Factory $filterCommandFactory,
-        EngineBlock_Database_ConnectionFactory $databaseConnectionFactory,
         ConsentHashService $hashService
-    )
-    {
+    ) {
         $this->_filterCommandFactory = $filterCommandFactory;
-        $this->_databaseConnectionFactory = $databaseConnectionFactory;
         $this->_hashService = $hashService;
     }
 
@@ -76,7 +69,6 @@ public function create(
             $proxyServer->getConfig('ConsentStoreValues', true),
             $response,
             $attributes,
-            $this->_databaseConnectionFactory,
             $amPriorToConsent,
             $consentEnabled,
             $this->_hashService

src/OpenConext/EngineBlock/Service/Consent/ConsentHashService.php

@@ -33,7 +33,7 @@
 use function strtolower;
 use function unserialize;
 
-final class ConsentHashService
+final class ConsentHashService implements ConsentHashServiceInterface
 {
     /**
      * @var ConsentRepository
@@ -45,12 +45,12 @@ public function __construct(ConsentRepository $consentHashRepository)
         $this->consentRepository = $consentHashRepository;
     }
 
-    public function retrieveConsentHashFromDb(array $parameters): bool
+    public function retrieveConsentHash(array $parameters): bool
     {
         return $this->consentRepository->hasConsentHash($parameters);
     }
 
-    public function storeConsentHashInDb(array $parameters): bool
+    public function storeConsentHash(array $parameters): bool
     {
         return $this->consentRepository->storeConsentHash($parameters);
     }

src/OpenConext/EngineBlock/Service/Consent/ConsentHashServiceInterface.php

@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * Copyright 2010 SURFnet B.V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OpenConext\EngineBlock\Service\Consent;
+
+interface ConsentHashServiceInterface
+{
+    public function retrieveConsentHash(array $parameters): bool;
+
+    public function storeConsentHash(array $parameters): bool;
+
+    public function countTotalConsent($consentUid): int;
+
+    public function getUnstableAttributesHash(array $attributes, bool $mustStoreValues): string;
+
+    public function getStableAttributesHash(array $attributes, bool $mustStoreValues) : string;
+}

tests/library/EngineBlock/Test/Corto/Model/ConsentTest.php

@@ -16,60 +16,71 @@
  * limitations under the License.
  */
 
+use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
 use OpenConext\EngineBlock\Metadata\Entity\ServiceProvider;
+use OpenConext\EngineBlock\Service\ConsentHashServiceInterface;
 use PHPUnit\Framework\TestCase;
 
 class EngineBlock_Corto_Model_Consent_Test extends TestCase
 {
+    use MockeryPHPUnitIntegration;
+
     private $consentDisabled;
     private $consent;
-    private $mockedDatabaseConnection;
+    private $consentService;
 
     public function setup()
     {
-        $this->mockedDatabaseConnection = Phake::mock('EngineBlock_Database_ConnectionFactory');
         $mockedResponse = Phake::mock('EngineBlock_Saml2_ResponseAnnotationDecorator');
 
+        $this->consentService = Mockery::mock(ConsentHashServiceInterface::class);
+
         $this->consentDisabled = new EngineBlock_Corto_Model_Consent(
             "consent",
             true,
             $mockedResponse,
             [],
-            $this->mockedDatabaseConnection,
             false,
-            false
+            false,
+            $this->consentService
         );
 
         $this->consent = new EngineBlock_Corto_Model_Consent(
             "consent",
             true,
             $mockedResponse,
             [],
-            $this->mockedDatabaseConnection,
             false,
-            true
+            true,
+            $this->consentService
         );
     }
 
     public function testConsentDisabledDoesNotWriteToDatabase()
     {
         $serviceProvider = new ServiceProvider("service-provider-entity-id");
+
+        $this->consentService->shouldReceive('getUnstableAttributesHash');
+        $this->consentService->shouldNotReceive('storeConsentHash');
         $this->consentDisabled->explicitConsentWasGivenFor($serviceProvider);
         $this->consentDisabled->implicitConsentWasGivenFor($serviceProvider);
         $this->consentDisabled->giveExplicitConsentFor($serviceProvider);
         $this->consentDisabled->giveImplicitConsentFor($serviceProvider);
-
-        Phake::verify($this->mockedDatabaseConnection, Phake::times(0))->create();
     }
 
     public function testConsentWriteToDatabase()
     {
         $serviceProvider = new ServiceProvider("service-provider-entity-id");
+
+        $this->consentService->shouldReceive('getUnstableAttributesHash')->andReturn(sha1('unstable'));
+        $this->consentService->shouldReceive('retrieveConsentHash')->andReturn(sha1('unstable'));
         $this->consent->explicitConsentWasGivenFor($serviceProvider);
+
+        $this->consentService->shouldReceive('getStableAttributesHash')->andReturn(sha1('stable'));
         $this->consent->implicitConsentWasGivenFor($serviceProvider);
+
+        $this->consentService->shouldReceive('storeConsentHash')->andReturn(true);
         $this->consent->giveExplicitConsentFor($serviceProvider);
         $this->consent->giveImplicitConsentFor($serviceProvider);
-
-        Phake::verify($this->mockedDatabaseConnection, Phake::times(4))->create();
     }
 }