SimpleSAML\Module\monitor\TestSuite\Modules\ModuleSet

Complexity

Total Complexity

15

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Importance

Changes	9
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	setTestCase()	0	4	1
A	setDependencies()	0	4	1
A	setType()	0	4	1
A	initialize()	0	8	1
A	setAvailable()	0	4	1
A	setRequired()	0	4	1
D	invokeTest()	0	40	9

<?php

namespace SimpleSAML\Module\monitor\TestSuite\Modules;

use \SimpleSAML\Module\monitor\State as State;
use \SimpleSAML\Module\monitor\TestCaseFactory as TestCaseFactory;
use \SimpleSAML\Module\monitor\TestData as TestData;

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

    /**
     * @var array
     */
    private $available;
 
    /**
     * @var array
     */
    private $dependencies;

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

    /**
     * @var TestCaseFactory
     */
    private $testCase;

    /**
     * @param TestData $testData
     *
     * @return void
     */
    protected function initialize($testData)
    {
        $this->setRequired($testData->getInput('required'));
        $this->setAvailable($testData->getInput('available'));
        $this->setDependencies($testData->getInput('dependencies'));
        $this->setType($testData->getInput('type'));
        $this->setTestCase($testData->getInput('testCase'));
        $this->setCategory($this->type.' modules');

Are you sure $this->type of type null|mixed|array can be used in concatenation?

    }

    /**
     * @param array
     */
    private function setRequired($required)
    {
        assert(is_array($required));
        $this->required = $required;
    }


    /**
     * @param array
     */
    private function setAvailable($available)
    {
        assert(is_array($available));
        $this->available = $available;
    }


    /**
     * @param array
     */
    private function setDependencies($dependencies)
    {
        assert(is_array($dependencies));
        $this->dependencies = $dependencies;
    }


    /**
     * @param string
     */
    private function setType($type)
    {
        assert(is_string($type));
        $this->type = $type;
    }


    /**
     * @param TestCase
     */
    private function setTestCase($testCase)
    {
        assert($testCase instanceof TestCaseFactory);
        $this->testCase = $testCase;
    }

    
    /**
     * @return void
     */
    public function invokeTest()
    {
        if (empty($this->available)) {
            $state = State::SKIPPED;
        } else {
            foreach ($this->required as $module) {
                $testData = new TestData([
                    'required' => $module,
                    'available' => $this->available
                ]);
        
                $moduleTest = new $this->testCase($this, $testData);
                $moduleTestResult = $moduleTest->getTestResult();
                if ($moduleTestResult->getState() !== State::OK) {
                    $missing = array();
                    while ($dependency = array_search($this->required, $this->dependencies)) {
                        if (\SimpleSAML\Module::isModuleEnabled($dependency)) {
                            $missing[] = $dependency;
                        }
                        unset($dependencies[$dependency]);

The variable $dependencies does not exist. Did you maybe mean $dependency?

                    }
                    if (!empty($missing)) {
                        $moduleTestResult->setSubject($moduleTest->getModuleName());
                        $moduleTestResult->setMessage('Module not loaded; dependency for ' . implode(', ', $missing));
                    }
                    $this->addTestResult($moduleTestResult);
                }
            }
             $state = $this->calculateState();
        }

        $testResult = new TestResult($this->type, implode(', ', $this->required));       

The type SimpleSAML\Module\monitor\TestSuite\Modules\TestResult was not found. Maybe you did not declare it correctly or list all dependencies?

        if ($state === State::OK) {
            $testResult->setMessage('All required modules are loaded');
        } elseif ($state === State::SKIPPED) {
            $testResult->setMessage('Unable to verify installed modules');
        } else {
            $testResult->setMessage('Not all required modules are loaded');
        }
        $this->setTestResult($testResult);
    }
}