ServiceTest::testUnknownEnvVariableTypePayload() - Code Metrics - Inspection of "Implement Kubernetes' resources' requests/limits m..." - theaentmachine/aent-console - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#36)

by Jindun

created 2018-08-01 08:45 UTC

ServiceTest::testUnknownEnvVariableTypePayload() A

↳ Parent: ServiceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	0
dl	0
loc	5
rs	10
c	0
b	0
f	0

<?php

namespace TheAentMachine\Registry;

use PHPUnit\Framework\TestCase;
use TheAentMachine\Aenthill\CommonMetadata;
use TheAentMachine\Service\Enum\VolumeTypeEnum;
use TheAentMachine\Service\Exception\ServiceException;
use TheAentMachine\Service\Service;
use TheAentMachine\Service\Volume\BindVolume;
use TheAentMachine\Service\Volume\NamedVolume;

class ServiceTest extends TestCase
{
    private const VALID_PAYLOAD = <<< 'JSON'
{
  "serviceName" : "foo",
  "service": {
    "image"         : "foo/bar:baz",
    "command"       : ["foo", "-bar", "-baz", "--qux"],
    "internalPorts" : [1, 2, 3],
    "dependsOn"     : ["foo", "bar"],
    "ports"         : [{"source": 80, "target": 8080}],
    "environment"   : {
                        "FOO": {"value": "foo", "type": "sharedEnvVariable"},
                        "BAR": {"value": "bar", "type": "sharedSecret"},
                        "BAZ": {"value": "baz", "type": "imageEnvVariable"},
                        "QUX": {"value": "qux", "type": "containerEnvVariable"}
                      },
    "labels"        : {
                        "foo": {"value": "fooo"},
                        "bar": {"value": "baar"}
                      },               
    "volumes"       : [
                        {"type": "volume", "source": "foo", "target": "/foo", "readOnly": true},
                        {"type": "bind", "source": "/bar", "target": "/bar", "readOnly": false},
                        {"type": "tmpfs", "source": "baz"}
                      ],
    "needVirtualHost": true,
    "needBuild": true
  },
  "dockerfileCommands": [
    "RUN composer install"
  ],
  "destEnvTypes": [
    "DEV"
  ],
  "requestMemory": "64Mi",
  "requestCpu": "250m",
  "limitMemory": "128Mi",
  "limitCpu": "500m"
}
JSON;

    private const MISSING_SERVICE_NAME_PAYLOAD = <<< 'JSON'
{
  "service": {
    "internalPorts": [80]
  }
}
JSON;

    private const UNKNOWN_ENV_VARIABLE_TYPE_PAYLOAD = <<< 'JSON'
{
  "serviceName": "foo",
  "service": {
    "environment": {
      "FOO": {
        "value": "fooo",
        "type": "YIKES_THATS_SOME_BAD_TYPE_HERE"
      }
    }
  }
}
JSON;

    private const UNKNOWN_VOLUME_TYPE_PAYLOAD = <<< 'JSON'
{
  "serviceName": "foo",
  "service": {
    "volumes": [
      {
        "type": "AGAIN?WTH",
        "source": "foo"
      }
    ]
  }
}
JSON;

    /** @throws ServiceException */
    public function testValidPayload(): void
    {
        $array = \GuzzleHttp\json_decode(self::VALID_PAYLOAD, true);
        $service = Service::parsePayload($array);
        $out = $service->jsonSerialize();
        $this->assertEquals($array, $out);
        $this->assertTrue($service->isForDevEnvType());
        $this->assertFalse($service->isForTestEnvType());
        $this->assertFalse($service->isForProdEnvType());
    }

    /** @throws ServiceException */
    public function testMissingServiceNamePayload(): void
    {
        $this->expectException(ServiceException::class);
        $array = \GuzzleHttp\json_decode(self::MISSING_SERVICE_NAME_PAYLOAD, true);
        Service::parsePayload($array)->jsonSerialize();
    }

    /** @throws ServiceException */
    public function testUnknownEnvVariableTypePayload(): void
    {
        $this->expectException(ServiceException::class);
        $array = \GuzzleHttp\json_decode(self::UNKNOWN_ENV_VARIABLE_TYPE_PAYLOAD, true);
        Service::parsePayload($array)->jsonSerialize();
    }

    /** @throws ServiceException */
    public function testUnknownVolumeTypePayload(): void
    {
        $this->expectException(ServiceException::class);
        $array = \GuzzleHttp\json_decode(self::UNKNOWN_VOLUME_TYPE_PAYLOAD, true);
        Service::parsePayload($array)->jsonSerialize();
    }

    /** @throws ServiceException */
    public function testSettersAndAdders(): void
    {
        $s = new Service();
        $s->setServiceName('foo');
        $s->setImage('foo/bar:baz');
        $s->setCommand(['foo', '-bar', '-baz']);
        $s->addCommand('--qux');
        $s->setInternalPorts([1, 2]);
        $s->addInternalPort(3);
        $s->setDependsOn(['foo']);
        $s->addDependsOn('bar');
        $s->addPort(80, 8080);
        $s->addLabel('foo', 'fooo');
        $s->addLabel('bar', 'baar');
        $s->addSharedEnvVariable('FOO', 'foo');
        $s->addSharedSecret('BAR', 'bar');
        $s->addImageEnvVariable('BAZ', 'baz');
        $s->addContainerEnvVariable('QUX', 'qux');
        $s->addNamedVolume('foo', '/foo', true);
        $s->addBindVolume('/bar', '/bar', false);
        $s->addTmpfsVolume('baz');
        $s->addDockerfileCommand('RUN composer install');
        $s->setNeedVirtualHost(true);
        $s->setNeedBuild(true);
        $s->addDestEnvType(CommonMetadata::ENV_TYPE_DEV, true);
        $s->setRequestMemory('64Mi');
        $s->setRequestCpu('250m');
        $s->setLimitMemory('128Mi');
        $s->setLimitCpu('500m');
        $outArray = $s->jsonSerialize();
        $expectedArray = \GuzzleHttp\json_decode(self::VALID_PAYLOAD, true);
        $this->assertEquals($outArray, $expectedArray);

        $outArray = $s->imageJsonSerialize();
        $expectedArray = [
            'serviceName' => 'foo',
            'dockerfileCommands' => [
                'FROM foo/bar:baz',
                'ENV BAZ=baz',
                'COPY /bar /bar',
                'CMD foo -bar -baz --qux',
                'RUN composer install'
            ],
            'destEnvTypes' => ['DEV']
        ];
        $this->assertEquals($outArray, $expectedArray);
    }

    /** @throws ServiceException */
    public function testUnvalidRequestMemoryPattern(): void
    {
        $s = new Service();
        $s->setServiceName('foo');
        $s->setRequestMemory('0.5Zi');
        $this->expectException(ServiceException::class);
        $s->jsonSerialize();
    }

    /** @throws ServiceException */
    public function testUnvalidRequestCpuPattern(): void
    {
        $s = new Service();
        $s->setServiceName('foo');
        $s->setRequestCpu('0,1');
        $this->expectException(ServiceException::class);
        $s->jsonSerialize();
    }

    /** @throws ServiceException */
    public function testVolumeRemovers(): void
    {
        $s = new Service();
        $s->setServiceName('my_service');
        $s->addBindVolume('./foo', '/opt/app/foo', true);
        $s->addBindVolume('./bar', '/opt/app/baz', false);
        $s->addNamedVolume('my_data', '/data', true);
        $s->removeVolumesBySource('./bar');
        /** @var BindVolume[]|NamedVolume[] $volumes */
        $volumes = $s->getVolumes();
        print_r($volumes);
        $this->assertEquals(count($volumes), 2);
        $this->assertEquals($volumes[0]->getType(), VolumeTypeEnum::BIND_VOLUME);
        $this->assertEquals($volumes[0]->getSource(), './foo');
        $this->assertEquals($volumes[1]->getType(), VolumeTypeEnum::NAMED_VOLUME);

        $s->addBindVolume('./bar', '/opt/app/baz', false);
        $s->removeAllBindVolumes();
        $volumes = $s->getVolumes();
        $this->assertEquals(count($volumes), 1);
        $this->assertEquals($volumes[0]->getType(), VolumeTypeEnum::NAMED_VOLUME);
        $this->assertEquals($volumes[0]->getTarget(), '/data');
    }
}

1			<?php
2
3			namespace TheAentMachine\Registry;
4
5			use PHPUnit\Framework\TestCase;
6			use TheAentMachine\Aenthill\CommonMetadata;
7			use TheAentMachine\Service\Enum\VolumeTypeEnum;
8			use TheAentMachine\Service\Exception\ServiceException;
9			use TheAentMachine\Service\Service;
10			use TheAentMachine\Service\Volume\BindVolume;
11			use TheAentMachine\Service\Volume\NamedVolume;
12
13			class ServiceTest extends TestCase
14			{
15			private const VALID_PAYLOAD = <<< 'JSON'
16			{
17			"serviceName" : "foo",
18			"service": {
19			"image" : "foo/bar:baz",
20			"command" : ["foo", "-bar", "-baz", "--qux"],
21			"internalPorts" : [1, 2, 3],
22			"dependsOn" : ["foo", "bar"],
23			"ports" : [{"source": 80, "target": 8080}],
24			"environment" : {
25			"FOO": {"value": "foo", "type": "sharedEnvVariable"},
26			"BAR": {"value": "bar", "type": "sharedSecret"},
27			"BAZ": {"value": "baz", "type": "imageEnvVariable"},
28			"QUX": {"value": "qux", "type": "containerEnvVariable"}
29			},
30			"labels" : {
31			"foo": {"value": "fooo"},
32			"bar": {"value": "baar"}
33			},
34			"volumes" : [
35			{"type": "volume", "source": "foo", "target": "/foo", "readOnly": true},
36			{"type": "bind", "source": "/bar", "target": "/bar", "readOnly": false},
37			{"type": "tmpfs", "source": "baz"}
38			],
39			"needVirtualHost": true,
40			"needBuild": true
41			},
42			"dockerfileCommands": [
43			"RUN composer install"
44			],
45			"destEnvTypes": [
46			"DEV"
47			],
48			"requestMemory": "64Mi",
49			"requestCpu": "250m",
50			"limitMemory": "128Mi",
51			"limitCpu": "500m"
52			}
53			JSON;
54
55			private const MISSING_SERVICE_NAME_PAYLOAD = <<< 'JSON'
56			{
57			"service": {
58			"internalPorts": [80]
59			}
60			}
61			JSON;
62
63			private const UNKNOWN_ENV_VARIABLE_TYPE_PAYLOAD = <<< 'JSON'
64			{
65			"serviceName": "foo",
66			"service": {
67			"environment": {
68			"FOO": {
69			"value": "fooo",
70			"type": "YIKES_THATS_SOME_BAD_TYPE_HERE"
71			}
72			}
73			}
74			}
75			JSON;
76
77			private const UNKNOWN_VOLUME_TYPE_PAYLOAD = <<< 'JSON'
78			{
79			"serviceName": "foo",
80			"service": {
81			"volumes": [
82			{
83			"type": "AGAIN?WTH",
84			"source": "foo"
85			}
86			]
87			}
88			}
89			JSON;
90
91			/** @throws ServiceException */
92			public function testValidPayload(): void
93			{
94			$array = \GuzzleHttp\json_decode(self::VALID_PAYLOAD, true);
95			$service = Service::parsePayload($array);
96			$out = $service->jsonSerialize();
97			$this->assertEquals($array, $out);
98			$this->assertTrue($service->isForDevEnvType());
99			$this->assertFalse($service->isForTestEnvType());
100			$this->assertFalse($service->isForProdEnvType());
101			}
102
103			/** @throws ServiceException */
104			public function testMissingServiceNamePayload(): void
105			{
106			$this->expectException(ServiceException::class);
107			$array = \GuzzleHttp\json_decode(self::MISSING_SERVICE_NAME_PAYLOAD, true);
108			Service::parsePayload($array)->jsonSerialize();
109			}
110
111			/** @throws ServiceException */
112			public function testUnknownEnvVariableTypePayload(): void
113			{
114			$this->expectException(ServiceException::class);
115			$array = \GuzzleHttp\json_decode(self::UNKNOWN_ENV_VARIABLE_TYPE_PAYLOAD, true);
116			Service::parsePayload($array)->jsonSerialize();
117			}
118
119			/** @throws ServiceException */
120			public function testUnknownVolumeTypePayload(): void
121			{
122			$this->expectException(ServiceException::class);
123			$array = \GuzzleHttp\json_decode(self::UNKNOWN_VOLUME_TYPE_PAYLOAD, true);
124			Service::parsePayload($array)->jsonSerialize();
125			}
126
127			/** @throws ServiceException */
128			public function testSettersAndAdders(): void
129			{
130			$s = new Service();
131			$s->setServiceName('foo');
132			$s->setImage('foo/bar:baz');
133			$s->setCommand(['foo', '-bar', '-baz']);
134			$s->addCommand('--qux');
135			$s->setInternalPorts([1, 2]);
136			$s->addInternalPort(3);
137			$s->setDependsOn(['foo']);
138			$s->addDependsOn('bar');
139			$s->addPort(80, 8080);
140			$s->addLabel('foo', 'fooo');
141			$s->addLabel('bar', 'baar');
142			$s->addSharedEnvVariable('FOO', 'foo');
143			$s->addSharedSecret('BAR', 'bar');
144			$s->addImageEnvVariable('BAZ', 'baz');
145			$s->addContainerEnvVariable('QUX', 'qux');
146			$s->addNamedVolume('foo', '/foo', true);
147			$s->addBindVolume('/bar', '/bar', false);
148			$s->addTmpfsVolume('baz');
149			$s->addDockerfileCommand('RUN composer install');
150			$s->setNeedVirtualHost(true);
151			$s->setNeedBuild(true);
152			$s->addDestEnvType(CommonMetadata::ENV_TYPE_DEV, true);
153			$s->setRequestMemory('64Mi');
154			$s->setRequestCpu('250m');
155			$s->setLimitMemory('128Mi');
156			$s->setLimitCpu('500m');
157			$outArray = $s->jsonSerialize();
158			$expectedArray = \GuzzleHttp\json_decode(self::VALID_PAYLOAD, true);
159			$this->assertEquals($outArray, $expectedArray);
160
161			$outArray = $s->imageJsonSerialize();
162			$expectedArray = [
163			'serviceName' => 'foo',
164			'dockerfileCommands' => [
165			'FROM foo/bar:baz',
166			'ENV BAZ=baz',
167			'COPY /bar /bar',
168			'CMD foo -bar -baz --qux',
169			'RUN composer install'
170			],
171			'destEnvTypes' => ['DEV']
172			];
173			$this->assertEquals($outArray, $expectedArray);
174			}
175
176			/** @throws ServiceException */
177			public function testUnvalidRequestMemoryPattern(): void
178			{
179			$s = new Service();
180			$s->setServiceName('foo');
181			$s->setRequestMemory('0.5Zi');
182			$this->expectException(ServiceException::class);
183			$s->jsonSerialize();
184			}
185
186			/** @throws ServiceException */
187			public function testUnvalidRequestCpuPattern(): void
188			{
189			$s = new Service();
190			$s->setServiceName('foo');
191			$s->setRequestCpu('0,1');
192			$this->expectException(ServiceException::class);
193			$s->jsonSerialize();
194			}
195
196			/** @throws ServiceException */
197			public function testVolumeRemovers(): void
198			{
199			$s = new Service();
200			$s->setServiceName('my_service');
201			$s->addBindVolume('./foo', '/opt/app/foo', true);
202			$s->addBindVolume('./bar', '/opt/app/baz', false);
203			$s->addNamedVolume('my_data', '/data', true);
204			$s->removeVolumesBySource('./bar');
205			/** @var BindVolume[]\|NamedVolume[] $volumes */
206			$volumes = $s->getVolumes();
207			print_r($volumes);
208			$this->assertEquals(count($volumes), 2);
209			$this->assertEquals($volumes[0]->getType(), VolumeTypeEnum::BIND_VOLUME);
210			$this->assertEquals($volumes[0]->getSource(), './foo');
211			$this->assertEquals($volumes[1]->getType(), VolumeTypeEnum::NAMED_VOLUME);
212
213			$s->addBindVolume('./bar', '/opt/app/baz', false);
214			$s->removeAllBindVolumes();
215			$volumes = $s->getVolumes();
216			$this->assertEquals(count($volumes), 1);
217			$this->assertEquals($volumes[0]->getType(), VolumeTypeEnum::NAMED_VOLUME);
218			$this->assertEquals($volumes[0]->getTarget(), '/data');
219			}
220			}

theaentmachine / aent-console

Pull Request — master (#36)

ServiceTest::testUnknownEnvVariableTypePayload() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like