Merge pull request #6 from mybuilder/ignore-policy

Ignore policy

Author: keyvanakbary

README.md

@@ -1,32 +1,57 @@
-PHPUnit Accelerator
-===================
+# PHPUnit Accelerator
+
 [![Build Status](https://secure.travis-ci.org/mybuilder/phpunit-accelerator.svg?branch=master)](http://travis-ci.org/mybuilder/phpunit-accelerator)
 
 Inspired by [Kris Wallsmith faster PHPUnit article](http://kriswallsmith.net/post/18029585104/faster-phpunit), we've created a [PHPUnit](http://phpunit.de) test listener that speeds up PHPUnit tests about 20% by freeing memory.
 
-Setup and Configuration
------------------------
-Add the following to your `composer.json` file
-```json
-{
-    "require-dev": {
-        "mybuilder/phpunit-accelerator": "~1.0"
-    }
-}
-```
+## Installation
+
+To install this library, run the command below and you will get the latest version
 
-Update the vendor libraries
+``` bash
+composer require mybuilder/phpunit-accelerator
+```
 
-    curl -s http://getcomposer.org/installer | php
-    php composer.phar install
+## Usage
 
-Usage
------
 Just add to your `phpunit.xml` configuration
+
 ```xml
 <phpunit>
     <listeners>
         <listener class="\MyBuilder\PhpunitAccelerator\TestListener"/>
     </listeners>
 </phpunit>
 ```
+
+### Ignoring Tests
+
+Sometimes it is necessary to ignore specific tests, where freeing their properties is undesired. For this use case, you have the ability to *extend the behaviour* of the listener by implementing the `IgnoreTestPolicy` interface.
+
+As an example, if we hypothetically wanted to ignore all tests which include "Legacy" in their test filename, we could create a custom ignore policy as follows
+
+```php
+<?php
+
+use MyBuilder\PhpunitAccelerator\IgnoreTestPolicy;
+
+class IgnoreLegacyTestPolicy implements IgnoreTestPolicy {
+    public function shouldIgnore(\ReflectionObject $testReflection) {
+        return strpos($testReflection->getFilename(), 'Legacy') !== false;
+    }
+}
+```
+
+And pass it to the constructor of our test listener in `phpunit.xml` configuration
+
+```xml
+<phpunit>
+    <listeners>
+        <listener class="\MyBuilder\PhpunitAccelerator\TestListener">
+            <arguments>
+                <object class="\IgnoreLegacyTestPolicy"/>
+            </arguments>
+        </listener>
+    </listeners>
+</phpunit>
+```

src/IgnoreTestPolicy.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace MyBuilder\PhpunitAccelerator;
+
+interface IgnoreTestPolicy
+{
+    /**
+     * @return boolean
+     */
+    public function shouldIgnore(\ReflectionObject $testReflection);
+}

src/TestListener.php

@@ -4,40 +4,46 @@
 
 class TestListener implements \PHPUnit_Framework_TestListener
 {
+    private $ignorePolicy;
+
     const PHPUNIT_PROPERTY_PREFIX = 'PHPUnit_';
 
+    public function __construct(IgnoreTestPolicy $ignorePolicy = null)
+    {
+        $this->ignorePolicy = ($ignorePolicy) ?: new NeverIgnoreTestPolicy();
+    }
+
     public function endTest(\PHPUnit_Framework_Test $test, $time)
     {
-        $this->safelyFreeProperties($test);
+        $testReflection = new \ReflectionObject($test);
+
+        if ($this->ignorePolicy->shouldIgnore($testReflection)) {
+            return;
+        }
+
+        $this->safelyFreeProperties($test, $testReflection->getProperties());
     }
 
-    private function safelyFreeProperties($test)
+    private function safelyFreeProperties(\PHPUnit_Framework_Test $test, array $properties)
     {
-        foreach ($this->getProperties($test) as $property) {
+        foreach ($properties as $property) {
             if ($this->isSafeToFreeProperty($property)) {
                 $this->freeProperty($test, $property);
             }
         }
     }
 
-    private function getProperties($test)
-    {
-        $reflection = new \ReflectionObject($test);
-
-        return $reflection->getProperties();
-    }
-
-    private function isSafeToFreeProperty($property)
+    private function isSafeToFreeProperty(\ReflectionProperty $property)
     {
         return !$property->isStatic() && $this->isNotPhpUnitProperty($property);
     }
 
-    private function isNotPhpUnitProperty($property)
+    private function isNotPhpUnitProperty(\ReflectionProperty $property)
     {
         return 0 !== strpos($property->getDeclaringClass()->getName(), self::PHPUNIT_PROPERTY_PREFIX);
     }
 
-    private function freeProperty($test, $property)
+    private function freeProperty(\PHPUnit_Framework_Test $test, \ReflectionProperty $property)
     {
         $property->setAccessible(true);
         $property->setValue($test, null);
@@ -59,3 +65,11 @@ public function startTest(\PHPUnit_Framework_Test $test) {}
 
     public function addRiskyTest(\PHPUnit_Framework_Test $test, \Exception $e, $time) {}
 }
+
+class NeverIgnoreTestPolicy implements IgnoreTestPolicy
+{
+    public function shouldIgnore(\ReflectionObject $testReflection)
+    {
+        return false;
+    }
+}

tests/TestListenerTest.php

@@ -1,25 +1,34 @@
 <?php
 
 use MyBuilder\PhpunitAccelerator\TestListener;
+use MyBuilder\PhpunitAccelerator\IgnoreTestPolicy;
 
 class TestListenerTest extends \PHPUnit_Framework_TestCase
 {
-    private $listener;
     private $dummyTest;
 
     protected function setUp()
     {
-        $this->listener = new TestListener();
         $this->dummyTest = new DummyTest();
     }
 
     /**
      * @test
      */
-    public function shouldFreeProperty()
+    public function shouldFreeTestProperty()
     {
-        $this->endTest();
+        $this->endTest(new TestListener());
 
+        $this->assertFreesTestProperty();
+    }
+
+    private function endTest(TestListener $listener)
+    {
+        $listener->endTest($this->dummyTest, 0);
+    }
+
+    private function assertFreesTestProperty()
+    {
         $this->assertNull($this->dummyTest->property);
     }
 
@@ -28,14 +37,29 @@ public function shouldFreeProperty()
      */
     public function shouldNotFreePhpUnitProperty()
     {
-        $this->endTest();
+        $this->endTest(new TestListener());
 
+        $this->assertDoesNotFreePHPUnitProperty();
+    }
+
+    private function assertDoesNotFreePHPUnitProperty()
+    {
         $this->assertNotNull($this->dummyTest->phpUnitProperty);
     }
 
-    private function endTest()
+    /**
+     * @test
+     */
+    public function shouldNotFreeTestPropertyWithIgnoreAlwaysPolicy()
+    {
+        $this->endTest(new TestListener(new AlwaysIgnoreTestPolicy()));
+
+        $this->assertDoesNotFreeTestProperty();
+    }
+
+    private function assertDoesNotFreeTestProperty()
     {
-        $this->listener->endTest($this->dummyTest, 0);
+        $this->assertNotNull($this->dummyTest->property);
     }
 }
 
@@ -48,3 +72,11 @@ class DummyTest extends \PHPUnit_Fake
 {
     public $property = 1;
 }
+
+class AlwaysIgnoreTestPolicy implements IgnoreTestPolicy
+{
+    public function shouldIgnore(\ReflectionObject $testReflection)
+    {
+        return true;
+    }
+}