MockDelegateFunctionBuilder reuses classes if the signature would match. This allows running tests with @backupStaticAttributes enabled

Author: malkusch

classes/MockDelegateFunctionBuilder.php

@@ -20,11 +20,6 @@ class MockDelegateFunctionBuilder
      */
     const METHOD = "delegate";
 
-    /**
-     * @var int The instance counter.
-     */
-    private static $counter = 0;
-    
     /**
      * @var string The namespace of the build class.
      */
@@ -52,16 +47,23 @@ public function __construct()
      */
     public function build($functionName = null)
     {
-        self::$counter++;
-        
-        $this->namespace = __NAMESPACE__ . self::$counter;
-        
         $parameterBuilder = new ParameterBuilder();
         $parameterBuilder->build($functionName);
+        $signatureParameters = $parameterBuilder->getSignatureParameters();
+
+        /**
+         * If a class with the same signature exists, it is considered equivalent
+         * to the generated class.
+         */
+        $hash = md5($signatureParameters);
+        $this->namespace = __NAMESPACE__.$hash;
+        if (class_exists($this->getFullyQualifiedClassName())) {
+            return;
+        }
 
         $data = [
-            "namespace" => $this->namespace,
-            "signatureParameters" => $parameterBuilder->getSignatureParameters(),
+            "namespace"           => $this->namespace,
+            "signatureParameters" => $signatureParameters,
         ];
         $this->template->setVar($data, false);
         $definition = $this->template->render();

tests/MockDelegateFunctionBuilderTest.php

@@ -26,26 +26,71 @@ public function testBuild()
     }
 
     /**
-     * Test build() would never create the same class name.
+     * Test build() would never create the same class name for different signatures.
      *
      * @test
      */
-    public function testSubsequentCallsProduceDifferentClasses()
+    public function testDiverseSignaturesProduceDifferentClasses()
     {
         $builder = new MockDelegateFunctionBuilder();
 
-        $builder->build();
+        $builder->build(create_function('', ''));
         $class1 = $builder->getFullyQualifiedClassName();
 
-        $builder->build();
+        $builder->build(create_function('$a', ''));
         $class2 = $builder->getFullyQualifiedClassName();
 
         $builder2 = new MockDelegateFunctionBuilder();
-        $builder2->build();
+        $builder2->build(create_function('$a, $b', ''));
         $class3 = $builder2->getFullyQualifiedClassName();
 
         $this->assertNotEquals($class1, $class2);
         $this->assertNotEquals($class1, $class3);
         $this->assertNotEquals($class2, $class3);
     }
+
+    /**
+     * Test build() would create the same class name for identical signatures.
+     *
+     * @test
+     */
+    public function testSameSignaturesProduceSameClass()
+    {
+        $signature = '$a';
+        $builder   = new MockDelegateFunctionBuilder();
+
+        $builder->build(create_function($signature, ''));
+        $class1 = $builder->getFullyQualifiedClassName();
+        
+        $builder->build(create_function($signature, ''));
+        $class2 = $builder->getFullyQualifiedClassName();
+        
+        $this->assertEquals($class1, $class2);
+    }
+    
+    /**
+     * Tests declaring a class with enabled backupStaticAttributes.
+     *
+     * @test
+     * @backupStaticAttributes enabled
+     * @dataProvider provideTestBackupStaticAttributes
+     */
+    public function testBackupStaticAttributes()
+    {
+        $builder = new MockDelegateFunctionBuilder();
+        $builder->build("min");
+    }
+    
+    /**
+     * Just repeat testBackupStaticAttributes a few times.
+     *
+     * @return array Test cases.
+     */
+    public function provideTestBackupStaticAttributes()
+    {
+        return [
+            [],
+            []
+        ];
+    }
 }