Modules::setRequiredSspModules() - Code Metrics - Inspection of "Add \\ to namespace" - tvdijen/simplesamlphp-module-monitor - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — feature-unit-tests (9d0273)

by Tim

created 2018-05-11 17:55 UTC

Modules::setRequiredSspModules() B

↳ Parent: Modules

Complexity

Conditions	7
Paths	8

Size

Total Lines	15
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	11
c	0
b	0
f	0
nc	8
nop	0
dl	0
loc	15
rs	8.2222

<?php

namespace SimpleSAML\Module\monitor\TestSuite;

use \SimpleSAML\Module\monitor\TestConfiguration as TestConfiguration;
use \SimpleSAML\Module\monitor\State as State;
use \SimpleSAML\Module\monitor\TestCase as TestCase;
use \SimpleSAML\Module\monitor\TestData as TestData;
use \SimpleSAML\Module\monitor\TestResult as TestResult;

class Modules extends \SimpleSAML\Module\monitor\TestSuiteFactory
{
    /**
     * @var array
     */
    private $requiredApacheModules = array();

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

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

    /**
     * @var array
     */
    private $requiredPhpModules = array();

    /**
     * @var array
     */
    private $storePhpDependencies = array(
        'memcache' => 'memcached|memcache',
        'phpsession' => 'session',
        'redis' => 'redis',
        'redissentinel' => 'redis',
        'riak:Store' => 'riak',
        'sql' => 'PDO'
    );

    /**
     * @var array
     */
    private $modulePhpDependencies = array(
        'authfacebook' => array('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',
        'riak' => 'riak',
        'sqlauth' => 'PDO'
    );

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


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


    /**
     * @return void
     */
    private function setRequiredApacheModules()
    {
        // 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]);
        }
    }


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


    /**
     * @return void
     */
    private function setRequiredPhpModules()
    {
        // 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()
    {
        $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()
    {
        $configuration = $this->getConfiguration();
        return $configuration->getAvailableApacheModules();
    }

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

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


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


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

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

tvdijen / simplesamlphp-module-monitor

Branch — feature-unit-tests (9d0273)

Modules::setRequiredSspModules() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like