Add coverage

Author: cicnavi

src/Repositories/UserRepository.php

@@ -76,9 +76,11 @@ public function getUserEntityByIdentifier(string $identifier): ?UserEntity
 
         $row = current($rows);
 
+        // @codeCoverageIgnoreStart
         if (!is_array($row)) {
             return null;
         }
+        // @codeCoverageIgnoreEnd
 
         $userEntity = $this->userEntityFactory->fromState($row);
 

tests/unit/src/Repositories/ClientRepositoryTest.php

@@ -277,24 +277,25 @@ public function testFindPaginationWithEmptyList()
      */
     public function testUpdate(): void
     {
-        $client = self::getClient('clientid');
+        $client = self::getClient(id: 'clientId', entityId: 'entityId');
         $this->repository->add($client);
 
         $client = new ClientEntity(
-            'clientid',
-            'newclientsecret',
-            'Client',
-            'Description',
-            ['http://localhost/redirect'],
-            ['openid'],
-            true,
-            false,
-            'admin',
+            identifier: 'clientId',
+            secret: 'newclientsecret',
+            name: 'Client',
+            description: 'Description',
+            redirectUri: ['http://localhost/redirect'],
+            scopes: ['openid'],
+            isEnabled: true,
+            isConfidential: false,
+            authSource: 'admin',
+            entityIdentifier: 'newEntityId',
         );
 
         $this->repository->update($client);
         $this->clientEntityFactoryMock->expects($this->once())->method('fromState')->willReturn($client);
-        $foundClient = $this->repository->findById('clientid');
+        $foundClient = $this->repository->findById('clientId');
 
         $this->assertEquals($client, $foundClient);
     }
@@ -305,13 +306,13 @@ public function testUpdate(): void
      */
     public function testDelete(): void
     {
-        $client = self::getClient('clientid');
+        $client = self::getClient(id: 'clientId', entityId: 'entityId');
         $this->repository->add($client);
 
         $this->clientEntityFactoryMock->expects($this->once())->method('fromState')->willReturn($client);
-        $client = $this->repository->findById('clientid');
+        $client = $this->repository->findById('clientId');
         $this->repository->delete($client);
-        $foundClient = $this->repository->findById('clientid');
+        $foundClient = $this->repository->findById('clientId');
 
         $this->assertNull($foundClient);
     }

tests/unit/src/Repositories/CodeChallengeVerifiersRepositoryTest.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\Test\Module\oidc\unit\Repositories;
+
+use League\OAuth2\Server\CodeChallengeVerifiers\CodeChallengeVerifierInterface;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\Module\oidc\Repositories\CodeChallengeVerifiersRepository;
+
+#[CoversClass(CodeChallengeVerifiersRepository::class)]
+class CodeChallengeVerifiersRepositoryTest extends TestCase
+{
+    protected function sut(): CodeChallengeVerifiersRepository
+    {
+        return new CodeChallengeVerifiersRepository();
+    }
+
+    public function testCanCreateInstance(): void
+    {
+        $this->assertInstanceOf(CodeChallengeVerifiersRepository::class, $this->sut());
+    }
+
+    public function testCanGetCodeChallengeVerifier(): void
+    {
+        $this->assertInstanceOf(
+            CodeChallengeVerifierInterface::class,
+            $this->sut()->get('S256'),
+        );
+        $this->assertTrue($this->sut()->has('S256'));
+
+        $this->assertInstanceOf(
+            CodeChallengeVerifierInterface::class,
+            $this->sut()->get('plain'),
+        );
+        $this->assertTrue($this->sut()->has('plain'));
+
+        $this->assertNotEmpty($this->sut()->getAll());
+    }
+
+    public function testReturnsNullForUnsuportedVerifier(): void
+    {
+        $this->assertNull($this->sut()->get('unsuported'));
+    }
+}

tests/unit/src/Repositories/RefreshTokenRepositoryTest.php

@@ -17,6 +17,8 @@
 
 use DateTimeImmutable;
 use DateTimeZone;
+use League\OAuth2\Server\Entities\RefreshTokenEntityInterface;
+use League\OAuth2\Server\Exception\OAuthServerException;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 use RuntimeException;
@@ -40,6 +42,7 @@ class RefreshTokenRepositoryTest extends TestCase
     final public const USER_ID = 'refresh_token_user_id';
     final public const ACCESS_TOKEN_ID = 'refresh_token_access_token_id';
     final public const REFRESH_TOKEN_ID = 'refresh_token_id';
+    final public const AUTH_CODE_ID = 'auth_code_id';
 
     protected RefreshTokenRepository $repository;
     protected MockObject $accessTokenMock;
@@ -184,4 +187,45 @@ public function testRemoveExpired(): void
 
         $this->assertNull($notFoundRefreshToken);
     }
+
+    public function testGetNewRefreshTokenThrows(): void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Not implemented');
+
+        $this->repository->getNewRefreshToken();
+    }
+
+    public function testPersistNewRefreshTokenThrowsIfNotRefreshTokenEntity(): void
+    {
+        $this->expectException(OAuthServerException::class);
+
+        $oAuthRefreshTokenEntity = $this->createMock(RefreshTokenEntityInterface::class);
+
+        $this->repository->persistNewRefreshToken($oAuthRefreshTokenEntity);
+    }
+
+    public function testCanRevokeByAuthCodeId(): void
+    {
+        $refreshToken = new RefreshTokenEntity(
+            self::REFRESH_TOKEN_ID,
+            new DateTimeImmutable('tomorrow', new DateTimeZone('UTC')),
+            $this->accessTokenMock,
+            self::AUTH_CODE_ID,
+        );
+
+        $this->repository->persistNewRefreshToken($refreshToken);
+
+        $this->refreshTokenEntityFactoryMock->expects($this->once())
+            ->method('fromState')
+            ->with($this->callback(function (array $state): bool {
+                return $state['id'] === self::REFRESH_TOKEN_ID;
+            }))->willReturn($this->refreshTokenEntityMock);
+
+        $this->accessTokenRepositoryMock->method('findById')->willReturn($this->accessTokenMock);
+
+        $this->refreshTokenEntityMock->expects($this->once())->method('revoke');
+
+        $this->repository->revokeByAuthCodeId(self::AUTH_CODE_ID);
+    }
 }

tests/unit/src/Repositories/ScopeRepositoryTest.php

@@ -15,6 +15,7 @@
  */
 namespace SimpleSAML\Test\Module\oidc\unit\Repositories;
 
+use League\OAuth2\Server\Entities\ClientEntityInterface;
 use PHPUnit\Framework\TestCase;
 use SimpleSAML\Configuration;
 use SimpleSAML\Module\oidc\Entities\ScopeEntity;
@@ -90,4 +91,17 @@ public function testFinalizeScopes(): void
         ];
         $this->assertEquals($expectedScopes, $finalizedScopes);
     }
+
+    public function testFinalizeScopesReturnsEmptyIfNotClientEntity(): void
+    {
+        $scopeRepository = new ScopeRepository(new ModuleConfig(), new ScopeEntityFactory());
+        $scopes = [
+            new ScopeEntity('openid'),
+            new ScopeEntity('basic'),
+        ];
+
+        $clientMock = $this->createMock(ClientEntityInterface::class);
+
+        $this->assertEmpty($scopeRepository->finalizeScopes($scopes, 'any', $clientMock));
+    }
 }

tests/unit/src/Repositories/UserRepositoryTest.php

@@ -22,6 +22,7 @@
 use PHPUnit\Framework\TestCase;
 use SimpleSAML\Configuration;
 use SimpleSAML\Database;
+use SimpleSAML\Module\oidc\Entities\Interfaces\ClientEntityInterface;
 use SimpleSAML\Module\oidc\Entities\UserEntity;
 use SimpleSAML\Module\oidc\Factories\Entities\UserEntityFactory;
 use SimpleSAML\Module\oidc\Helpers;
@@ -307,4 +308,17 @@ public function testWillDeleteFromDatabaseAndCache(): void
             protocolCache: $this->protocolCacheMock,
         )->delete($this->userEntityMock);
     }
+
+    public function testGetUserEntityByUserCredentialsThrows(): void
+    {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('Not supported');
+
+        $this->mock()->getUserEntityByUserCredentials(
+            'username',
+            'password',
+            'grantType',
+            $this->createMock(ClientEntityInterface::class),
+        );
+    }
 }