WIP adding mocks

Author: eceltov

app/V1Module/presenters/base/BasePresenter.php

@@ -12,7 +12,6 @@
 use App\Exceptions\WrongHttpMethodException;
 use App\Exceptions\NotImplementedException;
 use App\Exceptions\InternalServerException;
-use App\Exceptions\InvalidApiArgumentException;
 use App\Exceptions\FrontendErrorMappings;
 use App\Security\AccessManager;
 use App\Security\Authorizator;
@@ -27,7 +26,6 @@
 use App\Responses\StorageFileResponse;
 use App\Responses\ZipFilesResponse;
 use Nette\Application\Application;
-use Nette\Application\Request;
 use Nette\Http\IResponse;
 use Tracy\ILogger;
 use ReflectionClass;
@@ -130,7 +128,7 @@ public function startup()
         $this->tryCall($this->formatPermissionCheckMethod($this->getAction()), $this->params);
 
         Validators::init();
-        $this->processParams($this->getRequest(), $actionReflection);
+        $this->processParams($actionReflection);
     }
 
     protected function isRequestJson(): bool
@@ -206,30 +204,28 @@ public function getFormatInstance(): MetaFormat
         return $this->requestFormatInstance;
     }
 
-    private function processParams(Request $request, ReflectionMethod $reflection)
+    private function processParams(ReflectionMethod $reflection)
     {
         // use a method specialized for formats if there is a format available
         $format = MetaFormatHelper::extractFormatFromAttribute($reflection);
         if ($format !== null) {
-            $this->requestFormatInstance = $this->processParamsFormat($request, $format, null);
+            $this->requestFormatInstance = $this->processParamsFormat($format, null);
         }
 
         // handle loose parameters
         $paramData = MetaFormatHelper::extractRequestParamData($reflection);
-        $this->processParamsLoose($request, $paramData);
+        $this->processParamsLoose($paramData);
     }
 
     /**
      * Processes loose parameters. Request parameters are validated, no new data is created.
-     * @throws InvalidApiArgumentException Thrown when the request parameter values do not conform to the definition.
-     * @param Request $request Request object holding the request data.
      * @param array $paramData Parameter data to be validated.
      */
-    private function processParamsLoose(Request $request, array $paramData)
+    private function processParamsLoose(array $paramData)
     {
         // validate each param
         foreach ($paramData as $param) {
-            $paramValue = $this->getValueFromParamData($request, $param);
+            $paramValue = $this->getValueFromParamData($param);
 
             // this throws when it does not conform
             $param->conformsToDefinition($paramValue);
@@ -239,17 +235,15 @@ private function processParamsLoose(Request $request, array $paramData)
     /**
      * Processes parameters defined by a format. Request parameters are validated and a format instance with
      *  parameter values created.
-     * @param Request $request Request object holding the request data.
      * @param string $format The format defining the parameters.
      * @param ?array $valueDictionary If not null, a nested format instance will be created. The values will be taken
      *  from here instead of the request object. Format validation ignores parameter type (path, query or post).
      *  A top-level format will be created if null.
      * @throws InternalServerException Thrown when the format definition is corrupted/absent.
-     * @throws BadRequestException Thrown when the request parameter values do not meet the structural constraints.
-     * @throws InvalidApiArgumentException Thrown when the request parameter values do not conform to the definition.
+     * @throws BadRequestException Thrown when the request parameter values do not conform to the definition.
      * @return MetaFormat Returns a format instance with values filled from the request object.
      */
-    private function processParamsFormat(Request $request, string $format, ?array $valueDictionary): MetaFormat
+    private function processParamsFormat(string $format, ?array $valueDictionary): MetaFormat
     {
         // get the parsed attribute data from the format fields
         $formatToFieldDefinitionsMap = FormatCache::getFormatToFieldDefinitionsMap();
@@ -265,7 +259,7 @@ private function processParamsFormat(Request $request, string $format, ?array $v
             $value = null;
             // top-level format
             if ($valueDictionary === null) {
-                $value = $this->getValueFromParamData($request, $requestParamData);
+                $value = $this->getValueFromParamData($requestParamData);
                 // nested format
             } else {
                 // Instead of retrieving the values with the getRequest call, use the provided $valueDictionary.
@@ -281,7 +275,7 @@ private function processParamsFormat(Request $request, string $format, ?array $v
             // replace the value dictionary stored in $value with a format instance
             $nestedFormatName = $requestParamData->getFormatName();
             if ($nestedFormatName !== null) {
-                $value = $this->processParamsFormat($request, $nestedFormatName, $value);
+                $value = $this->processParamsFormat($nestedFormatName, $value);
             }
 
             // this throws if the value is invalid
@@ -298,37 +292,37 @@ private function processParamsFormat(Request $request, string $format, ?array $v
 
     /**
      * Calls either getPostField, getQueryField or getPathField based on the provided metadata.
-     * @param Request $request Request object holding the request data.
      * @param \App\Helpers\MetaFormats\RequestParamData $paramData Metadata of the request parameter.
      * @throws \App\Exceptions\InternalServerException Thrown when an unexpected parameter location was set.
      * @return mixed Returns the value from the request.
      */
-    private function getValueFromParamData(Request $request, RequestParamData $paramData): mixed
+    private function getValueFromParamData(RequestParamData $paramData): mixed
     {
         switch ($paramData->type) {
             case Type::Post:
-                return $this->getPostField($request, $paramData->name, required: $paramData->required);
+                return $this->getPostField($paramData->name, required: $paramData->required);
             case Type::Query:
-                return $this->getQueryField($request, $paramData->name, required: $paramData->required);
+                return $this->getQueryField($paramData->name, required: $paramData->required);
             case Type::Path:
-                return $this->getPathField($request, $paramData->name);
+                return $this->getPathField($paramData->name);
             default:
                 throw new InternalServerException("Unknown parameter type: {$paramData->type->name}");
         }
     }
 
-    private function getPostField(Request $request, $param, $required = true)
+    private function getPostField($param, $required = true)
     {
-        $post = $request->getPost();
+        $req = $this->getRequest();
+        $post = $req->getPost();
 
-        if ($request->isMethod("POST")) {
+        if ($req->isMethod("POST")) {
             // nothing to see here...
         } else {
-            if ($request->isMethod("PUT") || $request->isMethod("DELETE")) {
+            if ($req->isMethod("PUT") || $req->isMethod("DELETE")) {
                 parse_str(file_get_contents('php://input'), $post);
             } else {
                 throw new WrongHttpMethodException(
-                    "Cannot get the post parameters in method '" . $request->getMethod() . "'."
+                    "Cannot get the post parameters in method '" . $req->getMethod() . "'."
                 );
             }
         }
@@ -344,18 +338,18 @@ private function getPostField(Request $request, $param, $required = true)
         }
     }
 
-    private function getQueryField(Request $request, $param, $required = true)
+    private function getQueryField($param, $required = true)
     {
-        $value = $request->getParameter($param);
+        $value = $this->getRequest()->getParameter($param);
         if ($value === null && $required) {
             throw new BadRequestException("Missing required query field $param");
         }
         return $value;
     }
 
-    private function getPathField(Request $request, $param)
+    private function getPathField($param)
     {
-        $value = $request->getParameter($param);
+        $value = $this->getParameter($param);
         if ($value === null) {
             throw new BadRequestException("Missing required path field $param");
         }

app/helpers/Mocks/MockHelper.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Helpers\Mocks;
+
+use App\Helpers\Mocks\MockUserStorage;
+use App\Security\UserStorage;
+use App\V1Module\Presenters\BasePresenter;
+use App\V1Module\Presenters\RegistrationPresenter;
+use Nette\Application\Application;
+use Nette\Application\PresenterFactory;
+use Nette\Application\Request;
+use Nette\Application\Responses\JsonResponse;
+use Nette\Application\Routers\RouteList;
+use Nette\Http\Response;
+use Nette\Http\UrlScript;
+use Nette\Security\User;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use App\Exceptions\InvalidAccessTokenException;
+use App\Exceptions\InvalidArgumentException;
+use Nette;
+use Nette\Security\IIdentity;
+
+class MockHelper
+{
+    /**
+     * Initializes a presenter object with empty http request, response, and user objects.
+     * @param BasePresenter $presenter The presenter to be initialized.
+     */
+    public static function initPresenter(BasePresenter $presenter)
+    {
+        $httpRequest = new \Nette\Http\Request(new UrlScript());
+        $httpResponse = new Response();
+        $user = new User(new MockUserStorage());
+
+        $application = new Application(new PresenterFactory(), new RouteList("V1"), $httpRequest, $httpResponse);
+        $presenter->application = $application;
+
+        $factory = new MockTemplateFactory();
+
+        $presenter->injectPrimary($httpRequest, $httpResponse, user: $user, templateFactory: $factory);
+    }
+}

app/helpers/Mocks/MockTemplate.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Helpers\Mocks;
+
+use Nette;
+use Nette\Application\UI\Template;
+use Nette\Application\UI\TemplateFactory;
+use Nette\Security\IIdentity;
+
+class MockTemplate implements Template
+{
+    public function render(): void
+    {
+    }
+
+    public function setFile(string $file): static
+    {
+        return $this;
+    }
+
+    public function getFile(): ?string
+    {
+        return "test";
+    }
+}

app/helpers/Mocks/MockTemplateFactory.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Helpers\Mocks;
+
+use Nette;
+use Nette\Application\UI\Control;
+use Nette\Application\UI\Template;
+use Nette\Application\UI\TemplateFactory;
+use Nette\Security\IIdentity;
+
+class MockTemplateFactory implements TemplateFactory
+{
+    public function createTemplate(?Control $control = null): Template
+    {
+        return new MockTemplate();
+    }
+}

app/helpers/Mocks/MockUserStorage.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Helpers\Mocks;
+
+use Nette;
+use Nette\Security\IIdentity;
+
+class MockUserStorage implements Nette\Security\UserStorage
+{
+    public function setExpiration(?string $expire, bool $clearIdentity): void
+    {
+    }
+
+    public function saveAuthentication(IIdentity $identity): void
+    {
+    }
+
+    public function clearAuthentication(bool $clearIdentity): void
+    {
+    }
+
+    public function getState(): array
+    {
+        return [false, null, 0];
+    }
+}

tests/Validation/BasePresenter.phpt

@@ -24,6 +24,7 @@ use App\Helpers\MetaFormats\Validators\VObject;
 use App\Helpers\MetaFormats\Validators\VString;
 use App\Helpers\MetaFormats\Validators\VTimestamp;
 use App\Helpers\MetaFormats\Validators\VUuid;
+use App\Helpers\Mocks\MockHelper;
 use App\V1Module\Presenters\BasePresenter;
 use Nette\Application\Request;
 use Tester\Assert;
@@ -55,17 +56,20 @@ class TestPresenter extends BasePresenter
     #[Path("path", new VInt())]
     public function actionTestLoose()
     {
+        $this->sendSuccessResponse("OK");
     }
 
     #[Format(PresenterTestFormat::class)]
     public function actionTestFormat()
     {
+        $this->sendSuccessResponse("OK");
     }
 
     #[Format(PresenterTestFormat::class)]
     #[Post("loose", new VInt())]
     public function actionTestCombined()
     {
+        $this->sendSuccessResponse("OK");
     }
 }
 
@@ -106,44 +110,38 @@ class TestBasePresenter extends Tester\TestCase
         Assert::notNull(FormatCache::getFieldDefinitions($format), "Tests whether a format was injected successfully.");
     }
 
-    private static function getMethod(BasePresenter $presenter, string $methodName): ReflectionMethod
-    {
-        $presenterReflection = new ReflectionObject($presenter);
-        $methodReflection = $presenterReflection->getMethod($methodName);
-        $methodReflection->setAccessible(true);
-        return $methodReflection;
-    }
-
     public function testLooseValid()
     {
         $presenter = new TestPresenter();
-        $action = self::getMethod($presenter, "actionTestLoose");
-        $processParams = self::getMethod($presenter, "processParams");
+        MockHelper::initPresenter($presenter);
 
-        // create a request object and invoke the actionTestLoose method
-        $request = new Request("name", method: "POST", params: ["path" => "1", "query" => "1"], post: ["post" => 1]);
-        $processParams->invoke($presenter, $request, $action);
+        // create a request object
+        $request = new Request(
+            "name",
+            method: "POST",
+            params: ["action" => "testLoose", "path" => "1", "query" => "1"],
+            post: ["post" => 1]
+        );
 
-        // check that the previous row did not throw
-        Assert::true(true);
+        $response = $presenter->run($request);
+        Assert::equal("OK", $response->getPayload()["payload"]);
     }
 
     public function testLooseInvalid()
     {
         $presenter = new TestPresenter();
-        $action = self::getMethod($presenter, "actionTestLoose");
-        $processParams = self::getMethod($presenter, "processParams");
+        MockHelper::initPresenter($presenter);
 
         // set an invalid parameter value and assert that the validation fails
         $request = new Request(
             "name",
             method: "POST",
-            params: ["path" => "string", "query" => "1"],
+            params: ["action" => "testLoose", "path" => "string", "query" => "1"],
             post: ["post" => 1]
         );
         Assert::throws(
-            function () use ($processParams, $presenter, $request, $action) {
-                $processParams->invoke($presenter, $request, $action);
+            function () use ($presenter, $request) {
+                $presenter->run($request);
             },
             InvalidApiArgumentException::class
         );