Add better integration tests

Author: Jamie Hannaford

src/Common/Api/OperatorInterface.php

@@ -44,11 +44,21 @@ public function execute(array $definition, array $userValues = []): ResponseInte
     public function executeAsync(array $definition, array $userValues = []): PromiseInterface;
 
     /**
-     * @param string $name The name of the model class.
+     * Retrieves a populated Operation according to the definition and values provided. A
+     * HTTP client is also injected into the object to allow it to communicate with the remote API.
+     *
+     * @param array $definition The data that dictates how the operation works
+     *
+     * @return Operation
+     */
+    public function getOperation(array $definition): Operation;
+
+    /**
+     * @param string $class The name of the model class.
      * @param mixed  $data Either a {@see ResponseInterface} or data array that will populate the newly
      *                     created model class.
      *
      * @return \OpenCloud\Common\Resource\ResourceInterface
      */
-    public function model(string $name, $data = null): ResourceInterface;
+    public function model(string $class, $data = null): ResourceInterface;
 }

src/Common/Api/Operator.php renamed to src/Common/Api/OperatorTrait.php

@@ -11,10 +11,7 @@
 use OpenCloud\Common\Transport\RequestSerializer;
 use Psr\Http\Message\ResponseInterface;
 
-/**
- * {@inheritDoc}
- */
-abstract class Operator implements OperatorInterface
+trait OperatorTrait
 {
     /** @var ClientInterface */
     protected $client;
@@ -55,18 +52,58 @@ public function __debugInfo()
     }
 
     /**
-     * Retrieves a populated Operation according to the definition and values provided. A
-     * HTTP client is also injected into the object to allow it to communicate with the remote API.
+     * Magic method which intercepts async calls, finds the sequential version, and wraps it in a
+     * {@see Promise} object. In order for this to happen, the called methods need to be in the
+     * following format: `createAsync`, where `create` is the sequential method being wrapped.
+     *
+     * @param $methodName The name of the method being invoked.
+     * @param $args       The arguments to be passed to the sequential method.
      *
-     * @param array $definition The data that dictates how the operation works
+     * @throws \RuntimeException If method does not exist
      *
-     * @return Operation
+     * @return Promise
+     */
+    public function __call($methodName, $args)
+    {
+        $e = function ($name) {
+            return new \RuntimeException(sprintf('%s::%s is not defined', get_class($this), $name));
+        };
+
+        if (substr($methodName, -5) === 'Async') {
+            $realMethod = substr($methodName, 0, -5);
+            if (!method_exists($this, $realMethod)) {
+                throw $e($realMethod);
+            }
+
+            $promise = new Promise(
+                function () use (&$promise, $realMethod, $args) {
+                    $value = call_user_func_array([$this, $realMethod], $args);
+                    $promise->resolve($value);
+                }
+            );
+
+            return $promise;
+        }
+
+        throw $e($methodName);
+    }
+
+    /**
+     * {@inheritdoc}
      */
     public function getOperation(array $definition): Operation
     {
         return new Operation($definition);
     }
 
+    /**
+     * @param Operation $operation
+     * @param array     $userValues
+     * @param bool      $async
+     *
+     * @return mixed
+     * @throws \Exception
+     */
     protected function sendRequest(Operation $operation, array $userValues = [], bool $async = false)
     {
         $operation->validate($userValues);
@@ -100,76 +137,16 @@ public function executeAsync(array $definition, array $userValues = []): Promise
     public function model(string $class, $data = null): ResourceInterface
     {
         $model = new $class($this->client, $this->api);
-
         // @codeCoverageIgnoreStart
         if (!$model instanceof ResourceInterface) {
             throw new \RuntimeException(sprintf('%s does not implement %s', $class, ResourceInterface::class));
         }
         // @codeCoverageIgnoreEnd
-
         if ($data instanceof ResponseInterface) {
             $model->populateFromResponse($data);
         } elseif (is_array($data)) {
             $model->populateFromArray($data);
         }
-
         return $model;
     }
-
-    /**
-     * Will create a new instance of this class with the current HTTP client and API injected in. This
-     * is useful when enumerating over a collection since multiple copies of the same resource class
-     * are needed.
-     *
-     * @return static
-     */
-    public function newInstance(): self
-    {
-        return new static($this->client, $this->api);
-    }
-
-    /**
-     * @return \GuzzleHttp\Psr7\Uri:null
-     */
-    protected function getHttpBaseUrl()
-    {
-        return $this->client->getConfig('base_uri');
-    }
-
-    /**
-     * Magic method which intercepts async calls, finds the sequential version, and wraps it in a
-     * {@see Promise} object. In order for this to happen, the called methods need to be in the
-     * following format: `createAsync`, where `create` is the sequential method being wrapped.
-     *
-     * @param $methodName The name of the method being invoked.
-     * @param $args       The arguments to be passed to the sequential method.
-     *
-     * @throws \RuntimeException If method does not exist
-     *
-     * @return Promise
-     */
-    public function __call($methodName, $args)
-    {
-        $e = function ($name) {
-            return new \RuntimeException(sprintf('%s::%s is not defined', get_class($this), $name));
-        };
-
-        if (substr($methodName, -5) === 'Async') {
-            $realMethod = substr($methodName, 0, -5);
-            if (!method_exists($this, $realMethod)) {
-                throw $e($realMethod);
-            }
-
-            $promise = new Promise(
-                function () use (&$promise, $realMethod, $args) {
-                    $value = call_user_func_array([$this, $realMethod], $args);
-                    $promise->resolve($value);
-                }
-            );
-
-            return $promise;
-        }
-
-        throw $e($methodName);
-    }
 }

src/Common/Api/Parameter.php

@@ -240,7 +240,7 @@ private function validateObject($userValues)
     /**
      * Internal method which retrieves a nested property for object parameters.
      *
-     * @param $key The name of the child parameter
+     * @param string $key The name of the child parameter
      *
      * @returns Parameter
      * @throws \Exception

src/Common/HydratorStrategyTrait.php

@@ -15,17 +15,17 @@ trait HydratorStrategyTrait
      * @param array $data    The data to set
      * @param array $aliases Any aliases
      */
-    private function hydrate(array $data, array $aliases = [])
+    public function hydrate(array $data, array $aliases = [])
     {
         foreach ($data as $key => $val) {
             $key = isset($aliases[$key]) ? $aliases[$key] : $key;
             if (property_exists($this, $key)) {
-                $this->$key = $val;
+                $this->{$key} = $val;
             }
         }
     }
 
-    private function set(string $key, $property, array $data, callable $fn = null)
+    public function set(string $key, $property, array $data, callable $fn = null)
     {
         if (isset($data[$key]) && property_exists($this, $property)) {
             $value = $fn ? call_user_func($fn, $data[$key]) : $data[$key];

src/Common/Resource/AbstractResource.php

@@ -2,7 +2,7 @@
 
 namespace OpenCloud\Common\Resource;
 
-use OpenCloud\Common\Api\Operator;
+use OpenCloud\Common\Transport\Serializable;
 use OpenCloud\Common\Transport\Utils;
 use Psr\Http\Message\ResponseInterface;
 
@@ -13,10 +13,8 @@
  *
  * @package OpenCloud\Common\Resource
  */
-abstract class AbstractResource extends Operator implements ResourceInterface
+abstract class AbstractResource implements ResourceInterface, Serializable
 {
-    const DEFAULT_MARKER_KEY = 'id';
-
     /**
      * The JSON key that indicates how the API nests singular resources. For example, when
      * performing a GET, it could respond with ``{"server": {"id": "12345"}}``. In this case,
@@ -26,22 +24,6 @@ abstract class AbstractResource extends Operator implements ResourceInterface
      */
     protected $resourceKey;
 
-    /**
-     * The key that indicates how the API nests resource collections. For example, when
-     * performing a GET, it could respond with ``{"servers": [{}, {}]}``. In this case, "servers"
-     * is the resources key, since the array of servers is nested inside.
-     *
-     * @var string
-     */
-    protected $resourcesKey;
-
-    /**
-     * Indicates which attribute of the current resource should be used for pagination markers.
-     *
-     * @var string
-     */
-    protected $markerKey;
-
     /**
      * An array of aliases that will be checked when the resource is being populated. For example,
      *
@@ -58,7 +40,7 @@ abstract class AbstractResource extends Operator implements ResourceInterface
      *
      * @param ResponseInterface $response
      *
-     * @return $this|ResourceInterface
+     * @return AbstractResource
      */
     public function populateFromResponse(ResponseInterface $response): self
     {
@@ -166,80 +148,46 @@ protected function getAttrs(array $keys)
         return $output;
     }
 
-    /**
-     * @param array $definition
-     *
-     * @return mixed
-     */
-    public function executeWithState(array $definition)
+    public function model(string $class, $data = null): ResourceInterface
     {
-        return $this->execute($definition, $this->getAttrs(array_keys($definition['params'])));
-    }
+        $model = new $class();
 
-    private function getResourcesKey(): string
-    {
-        $resourcesKey = $this->resourcesKey;
+        // @codeCoverageIgnoreStart
+        if (!$model instanceof ResourceInterface) {
+            throw new \RuntimeException(sprintf('%s does not implement %s', $class, ResourceInterface::class));
+        }
+        // @codeCoverageIgnoreEnd
 
-        if (!$resourcesKey) {
-            $class = substr(static::class, strrpos(static::class, '\\') + 1);
-            $resourcesKey = strtolower(preg_replace('/([a-z])([A-Z])/', '$1_$2', $class)) . 's';
+        if ($data instanceof ResponseInterface) {
+            $model->populateFromResponse($data);
+        } elseif (is_array($data)) {
+            $model->populateFromArray($data);
         }
 
-        return $resourcesKey;
+        return $model;
     }
 
-    /**
-     * {@inheritDoc}
-     */
-    public function enumerate(array $def, array $userVals = [], callable $mapFn = null): \Generator
+    public function serialize(): \stdClass
     {
-        $operation = $this->getOperation($def);
+        $output = new \stdClass();
 
-        $requestFn = function ($marker) use ($operation, $userVals) {
-            if ($marker) {
-                $userVals['marker'] = $marker;
-            }
-            return $this->sendRequest($operation, $userVals);
-        };
-
-        $resourceFn = function (array $data) {
-            $resource = $this->newInstance();
-            $resource->populateFromArray($data);
-            return $resource;
-        };
-
-        $opts = [
-            'limit'        => isset($userVals['limit']) ? $userVals['limit'] : null,
-            'resourcesKey' => $this->getResourcesKey(),
-            'markerKey'    => $this->markerKey,
-            'mapFn'        => $mapFn,
-        ];
-
-        $iterator = new Iterator($opts, $requestFn, $resourceFn);
-        return $iterator();
-    }
+        foreach ((new \ReflectionClass($this))->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
+            $name = $property->getName();
+            $val = $this->{$name};
 
-    public function extractMultipleInstances(ResponseInterface $response, string $key = null): array
-    {
-        $key = $key ?: $this->getResourcesKey();
-        $resourcesData = Utils::jsonDecode($response)[$key];
+            $fn = function ($val) {
+                return ($val instanceof Serializable) ? $val->serialize() : $val;
+            };
 
-        $resources = [];
+            if (is_array($val)) {
+                foreach ($val as $sk => $sv) {
+                    $val[$sk] = $fn($sv);
+                }
+            }
 
-        foreach ($resourcesData as $resourceData) {
-            $resource = $this->newInstance();
-            $resource->populateFromArray($resourceData);
-            $resources[] = $resource;
+            $output->{$name} = $fn($val);
         }
 
-        return $resources;
-    }
-
-    protected function getService()
-    {
-        $class = static::class;
-        $service = substr($class, 0, strpos($class, 'Models') - 1) . '\\Service';
-
-        return new $service($this->client, $this->api);
+        return $output;
     }
 }