Merge pull request #17 from bestit/feature/16-blacklist-mode

#16 Add new blacklist mode for CookieActivator

Author: migo315

CHANGELOG.md

@@ -1,3 +1,7 @@
+## [1.4.0]
+### Added
+- \#16 Add new blacklist mode for [CookieActivator](docs/activator/cookie.md) @migo315
+
 ## [1.3.0]
 ### Added
 - \#1 \#4 Add new [CacheActivator](docs/activator/cache.md) @migo315

docs/activator/cookie.md

@@ -68,6 +68,41 @@ Example:
  }
  ```
 
+The CookieActivator acts as whitelist. You can change this behavior to a blacklist if you set the fourth argument.
+ 
+ Example:
+ 
+  ```php
+  // MyClass.php
+  class MyClass
+  {
+      public function doSomething()
+      {
+          $activator = new CookieActivator([
+              'feature_abc',
+              'feature_ghi'
+          ], 'my_cookie_name', '|', CookieActivator::BLACKLIST);
+  
+          $manager = new FeatureManager($activator);
+          
+          // Will return true, if you have set a cookie called "my_cookie_name" with value "feature_wxy|feature_ghi")
+          if ($manager->isActive('feature_wxy')) {
+              // do something
+          }
+  
+          // Will return always false, because the feature is blacklisted
+          if ($manager->isActive('feature_abc')) {
+              // do something
+          }
+          
+          // Will return always false, because the feature is blacklisted
+          if ($manager->isActive('feature_ghi')) {
+              // do something
+          }
+      }
+  }
+  ```
+ 
  ### Beware!
  Cookies are not secure. You should only use this activator for internal stuff. Do not use this for critical or public parts
  of your project.

src/Activator/CookieActivator.php

@@ -2,6 +2,7 @@
 
 namespace Flagception\Activator;
 
+use Flagception\Exception\InvalidArgumentException;
 use Flagception\Model\Context;
 
 /**
@@ -13,7 +14,17 @@
 class CookieActivator implements FeatureActivatorInterface
 {
     /**
-     * Allowed features
+     * Activator should act as whitelist
+     */
+    const WHITELIST = 'whitelist';
+
+    /**
+     * Activator should act as blacklist
+     */
+    const BLACKLIST = 'blacklist';
+
+    /**
+     * Features collection
      *
      * @var array
      */
@@ -33,18 +44,38 @@ class CookieActivator implements FeatureActivatorInterface
      */
     private $separator;
 
+    /**
+     * Mode (whitelist / blacklist)
+     *
+     * @var string
+     */
+    private $mode;
+
     /**
      * CookieActivator constructor.
      *
      * @param array $features
      * @param string $name
      * @param string $separator
+     * @param string $mode
+     *
+     * @throws InvalidArgumentException
      */
-    public function __construct(array $features, $name = 'flagception', $separator = ',')
+    public function __construct(array $features, $name = 'flagception', $separator = ',', $mode = self::WHITELIST)
     {
+        if (!in_array($mode, [self::BLACKLIST, self::WHITELIST], true)) {
+            throw new InvalidArgumentException(
+                sprintf(
+                    'Invalid mode argument for cookie activator: "%s". Expected: "whitelist" or "blacklist"',
+                    $mode
+                )
+            );
+        }
+
         $this->features = $features;
         $this->name = $name;
         $this->separator = $separator;
+        $this->mode = $mode;
     }
 
     /**
@@ -60,14 +91,22 @@ public function getName()
      */
     public function isActive($name, Context $context)
     {
-        if (!in_array($name, $this->features, true)) {
+        // Disable features which aren't whitelisted
+        if ($this->mode === self::WHITELIST && !in_array($name, $this->features, true)) {
+            return false;
+        }
+
+        // Disable features which are blacklisted
+        if ($this->mode === self::BLACKLIST && in_array($name, $this->features, true)) {
             return false;
         }
 
+        // Disable if non cookie exists
         if (!array_key_exists($this->name, $_COOKIE)) {
             return false;
         }
 
+        // Enable, if feature is set in cookie
         return in_array($name, array_map('trim', explode($this->separator, $_COOKIE[$this->name])), true);
     }
 }

src/Exception/InvalidArgumentException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Flagception\Exception;
+
+/**
+ * Class InvalidArgumentException
+ *
+ * @author Michel Chowanski <[email protected]>
+ * @package Flagception\Exception
+ */
+class InvalidArgumentException extends FlagceptionException
+{
+}

tests/Activator/CookieActivatorTest.php

@@ -4,6 +4,7 @@
 
 use Flagception\Activator\CookieActivator;
 use Flagception\Activator\FeatureActivatorInterface;
+use Flagception\Exception\InvalidArgumentException;
 use Flagception\Model\Context;
 use PHPUnit\Framework\TestCase;
 
@@ -30,6 +31,8 @@ protected function setUp()
      * Test implement interface
      *
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function testImplementInterface()
     {
@@ -40,6 +43,8 @@ public function testImplementInterface()
      * Test name
      *
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function testName()
     {
@@ -51,6 +56,8 @@ public function testName()
      * Test feature is unknown
      *
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function testFeatureIsUnknown()
     {
@@ -64,6 +71,8 @@ public function testFeatureIsUnknown()
      * Test feature is known
      *
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function testFeatureIsKnown()
     {
@@ -79,6 +88,8 @@ public function testFeatureIsKnown()
      * Test multiple features
      *
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function testMultipleFeatures()
     {
@@ -101,6 +112,8 @@ public function testMultipleFeatures()
      * Test changed cookie name is unknown
      *
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function testCookieNameChangeUnknown()
     {
@@ -116,6 +129,8 @@ public function testCookieNameChangeUnknown()
      * Test changed cookie name is known
      *
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function testCookieNameChangeKnown()
     {
@@ -131,6 +146,8 @@ public function testCookieNameChangeKnown()
      * Test multiple features with changed separator
      *
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function testMultipleFeaturesWithChangedSeparator()
     {
@@ -148,4 +165,79 @@ public function testMultipleFeaturesWithChangedSeparator()
         static::assertFalse($activator->isActive('foobar', new Context()));
         static::assertFalse($activator->isActive('feature_xyz', new Context()));
     }
+
+    /**
+     * Test multiple features by blacklist
+     *
+     * @return void
+     *
+     * @throws InvalidArgumentException
+     */
+    public function testMultipleFeaturesByBlacklist()
+    {
+        $activator = new CookieActivator([
+            'feature_abc',
+            'feature_def',
+            'feature_ghi',
+            'feature_xyz'
+        ], 'flagception', ',', CookieActivator::BLACKLIST);
+
+        $_COOKIE['flagception'] = 'feature_abc,feature_def, feature_ghi, foobar';
+        static::assertFalse($activator->isActive('feature_abc', new Context()));
+        static::assertFalse($activator->isActive('feature_def', new Context()));
+        static::assertFalse($activator->isActive('feature_ghi', new Context()));
+        static::assertTrue($activator->isActive('foobar', new Context()));
+        static::assertFalse($activator->isActive('feature_xyz', new Context()));
+    }
+
+    /**
+     * Test public constants
+     *
+     * @return void
+     */
+    public function testConstants()
+    {
+        static::assertEquals('whitelist', CookieActivator::WHITELIST);
+        static::assertEquals('blacklist', CookieActivator::BLACKLIST);
+    }
+
+    /**
+     * Test if "whitelist" is a valid argument as mode
+     *
+     * @return void
+     *
+     * @throws InvalidArgumentException
+     */
+    public function testWhitelistModeArgument()
+    {
+        $activator = new CookieActivator([], 'flagception', ',', 'whitelist');
+        static::assertEquals('cookie', $activator->getName());
+    }
+
+    /**
+     * Test if "blacklist" is a valid argument as mode
+     *
+     * @return void
+     *
+     * @throws InvalidArgumentException
+     */
+    public function testBlacklistModeArgument()
+    {
+        $activator = new CookieActivator([], 'flagception', ',', 'blacklist');
+        static::assertEquals('cookie', $activator->getName());
+    }
+
+    /**
+     * Test if "foobar" is an invalid argument as mode
+     *
+     * @return void
+     *
+     * @throws InvalidArgumentException
+     */
+    public function testFoobarModeArgument()
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        new CookieActivator([], 'flagception', ',', 'foobar');
+    }
 }

tests/Exception/InvalidArgumentExceptionTest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Flagception\Tests\Exception;
+
+use Flagception\Exception\InvalidArgumentException;
+use Flagception\Exception\FlagceptionException;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Class InvalidArgumentExceptionTest
+ *
+ * @author Michel Chowanski <[email protected]>
+ * @package Flagception\Tests\Exception
+ */
+class InvalidArgumentExceptionTest extends TestCase
+{
+    /**
+     * Test extends from base exception
+     *
+     * @return void
+     */
+    public function testExtends()
+    {
+        static::assertInstanceOf(FlagceptionException::class, new InvalidArgumentException());
+    }
+}