Merge pull request #35 from chintan-j-patel/master

Fixing Swagger to ignore abstract classes

src/Zynga/Framework/Dynamic/V1/DynamicClassCreation.hh

@@ -41,6 +41,24 @@ class DynamicClassCreation {
     return in_array($interfaceName, $reflected->getInterfaceNames());
   }
 
+  public static function isClassAbstract(
+    string $className,
+  ): bool {
+    if (DynamicClassCreation::doesClassExist($className) === false) {
+      throw new UnableToFindClassException('class='.$className);
+    }
+
+    $reflected = ReflectionClasses::getReflection($className);
+
+    if (!$reflected instanceof ReflectionClass) {
+      throw new UnableToFindClassException(
+        'class='.$className.' - unable to reflect',
+      );
+    }
+
+    return $reflected->isAbstract();
+  }
+
   public static function createClassByNameGeneric<Tv>(
     string $name,
     Vector<mixed> $params,

src/Zynga/Framework/Dynamic/V1/DynamicClassCreationTest.hh

@@ -9,9 +9,19 @@ use Zynga\Framework\Dynamic\V1\Exceptions\MissingRequiredParametersException;
 use Zynga\Framework\Dynamic\V1\Mocks\EmptyClass;
 use Zynga\Framework\Dynamic\V1\Mocks\ClassWithConstructor;
 use Zynga\Framework\Dynamic\V1\Mocks\ClassWithConstructorParams;
+use Zynga\Framework\ReflectionCache\V1\ReflectionClasses;
 
 class DynamicClassCreationTest extends TestCase {
 
+  <<__Override>>
+  public function tearDown(): void {
+    parent::tearDown();
+
+    // Disable failure for ReflectionClasses so that
+    // it can function normally
+    ReflectionClasses::disableFailure(); 
+  }
+
   public function testDoesClassExist(): void {
     $this->assertTrue(
       DynamicClassCreation::doesClassExist(
@@ -36,6 +46,19 @@ class DynamicClassCreationTest extends TestCase {
     $this->assertTrue($obj instanceof EmptyClass);
   }
 
+  public function testFailureToReflectThrowsExceptionForClassExistsGeneric(
+  ): void {
+    $this->expectException(UnableToFindClassException::class);
+
+    $className = 'Zynga\Framework\Dynamic\V1\Mocks\EmptyClass';
+    ReflectionClasses::enableFailure($className);
+
+    DynamicClassCreation::createClassByNameGeneric(
+      $className,
+      Vector {},
+    );
+  }
+
   public function testClassExists(): void {
     $obj = DynamicClassCreation::createClassByName(
       'Zynga\Framework\Dynamic\V1\Mocks\EmptyClass',
@@ -125,4 +148,46 @@ class DynamicClassCreationTest extends TestCase {
     );
   }
 
+  public function testFailureToReflectThrowsExceptionForDoesClassImplementInterface(
+  ): void {
+    $this->expectException(UnableToFindClassException::class);
+
+    $className = 'Zynga\Framework\Dynamic\V1\Mocks\ClassWithSingleInterface';
+    ReflectionClasses::enableFailure($className);
+
+    DynamicClassCreation::doesClassImplementInterface(
+      $className,
+      'Zynga\Framework\Dynamic\V1\Mocks\EmptyInterface',
+    );
+  }
+
+  public function testIsClassAbstract(): void {
+    $this->assertTrue(
+      DynamicClassCreation::isClassAbstract(
+        'Zynga\Framework\Dynamic\V1\Mocks\AbstractClass',
+      ),
+      'AbstractClass is not marked as abstract',
+    );
+    $this->assertFalse(
+      DynamicClassCreation::isClassAbstract(
+        'Zynga\Framework\Dynamic\V1\Mocks\EmptyClass',
+      ),
+      'EmptyClass is marked as abstract',
+    );
+  }
+
+  public function testInvalidClassThrowsExceptionForIsClassAbstract(): void {
+    $this->expectException(UnableToFindClassException::class);
+    $obj = DynamicClassCreation::isClassAbstract('Not_Real_Class');
+  }
+
+  public function testFailureToReflectThrowsExceptionForIsClassAbstract(
+  ): void {
+    $this->expectException(UnableToFindClassException::class);
+
+    $className = 'Zynga\Framework\Dynamic\V1\Mocks\AbstractClass';
+    ReflectionClasses::enableFailure($className);
+
+    DynamicClassCreation::isClassAbstract($className);
+  }
 }

src/Zynga/Framework/Dynamic/V1/Mocks/AbstractClass.hh

@@ -0,0 +1,5 @@
+<?hh // strict
+
+namespace Zynga\Framework\Dynamic\V1\Mocks;
+
+abstract class AbstractClass {}

src/Zynga/Framework/ReflectionCache/V1/ReflectionClasses.hh

@@ -6,19 +6,16 @@ use \Exception;
 use \ReflectionClass;
 
 class ReflectionClasses {
+  private static bool $shouldFail = false;
+  private static string $classNameToFail = '';
 
   private static Map<string, ?ReflectionClass> $_classes = Map {};
 
   public static function getReflection(mixed $classOrName): ?ReflectionClass {
+    $className = self::getClassName($classOrName);
 
-    $className = '';
-
-    if (is_string($classOrName)) {
-      $className = $classOrName;
-    } else if (is_object($classOrName)) {
-      $className = get_class($classOrName);
-    } else {
-      $className = strval($classOrName);
+    if (self::$shouldFail === true && self::$classNameToFail === $className) {
+      return null;
     }
 
     try {
@@ -49,4 +46,25 @@ class ReflectionClasses {
 
   }
 
+  private static function getClassName(mixed $classOrName): string {
+    if (is_string($classOrName)) {
+      return $classOrName;
+    }
+
+    if (is_object($classOrName)) {
+      return get_class($classOrName);
+    }
+
+    return strval($classOrName);
+  }
+
+  public static function enableFailure(mixed $classOrName): void {
+    self::$shouldFail = true;
+    self::$classNameToFail = self::getClassName($classOrName);
+  }
+
+  public static function disableFailure(): void {
+    self::$shouldFail = false;
+    self::$classNameToFail = '';
+  }
 }

src/Zynga/Framework/Service/V2/Swagger/Base.hh

@@ -214,6 +214,15 @@ abstract class Base extends ServiceBase {
         // non-services might not have consistent constructors
         continue;
       }
+
+      if (DynamicClassCreation::isClassAbstract(
+            $longClassName,
+          )) {
+        // We also need to check this before instantiating the class because
+        // abstract class cant be instantiated and will cause fatal error
+        continue;
+      }
+
       // Stand up the service in question and ask it about the request
       // and response objects it has.
       $service =