Improve ResultMockFactory (#342)

* Improve ResultMock

* Update src/Core/src/Test/ResultMockFactory.php

Co-Authored-By: Clement Seiller <[email protected]>

Co-authored-by: Clement Seiller <[email protected]>

Author: jderusse

src/Test/ResultMockFactory.php

@@ -4,7 +4,10 @@
 
 namespace AsyncAws\Core\Test;
 
+use AsyncAws\Core\Response;
 use AsyncAws\Core\Result;
+use AsyncAws\Core\Test\Http\SimpleMockedResponse;
+use Symfony\Component\HttpClient\MockHttpClient;
 
 /**
  * An easy way to create Result objects for your tests.
@@ -13,6 +16,36 @@
  */
 class ResultMockFactory
 {
+    /**
+     * Instantiate a Result class that throws exception.
+     *
+     * <code>
+     * ResultMockFactory::createFailing(SendEmailResponse::class, 400, 'invalid value');
+     * </code>
+     *
+     * @template T
+     * @psalm-param class-string<T> $class
+     *
+     * @return Result|T
+     */
+    public static function createFailing(string $class, int $code, ?string $message = null)
+    {
+        if (Result::class !== $class) {
+            $parent = get_parent_class($class);
+            if (false === $parent || Result::class !== $parent) {
+                throw new \LogicException(sprintf('The "%s::%s" can only be used for classes that extend "%s"', __CLASS__, __METHOD__, Result::class));
+            }
+        }
+
+        $httpResponse = new SimpleMockedResponse(\json_encode(['message' => $message]), ['content-type' => 'application/json'], $code);
+        $client = new MockHttpClient($httpResponse);
+        $response = new Response($client->request('POST', 'http://localhost'), $client);
+
+        $reflectionClass = new \ReflectionClass($class);
+
+        return $reflectionClass->newInstance($response);
+    }
+
     /**
      * Instantiate a Result class with some data.
      *
@@ -23,26 +56,34 @@ class ResultMockFactory
      * @template T
      * @psalm-param class-string<T> $class
      *
-     * @return T
+     * @return Result|T
      */
     public static function create(string $class, array $data = [])
     {
-        $parent = get_parent_class($class);
-        if (false === $parent || Result::class !== $parent) {
-            throw new \LogicException(sprintf('The "%s::%s" can only be used for classes that extend "%s"', __CLASS__, __METHOD__, Result::class));
+        if (Result::class !== $class) {
+            $parent = get_parent_class($class);
+            if (false === $parent || Result::class !== $parent) {
+                throw new \LogicException(sprintf('The "%s::%s" can only be used for classes that extend "%s"', __CLASS__, __METHOD__, Result::class));
+            }
         }
 
-        $rereflectionClass = new \ReflectionClass($class);
-        $object = $rereflectionClass->newInstanceWithoutConstructor();
+        $reflectionClass = new \ReflectionClass(Response::class);
+        $response = $reflectionClass->newInstanceWithoutConstructor();
+        $property = $reflectionClass->getProperty('resolveResult');
+        $property->setAccessible(true);
+        $property->setValue($response, true);
+
+        $reflectionClass = new \ReflectionClass($class);
+        $object = $reflectionClass->newInstance($response);
         $data['initialized'] = true;
 
         foreach ($data as $propertyName => $propertyValue) {
-            $property = $rereflectionClass->getProperty($propertyName);
+            $property = $reflectionClass->getProperty($propertyName);
             $property->setAccessible(true);
             $property->setValue($object, $propertyValue);
         }
 
-        self::addUndefinedProperties($rereflectionClass, $object, $data);
+        self::addUndefinedProperties($reflectionClass, $object, $data);
 
         return $object;
     }
@@ -52,14 +93,18 @@ public static function create(string $class, array $data = [])
      *
      * @throws \ReflectionException
      */
-    private static function addUndefinedProperties(\ReflectionClass $rereflectionClass, $object, array $data): void
+    private static function addUndefinedProperties(\ReflectionClass $reflectionClass, $object, array $data): void
     {
-        foreach ($rereflectionClass->getProperties(\ReflectionProperty::IS_PRIVATE) as $property) {
+        foreach ($reflectionClass->getProperties(\ReflectionProperty::IS_PRIVATE) as $property) {
             if (\array_key_exists($property->getName(), $data)) {
                 continue;
             }
 
-            $getter = $rereflectionClass->getMethod('get' . $property->getName());
+            if (!$reflectionClass->hasMethod('get' . $property->getName())) {
+                continue;
+            }
+
+            $getter = $reflectionClass->getMethod('get' . $property->getName());
             /** @psalm-suppress PossiblyNullReference */
             if (!$getter->hasReturnType() || $getter->getReturnType()->allowsNull()) {
                 continue;

tests/Unit/Test/ResultMockFactoryTest.php

@@ -4,6 +4,8 @@
 
 namespace AsyncAws\Core\Tests\Unit\Test;
 
+use AsyncAws\Core\Exception\Http\ClientException;
+use AsyncAws\Core\Result;
 use AsyncAws\Core\Sts\Result\AssumedRoleUser;
 use AsyncAws\Core\Sts\Result\AssumeRoleResponse;
 use AsyncAws\Core\Test\ResultMockFactory;
@@ -52,4 +54,33 @@ public function testCreateWithInvalidClass()
             'AssumedRoleId' => 'foo123',
         ]);
     }
+
+    public function testCreateWithResult()
+    {
+        $result = ResultMockFactory::create(Result::class, []);
+
+        self::assertInstanceOf(Result::class, $result);
+    }
+
+    public function testCallToResolveDontFail()
+    {
+        $result = ResultMockFactory::create(Result::class, []);
+
+        self::assertTrue($result->resolve());
+    }
+
+    public function testCreateFailling()
+    {
+        $result = ResultMockFactory::createFailing(Result::class, 400, 'Boom');
+
+        $this->expectException(ClientException::class);
+        $this->expectExceptionCode(400);
+        $this->expectExceptionMessage('HTTP 400 returned for "http://localhost/".
+
+Boom
+
+');
+
+        $result->resolve();
+    }
 }