AgreementMethodTest::testMarshallingElementOrdering() - Code Metrics - Inspection of "Update simplesamlphp/simplesamlphp-test-framework..." - simplesamlphp/xml-security - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#61)

unknown

created 2025-04-04 23:39 UTC

AgreementMethodTest::testMarshallingElementOrdering() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	75
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	42
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	75
rs	9.248

How to fix Long Method

<?php

declare(strict_types=1);

namespace SimpleSAML\XMLSecurity\Test\XML\xenc;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\TestCase;
use SimpleSAML\XML\Chunk;
use SimpleSAML\XML\DOMDocumentFactory;
use SimpleSAML\XML\TestUtils\{SerializableElementTestTrait, SchemaValidationTestTrait};
use SimpleSAML\XMLSecurity\Constants as C;
use SimpleSAML\XMLSecurity\TestUtils\PEMCertificatesMock;
use SimpleSAML\XMLSecurity\Utils\XPath;
use SimpleSAML\XMLSecurity\XML\ds\{DigestMethod, KeyName, X509Certificate, X509Data, X509SubjectName};
use SimpleSAML\XMLSecurity\XML\xenc\{AbstractAgreementMethodType, AbstractXencElement};
use SimpleSAML\XMLSecurity\XML\xenc\{AgreementMethod, KANonce, OriginatorKeyInfo, RecipientKeyInfo};

use function dirname;
use function openssl_x509_parse;
use function str_replace;
use function strval;

/**
 * Class \SimpleSAML\XMLSecurity\Test\XML\xenc\AgreementMethodTest
 *
 * @package simplesamlphp/xml-security
 */
#[CoversClass(AbstractXencElement::class)]
#[CoversClass(AbstractAgreementMethodType::class)]
#[CoversClass(AgreementMethod::class)]
final class AgreementMethodTest extends TestCase
{
    use SchemaValidationTestTrait;
    use SerializableElementTestTrait;

    /** @var string */
    private static string $certificate;

    /** @var string[] */
    private static array $certData;


    /**
     */
    public function setUp(): void
    {
        self::$testedClass = AgreementMethod::class;

        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
            dirname(__FILE__, 3) . '/resources/xml/xenc_AgreementMethod.xml',
        );

        self::$certificate = str_replace(
            [
                '-----BEGIN CERTIFICATE-----',
                '-----END CERTIFICATE-----',
                '-----BEGIN RSA PUBLIC KEY-----',
                '-----END RSA PUBLIC KEY-----',
                "\r\n",
                "\n",
            ],
            [
                '',
                '',
                '',
                '',
                "\n",
                '',
            ],
            PEMCertificatesMock::getPlainCertificate(PEMCertificatesMock::SELFSIGNED_CERTIFICATE),
        );

        self::$certData = openssl_x509_parse(
            PEMCertificatesMock::getPlainCertificate(PEMCertificatesMock::SELFSIGNED_CERTIFICATE),
        );
    }


    /**
     */
    public function testMarshalling(): void
    {
        $kaNonce = new KANonce('/CTj03d1DB5e2t7CTo9BEzCf5S9NRzwnBgZRlm32REI=');

        $digestMethod = new DigestMethod(
            C::DIGEST_SHA256,
            [
                new Chunk(DOMDocumentFactory::fromString(
                    '<some:Chunk xmlns:some="urn:x-simplesamlphp:namespace">some</some:Chunk>',
                )->documentElement),
            ],
        );

        $originatorKeyInfo = new OriginatorKeyInfo(
            [
                new KeyName('testkey'),
                new X509Data(
                    [
                        new X509Certificate(self::$certificate),
                        new X509SubjectName(self::$certData['name']),
                    ],
                ),
                new Chunk(DOMDocumentFactory::fromString(
                    '<ssp:Chunk xmlns:ssp="urn:x-simplesamlphp:namespace">originator</ssp:Chunk>',
                )->documentElement),
            ],
            'fed123',
        );

        $recipientKeyInfo = new RecipientKeyInfo(
            [
                new KeyName('testkey'),
                new X509Data(
                    [
                        new X509Certificate(self::$certificate),
                        new X509SubjectName(self::$certData['name']),
                    ],
                ),
                new Chunk(DOMDocumentFactory::fromString(
                    '<ssp:Chunk xmlns:ssp="urn:x-simplesamlphp:namespace">recipient</ssp:Chunk>',
                )->documentElement),
            ],
            'fed654',
        );

        $agreementMethod = new AgreementMethod(
            C::XMLENC11_ECDH_ES,
            $kaNonce,
            $originatorKeyInfo,
            $recipientKeyInfo,
            [$digestMethod],
        );

        $this->assertEquals(
            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
            strval($agreementMethod),
        );
    }


    public function testMarshallingElementOrdering(): void
    {
        $kaNonce = new KANonce('/CTj03d1DB5e2t7CTo9BEzCf5S9NRzwnBgZRlm32REI=');

        $digestMethod = new DigestMethod(
            C::DIGEST_SHA256,
            [
                new Chunk(DOMDocumentFactory::fromString(
                    '<some:Chunk xmlns:some="urn:x-simplesamlphp:namespace">some</some:Chunk>',
                )->documentElement),
            ],
        );

        $originatorKeyInfo = new OriginatorKeyInfo(
            [
                new KeyName('testkey'),
                new X509Data(
                    [
                        new X509Certificate(self::$certificate),
                        new X509SubjectName(self::$certData['name']),
                    ],
                ),
                new Chunk(DOMDocumentFactory::fromString(
                    '<ssp:Chunk xmlns:ssp="urn:x-simplesamlphp:namespace">originator</ssp:Chunk>',
                )->documentElement),
            ],
            'fed321',
        );

        $recipientKeyInfo = new RecipientKeyInfo(
            [
                new KeyName('testkey'),
                new X509Data(
                    [
                        new X509Certificate(self::$certificate),
                        new X509SubjectName(self::$certData['name']),
                    ],
                ),
                new Chunk(DOMDocumentFactory::fromString(
                    '<ssp:Chunk xmlns:ssp="urn:x-simplesamlphp:namespace">recipient</ssp:Chunk>',
                )->documentElement),
            ],
            'fed654',
        );

        $agreementMethod = new AgreementMethod(
            C::XMLENC11_ECDH_ES,
            $kaNonce,
            $originatorKeyInfo,
            $recipientKeyInfo,
            [$digestMethod],
        );

        // Marshall it to a \DOMElement
        $agreementMethodElement = $agreementMethod->toXML();

        $xpCache = XPath::getXPath($agreementMethodElement);

        // Test for an KA-Nonce
        /** @var \DOMElement[] $kaNonceElements */
        $kaNonceElements = XPath::xpQuery($agreementMethodElement, './xenc:KA-Nonce', $xpCache);
        $this->assertCount(1, $kaNonceElements);

        // Test ordering of AgreementMethod contents
        /** @var \DOMElement[] $agreementMethodElements */
        $agreementMethodElements = XPath::xpQuery(
            $agreementMethodElement,
            './xenc:KA-Nonce/following-sibling::*',
            $xpCache,
        );

        $this->assertCount(3, $agreementMethodElements);
        $this->assertEquals('ds:DigestMethod', $agreementMethodElements[0]->tagName);
        $this->assertEquals('xenc:OriginatorKeyInfo', $agreementMethodElements[1]->tagName);
        $this->assertEquals('xenc:RecipientKeyInfo', $agreementMethodElements[2]->tagName);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace SimpleSAML\XMLSecurity\Test\XML\xenc;
6
7			use PHPUnit\Framework\Attributes\CoversClass;
8			use PHPUnit\Framework\TestCase;
9			use SimpleSAML\XML\Chunk;
10			use SimpleSAML\XML\DOMDocumentFactory;
11			use SimpleSAML\XML\TestUtils\{SerializableElementTestTrait, SchemaValidationTestTrait};
12			use SimpleSAML\XMLSecurity\Constants as C;
13			use SimpleSAML\XMLSecurity\TestUtils\PEMCertificatesMock;
14			use SimpleSAML\XMLSecurity\Utils\XPath;
15			use SimpleSAML\XMLSecurity\XML\ds\{DigestMethod, KeyName, X509Certificate, X509Data, X509SubjectName};
16			use SimpleSAML\XMLSecurity\XML\xenc\{AbstractAgreementMethodType, AbstractXencElement};
17			use SimpleSAML\XMLSecurity\XML\xenc\{AgreementMethod, KANonce, OriginatorKeyInfo, RecipientKeyInfo};
18
19			use function dirname;
20			use function openssl_x509_parse;
21			use function str_replace;
22			use function strval;
23
24			/**
25			* Class \SimpleSAML\XMLSecurity\Test\XML\xenc\AgreementMethodTest
26			*
27			* @package simplesamlphp/xml-security
28			*/
29			#[CoversClass(AbstractXencElement::class)]
30			#[CoversClass(AbstractAgreementMethodType::class)]
31			#[CoversClass(AgreementMethod::class)]
32			final class AgreementMethodTest extends TestCase
33			{
34			use SchemaValidationTestTrait;
35			use SerializableElementTestTrait;
36
37			/** @var string */
38			private static string $certificate;
39
40			/** @var string[] */
41			private static array $certData;
42
43
44			/**
45			*/
46			public function setUp(): void
47			{
48			self::$testedClass = AgreementMethod::class;
49
50			self::$xmlRepresentation = DOMDocumentFactory::fromFile(
51			dirname(__FILE__, 3) . '/resources/xml/xenc_AgreementMethod.xml',
52			);
53
54			self::$certificate = str_replace(
55			[
56			'-----BEGIN CERTIFICATE-----',
57			'-----END CERTIFICATE-----',
58			'-----BEGIN RSA PUBLIC KEY-----',
59			'-----END RSA PUBLIC KEY-----',
60			"\r\n",
61			"\n",
62			],
63			[
64			'',
65			'',
66			'',
67			'',
68			"\n",
69			'',
70			],
71			PEMCertificatesMock::getPlainCertificate(PEMCertificatesMock::SELFSIGNED_CERTIFICATE),
72			);
73
74			self::$certData = openssl_x509_parse(
75			PEMCertificatesMock::getPlainCertificate(PEMCertificatesMock::SELFSIGNED_CERTIFICATE),
76			);
77			}
78
79
80			/**
81			*/
82			public function testMarshalling(): void
83			{
84			$kaNonce = new KANonce('/CTj03d1DB5e2t7CTo9BEzCf5S9NRzwnBgZRlm32REI=');
85
86			$digestMethod = new DigestMethod(
87			C::DIGEST_SHA256,
88			[
89			new Chunk(DOMDocumentFactory::fromString(
90			'<some:Chunk xmlns:some="urn:x-simplesamlphp:namespace">some</some:Chunk>',
91			)->documentElement),
92			],
93			);
94
95			$originatorKeyInfo = new OriginatorKeyInfo(
96			[
97			new KeyName('testkey'),
98			new X509Data(
99			[
100			new X509Certificate(self::$certificate),
101			new X509SubjectName(self::$certData['name']),
102			],
103			),
104			new Chunk(DOMDocumentFactory::fromString(
105			'<ssp:Chunk xmlns:ssp="urn:x-simplesamlphp:namespace">originator</ssp:Chunk>',
106			)->documentElement),
107			],
108			'fed123',
109			);
110
111			$recipientKeyInfo = new RecipientKeyInfo(
112			[
113			new KeyName('testkey'),
114			new X509Data(
115			[
116			new X509Certificate(self::$certificate),
117			new X509SubjectName(self::$certData['name']),
118			],
119			),
120			new Chunk(DOMDocumentFactory::fromString(
121			'<ssp:Chunk xmlns:ssp="urn:x-simplesamlphp:namespace">recipient</ssp:Chunk>',
122			)->documentElement),
123			],
124			'fed654',
125			);
126
127			$agreementMethod = new AgreementMethod(
128			C::XMLENC11_ECDH_ES,
129			$kaNonce,
130			$originatorKeyInfo,
131			$recipientKeyInfo,
132			[$digestMethod],
133			);
134
135			$this->assertEquals(
136			self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
137			strval($agreementMethod),
138			);
139			}
140
141
142			public function testMarshallingElementOrdering(): void
143			{
144			$kaNonce = new KANonce('/CTj03d1DB5e2t7CTo9BEzCf5S9NRzwnBgZRlm32REI=');
145
146			$digestMethod = new DigestMethod(
147			C::DIGEST_SHA256,
148			[
149			new Chunk(DOMDocumentFactory::fromString(
150			'<some:Chunk xmlns:some="urn:x-simplesamlphp:namespace">some</some:Chunk>',
151			)->documentElement),
152			],
153			);
154
155			$originatorKeyInfo = new OriginatorKeyInfo(
156			[
157			new KeyName('testkey'),
158			new X509Data(
159			[
160			new X509Certificate(self::$certificate),
161			new X509SubjectName(self::$certData['name']),
162			],
163			),
164			new Chunk(DOMDocumentFactory::fromString(
165			'<ssp:Chunk xmlns:ssp="urn:x-simplesamlphp:namespace">originator</ssp:Chunk>',
166			)->documentElement),
167			],
168			'fed321',
169			);
170
171			$recipientKeyInfo = new RecipientKeyInfo(
172			[
173			new KeyName('testkey'),
174			new X509Data(
175			[
176			new X509Certificate(self::$certificate),
177			new X509SubjectName(self::$certData['name']),
178			],
179			),
180			new Chunk(DOMDocumentFactory::fromString(
181			'<ssp:Chunk xmlns:ssp="urn:x-simplesamlphp:namespace">recipient</ssp:Chunk>',
182			)->documentElement),
183			],
184			'fed654',
185			);
186
187			$agreementMethod = new AgreementMethod(
188			C::XMLENC11_ECDH_ES,
189			$kaNonce,
190			$originatorKeyInfo,
191			$recipientKeyInfo,
192			[$digestMethod],
193			);
194
195			// Marshall it to a \DOMElement
196			$agreementMethodElement = $agreementMethod->toXML();
197
198			$xpCache = XPath::getXPath($agreementMethodElement);
199
200			// Test for an KA-Nonce
201			/** @var \DOMElement[] $kaNonceElements */
202			$kaNonceElements = XPath::xpQuery($agreementMethodElement, './xenc:KA-Nonce', $xpCache);
203			$this->assertCount(1, $kaNonceElements);
204
205			// Test ordering of AgreementMethod contents
206			/** @var \DOMElement[] $agreementMethodElements */
207			$agreementMethodElements = XPath::xpQuery(
208			$agreementMethodElement,
209			'./xenc:KA-Nonce/following-sibling::*',
210			$xpCache,
211			);
212
213			$this->assertCount(3, $agreementMethodElements);
214			$this->assertEquals('ds:DigestMethod', $agreementMethodElements[0]->tagName);
215			$this->assertEquals('xenc:OriginatorKeyInfo', $agreementMethodElements[1]->tagName);
216			$this->assertEquals('xenc:RecipientKeyInfo', $agreementMethodElements[2]->tagName);
217			}
218			}
219

simplesamlphp / xml-security

Pull Request — master (#61)

AgreementMethodTest::testMarshallingElementOrdering() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like