EnvTest::testUnsetVariables() - Code Metrics - Inspection of "... add php 5.3 unit tests to local ci" - ktomk/pipelines - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — test ( d838cf...cef4a5 )

by Tom

created 2020-12-11 01:43 UTC

EnvTest::testUnsetVariables() A

↳ Parent: EnvTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	0
dl	0
loc	11
rs	10
c	0
b	0
f	0

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\Runner;

use Ktomk\Pipelines\Cli\Args;
use Ktomk\Pipelines\Cli\Args\ArgsTester;
use Ktomk\Pipelines\TestCase;
use Ktomk\Pipelines\Utility\App as UtilityApp;

/**
 * @covers \Ktomk\Pipelines\Runner\Env
 */
class EnvTest extends TestCase
{
    public function testCreation()
    {
        $env = new Env();
        self::assertInstanceOf('Ktomk\Pipelines\Runner\Env', $env);
        self::assertNotNull($env->getArgs('-e'));
    }

    public function testStaticCreation()
    {
        $env = Env::create();
        self::assertInstanceOf('Ktomk\Pipelines\Runner\Env', $env);
        self::assertNotNull($env->getArgs('-e'));
    }

    public function testStaticCreationEx()
    {
        $env = Env::createEx();
        self::assertInstanceOf('Ktomk\Pipelines\Runner\Env', $env);
        self::assertNotNull($env->getArgs('-e'));
    }

    public function testDefaultEnvsEmptyUnlessInitialized()
    {
        $env = new Env();
        $array = $env->getArgs('-e');
        self::assertIsArray($array);
        self::assertCount(0, $array);

        $env->initDefaultVars(array());
        $array = $env->getArgs('-e');
        self::assertCount(12, $array);
    }

    public function testDefaultValue()
    {
        $slug = UtilityApp::UTILITY_NAME;
        $env = Env::createEx(array('BITBUCKET_REPO_SLUG' => $slug));
        self::assertSame($slug, $env->getValue('BITBUCKET_REPO_SLUG'));
    }

    public function testUserInheritance()
    {
        $user = 'adele';
        $env = Env::createEx(array('USER' => $user));
        self::assertNull($env->getValue('USER'));
        self::assertSame($user, $env->getValue('BITBUCKET_REPO_OWNER'));
    }

    public function testInheritOnInit()
    {
        $env = new Env();
        $env->initDefaultVars(array('BITBUCKET_BUILD_NUMBER' => '123'));
        $array = $env->getArgs('-e');
        self::assertContains('BITBUCKET_BUILD_NUMBER=123', $array);
    }

    public function testGetOptionArgs()
    {
        $env = Env::createEx();
        $args = $env->getArgs('-e');
        self::assertIsArray($args);
        while ($args) {

            $argument = array_pop($args);
            self::assertIsString($argument);
            self::assertGreaterThan(0, strpos($argument, '='), 'must be a variable definition');
            self::assertGreaterThan(0, count($args));
            $option = array_pop($args);
            self::assertSame('-e', $option);
        }
    }

    public function testUnsetVariables()
    {
        $env = new Env();
        $env->initDefaultVars(array());
        # start count has some vars unset
        $default = count($env->getArgs('-e'));

        $env->initDefaultVars(array('BITBUCKET_BRANCH' => 'test'));
        # start count has some vars unset
        $new = count($env->getArgs('-e'));
        self::assertSame($default + 2, $new);
    }

    public function testAddRefType()
    {
        $env = Env::createEx();
        $default = count($env->getArgs('-e'));

        $env->addReference(Reference::create());
        self::assertCount($default, $env->getArgs('-e'), 'null reference does not add any variables');

        $env->addReference(Reference::create('branch:testing'));
        self::assertCount($default + 2, $env->getArgs('-e'), 'full reference does add variables');
    }

    public function testPullRequestAddsBranchName()
    {
        $env = Env::createEx();
        $default = count($env->getArgs('-e'));

        $env->addReference(Reference::create());
        self::assertCount($default, $env->getArgs('-e'), 'null reference does not add any variables');

        $env->addReference(Reference::create('pr:feature'));
        self::assertCount($default + 2, $env->getArgs('-e'), 'full reference does add variables');

        $env->addReference(Reference::create('pr:topic:master'));
        self::assertCount($default + 4, $env->getArgs('-e'), 'pr destination does add variables');
    }

    public function testAddRefTypeIfSet()
    {
        $env = Env::createEx(array('BITBUCKET_TAG' => 'inherit'));
        $default = count($env->getArgs('-e'));

        $env->addReference(Reference::create('tag:testing'));
        $actual = $env->getArgs('-e');
        self::assertCount($default, $actual);

        self::assertContains('BITBUCKET_TAG=inherit', $actual);
    }

    public function testSetContainerName()
    {
        $env = Env::createEx();
        $count = count($env->getArgs('-e'));

        $env->setContainerName('blue-seldom');
        $args = $env->getArgs('-e');
        self::assertCount($count + 2, $args);
        self::assertContains('PIPELINES_CONTAINER_NAME=blue-seldom', $args);

        $env->setContainerName('solar-bottom');
        $args = $env->getArgs('-e');
        self::assertCount($count + 4, $args);
        self::assertContains('PIPELINES_PARENT_CONTAINER_NAME=blue-seldom', $args);
        self::assertContains('PIPELINES_CONTAINER_NAME=solar-bottom', $args);
    }

    public function testInheritedContainerName()
    {
        $inherit = array(
            'PIPELINES_CONTAINER_NAME' => 'cloud-sea',
        );
        $env = Env::createEx($inherit);
        $env->setContainerName('dream-blue');
        $args = $env->getArgs('-e');
        self::assertContains('PIPELINES_PARENT_CONTAINER_NAME=cloud-sea', $args);
        self::assertContains('PIPELINES_CONTAINER_NAME=dream-blue', $args);
    }

    /**
     * @covers \Ktomk\Pipelines\Runner\Env::getInheritValue
     */
    public function testGetInheritValue()
    {
        $inherit = array(
            'DOCKER_HOST' => 'unix:///var/run/docker.sock',
            'DOCKER_TMP' => false,
        );
        $env = Env::createEx($inherit);
        $actual = $env->getInheritValue('DOCKER_HOST');
        self::assertSame('unix:///var/run/docker.sock', $actual);
        $actual = $env->getInheritValue('DOCKER_TMP');
        self::assertNull($actual);
        $actual = $env->getInheritValue('FOO_BAR_LE_BAZ');
        self::assertNull($actual);
    }

    public function testGetValue()
    {
        $env = Env::createEx();
        $actual = $env->getValue('BITBUCKET_BUILD_NUMBER');
        self::assertSame('0', $actual);
        $actual = $env->getValue('BITBUCKET_BRANCH');
        self::assertNull($actual);
    }

    public function testSetPipelinesId()
    {
        $env = Env::createEx();
        self::assertNull($env->getValue('PIPELINES_ID'));
        self::assertNull($env->getValue('PIPELINES_IDS'));

        // set the first id
        $result = $env->setPipelinesId('default');
        self::assertFalse($result);
        self::assertSame('default', $env->getValue('PIPELINES_ID'));

        // set the second id (next run)
        $result = $env->setPipelinesId('default');
        self::assertTrue($result);
        $actual = $env->getValue('PIPELINES_IDS');
        self::assertNotNull($actual);
        self::assertMatchesRegularExpression('~^([a-z0-9]+) \1$~', $actual, 'list of hashes');
    }

    public function testSetPipelinesProjectPath()
    {
        $env = Env::createEx();
        $env->setPipelinesProjectPath('/my-path');
        self::assertNull($env->getValue('PIPELINES_PROJECT_PATH'), 'needs ID/s configuration');

        $env->setPipelinesId('custom/test-for-nothing');
        $env->setPipelinesProjectPath('/my-path');
        self::assertSame('/my-path', $env->getValue('PIPELINES_PROJECT_PATH'), 'works for ID/s');

        $env->setPipelinesProjectPath('/my-path/too');
        self::assertSame('/my-path', $env->getValue('PIPELINES_PROJECT_PATH'), 'can not overwrite');
    }

    public function testSetPipelinesProjectPathThrowsOnRelativePath()
    {
        $env = Env::createEx();

        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('not an absolute path: "./my-path"');
        $env->setPipelinesProjectPath('./my-path');
    }

    public function testInheritPipelinesId()
    {
        $inherit = array('PIPELINES_ID', 'custom/the-other-day');
        $env = Env::createEx($inherit);
        self::assertNull($env->getValue('PIPELINES_ID'));
    }

    /**
     * @throws \Ktomk\Pipelines\Cli\ArgsException
     */
    public function testCollect()
    {
        $env = Env::createEx();
        $env->collect(new ArgsTester(), array());
        $expected = array (
            0 => 'e',
            1 => 'BITBUCKET_BUILD_NUMBER=0',
            2 => 'e',
            3 => 'BITBUCKET_COMMIT=0000000000000000000000000000000000000000',
            4 => 'e',
            5 => 'BITBUCKET_REPO_OWNER=nobody',
            6 => 'e',
            7 => 'BITBUCKET_REPO_SLUG=local-has-no-slug',
            8 => 'e',
            9 => 'BITBUCKET_STEP_RUN_NUMBER=1',
            10 => 'e',
            11 => 'CI=true',
        );
        $actual = $env->getArgs('e');
        self::assertSame($expected, $actual);
    }

    public function testCollectFiles1()
    {
        $env = Env::createEx(array('DOCKER_ID_USER' => 'electra'));
        $env->collectFiles(array(
            __DIR__ . '/../../data/env/.env.dist',
            '/abc/xyz/nada-kar-la-da',
        ));
        $actual = $env->getResolver()->getValue('DOCKER_ID_USER');
        self::assertSame('electra', $actual, '.dist imports');

        $actual = $env->getResolver()->getValue('FOO');
        self::assertSame('BAR', $actual, '.dist sets');
    }

    public function testCollectFiles2()
    {
        $env = Env::createEx(array('DOCKER_ID_USER' => 'electra'));
        $env->collectFiles(array(
            '/abc/xyz/nada-kar-la-da',
            __DIR__ . '/../../data/env/.env.dist',
            __DIR__ . '/../../data/env/.env',
        ));
        $resolver = $env->getResolver();
        $actual = $resolver->getValue('DOCKER_ID_USER');
        self::assertSame('l-oracle-de-delphi', $actual, '.env sets');

        $actual = $resolver->getValue('FOO');
        self::assertSame('BAZ', $actual, '.env overwrites');

        $array = array(
            'first' => '$DOCKER_ID_USER',
            'second'=> '$FOO',
            'third' => '$BAZ-LE-BAZ',
        );
        $expected = array(
            'first' => 'l-oracle-de-delphi',
            'second'=> 'BAZ',
            'third' => '$BAZ-LE-BAZ',
        );
        $actual = $resolver($array);
        self::assertSame($expected, $actual);
    }

    public function testGetResolver()
    {
        $env = new Env();
        self::assertInstanceOf(
            'Ktomk\Pipelines\Runner\EnvResolver',
            $env->getResolver()
        );
    }

    /**
     */
    public function testAddReferenceOfUnknownType()
    {
        $this->expectException('UnexpectedValueException');
        $this->expectExceptionMessage('Unknown reference type: "foo"');

        $env = new Env();

        $reference = $this->createMock('\Ktomk\Pipelines\Runner\Reference');
        $reference
            ->method('getType')
            ->willReturn('foo');

        $env->addReference($reference);
    }

    /**
     * @covers \Ktomk\Pipelines\Runner\EnvResolver::getVariables
     *
     * @return void
     */
    public function testGetVariablesEmptyArrayOnInit()
    {
        $env = new Env();
        self::assertSame(array(), $env->getVariables());
    }

    /**
     * @throws \Ktomk\Pipelines\Cli\ArgsException
     *
     * @return void
     */
    public function testInheritanceResolution()
    {
        $inherit = array();
        $args = new Args(array('', '-e', 'BITBUCKET_REPO_SLUG=bar'));

        // empty on create (new behaviour)
        $env = Env::create($inherit);
        self::assertNull($env->getValue('BITBUCKET_REPO_SLUG'));

        // init default vars initializes default
        $env->initDefaultVars($env->getVariables() + $inherit);
        self::assertSame('local-has-no-slug', $env->getValue('BITBUCKET_REPO_SLUG'));

        // collecting args works still
        $env->collect($args, array('e', 'env', 'env-file'));
        $env->initDefaultVars($env->getVariables() + $inherit);
        self::assertSame('bar', $env->getValue('BITBUCKET_REPO_SLUG'));
    }

    public function testResetStepRunNumber()
    {
        $inherit = array();

        $env = Env::create($inherit);
        self::assertNull($env->getValue('BITBUCKET_STEP_RUN_NUMBER'));

        $env->initDefaultVars($inherit);
        self::assertSame('1', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));

        $inherit = array('BITBUCKET_STEP_RUN_NUMBER' => '2');

        $env = Env::create($inherit);
        self::assertNull($env->getValue('BITBUCKET_STEP_RUN_NUMBER'));

        $env->initDefaultVars($inherit);
        self::assertSame('2', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));

        $env->resetStepRunNumber();
        self::assertSame('1', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));

        $env->resetStepRunNumber();
        self::assertSame('1', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));

        $inherit = array();

        $env = Env::create($inherit);
        self::assertNull($env->getValue('BITBUCKET_STEP_RUN_NUMBER'));

        $env->resetStepRunNumber();
        self::assertSame('1', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
    }
}


1			<?php
2
3			/* this file is part of pipelines */
4
5			namespace Ktomk\Pipelines\Runner;
6
7			use Ktomk\Pipelines\Cli\Args;
8			use Ktomk\Pipelines\Cli\Args\ArgsTester;
9			use Ktomk\Pipelines\TestCase;
10			use Ktomk\Pipelines\Utility\App as UtilityApp;
11
12			/**
13			* @covers \Ktomk\Pipelines\Runner\Env
14			*/
15			class EnvTest extends TestCase
16			{
17			public function testCreation()
18			{
19			$env = new Env();
20			self::assertInstanceOf('Ktomk\Pipelines\Runner\Env', $env);
21			self::assertNotNull($env->getArgs('-e'));
22			}
23
24			public function testStaticCreation()
25			{
26			$env = Env::create();
27			self::assertInstanceOf('Ktomk\Pipelines\Runner\Env', $env);
28			self::assertNotNull($env->getArgs('-e'));
29			}
30
31			public function testStaticCreationEx()
32			{
33			$env = Env::createEx();
34			self::assertInstanceOf('Ktomk\Pipelines\Runner\Env', $env);
35			self::assertNotNull($env->getArgs('-e'));
36			}
37
38			public function testDefaultEnvsEmptyUnlessInitialized()
39			{
40			$env = new Env();
41			$array = $env->getArgs('-e');
42			self::assertIsArray($array);
43			self::assertCount(0, $array);
44
45			$env->initDefaultVars(array());
46			$array = $env->getArgs('-e');
47			self::assertCount(12, $array);
48			}
49
50			public function testDefaultValue()
51			{
52			$slug = UtilityApp::UTILITY_NAME;
53			$env = Env::createEx(array('BITBUCKET_REPO_SLUG' => $slug));
54			self::assertSame($slug, $env->getValue('BITBUCKET_REPO_SLUG'));
55			}
56
57			public function testUserInheritance()
58			{
59			$user = 'adele';
60			$env = Env::createEx(array('USER' => $user));
61			self::assertNull($env->getValue('USER'));
62			self::assertSame($user, $env->getValue('BITBUCKET_REPO_OWNER'));
63			}
64
65			public function testInheritOnInit()
66			{
67			$env = new Env();
68			$env->initDefaultVars(array('BITBUCKET_BUILD_NUMBER' => '123'));
69			$array = $env->getArgs('-e');
70			self::assertContains('BITBUCKET_BUILD_NUMBER=123', $array);
71			}
72
73			public function testGetOptionArgs()
74			{
75			$env = Env::createEx();
76			$args = $env->getArgs('-e');
77			self::assertIsArray($args);
78			while ($args) {
			0 ignored issues – show Bug Best Practice introduced 2020-12-10 03:16 UTC by Report Bug Copy Issue Report The expression `$args` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
79			$argument = array_pop($args);
80			self::assertIsString($argument);
81			self::assertGreaterThan(0, strpos($argument, '='), 'must be a variable definition');
82			self::assertGreaterThan(0, count($args));
83			$option = array_pop($args);
84			self::assertSame('-e', $option);
85			}
86			}
87
88			public function testUnsetVariables()
89			{
90			$env = new Env();
91			$env->initDefaultVars(array());
92			# start count has some vars unset
93			$default = count($env->getArgs('-e'));
94
95			$env->initDefaultVars(array('BITBUCKET_BRANCH' => 'test'));
96			# start count has some vars unset
97			$new = count($env->getArgs('-e'));
98			self::assertSame($default + 2, $new);
99			}
100
101			public function testAddRefType()
102			{
103			$env = Env::createEx();
104			$default = count($env->getArgs('-e'));
105
106			$env->addReference(Reference::create());
107			self::assertCount($default, $env->getArgs('-e'), 'null reference does not add any variables');
108
109			$env->addReference(Reference::create('branch:testing'));
110			self::assertCount($default + 2, $env->getArgs('-e'), 'full reference does add variables');
111			}
112
113			public function testPullRequestAddsBranchName()
114			{
115			$env = Env::createEx();
116			$default = count($env->getArgs('-e'));
117
118			$env->addReference(Reference::create());
119			self::assertCount($default, $env->getArgs('-e'), 'null reference does not add any variables');
120
121			$env->addReference(Reference::create('pr:feature'));
122			self::assertCount($default + 2, $env->getArgs('-e'), 'full reference does add variables');
123
124			$env->addReference(Reference::create('pr:topic:master'));
125			self::assertCount($default + 4, $env->getArgs('-e'), 'pr destination does add variables');
126			}
127
128			public function testAddRefTypeIfSet()
129			{
130			$env = Env::createEx(array('BITBUCKET_TAG' => 'inherit'));
131			$default = count($env->getArgs('-e'));
132
133			$env->addReference(Reference::create('tag:testing'));
134			$actual = $env->getArgs('-e');
135			self::assertCount($default, $actual);
136
137			self::assertContains('BITBUCKET_TAG=inherit', $actual);
138			}
139
140			public function testSetContainerName()
141			{
142			$env = Env::createEx();
143			$count = count($env->getArgs('-e'));
144
145			$env->setContainerName('blue-seldom');
146			$args = $env->getArgs('-e');
147			self::assertCount($count + 2, $args);
148			self::assertContains('PIPELINES_CONTAINER_NAME=blue-seldom', $args);
149
150			$env->setContainerName('solar-bottom');
151			$args = $env->getArgs('-e');
152			self::assertCount($count + 4, $args);
153			self::assertContains('PIPELINES_PARENT_CONTAINER_NAME=blue-seldom', $args);
154			self::assertContains('PIPELINES_CONTAINER_NAME=solar-bottom', $args);
155			}
156
157			public function testInheritedContainerName()
158			{
159			$inherit = array(
160			'PIPELINES_CONTAINER_NAME' => 'cloud-sea',
161			);
162			$env = Env::createEx($inherit);
163			$env->setContainerName('dream-blue');
164			$args = $env->getArgs('-e');
165			self::assertContains('PIPELINES_PARENT_CONTAINER_NAME=cloud-sea', $args);
166			self::assertContains('PIPELINES_CONTAINER_NAME=dream-blue', $args);
167			}
168
169			/**
170			* @covers \Ktomk\Pipelines\Runner\Env::getInheritValue
171			*/
172			public function testGetInheritValue()
173			{
174			$inherit = array(
175			'DOCKER_HOST' => 'unix:///var/run/docker.sock',
176			'DOCKER_TMP' => false,
177			);
178			$env = Env::createEx($inherit);
179			$actual = $env->getInheritValue('DOCKER_HOST');
180			self::assertSame('unix:///var/run/docker.sock', $actual);
181			$actual = $env->getInheritValue('DOCKER_TMP');
182			self::assertNull($actual);
183			$actual = $env->getInheritValue('FOO_BAR_LE_BAZ');
184			self::assertNull($actual);
185			}
186
187			public function testGetValue()
188			{
189			$env = Env::createEx();
190			$actual = $env->getValue('BITBUCKET_BUILD_NUMBER');
191			self::assertSame('0', $actual);
192			$actual = $env->getValue('BITBUCKET_BRANCH');
193			self::assertNull($actual);
194			}
195
196			public function testSetPipelinesId()
197			{
198			$env = Env::createEx();
199			self::assertNull($env->getValue('PIPELINES_ID'));
200			self::assertNull($env->getValue('PIPELINES_IDS'));
201
202			// set the first id
203			$result = $env->setPipelinesId('default');
204			self::assertFalse($result);
205			self::assertSame('default', $env->getValue('PIPELINES_ID'));
206
207			// set the second id (next run)
208			$result = $env->setPipelinesId('default');
209			self::assertTrue($result);
210			$actual = $env->getValue('PIPELINES_IDS');
211			self::assertNotNull($actual);
212			self::assertMatchesRegularExpression('~^([a-z0-9]+) \1$~', $actual, 'list of hashes');
213			}
214
215			public function testSetPipelinesProjectPath()
216			{
217			$env = Env::createEx();
218			$env->setPipelinesProjectPath('/my-path');
219			self::assertNull($env->getValue('PIPELINES_PROJECT_PATH'), 'needs ID/s configuration');
220
221			$env->setPipelinesId('custom/test-for-nothing');
222			$env->setPipelinesProjectPath('/my-path');
223			self::assertSame('/my-path', $env->getValue('PIPELINES_PROJECT_PATH'), 'works for ID/s');
224
225			$env->setPipelinesProjectPath('/my-path/too');
226			self::assertSame('/my-path', $env->getValue('PIPELINES_PROJECT_PATH'), 'can not overwrite');
227			}
228
229			public function testSetPipelinesProjectPathThrowsOnRelativePath()
230			{
231			$env = Env::createEx();
232
233			$this->expectException('InvalidArgumentException');
234			$this->expectExceptionMessage('not an absolute path: "./my-path"');
235			$env->setPipelinesProjectPath('./my-path');
236			}
237
238			public function testInheritPipelinesId()
239			{
240			$inherit = array('PIPELINES_ID', 'custom/the-other-day');
241			$env = Env::createEx($inherit);
242			self::assertNull($env->getValue('PIPELINES_ID'));
243			}
244
245			/**
246			* @throws \Ktomk\Pipelines\Cli\ArgsException
247			*/
248			public function testCollect()
249			{
250			$env = Env::createEx();
251			$env->collect(new ArgsTester(), array());
252			$expected = array (
253			0 => 'e',
254			1 => 'BITBUCKET_BUILD_NUMBER=0',
255			2 => 'e',
256			3 => 'BITBUCKET_COMMIT=0000000000000000000000000000000000000000',
257			4 => 'e',
258			5 => 'BITBUCKET_REPO_OWNER=nobody',
259			6 => 'e',
260			7 => 'BITBUCKET_REPO_SLUG=local-has-no-slug',
261			8 => 'e',
262			9 => 'BITBUCKET_STEP_RUN_NUMBER=1',
263			10 => 'e',
264			11 => 'CI=true',
265			);
266			$actual = $env->getArgs('e');
267			self::assertSame($expected, $actual);
268			}
269
270			public function testCollectFiles1()
271			{
272			$env = Env::createEx(array('DOCKER_ID_USER' => 'electra'));
273			$env->collectFiles(array(
274			__DIR__ . '/../../data/env/.env.dist',
275			'/abc/xyz/nada-kar-la-da',
276			));
277			$actual = $env->getResolver()->getValue('DOCKER_ID_USER');
278			self::assertSame('electra', $actual, '.dist imports');
279
280			$actual = $env->getResolver()->getValue('FOO');
281			self::assertSame('BAR', $actual, '.dist sets');
282			}
283
284			public function testCollectFiles2()
285			{
286			$env = Env::createEx(array('DOCKER_ID_USER' => 'electra'));
287			$env->collectFiles(array(
288			'/abc/xyz/nada-kar-la-da',
289			__DIR__ . '/../../data/env/.env.dist',
290			__DIR__ . '/../../data/env/.env',
291			));
292			$resolver = $env->getResolver();
293			$actual = $resolver->getValue('DOCKER_ID_USER');
294			self::assertSame('l-oracle-de-delphi', $actual, '.env sets');
295
296			$actual = $resolver->getValue('FOO');
297			self::assertSame('BAZ', $actual, '.env overwrites');
298
299			$array = array(
300			'first' => '$DOCKER_ID_USER',
301			'second'=> '$FOO',
302			'third' => '$BAZ-LE-BAZ',
303			);
304			$expected = array(
305			'first' => 'l-oracle-de-delphi',
306			'second'=> 'BAZ',
307			'third' => '$BAZ-LE-BAZ',
308			);
309			$actual = $resolver($array);
310			self::assertSame($expected, $actual);
311			}
312
313			public function testGetResolver()
314			{
315			$env = new Env();
316			self::assertInstanceOf(
317			'Ktomk\Pipelines\Runner\EnvResolver',
318			$env->getResolver()
319			);
320			}
321
322			/**
323			*/
324			public function testAddReferenceOfUnknownType()
325			{
326			$this->expectException('UnexpectedValueException');
327			$this->expectExceptionMessage('Unknown reference type: "foo"');
328
329			$env = new Env();
330
331			$reference = $this->createMock('\Ktomk\Pipelines\Runner\Reference');
332			$reference
333			->method('getType')
334			->willReturn('foo');
335
336			$env->addReference($reference);
337			}
338
339			/**
340			* @covers \Ktomk\Pipelines\Runner\EnvResolver::getVariables
341			*
342			* @return void
343			*/
344			public function testGetVariablesEmptyArrayOnInit()
345			{
346			$env = new Env();
347			self::assertSame(array(), $env->getVariables());
348			}
349
350			/**
351			* @throws \Ktomk\Pipelines\Cli\ArgsException
352			*
353			* @return void
354			*/
355			public function testInheritanceResolution()
356			{
357			$inherit = array();
358			$args = new Args(array('', '-e', 'BITBUCKET_REPO_SLUG=bar'));
359
360			// empty on create (new behaviour)
361			$env = Env::create($inherit);
362			self::assertNull($env->getValue('BITBUCKET_REPO_SLUG'));
363
364			// init default vars initializes default
365			$env->initDefaultVars($env->getVariables() + $inherit);
366			self::assertSame('local-has-no-slug', $env->getValue('BITBUCKET_REPO_SLUG'));
367
368			// collecting args works still
369			$env->collect($args, array('e', 'env', 'env-file'));
370			$env->initDefaultVars($env->getVariables() + $inherit);
371			self::assertSame('bar', $env->getValue('BITBUCKET_REPO_SLUG'));
372			}
373
374			public function testResetStepRunNumber()
375			{
376			$inherit = array();
377
378			$env = Env::create($inherit);
379			self::assertNull($env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
380
381			$env->initDefaultVars($inherit);
382			self::assertSame('1', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
383
384			$inherit = array('BITBUCKET_STEP_RUN_NUMBER' => '2');
385
386			$env = Env::create($inherit);
387			self::assertNull($env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
388
389			$env->initDefaultVars($inherit);
390			self::assertSame('2', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
391
392			$env->resetStepRunNumber();
393			self::assertSame('1', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
394
395			$env->resetStepRunNumber();
396			self::assertSame('1', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
397
398			$inherit = array();
399
400			$env = Env::create($inherit);
401			self::assertNull($env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
402
403			$env->resetStepRunNumber();
404			self::assertSame('1', $env->getValue('BITBUCKET_STEP_RUN_NUMBER'));
405			}
406			}
407

ktomk / pipelines

Push — test ( d838cf...cef4a5 )

EnvTest::testUnsetVariables() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like