ConfigManifestTest::setUp() - Code Metrics - Inspection of "API Substitute silverstripe/config module for core..." - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#6641)

by Damian

created 2017-02-27 21:50 UTC

ConfigManifestTest::setUp() A

↳ Parent: ConfigManifestTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	7
rs	9.4285
c	1
b	0
f	0

<?php

namespace SilverStripe\Core\Tests\Manifest;

use Dotenv\Loader;
use SilverStripe\Config\Collections\MemoryConfigCollection;
use SilverStripe\Control\Director;
use SilverStripe\Core\Config\CoreConfigFactory;
use SilverStripe\Core\Manifest\ModuleLoader;
use SilverStripe\Core\Manifest\ModuleManifest;
use SilverStripe\Dev\SapphireTest;

class ConfigManifestTest extends SapphireTest
{
    public function setUp()
    {
        parent::setUp();

        $moduleManifest = new ModuleManifest(dirname(__FILE__) . '/fixtures/configmanifest');
        ModuleLoader::instance()->pushManifest($moduleManifest);
    }

    public function tearDown()
    {
        ModuleLoader::instance()->popManifest();
        parent::tearDown();
    }

    /**
     * This is a helper method for getting a new manifest
     *
     * @param string $name
     * @return mixed
     */
    protected function getConfigFixtureValue($name)
    {
        return $this->getTestConfig()->get(__CLASS__, $name);
    }

    /**
     * Build a new config based on YMl manifest
     *
     * @return MemoryConfigCollection
     */
    public function getTestConfig()
    {
        $config = new MemoryConfigCollection();
        $transformer = CoreConfigFactory::inst()->buildYamlTransformerForPath(dirname(__FILE__) . '/fixtures/configmanifest');
        $config->transform([$transformer]);
        return $config;
    }

    /**
     * This is a helper method for displaying a relevant message about a parsing failure
     *
     * @param string $path
     * @return string
     */
    protected function getParsedAsMessage($path)
    {
        return sprintf('Reference path "%s" failed to parse correctly', $path);
    }

    public function testClassRules()
    {
        $config = $this->getConfigFixtureValue('Class');

        $this->assertEquals(
            'Yes',
            @$config['DirectorExists'],
            'Only rule correctly detects existing class'
        );

        $this->assertEquals(
            'No',
            @$config['NoSuchClassExists'],
            'Except rule correctly detects missing class'
        );
    }

    public function testModuleRules()
    {
        $config = $this->getConfigFixtureValue('Module');

        $this->assertEquals(
            'Yes',
            @$config['MysiteExists'],
            'Only rule correctly detects existing module'
        );

        $this->assertEquals(
            'No',
            @$config['NoSuchModuleExists'],
            'Except rule correctly detects missing module'
        );
    }

    public function testEnvVarSetRules()
    {
        $loader = new Loader(null);
        $loader->setEnvironmentVariable('ENVVARSET_FOO', 1);
        $config = $this->getConfigFixtureValue('EnvVarSet');

        $this->assertEquals(
            'Yes',
            @$config['FooSet'],
            'Only rule correctly detects set environment variable'
        );

        $this->assertEquals(
            'No',
            @$config['BarSet'],
            'Except rule correctly detects unset environment variable'
        );
    }

    public function testConstantDefinedRules()
    {
        define('CONSTANTDEFINED_FOO', 1);
        $config = $this->getConfigFixtureValue('ConstantDefined');

        $this->assertEquals(
            'Yes',
            @$config['FooDefined'],
            'Only rule correctly detects defined constant'
        );

        $this->assertEquals(
            'No',
            @$config['BarDefined'],
            'Except rule correctly detects undefined constant'
        );
    }

    public function testEnvOrConstantMatchesValueRules()
    {
        $loader = new Loader(null);

        $loader->setEnvironmentVariable('CONSTANTMATCHESVALUE_FOO', 'Foo');
        define('CONSTANTMATCHESVALUE_BAR', 'Bar');
        $config = $this->getConfigFixtureValue('EnvOrConstantMatchesValue');

        $this->assertEquals(
            'Yes',
            @$config['FooIsFoo'],
            'Only rule correctly detects environment variable matches specified value'
        );

        $this->assertEquals(
            'Yes',
            @$config['BarIsBar'],
            'Only rule correctly detects constant matches specified value'
        );

        $this->assertEquals(
            'No',
            @$config['FooIsQux'],
            'Except rule correctly detects environment variable that doesn\'t match specified value'
        );

        $this->assertEquals(
            'No',
            @$config['BarIsQux'],
            'Except rule correctly detects environment variable that doesn\'t match specified value'
        );

        $this->assertEquals(
            'No',
            @$config['BazIsBaz'],
            'Except rule correctly detects undefined variable'
        );
    }

    public function testEnvironmentRules()
    {
        foreach (array('dev', 'test', 'live') as $env) {
            Director::set_environment_type($env);
            $config = $this->getConfigFixtureValue('Environment');

            foreach (array('dev', 'test', 'live') as $check) {
                $this->assertEquals(
                    $env == $check ? $check : 'not'.$check,
                    @$config[ucfirst($check).'Environment'],
                    'Only & except rules correctly detect environment in env ' . $env
                );
            }
        }
    }

    public function testMultipleRules()
    {
        $loader = new Loader(null);

        $loader->setEnvironmentVariable('MULTIPLERULES_ENVVARIABLESET', 1);
        define('MULTIPLERULES_DEFINEDCONSTANT', 'defined');
        $config = $this->getConfigFixtureValue('MultipleRules');

        $this->assertFalse(
            isset($config['TwoOnlyFail']),
            'Fragment is not included if one of the Only rules fails.'
        );

        $this->assertTrue(
            isset($config['TwoOnlySucceed']),
            'Fragment is included if both Only rules succeed.'
        );

        $this->assertTrue(
            isset($config['TwoExceptSucceed']),
            'Fragment is included if one of the Except rules matches.'
        );

        $this->assertFalse(
            isset($config['TwoExceptFail']),
            'Fragment is not included if both of the Except rules fail.'
        );

        $this->assertFalse(
            isset($config['TwoBlocksFail']),
            'Fragment is not included if one block fails.'
        );

        $this->assertTrue(
            isset($config['TwoBlocksSucceed']),
            'Fragment is included if both blocks succeed.'
        );
    }
}


1			<?php
2
3			namespace SilverStripe\Core\Tests\Manifest;
4
5			use Dotenv\Loader;
6			use SilverStripe\Config\Collections\MemoryConfigCollection;
7			use SilverStripe\Control\Director;
8			use SilverStripe\Core\Config\CoreConfigFactory;
9			use SilverStripe\Core\Manifest\ModuleLoader;
10			use SilverStripe\Core\Manifest\ModuleManifest;
11			use SilverStripe\Dev\SapphireTest;
12
13			class ConfigManifestTest extends SapphireTest
14			{
15			public function setUp()
16			{
17			parent::setUp();
18
19			$moduleManifest = new ModuleManifest(dirname(__FILE__) . '/fixtures/configmanifest');
20			ModuleLoader::instance()->pushManifest($moduleManifest);
21			}
22
23			public function tearDown()
24			{
25			ModuleLoader::instance()->popManifest();
26			parent::tearDown();
27			}
28
29			/**
30			* This is a helper method for getting a new manifest
31			*
32			* @param string $name
33			* @return mixed
34			*/
35			protected function getConfigFixtureValue($name)
36			{
37			return $this->getTestConfig()->get(__CLASS__, $name);
38			}
39
40			/**
41			* Build a new config based on YMl manifest
42			*
43			* @return MemoryConfigCollection
44			*/
45			public function getTestConfig()
46			{
47			$config = new MemoryConfigCollection();
48			$transformer = CoreConfigFactory::inst()->buildYamlTransformerForPath(dirname(__FILE__) . '/fixtures/configmanifest');
49			$config->transform([$transformer]);
50			return $config;
51			}
52
53			/**
54			* This is a helper method for displaying a relevant message about a parsing failure
55			*
56			* @param string $path
57			* @return string
58			*/
59			protected function getParsedAsMessage($path)
60			{
61			return sprintf('Reference path "%s" failed to parse correctly', $path);
62			}
63
64			public function testClassRules()
65			{
66			$config = $this->getConfigFixtureValue('Class');
67
68			$this->assertEquals(
69			'Yes',
70			@$config['DirectorExists'],
71			'Only rule correctly detects existing class'
72			);
73
74			$this->assertEquals(
75			'No',
76			@$config['NoSuchClassExists'],
77			'Except rule correctly detects missing class'
78			);
79			}
80
81			public function testModuleRules()
82			{
83			$config = $this->getConfigFixtureValue('Module');
84
85			$this->assertEquals(
86			'Yes',
87			@$config['MysiteExists'],
88			'Only rule correctly detects existing module'
89			);
90
91			$this->assertEquals(
92			'No',
93			@$config['NoSuchModuleExists'],
94			'Except rule correctly detects missing module'
95			);
96			}
97
98			public function testEnvVarSetRules()
99			{
100			$loader = new Loader(null);
101			$loader->setEnvironmentVariable('ENVVARSET_FOO', 1);
102			$config = $this->getConfigFixtureValue('EnvVarSet');
103
104			$this->assertEquals(
105			'Yes',
106			@$config['FooSet'],
107			'Only rule correctly detects set environment variable'
108			);
109
110			$this->assertEquals(
111			'No',
112			@$config['BarSet'],
113			'Except rule correctly detects unset environment variable'
114			);
115			}
116
117			public function testConstantDefinedRules()
118			{
119			define('CONSTANTDEFINED_FOO', 1);
120			$config = $this->getConfigFixtureValue('ConstantDefined');
121
122			$this->assertEquals(
123			'Yes',
124			@$config['FooDefined'],
125			'Only rule correctly detects defined constant'
126			);
127
128			$this->assertEquals(
129			'No',
130			@$config['BarDefined'],
131			'Except rule correctly detects undefined constant'
132			);
133			}
134
135			public function testEnvOrConstantMatchesValueRules()
136			{
137			$loader = new Loader(null);
138
139			$loader->setEnvironmentVariable('CONSTANTMATCHESVALUE_FOO', 'Foo');
140			define('CONSTANTMATCHESVALUE_BAR', 'Bar');
141			$config = $this->getConfigFixtureValue('EnvOrConstantMatchesValue');
142
143			$this->assertEquals(
144			'Yes',
145			@$config['FooIsFoo'],
146			'Only rule correctly detects environment variable matches specified value'
147			);
148
149			$this->assertEquals(
150			'Yes',
151			@$config['BarIsBar'],
152			'Only rule correctly detects constant matches specified value'
153			);
154
155			$this->assertEquals(
156			'No',
157			@$config['FooIsQux'],
158			'Except rule correctly detects environment variable that doesn\'t match specified value'
159			);
160
161			$this->assertEquals(
162			'No',
163			@$config['BarIsQux'],
164			'Except rule correctly detects environment variable that doesn\'t match specified value'
165			);
166
167			$this->assertEquals(
168			'No',
169			@$config['BazIsBaz'],
170			'Except rule correctly detects undefined variable'
171			);
172			}
173
174			public function testEnvironmentRules()
175			{
176			foreach (array('dev', 'test', 'live') as $env) {
177			Director::set_environment_type($env);
178			$config = $this->getConfigFixtureValue('Environment');
179
180			foreach (array('dev', 'test', 'live') as $check) {
181			$this->assertEquals(
182			$env == $check ? $check : 'not'.$check,
183			@$config[ucfirst($check).'Environment'],
184			'Only & except rules correctly detect environment in env ' . $env
185			);
186			}
187			}
188			}
189
190			public function testMultipleRules()
191			{
192			$loader = new Loader(null);
193
194			$loader->setEnvironmentVariable('MULTIPLERULES_ENVVARIABLESET', 1);
195			define('MULTIPLERULES_DEFINEDCONSTANT', 'defined');
196			$config = $this->getConfigFixtureValue('MultipleRules');
197
198			$this->assertFalse(
199			isset($config['TwoOnlyFail']),
200			'Fragment is not included if one of the Only rules fails.'
201			);
202
203			$this->assertTrue(
204			isset($config['TwoOnlySucceed']),
205			'Fragment is included if both Only rules succeed.'
206			);
207
208			$this->assertTrue(
209			isset($config['TwoExceptSucceed']),
210			'Fragment is included if one of the Except rules matches.'
211			);
212
213			$this->assertFalse(
214			isset($config['TwoExceptFail']),
215			'Fragment is not included if both of the Except rules fail.'
216			);
217
218			$this->assertFalse(
219			isset($config['TwoBlocksFail']),
220			'Fragment is not included if one block fails.'
221			);
222
223			$this->assertTrue(
224			isset($config['TwoBlocksSucceed']),
225			'Fragment is included if both blocks succeed.'
226			);
227			}
228			}
229

silverstripe / silverstripe-framework

Pull Request — master (#6641)

ConfigManifestTest::setUp() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like