Is there an award for this?

tests/Controllers/ControllerTest.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\Tests\Controllers;
+
+use League\Route\Http\Exception\NotFoundException;
+use Nyholm\Psr7\ServerRequest;
+use PHPUnit\Framework\MockObject\Exception;
+use Psr\Log\LoggerInterface;
+use Siteworxpro\App\Controllers\Controller;
+use Siteworxpro\App\Facades\Logger;
+use Siteworxpro\App\Traefik\ProtocolEnum;
+use Siteworxpro\Tests\Unit;
+
+class ControllerTest extends Unit
+{
+    /**
+     * @throws NotFoundException
+     */
+    public function testGet(): void
+    {
+        $fooController = new FooController();
+        $request = new ServerRequest('GET', '/foo');
+
+        $this->expectException(NotFoundException::class);
+
+        $fooController->get($request);
+    }
+
+    /**
+     * @throws NotFoundException
+     */
+    public function testPost(): void
+    {
+        $fooController = new FooController();
+        $request = new ServerRequest('GET', '/foo');
+
+        $this->expectException(NotFoundException::class);
+
+        $fooController->post($request);
+    }
+
+    /**
+     * @throws NotFoundException
+     */
+    public function testDelete(): void
+    {
+        $fooController = new FooController();
+        $request = new ServerRequest('GET', '/foo');
+
+        $this->expectException(NotFoundException::class);
+
+        $fooController->delete($request);
+    }
+
+    /**
+     * @throws NotFoundException
+     */
+    public function testPatch(): void
+    {
+        $fooController = new FooController();
+        $request = new ServerRequest('GET', '/foo');
+
+        $this->expectException(NotFoundException::class);
+
+        $fooController->patch($request);
+    }
+
+}
+
+class FooController extends Controller
+{
+
+}

tests/Controllers/MiddlewareControllerTest.php

@@ -0,0 +1,146 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\Tests\Controllers;
+
+use Nyholm\Psr7\ServerRequest;
+use Siteworxpro\App\Controllers\MiddlewaresController;
+use Siteworxpro\App\Facades\RedisClient;
+use Siteworxpro\App\Traefik\EntityEnum;
+use Siteworxpro\App\Traefik\ProtocolEnum;
+use Siteworxpro\Tests\Unit;
+
+class MiddlewareControllerTest extends Unit
+{
+
+    /**
+     * @throws \JsonException
+     */
+    public function testGet(): void
+    {
+        $request = new ServerRequest('GET', '/middlewares');
+
+        $request = $request->withAttribute('protocol', 'http');
+
+        RedisClient::expects('getAllMiddlewares')
+            ->with(ProtocolEnum::HTTP)
+            ->andReturn(['middleware1', 'middleware2']);
+
+        $controller = new MiddlewaresController();
+
+        $response = $controller->get($request);
+
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('["middleware1","middleware2"]', (string)$response->getBody());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testGetInd(): void
+    {
+        $request = new ServerRequest('GET', '/middlewares/foo');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo');
+
+        RedisClient::expects('getMiddleware')
+            ->with('foo', ProtocolEnum::HTTP)
+            ->andReturn([
+                'traefik/http/middlewares/foo' => 'bar',
+            ]);
+
+        $controller = new MiddlewaresController();
+
+        $response = $controller->get($request);
+
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"traefik\/http\/middlewares\/foo":"bar"}', (string)$response->getBody());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testPost(): void
+    {
+
+        $request = new ServerRequest('POST', '/middlewares');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo')
+            ->withParsedBody(['foo' => 'bar']);
+
+        RedisClient::expects('createOrReplace')
+            ->with('foo', ['foo' => 'bar'], EntityEnum::MIDDLEWARE, ProtocolEnum::HTTP)
+            ->andReturn(true);
+
+        $controller = new MiddlewaresController();
+        $response = $controller->post($request);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"message":"Middleware added successfully"}', (string)$response->getBody());
+    }
+
+    public function testPostValidationFailure(): void
+    {
+        $request = new ServerRequest('POST', '/middlewares');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo')
+            ->withParsedBody([]);
+
+        RedisClient::expects('createOrReplace')
+            ->never();
+
+        $controller = new MiddlewaresController();
+        $response = $controller->post($request);
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertEquals('{"error":"Middleware is invalid"}', (string)$response->getBody());
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testDelete(): void
+    {
+        $request = new ServerRequest('DELETE', '/middlewares/foo');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo');
+
+        RedisClient::expects('deleteAllKeys')
+            ->with('foo', EntityEnum::MIDDLEWARE, ProtocolEnum::HTTP)
+            ->andReturn(true);
+
+        $controller = new MiddlewaresController();
+        $response = $controller->delete($request);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"message":"Middleware deleted successfully"}', (string)$response->getBody());
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testDeleteValidationFailure(): void
+    {
+        $request = new ServerRequest('DELETE', '/middlewares');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', '');
+
+        RedisClient::expects('deleteAllKeys')
+            ->never();
+
+        $controller = new MiddlewaresController();
+        $response = $controller->delete($request);
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertEquals('{"error":"Middleware is invalid"}', (string)$response->getBody());
+    }
+}

tests/Controllers/RoutesControllerTest.php

@@ -0,0 +1,160 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\Tests\Controllers;
+
+use Nyholm\Psr7\ServerRequest;
+use Siteworxpro\App\Controllers\RoutesController;
+use Siteworxpro\App\Facades\RedisClient;
+use Siteworxpro\App\Traefik\EntityEnum;
+use Siteworxpro\App\Traefik\ProtocolEnum;
+use Siteworxpro\Tests\Unit;
+
+class RoutesControllerTest extends Unit
+{
+
+    /**
+     * @throws \JsonException
+     */
+    public function testGet(): void
+    {
+        $request = new ServerRequest('GET', '/routes');
+
+        $request = $request->withAttribute('protocol', 'http');
+
+        RedisClient::expects('getAllRouters')
+            ->with(ProtocolEnum::HTTP)
+            ->andReturn(['route1', 'route2']);
+
+        $controller = new RoutesController();
+        $response = $controller->get($request);
+
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('["route1","route2"]', (string)$response->getBody());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testGetInd(): void
+    {
+        $request = new ServerRequest('GET', '/routes/foo');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo');
+
+        RedisClient::expects('getRouter')
+            ->with('foo', ProtocolEnum::HTTP)
+            ->andReturn([
+                'traefik/http/routers/foo' => 'bar',
+            ]);
+
+        $controller = new RoutesController();
+        $response = $controller->get($request);
+
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"traefik\/http\/routers\/foo":"bar"}', (string)$response->getBody());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testDelete(): void
+    {
+        $request = new ServerRequest('DELETE', '/routes/foo');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo');
+
+        RedisClient::expects('deleteAllKeys')
+            ->with('foo', EntityEnum::ROUTER, ProtocolEnum::HTTP)
+            ->andReturn(true);
+
+        $controller = new RoutesController();
+        $response = $controller->delete($request);
+
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"message":"Router deleted successfully"}', (string)$response->getBody());
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testPost(): void
+    {
+        $request = new ServerRequest('POST', '/routes/foo');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo')
+            ->withParsedBody([
+                'service' => 'my-service',
+                'rule' => 'Host(`example.com`)',
+            ]);
+
+        RedisClient::expects('createOrReplace')
+            ->with(
+                'foo',
+                [
+                    'service' => 'my-service',
+                    'rule' => 'Host(`example.com`)',
+                ],
+                EntityEnum::ROUTER,
+                ProtocolEnum::HTTP
+            )
+            ->andReturn(true);
+
+        $controller = new RoutesController();
+        $response = $controller->post($request);
+
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"message":"Router created successfully"}', (string)$response->getBody());
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testPostWithoutService(): void
+    {
+        $request = new ServerRequest('POST', '/routes/foo');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo')
+            ->withParsedBody([
+                'rule' => 'Host(`example.com`)',
+            ]);
+
+        $controller = new RoutesController();
+        $response = $controller->post($request);
+
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertEquals('{"error":"Service is required"}', (string)$response->getBody());
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testPostWithoutRule(): void
+    {
+        $request = new ServerRequest('POST', '/routes/foo');
+
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo')
+            ->withParsedBody([
+                'service' => 'my-service',
+            ]);
+
+        $controller = new RoutesController();
+        $response = $controller->post($request);
+
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertEquals('{"error":"Rule is required"}', (string)$response->getBody());
+    }
+}

tests/Controllers/ServicesControllerTest.php

@@ -0,0 +1,163 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Siteworxpro\Tests\Controllers;
+
+use Nyholm\Psr7\ServerRequest;
+use Siteworxpro\App\Controllers\ServicesController;
+use Siteworxpro\App\Facades\RedisClient;
+use Siteworxpro\App\Traefik\EntityEnum;
+use Siteworxpro\App\Traefik\ProtocolEnum;
+use Siteworxpro\Tests\Unit;
+
+class ServicesControllerTest extends Unit
+{
+
+    /**
+     * @throws \JsonException
+     */
+    public function testGet(): void
+    {
+        $request = new ServerRequest('GET', '/services');
+        $request = $request->withAttribute('protocol', 'http');
+
+        RedisClient::expects('getAllServices')
+            ->with(ProtocolEnum::HTTP)
+            ->andReturn(['service1', 'service2']);
+
+        $controller = new ServicesController();
+        $response = $controller->get($request);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('["service1","service2"]', (string)$response->getBody());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testGetInd(): void
+    {
+        $request = new ServerRequest('GET', '/services/foo');
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo');
+
+        RedisClient::expects('getService')
+            ->with('foo', ProtocolEnum::HTTP)
+            ->andReturn([
+                'traefik/http/services/foo' => 'bar',
+            ]);
+
+        $controller = new ServicesController();
+        $response = $controller->get($request);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"traefik\/http\/services\/foo":"bar"}', (string)$response->getBody());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testPost(): void
+    {
+        $request = new ServerRequest('POST', '/services/foo');
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo')
+            ->withParsedBody([
+                'loadbalancer' => [
+                    'servers' => [
+                        ['url' => 'https://example.com'],
+                    ],
+                ],
+            ]);
+
+        RedisClient::expects('createOrReplace')
+            ->with(
+                'foo',
+                [
+                    'loadbalancer' => [
+                        'servers' => [
+                            ['url' => 'https://example.com'],
+                        ],
+                    ],
+                ],
+                EntityEnum::SERVICE,
+                ProtocolEnum::HTTP
+            )
+            ->andReturn(true);
+
+        $controller = new ServicesController();
+        $response = $controller->post($request);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"message":"Service updated successfully"}', (string)$response->getBody());
+        $this->assertEquals('application/json', $response->getHeaderLine('Content-Type'));
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testPostValidation(): void
+    {
+        $request = new ServerRequest('POST', '/services/foo');
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo')
+            ->withParsedBody([]);
+
+        RedisClient::expects('createOrReplace')
+            ->with(
+                'foo',
+                [],
+                EntityEnum::SERVICE,
+                ProtocolEnum::HTTP
+            )
+            ->andReturn(true);
+
+        $controller = new ServicesController();
+        $response = $controller->post($request);
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertEquals('{"error":"loadbalancer is required"}', (string)$response->getBody());
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testDelete(): void
+    {
+        $request = new ServerRequest('DELETE', '/services/foo');
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', 'foo');
+
+        RedisClient::expects('deleteAllKeys')
+            ->with('foo', EntityEnum::SERVICE, ProtocolEnum::HTTP)
+            ->andReturn(true);
+
+        $controller = new ServicesController();
+        $response = $controller->delete($request);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"message":"Service deleted successfully"}', (string)$response->getBody());
+    }
+
+    /**
+     * @throws \JsonException
+     */
+    public function testDeleteValidation(): void
+    {
+        $request = new ServerRequest('DELETE', '/services');
+        $request = $request
+            ->withAttribute('protocol', 'http')
+            ->withAttribute('id', null);
+
+        RedisClient::expects('deleteAllKeys')
+            ->with(null, EntityEnum::SERVICE, ProtocolEnum::HTTP)
+            ->andReturn(true);
+
+        $controller = new ServicesController();
+        $response = $controller->delete($request);
+        $this->assertEquals(400, $response->getStatusCode());
+        $this->assertEquals('{"error":"Service name is required"}', (string)$response->getBody());
+    }
+}

tests/Traefik/MiddlewareServiceTest.php

@@ -48,7 +48,7 @@ class MiddlewareServiceTest extends Unit
                 '/middlewares/foo/headers/customrequestheaders/X-Forwarded-Proto',
             ]]);
 
-        $services = RedisClient::getAllMiddlewares($protocolEnum);
+        $services = new RedisClient()->getAllMiddlewares($protocolEnum);
         $this->assertCount(1, $services);
         $this->assertSame('foo', $services[0]);
     }
@@ -101,7 +101,7 @@ class MiddlewareServiceTest extends Unit
                 '/middlewares/foo/headers/customrequestheaders/X-Forwarded-Proto')
             ->andReturn('http');
 
-        $middleware = RedisClient::getMiddleware('foo', $protocolEnum);
+        $middleware = new RedisClient()->getMiddleware('foo', $protocolEnum);
 
         $this->assertCount(4, $middleware['headers']['customrequestheaders']);
         $this->assertSame('foo.localhost', $middleware['headers']['customrequestheaders']['Host']);

tests/Traefik/RedisClientRoutersTest.php

@@ -44,7 +44,7 @@ class RedisClientRoutersTest extends Unit
             ->once()
             ->andReturn(true);
 
-        RedisClient::createOrReplace('foo', [
+        new RedisClient()->createOrReplace('foo', [
             'rule' => 'Host(`foo.localhost`)',
             'service' => 'foo',
         ], EntityEnum::ROUTER, $protocol);
@@ -108,7 +108,7 @@ class RedisClientRoutersTest extends Unit
             ->with('traefik/' . $protocolEnum->getValue() . '/routers/foo/service')
             ->andReturn('foo');
 
-        $routers = RedisClient::getRouter('foo', $protocolEnum);
+        $routers = new RedisClient()->getRouter('foo', $protocolEnum);
 
         $this->assertIsArray($routers);
 
@@ -138,7 +138,7 @@ class RedisClientRoutersTest extends Unit
                 'traefik/' . $protocol->getValue() . '/routers/bar/url/0',
             ]]);
 
-        $routers = RedisClient::getAllRouters($protocol);
+        $routers = new RedisClient()->getAllRouters($protocol);
 
         $this->assertIsArray($routers);
         $this->assertCount(2, $routers);

tests/Traefik/RedisClientServiceTest.php

@@ -54,7 +54,7 @@ class RedisClientServiceTest extends Unit
             ->once()
             ->andReturn(true);
 
-        RedisClient::createOrReplace('foo', [
+        new RedisClient()->createOrReplace('foo', [
             'loadbalancer' => [
                 'servers' => [
                     'server1' => [
@@ -103,7 +103,7 @@ class RedisClientServiceTest extends Unit
             ->with('traefik/' . $protocol->getValue() . '/services/foo/loadbalancer/servers/server1/url')
             ->andReturn('http://foo.localhost:80');
 
-        $services = RedisClient::getService('foo', $protocol);
+        $services = new RedisClient()->getService('foo', $protocol);
 
         $this->assertIsArray($services);
         $this->assertArrayHasKey('loadbalancer', $services);
@@ -135,7 +135,7 @@ class RedisClientServiceTest extends Unit
                 'traefik/' . $protocol->getValue() . '/services/bar/loadbalancer/servers/server2/url',
             ]]);
 
-        $services = RedisClient::getAllServices($protocol);
+        $services = new RedisClient()->getAllServices($protocol);
 
         $this->assertIsArray($services);
         $this->assertCount(2, $services);