Improve tests and refactor generator

Author: GromNaN

generator/src/FluentStageFactoryGenerator.php

@@ -28,11 +28,11 @@
 use MongoDB\Model\BSONArray;
 use Nette\PhpGenerator\ClassType;
 use Nette\PhpGenerator\Method;
+use Nette\PhpGenerator\Parameter;
 use Nette\PhpGenerator\PhpNamespace;
 use Nette\PhpGenerator\TraitType;
-use RuntimeException;
+use ReflectionClass;
 use stdClass;
-use Throwable;
 
 use function array_key_last;
 use function array_map;
@@ -42,15 +42,11 @@
 
 /**
  * Generates a fluent factory class for aggregation pipeline stages.
- * The method definition is based on the manually edited static class
- * that imports the stage factory trait.
+ * The method definition is based on all the public static methods
+ * of the Stage class.
  */
 class FluentStageFactoryGenerator extends OperatorGenerator
 {
-    /**
-     * All public of this class are duplicated as instance methods of the
-     * fluent factory class.
-     */
     private const FACTORY_CLASS = Stage::class;
 
     public function generate(GeneratorDefinition $definition): void
@@ -98,37 +94,37 @@ private function createFluentFactoryClass(GeneratorDefinition $definition): PhpN
 
         $staticFactory = ClassType::from(self::FACTORY_CLASS);
         assert($staticFactory instanceof ClassType);
+
+        // Import the methods customized in the factory class
         foreach ($staticFactory->getMethods() as $method) {
             if (! $method->isPublic()) {
                 continue;
             }
 
-            try {
-                $this->addMethod($method, $namespace, $class);
-            } catch (Throwable $e) {
-                throw new RuntimeException(sprintf('Failed to generate class for operator "%s"', $operator->name), 0, $e);
-            }
+            $this->addMethod($method, $class);
         }
 
-        $staticFactory = TraitType::from(Stage\FactoryTrait::class);
-        assert($staticFactory instanceof TraitType);
-        foreach ($staticFactory->getMethods() as $method) {
-            if (! $method->isPublic()) {
-                continue;
-            }
-
-            try {
-                $this->addMethod($method, $namespace, $class);
-            } catch (Throwable $e) {
-                throw new RuntimeException(sprintf('Failed to generate class for operator "%s"', $operator->name), 0, $e);
+        // Import the other methods provided by the generated trait
+        foreach ($staticFactory->getTraits() as $trait) {
+            $staticFactory = TraitType::from($trait->getName());
+            assert($staticFactory instanceof TraitType);
+            foreach ($staticFactory->getMethods() as $method) {
+                $this->addMethod($method, $class);
             }
         }
 
         return $namespace;
     }
 
-    private function addMethod(Method $factoryMethod, PhpNamespace $namespace, ClassType $class): void
+    private function addMethod(Method $factoryMethod, ClassType $class): void
     {
+        // Non-public methods are not part of the API
+        if (! $factoryMethod->isPublic()) {
+            return;
+        }
+
+        // Some methods can be overridden in the class, so we skip them
+        // when importing the methods provided by the trait.
         if ($class->hasMethod($factoryMethod->getName())) {
             return;
         }
@@ -139,7 +135,7 @@ private function addMethod(Method $factoryMethod, PhpNamespace $namespace, Class
         $method->setParameters($factoryMethod->getParameters());
 
         $args = array_map(
-            fn ($param) => '$' . $param->getName(),
+            fn (Parameter $param): string => '$' . $param->getName(),
             $factoryMethod->getParameters(),
         );
 
@@ -155,9 +151,9 @@ private function addMethod(Method $factoryMethod, PhpNamespace $namespace, Class
 
             return $this;
             PHP,
-            'Stage',
+            (new ReflectionClass(self::FACTORY_CLASS))->getShortName(),
             $factoryMethod->getName(),
-            implode(',', $args),
+            implode(', ', $args),
         ));
     }
 }

src/Builder/Stage/FluentFactory.php

@@ -4,13 +4,11 @@
 
 namespace MongoDB\Tests\Builder;
 
-use MongoDB\Builder\Pipeline;
 use MongoDB\Builder\Query;
 use MongoDB\Builder\Stage\FluentFactory;
 use MongoDB\Builder\Type\Sort;
-use PHPUnit\Framework\TestCase;
 
-class FluentPipelineFactoryTest extends TestCase
+class FluentPipelineFactoryTest extends PipelineTestCase
 {
     public function testFluentPipelineFactory(): void
     {
@@ -20,7 +18,14 @@ public function testFluentPipelineFactory(): void
             ->sort(x: Sort::Asc)
             ->getPipeline();
 
-        $this->assertInstanceof(Pipeline::class, $pipeline);
-        $this->assertCount(3, $pipeline->getIterator());
+        $expected = <<<'json'
+        [
+            {"$match": {"x": {"$eq": {"$numberInt":  "1"}}}},
+            {"$project": {"_id": false, "x": true}},
+            {"$sort": {"x": {"$numberInt":  "1"}}}
+        ]
+        json;
+
+        $this->assertSamePipeline($expected, $pipeline);
     }
 }