ClientMetadataTest::testGetIdTokenEncryptedResponseEnc() - Code Metrics - facile-it/php-openid-client - Measure and Improve Code Quality continuously with Scrutinizer

testGetIdTokenEncryptedResponseEnc() A
last analyzed 2021-05-07 08:22 UTC

↳ Parent: ClientMetadataTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	5
nc	1
nop	0
dl	0
loc	11
rs	10
c	1
b	0
f	0

<?php

declare(strict_types=1);

namespace Facile\OpenIDClientTest\Client\Metadata;

use Facile\OpenIDClient\Client\Metadata\ClientMetadata;
use Facile\OpenIDClient\Exception\InvalidArgumentException;
use function json_decode;
use function json_encode;
use Facile\OpenIDClientTest\TestCase;

class ClientMetadataTest extends TestCase
{
    public function testFromClaims(): void
    {
        $metadata = ClientMetadata::fromArray([
            'client_id' => 'foo',
            'redirect_uris' => ['bar'],
        ]);

        static::assertSame('foo', $metadata->getClientId());
        static::assertSame(['bar'], $metadata->getRedirectUris());
    }

    public function testFromClaimsWithNoClientId(): void
    {
        $this->expectException(InvalidArgumentException::class);

        ClientMetadata::fromArray([
            'redirect_uris' => ['bar'],
        ]);
    }

    public function testGetClientId(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertSame('foo', $metadata->getClientId());
    }

    public function testGetRedirectUris(): void
    {
        $metadata = new ClientMetadata('foo');

        static::assertSame([], $metadata->getRedirectUris());

        $metadata = new ClientMetadata('foo', [
            'redirect_uris' => ['https://example.com/callback'],
        ]);

        static::assertSame(['https://example.com/callback'], $metadata->getRedirectUris());
    }

    public function testGetResponseTypes(): void
    {
        $metadata = new ClientMetadata('foo');

        static::assertSame(['code'], $metadata->getResponseTypes());

        $metadata = new ClientMetadata('foo', [
            'response_types' => ['code', 'id_token'],
        ]);

        static::assertSame(['code', 'id_token'], $metadata->getResponseTypes());
    }

    public function testGetIdTokenSignedResponseAlg(): void
    {
        $metadata = new ClientMetadata('foo');

        static::assertSame('RS256', $metadata->getIdTokenSignedResponseAlg());

        $metadata = new ClientMetadata('foo', [
            'id_token_signed_response_alg' => 'HS256',
        ]);

        static::assertSame('HS256', $metadata->getIdTokenSignedResponseAlg());
    }

    public function testGetIdTokenEncryptedResponseAlg(): void
    {
        $metadata = new ClientMetadata('foo');

        static::assertNull($metadata->getIdTokenEncryptedResponseAlg());

        $metadata = new ClientMetadata('foo', [
            'id_token_encrypted_response_alg' => 'RSA-OEAP',
        ]);

        static::assertSame('RSA-OEAP', $metadata->getIdTokenEncryptedResponseAlg());
    }

    public function testGetIdTokenEncryptedResponseEnc(): void
    {
        $metadata = new ClientMetadata('foo');

        static::assertNull($metadata->getIdTokenEncryptedResponseEnc());

        $metadata = new ClientMetadata('foo', [
            'id_token_encrypted_response_enc' => 'ALG',
        ]);

        static::assertSame('ALG', $metadata->getIdTokenEncryptedResponseEnc());
    }

    public function testGetUserinfoEncryptedResponseAlg(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getUserinfoEncryptedResponseAlg());

        $metadata = new ClientMetadata('foo', [
            'userinfo_encrypted_response_alg' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getUserinfoEncryptedResponseAlg());
    }

    public function testGetRevocationEndpointAuthMethod(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertSame($metadata->getTokenEndpointAuthMethod(), $metadata->getRevocationEndpointAuthMethod());

        $metadata = new ClientMetadata('foo', [
            'revocation_endpoint_auth_method' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getRevocationEndpointAuthMethod());
    }

    public function testGetClientSecret(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getClientSecret());

        $metadata = new ClientMetadata('foo', [
            'client_secret' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getClientSecret());
    }

    public function testGetAuthorizationEncryptedResponseAlg(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getAuthorizationEncryptedResponseAlg());

        $metadata = new ClientMetadata('foo', [
            'authorization_encrypted_response_alg' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getAuthorizationEncryptedResponseAlg());
    }

    public function testGetUserinfoSignedResponseAlg(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getUserinfoSignedResponseAlg());

        $metadata = new ClientMetadata('foo', [
            'userinfo_signed_response_alg' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getUserinfoSignedResponseAlg());
    }

    public function testGetIntrospectionEndpointAuthMethod(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertSame($metadata->getTokenEndpointAuthMethod(), $metadata->getIntrospectionEndpointAuthMethod());

        $metadata = new ClientMetadata('foo', [
            'introspection_endpoint_auth_method' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getIntrospectionEndpointAuthMethod());
    }

    public function testGetUserinfoEncryptedResponseEnc(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getUserinfoEncryptedResponseEnc());

        $metadata = new ClientMetadata('foo', [
            'userinfo_encrypted_response_enc' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getUserinfoEncryptedResponseEnc());
    }

    public function testGetAuthorizationEncryptedResponseEnc(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getAuthorizationEncryptedResponseEnc());

        $metadata = new ClientMetadata('foo', [
            'authorization_encrypted_response_enc' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getAuthorizationEncryptedResponseEnc());
    }

    public function testGetRequestObjectSigningAlg(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getRequestObjectSigningAlg());

        $metadata = new ClientMetadata('foo', [
            'request_object_signing_alg' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getRequestObjectSigningAlg());
    }

    public function testGetRequestObjectEncryptionAlg(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getRequestObjectEncryptionAlg());

        $metadata = new ClientMetadata('foo', [
            'request_object_encryption_alg' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getRequestObjectEncryptionAlg());
    }

    public function testGetRequestObjectEncryptionEnc(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getRequestObjectEncryptionEnc());

        $metadata = new ClientMetadata('foo', [
            'request_object_encryption_enc' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getRequestObjectEncryptionEnc());
    }

    public function testGetAuthorizationSignedResponseAlg(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->getAuthorizationSignedResponseAlg());

        $metadata = new ClientMetadata('foo', [
            'authorization_signed_response_alg' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getAuthorizationSignedResponseAlg());
    }

    public function testGetTokenEndpointAuthMethod(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertSame('client_secret_basic', $metadata->getTokenEndpointAuthMethod());

        $metadata = new ClientMetadata('foo', [
            'token_endpoint_auth_method' => 'foo',
        ]);

        static::assertSame('foo', $metadata->getTokenEndpointAuthMethod());
    }

    public function testDefaults(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertNull($metadata->get('require_auth_time'));
        static::assertNull($metadata->get('tls_client_certificate_bound_access_tokens'));
        static::assertNull($metadata->get('response_types'));
        static::assertSame(['code'], $metadata->getResponseTypes());
        static::assertNull($metadata->get('post_logout_redirect_uris'));
        static::assertNull($metadata->get('id_token_signed_response_alg'));
        static::assertSame('RS256', $metadata->getIdTokenSignedResponseAlg());
        static::assertSame('client_secret_basic', $metadata->getTokenEndpointAuthMethod());
    }

    public function testGet(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertSame('foo', $metadata->get('client_id'));
    }

    public function testHas(): void
    {
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertTrue($metadata->has('client_id'));
        static::assertFalse($metadata->has('foo'));
    }

    public function testJsonSerialize(): void
    {
        $expected = [
            'redirect_uris' => ['bar'],
            'client_id' => 'foo',
        ];
        $metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);

        static::assertSame($expected, json_decode(json_encode($metadata), true));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Facile\OpenIDClientTest\Client\Metadata;
6
7			use Facile\OpenIDClient\Client\Metadata\ClientMetadata;
8			use Facile\OpenIDClient\Exception\InvalidArgumentException;
9			use function json_decode;
10			use function json_encode;
11			use Facile\OpenIDClientTest\TestCase;
12
13			class ClientMetadataTest extends TestCase
14			{
15			public function testFromClaims(): void
16			{
17			$metadata = ClientMetadata::fromArray([
18			'client_id' => 'foo',
19			'redirect_uris' => ['bar'],
20			]);
21
22			static::assertSame('foo', $metadata->getClientId());
23			static::assertSame(['bar'], $metadata->getRedirectUris());
24			}
25
26			public function testFromClaimsWithNoClientId(): void
27			{
28			$this->expectException(InvalidArgumentException::class);
29
30			ClientMetadata::fromArray([
31			'redirect_uris' => ['bar'],
32			]);
33			}
34
35			public function testGetClientId(): void
36			{
37			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
38
39			static::assertSame('foo', $metadata->getClientId());
40			}
41
42			public function testGetRedirectUris(): void
43			{
44			$metadata = new ClientMetadata('foo');
45
46			static::assertSame([], $metadata->getRedirectUris());
47
48			$metadata = new ClientMetadata('foo', [
49			'redirect_uris' => ['https://example.com/callback'],
50			]);
51
52			static::assertSame(['https://example.com/callback'], $metadata->getRedirectUris());
53			}
54
55			public function testGetResponseTypes(): void
56			{
57			$metadata = new ClientMetadata('foo');
58
59			static::assertSame(['code'], $metadata->getResponseTypes());
60
61			$metadata = new ClientMetadata('foo', [
62			'response_types' => ['code', 'id_token'],
63			]);
64
65			static::assertSame(['code', 'id_token'], $metadata->getResponseTypes());
66			}
67
68			public function testGetIdTokenSignedResponseAlg(): void
69			{
70			$metadata = new ClientMetadata('foo');
71
72			static::assertSame('RS256', $metadata->getIdTokenSignedResponseAlg());
73
74			$metadata = new ClientMetadata('foo', [
75			'id_token_signed_response_alg' => 'HS256',
76			]);
77
78			static::assertSame('HS256', $metadata->getIdTokenSignedResponseAlg());
79			}
80
81			public function testGetIdTokenEncryptedResponseAlg(): void
82			{
83			$metadata = new ClientMetadata('foo');
84
85			static::assertNull($metadata->getIdTokenEncryptedResponseAlg());
86
87			$metadata = new ClientMetadata('foo', [
88			'id_token_encrypted_response_alg' => 'RSA-OEAP',
89			]);
90
91			static::assertSame('RSA-OEAP', $metadata->getIdTokenEncryptedResponseAlg());
92			}
93
94			public function testGetIdTokenEncryptedResponseEnc(): void
95			{
96			$metadata = new ClientMetadata('foo');
97
98			static::assertNull($metadata->getIdTokenEncryptedResponseEnc());
99
100			$metadata = new ClientMetadata('foo', [
101			'id_token_encrypted_response_enc' => 'ALG',
102			]);
103
104			static::assertSame('ALG', $metadata->getIdTokenEncryptedResponseEnc());
105			}
106
107			public function testGetUserinfoEncryptedResponseAlg(): void
108			{
109			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
110
111			static::assertNull($metadata->getUserinfoEncryptedResponseAlg());
112
113			$metadata = new ClientMetadata('foo', [
114			'userinfo_encrypted_response_alg' => 'foo',
115			]);
116
117			static::assertSame('foo', $metadata->getUserinfoEncryptedResponseAlg());
118			}
119
120			public function testGetRevocationEndpointAuthMethod(): void
121			{
122			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
123
124			static::assertSame($metadata->getTokenEndpointAuthMethod(), $metadata->getRevocationEndpointAuthMethod());
125
126			$metadata = new ClientMetadata('foo', [
127			'revocation_endpoint_auth_method' => 'foo',
128			]);
129
130			static::assertSame('foo', $metadata->getRevocationEndpointAuthMethod());
131			}
132
133			public function testGetClientSecret(): void
134			{
135			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
136
137			static::assertNull($metadata->getClientSecret());
138
139			$metadata = new ClientMetadata('foo', [
140			'client_secret' => 'foo',
141			]);
142
143			static::assertSame('foo', $metadata->getClientSecret());
144			}
145
146			public function testGetAuthorizationEncryptedResponseAlg(): void
147			{
148			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
149
150			static::assertNull($metadata->getAuthorizationEncryptedResponseAlg());
151
152			$metadata = new ClientMetadata('foo', [
153			'authorization_encrypted_response_alg' => 'foo',
154			]);
155
156			static::assertSame('foo', $metadata->getAuthorizationEncryptedResponseAlg());
157			}
158
159			public function testGetUserinfoSignedResponseAlg(): void
160			{
161			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
162
163			static::assertNull($metadata->getUserinfoSignedResponseAlg());
164
165			$metadata = new ClientMetadata('foo', [
166			'userinfo_signed_response_alg' => 'foo',
167			]);
168
169			static::assertSame('foo', $metadata->getUserinfoSignedResponseAlg());
170			}
171
172			public function testGetIntrospectionEndpointAuthMethod(): void
173			{
174			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
175
176			static::assertSame($metadata->getTokenEndpointAuthMethod(), $metadata->getIntrospectionEndpointAuthMethod());
177
178			$metadata = new ClientMetadata('foo', [
179			'introspection_endpoint_auth_method' => 'foo',
180			]);
181
182			static::assertSame('foo', $metadata->getIntrospectionEndpointAuthMethod());
183			}
184
185			public function testGetUserinfoEncryptedResponseEnc(): void
186			{
187			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
188
189			static::assertNull($metadata->getUserinfoEncryptedResponseEnc());
190
191			$metadata = new ClientMetadata('foo', [
192			'userinfo_encrypted_response_enc' => 'foo',
193			]);
194
195			static::assertSame('foo', $metadata->getUserinfoEncryptedResponseEnc());
196			}
197
198			public function testGetAuthorizationEncryptedResponseEnc(): void
199			{
200			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
201
202			static::assertNull($metadata->getAuthorizationEncryptedResponseEnc());
203
204			$metadata = new ClientMetadata('foo', [
205			'authorization_encrypted_response_enc' => 'foo',
206			]);
207
208			static::assertSame('foo', $metadata->getAuthorizationEncryptedResponseEnc());
209			}
210
211			public function testGetRequestObjectSigningAlg(): void
212			{
213			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
214
215			static::assertNull($metadata->getRequestObjectSigningAlg());
216
217			$metadata = new ClientMetadata('foo', [
218			'request_object_signing_alg' => 'foo',
219			]);
220
221			static::assertSame('foo', $metadata->getRequestObjectSigningAlg());
222			}
223
224			public function testGetRequestObjectEncryptionAlg(): void
225			{
226			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
227
228			static::assertNull($metadata->getRequestObjectEncryptionAlg());
229
230			$metadata = new ClientMetadata('foo', [
231			'request_object_encryption_alg' => 'foo',
232			]);
233
234			static::assertSame('foo', $metadata->getRequestObjectEncryptionAlg());
235			}
236
237			public function testGetRequestObjectEncryptionEnc(): void
238			{
239			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
240
241			static::assertNull($metadata->getRequestObjectEncryptionEnc());
242
243			$metadata = new ClientMetadata('foo', [
244			'request_object_encryption_enc' => 'foo',
245			]);
246
247			static::assertSame('foo', $metadata->getRequestObjectEncryptionEnc());
248			}
249
250			public function testGetAuthorizationSignedResponseAlg(): void
251			{
252			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
253
254			static::assertNull($metadata->getAuthorizationSignedResponseAlg());
255
256			$metadata = new ClientMetadata('foo', [
257			'authorization_signed_response_alg' => 'foo',
258			]);
259
260			static::assertSame('foo', $metadata->getAuthorizationSignedResponseAlg());
261			}
262
263			public function testGetTokenEndpointAuthMethod(): void
264			{
265			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
266
267			static::assertSame('client_secret_basic', $metadata->getTokenEndpointAuthMethod());
268
269			$metadata = new ClientMetadata('foo', [
270			'token_endpoint_auth_method' => 'foo',
271			]);
272
273			static::assertSame('foo', $metadata->getTokenEndpointAuthMethod());
274			}
275
276			public function testDefaults(): void
277			{
278			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
279
280			static::assertNull($metadata->get('require_auth_time'));
281			static::assertNull($metadata->get('tls_client_certificate_bound_access_tokens'));
282			static::assertNull($metadata->get('response_types'));
283			static::assertSame(['code'], $metadata->getResponseTypes());
284			static::assertNull($metadata->get('post_logout_redirect_uris'));
285			static::assertNull($metadata->get('id_token_signed_response_alg'));
286			static::assertSame('RS256', $metadata->getIdTokenSignedResponseAlg());
287			static::assertSame('client_secret_basic', $metadata->getTokenEndpointAuthMethod());
288			}
289
290			public function testGet(): void
291			{
292			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
293
294			static::assertSame('foo', $metadata->get('client_id'));
295			}
296
297			public function testHas(): void
298			{
299			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
300
301			static::assertTrue($metadata->has('client_id'));
302			static::assertFalse($metadata->has('foo'));
303			}
304
305			public function testJsonSerialize(): void
306			{
307			$expected = [
308			'redirect_uris' => ['bar'],
309			'client_id' => 'foo',
310			];
311			$metadata = new ClientMetadata('foo', ['redirect_uris' => ['bar']]);
312
313			static::assertSame($expected, json_decode(json_encode($metadata), true));
314			}
315			}
316

facile-it / php-openid-client

testGetIdTokenEncryptedResponseEnc() A last analyzed 2021-05-07 08:22 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testGetIdTokenEncryptedResponseEnc() A
last analyzed 2021-05-07 08:22 UTC