SimpleSAML\Module\monitor\TestSuite\Metadata\Entity

Complexity

Total Complexity

16

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getEncryption()	0	3	2
A	getType()	0	10	5
B	invokeTest()	0	67	6
A	getSigning()	0	3	2
A	__construct()	0	15	1

<?php

declare(strict_types=1);

namespace SimpleSAML\Module\monitor\TestSuite\Metadata;

use SimpleSAML\Assert\Assert;
use SimpleSAML\Module\monitor\State;
use SimpleSAML\Module\monitor\TestConfiguration;
use SimpleSAML\Module\monitor\TestCase;
use SimpleSAML\Module\monitor\TestData;
use SimpleSAML\Module\monitor\TestResult;
use SimpleSAML\Utils;

use function array_filter;
use function array_key_exists;
use function chunk_split;

final class Entity extends \SimpleSAML\Module\monitor\TestSuiteFactory
{
    /** @var array */
    private array $entityMetadata;

    /** @var string */
    private string $entityId;

    /** @var integer|null */
    private ?int $certExpirationWarning = null;


    /**
     * @param \SimpleSAML\Module\monitor\TestConfiguration $configuration
     * @param \SimpleSAML\Module\monitor\TestData $testData
     */
    public function __construct(TestConfiguration $configuration, TestData $testData)
    {
        $moduleConfig = $configuration->getModuleConfig();
        $entityMetadata = $testData->getInputItem('entityMetadata');
        $entityId = $testData->getInputItem('entityId');

        Assert::isArray($entityMetadata);
        Assert::string($entityId);

        $this->certExpirationWarning = $moduleConfig->getOptionalValue('certExpirationWarning', 28);
        $this->entityMetadata = $entityMetadata;
        $this->entityId = $entityId;

        $this->setCategory('Metadata entity');
        parent::__construct($configuration);
    }


    /**
     * @return void
     */
    public function invokeTest(): void
    {
        $input = [
            'entityId' => $this->entityId,
            'entityMetadata' => $this->entityMetadata,
        ];
        $testData = new TestData($input);

        $expTest = new TestCase\Metadata\Expiration($testData);
        $expTestResult = $expTest->getTestResult();
        $expTestResult->setSubject($this->entityId);
        $this->addTestResult($expTestResult);

        if (array_key_exists('keys', $this->entityMetadata)) {
            $keys = $this->entityMetadata['keys'];


            $signing = array_filter($keys, [self::class, 'getSigning']);

The assignment to $signing is dead and can be removed.

            $encryption = array_filter($keys, [self::class, 'getEncryption']);

The assignment to $encryption is dead and can be removed.

            foreach ($keys as $key) {
                $input = [
                    'category' => $this->getType($key),
                    'certData' => "-----BEGIN CERTIFICATE-----\n"
                        . chunk_split($key['X509Certificate'], 64)
                        . "-----END CERTIFICATE-----\n",
                    'certExpirationWarning' => $this->certExpirationWarning,
                ];
                $testData = new TestData($input);

                $certTest = new TestCase\Cert\Data($testData);
                $certTestResult = $certTest->getTestResult();

                $this->addTestResult($certTestResult);
            }
        } else {
            // saml20-idp-hosted
            $files = [];
            if (array_key_exists('certificate', $this->entityMetadata)) {
                $files[] = $this->entityMetadata['certificate'];
            }
            if (array_key_exists('new_certificate', $this->entityMetadata)) {
                $files[] = $this->entityMetadata['new_certificate'];
            }

            $configUtils = new Utils\Config();
            foreach ($files as $file) {
                $input = [
                    'category' => $this->getType(['signing' => true, 'encryption' => false]),
                    'certFile' => $configUtils->getCertPath($file),
                    'certExpirationWarning' => $this->certExpirationWarning,
                ];

                $testData = new TestData($input);

                $certTest = new TestCase\Cert\File($testData);
                $certTestResult = $certTest->getTestResult();

                $this->addTestResult($certTestResult);
            }
        }

        $state = $this->calculateState();

        $testResult = new TestResult('Metadata endpoint');
        $testResult->setState($state);
        $this->setTestResult($testResult);
    }


    /**
     * @param array $key
     * @return bool
     */
    private function getSigning(array $key): bool
    {
        return ($key['signing'] === true) && ($key['encryption'] === false);
    }


    /**
     * @param array $key
     * @return bool
     */
    private function getEncryption(array $key): bool
    {
        return ($key['signing'] === false) && ($key['encryption'] === true);
    }


    /**
     * @param array $key
     *
     * @return string
     */
    public function getType(array $key): string
    {
        if ($key['encryption'] === true && $key['signing'] === false) {
            $category = 'Encryption certificate';
        } elseif ($key['encryption'] === false && $key['signing'] === true) {
            $category = 'Signing certificate';
        } else {
            $category = 'Unknown type';
        }
        return $category;
    }
}