Modules::invokeTest() - Code Metrics - Inspection of "Monitor 3.0.x (#21)" - tvdijen/simplesamlphp-module-monitor - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (4b23d6)

by Tim

created 2019-10-25 15:02 UTC

Modules::invokeTest() A

↳ Parent: Modules

Complexity

Conditions	1
Paths	1

Size

Total Lines	31
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	20
dl	0
loc	31
rs	9.6
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace SimpleSAML\Module\Monitor\TestSuite;

use SimpleSAML\Module\Monitor\TestConfiguration;
use SimpleSAML\Module\Monitor\State;
use SimpleSAML\Module\Monitor\TestCase;
use SimpleSAML\Module\Monitor\TestData;
use SimpleSAML\Module\Monitor\TestResult;

class Modules extends \SimpleSAML\Module\Monitor\TestSuiteFactory
{
    /** @var array */
    private $requiredApacheModules = [];

    // Important!!  Modules-names are handled case-sensitive!!
    /** @var array */
    private $storeApacheDependencies = [];

    /** @var array */
    private $moduleApacheDependencies = [
        'negotiateext' => 'mod_auth_kerb|mod_auth_gssapi'
    ];

    /** @var array */
    private $requiredPhpModules = [];

    /** @var array */
    private $storePhpDependencies = [
        'memcache' => 'memcached|memcache',
        'phpsession' => 'session',
        'sql' => 'PDO'
    ];

    /** @var array */
    private $modulePhpDependencies = [
        'authfacebook' => ['curl', 'json'],
        'authYubiKey' => 'curl',
// TODO: consent only requires pdo when database backend is used..
//       Should probably add this to required-list when processing metadata
//        'consent' => 'PDO',
        'consentAdmin' => 'PDO',
        'ldap' => 'ldap',
        'memcacheMonitor' => 'memcached|memcache',
        'negotiate' => 'krb5',
        'radius' => 'radius',
        'sqlauth' => 'PDO'
    ];


    /**
     * @param \SimpleSAML\Module\Monitor\TestData|null $testData
     *
     * @return void
     */
    protected function initialize(TestData $testData = null): void
    {
        $this->setRequiredApacheModules();
        $this->setRequiredPhpModules();
        $this->setRequiredSspModules();
        $this->setCategory('Modules');

        parent::initialize($testData);
    }


    /**
     * @param string $module
     *
     * @return void
     */
    private function addRequiredApacheModule(string $module): void
    {
        if (!in_array($module, $this->requiredApacheModules)) {
            $this->requiredApacheModules[] = $module;
        }
    }


    /**
     * @return void
     */
    private function setRequiredApacheModules(): void
    {
        // Apache Modules
        if (function_exists('apache_get_modules')) {
            $this->addRequiredApacheModule('mod_php|mod_php5|mod_php7');
        }
        if (\SimpleSAML\Utils\HTTP::isHTTPS()) {
            $this->addRequiredApacheModule('mod_ssl');
        }

        // Determine extra required modules
        $configuration = $this->getConfiguration();
        $globalConfig = $configuration->getGlobalConfig();
        $store = $globalConfig->getValue('store.type');
        if (array_key_exists($store, $this->storeApacheDependencies)) {
            $this->addRequiredApacheModule($this->storeApacheDependencies[$store]);
        }
    }


    /**
     * @param string $module
     *
     * @return void
     */
    private function addRequiredPhpModule(string $module): void
    {
        if (!in_array($module, $this->requiredPhpModules)) {
            $this->requiredPhpModules[] = $module;
        }
    }


    /**
     * @return void
     */
    private function setRequiredPhpModules(): void
    {
        // PHP modules required
        $composerFile = \SimpleSAML\Utils\System::resolvePath('composer.json');
        $composerData = file_get_contents($composerFile);
        $composer = json_decode($composerData, true);
        $composerRequired = $composer['require'];

        foreach ($composerRequired as $ext => $ver) {
            if (preg_match('/^ext-/', $ext)) {
                $this->addRequiredPhpModule(substr($ext, 4));
            }
        }

        // Determine extra required modules
        $configuration = $this->getConfiguration();
        $globalConfig = $configuration->getGlobalConfig();
        $store = $globalConfig->getValue('store.type');
        if (array_key_exists($store, $this->storePhpDependencies)) {
            $this->addRequiredPhpModule($this->storePhpDependencies[$store]);
        }
    }


    /**
     * @return void
     */
    private function setRequiredSspModules(): void
    {
        $modules = \SimpleSAML\Module::getModules();
        foreach ($modules as $module) {
            if (\SimpleSAML\Module::isModuleEnabled($module)) {
                if (array_key_exists($module, $this->moduleApacheDependencies)) {
                    $dependencies = \SimpleSAML\Utils\Arrays::Arrayize($this->moduleApacheDependencies[$module]);
                    foreach ($dependencies as $dependency) {
                        $this->addRequiredApacheModule($dependency);
                    }
                }
                if (array_key_exists($module, $this->modulePhpDependencies)) {
                    $dependencies = \SimpleSAML\Utils\Arrays::Arrayize($this->modulePhpDependencies[$module]);
                    foreach ($dependencies as $dependency) {
                        $this->addRequiredPhpModule($dependency);
                    }
                }
            }
        }
    }


    /**
     * @return array
     */
    public function getAvailableApacheModules(): array
    {
        $configuration = $this->getConfiguration();
        return $configuration->getAvailableApacheModules();
    }


    /**
     * @return array
     */
    public function getAvailablePhpModules(): array
    {
        $configuration = $this->getConfiguration();
        return $configuration->getAvailablePhpModules();
    }


    /**
     * @return array
     */
    private function getRequiredApacheModules(): array
    {
        return $this->requiredApacheModules;
    }


    /**
     * @return array
     */
    private function getRequiredPhpModules(): array
    {
        return $this->requiredPhpModules;
    }


    /**
     * @return void
     */
    public function invokeTest(): void
    {
        $configuration = $this->getConfiguration();

        // Test Apache modules
        $testData = new TestData([
            'available' => $configuration->getAvailableApacheModules(),
            'required' => $this->getRequiredApacheModules(),
            'dependencies' => $this->moduleApacheDependencies,
            'type' => 'Apache',
        ]);
        $apacheTest = new Modules\ModuleSet($configuration, $testData);
        $apacheTestResult = $apacheTest->getTestResult();
        
         // Test Php modules
        $testData = new TestData([
            'available' => $configuration->getAvailablePhpModules(),
            'required' => $this->getRequiredPhpModules(),
            'dependencies' => $this->modulePhpDependencies,
            'type' => 'Php',
        ]);
        $phpTest = new Modules\ModuleSet($configuration, $testData);
        $phpTestResult = $phpTest->getTestResult();

        $this->addTestResult($apacheTestResult);
        $this->addTestResult($phpTestResult);

        $testResult = new TestResult('Modules', '');
        $testResult->setState($this->calculateState());
        
        $this->setTestResult($testResult);
    }
}


1			<?php
2
3			namespace SimpleSAML\Module\Monitor\TestSuite;
4
5			use SimpleSAML\Module\Monitor\TestConfiguration;
6			use SimpleSAML\Module\Monitor\State;
7			use SimpleSAML\Module\Monitor\TestCase;
8			use SimpleSAML\Module\Monitor\TestData;
9			use SimpleSAML\Module\Monitor\TestResult;
10
11			class Modules extends \SimpleSAML\Module\Monitor\TestSuiteFactory
12			{
13			/** @var array */
14			private $requiredApacheModules = [];
15
16			// Important!! Modules-names are handled case-sensitive!!
17			/** @var array */
18			private $storeApacheDependencies = [];
19
20			/** @var array */
21			private $moduleApacheDependencies = [
22			'negotiateext' => 'mod_auth_kerb\|mod_auth_gssapi'
23			];
24
25			/** @var array */
26			private $requiredPhpModules = [];
27
28			/** @var array */
29			private $storePhpDependencies = [
30			'memcache' => 'memcached\|memcache',
31			'phpsession' => 'session',
32			'sql' => 'PDO'
33			];
34
35			/** @var array */
36			private $modulePhpDependencies = [
37			'authfacebook' => ['curl', 'json'],
38			'authYubiKey' => 'curl',
39			// TODO: consent only requires pdo when database backend is used..
40			// Should probably add this to required-list when processing metadata
41			// 'consent' => 'PDO',
42			'consentAdmin' => 'PDO',
43			'ldap' => 'ldap',
44			'memcacheMonitor' => 'memcached\|memcache',
45			'negotiate' => 'krb5',
46			'radius' => 'radius',
47			'sqlauth' => 'PDO'
48			];
49
50
51			/**
52			* @param \SimpleSAML\Module\Monitor\TestData\|null $testData
53			*
54			* @return void
55			*/
56			protected function initialize(TestData $testData = null): void
57			{
58			$this->setRequiredApacheModules();
59			$this->setRequiredPhpModules();
60			$this->setRequiredSspModules();
61			$this->setCategory('Modules');
62
63			parent::initialize($testData);
64			}
65
66
67			/**
68			* @param string $module
69			*
70			* @return void
71			*/
72			private function addRequiredApacheModule(string $module): void
73			{
74			if (!in_array($module, $this->requiredApacheModules)) {
75			$this->requiredApacheModules[] = $module;
76			}
77			}
78
79
80			/**
81			* @return void
82			*/
83			private function setRequiredApacheModules(): void
84			{
85			// Apache Modules
86			if (function_exists('apache_get_modules')) {
87			$this->addRequiredApacheModule('mod_php\|mod_php5\|mod_php7');
88			}
89			if (\SimpleSAML\Utils\HTTP::isHTTPS()) {
90			$this->addRequiredApacheModule('mod_ssl');
91			}
92
93			// Determine extra required modules
94			$configuration = $this->getConfiguration();
95			$globalConfig = $configuration->getGlobalConfig();
96			$store = $globalConfig->getValue('store.type');
97			if (array_key_exists($store, $this->storeApacheDependencies)) {
98			$this->addRequiredApacheModule($this->storeApacheDependencies[$store]);
99			}
100			}
101
102
103			/**
104			* @param string $module
105			*
106			* @return void
107			*/
108			private function addRequiredPhpModule(string $module): void
109			{
110			if (!in_array($module, $this->requiredPhpModules)) {
111			$this->requiredPhpModules[] = $module;
112			}
113			}
114
115
116			/**
117			* @return void
118			*/
119			private function setRequiredPhpModules(): void
120			{
121			// PHP modules required
122			$composerFile = \SimpleSAML\Utils\System::resolvePath('composer.json');
123			$composerData = file_get_contents($composerFile);
124			$composer = json_decode($composerData, true);
125			$composerRequired = $composer['require'];
126
127			foreach ($composerRequired as $ext => $ver) {
128			if (preg_match('/^ext-/', $ext)) {
129			$this->addRequiredPhpModule(substr($ext, 4));
130			}
131			}
132
133			// Determine extra required modules
134			$configuration = $this->getConfiguration();
135			$globalConfig = $configuration->getGlobalConfig();
136			$store = $globalConfig->getValue('store.type');
137			if (array_key_exists($store, $this->storePhpDependencies)) {
138			$this->addRequiredPhpModule($this->storePhpDependencies[$store]);
139			}
140			}
141
142
143			/**
144			* @return void
145			*/
146			private function setRequiredSspModules(): void
147			{
148			$modules = \SimpleSAML\Module::getModules();
149			foreach ($modules as $module) {
150			if (\SimpleSAML\Module::isModuleEnabled($module)) {
151			if (array_key_exists($module, $this->moduleApacheDependencies)) {
152			$dependencies = \SimpleSAML\Utils\Arrays::Arrayize($this->moduleApacheDependencies[$module]);
153			foreach ($dependencies as $dependency) {
154			$this->addRequiredApacheModule($dependency);
155			}
156			}
157			if (array_key_exists($module, $this->modulePhpDependencies)) {
158			$dependencies = \SimpleSAML\Utils\Arrays::Arrayize($this->modulePhpDependencies[$module]);
159			foreach ($dependencies as $dependency) {
160			$this->addRequiredPhpModule($dependency);
161			}
162			}
163			}
164			}
165			}
166
167
168			/**
169			* @return array
170			*/
171			public function getAvailableApacheModules(): array
172			{
173			$configuration = $this->getConfiguration();
174			return $configuration->getAvailableApacheModules();
175			}
176
177
178			/**
179			* @return array
180			*/
181			public function getAvailablePhpModules(): array
182			{
183			$configuration = $this->getConfiguration();
184			return $configuration->getAvailablePhpModules();
185			}
186
187
188			/**
189			* @return array
190			*/
191			private function getRequiredApacheModules(): array
192			{
193			return $this->requiredApacheModules;
194			}
195
196
197			/**
198			* @return array
199			*/
200			private function getRequiredPhpModules(): array
201			{
202			return $this->requiredPhpModules;
203			}
204
205
206			/**
207			* @return void
208			*/
209			public function invokeTest(): void
210			{
211			$configuration = $this->getConfiguration();
212
213			// Test Apache modules
214			$testData = new TestData([
215			'available' => $configuration->getAvailableApacheModules(),
216			'required' => $this->getRequiredApacheModules(),
217			'dependencies' => $this->moduleApacheDependencies,
218			'type' => 'Apache',
219			]);
220			$apacheTest = new Modules\ModuleSet($configuration, $testData);
221			$apacheTestResult = $apacheTest->getTestResult();
222
223			// Test Php modules
224			$testData = new TestData([
225			'available' => $configuration->getAvailablePhpModules(),
226			'required' => $this->getRequiredPhpModules(),
227			'dependencies' => $this->modulePhpDependencies,
228			'type' => 'Php',
229			]);
230			$phpTest = new Modules\ModuleSet($configuration, $testData);
231			$phpTestResult = $phpTest->getTestResult();
232
233			$this->addTestResult($apacheTestResult);
234			$this->addTestResult($phpTestResult);
235
236			$testResult = new TestResult('Modules', '');
237			$testResult->setState($this->calculateState());
238
239			$this->setTestResult($testResult);
240			}
241			}
242

tvdijen / simplesamlphp-module-monitor

Branch — master (4b23d6)

Modules::invokeTest() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like