Added more unit tests, and fixed PropertyObfuscator's duplicate key check

Author: robtimus

src/Robtimus/Obfuscation/Obfuscate.php

@@ -12,8 +12,6 @@
  */
 final class Obfuscate
 {
-    private static ?Obfuscator $_none = null;
-
     private function __construct()
     {
         // private constructor to prevent initialization
@@ -55,22 +53,19 @@ public function obfuscateText(string $text): string
      */
     public static function none(): Obfuscator
     {
-        if (is_null(Obfuscate::$_none)) {
-            Obfuscate::$_none = new class extends Obfuscator
+        return new class extends Obfuscator
+        {
+            // phpcs:ignore PEAR.Commenting.FunctionComment.Missing
+            public function __construct()
             {
-                // phpcs:ignore PEAR.Commenting.FunctionComment.Missing
-                public function __construct()
-                {
-                }
+            }
 
-                // phpcs:ignore PEAR.Commenting.FunctionComment.Missing
-                public function obfuscateText(string $text): string
-                {
-                    return $text;
-                }
-            };
-        }
-        return Obfuscate::$_none;
+            // phpcs:ignore PEAR.Commenting.FunctionComment.Missing
+            public function obfuscateText(string $text): string
+            {
+                return $text;
+            }
+        };
     }
 
     /**

src/Robtimus/Obfuscation/PropertyObfuscator.php

@@ -103,7 +103,7 @@ public function withProperty(string $propertyName, Obfuscator $obfuscator, ?bool
             {
                 $this->_addLastProperty();
 
-                $caseSensitive = $caseSensitive ?: $this->_caseSensitiveByDefault;
+                $caseSensitive = is_null($caseSensitive) ? $this->_caseSensitiveByDefault : $caseSensitive;
                 $this->_testProperty($propertyName, $caseSensitive);
 
                 $this->_propertyName = $propertyName;

tests/Robtimus/Obfuscation/ObfuscatePortionTest.php

@@ -114,6 +114,23 @@ public static function obfuscationParameters(): array
         ];
     }
 
+    public function testWithDefaults(): void
+    {
+        $obfuscator = Obfuscate::portion()
+            ->keepAtStart(1)
+            ->keepAtEnd(1)
+            ->atLeastFromStart(1)
+            ->atLeastFromEnd(1)
+            ->withFixedTotalLength(10)
+            ->withMask('x')
+            ->withDefaults()
+            ->build();
+
+        $obfuscated = $obfuscator->obfuscateText('hello world');
+
+        $this->assertEquals('***********', $obfuscated);
+    }
+
     public function testNegativeKeepAtStart(): void
     {
         $builder = Obfuscate::portion();

tests/Robtimus/Obfuscation/ObfuscatorTest.php

@@ -0,0 +1,40 @@
+<?php
+namespace Robtimus\Obfuscation;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use ValueError;
+
+class ObfuscatorTest extends TestCase
+{
+    #[DataProvider('nonPositiveMinPrefixLengthParameters')]
+    public function testNonPositiveMinPrefixLength(int $minPrefixLength): void
+    {
+        $this->expectException(ValueError::class);
+        $this->expectExceptionMessage("$minPrefixLength < 1");
+
+        new class($minPrefixLength) extends Obfuscator
+        {
+            public function __construct(int $minPrefixLength)
+            {
+                parent::__construct($minPrefixLength);
+            }
+
+            public function obfuscateText(string $text): string
+            {
+                return $text;
+            }
+        };
+    }
+
+    /**
+     * @return array<array<int>>
+     */
+    public static function nonPositiveMinPrefixLengthParameters(): array
+    {
+        return [
+            [-1],
+            [0],
+        ];
+    }
+}

tests/Robtimus/Obfuscation/PropertyObfuscatorTest.php

@@ -3,6 +3,7 @@
 
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
+use ValueError;
 
 class PropertyObfuscatorTest extends TestCase
 {
@@ -103,6 +104,33 @@ class PropertyObfuscatorTest extends TestCase
 }
 EOD;
 
+    public function testDuplicateCaseSensitivePropertyNames(): void
+    {
+        $obfuscator = Obfuscate::fixedLength(3);
+        $builder = PropertyObfuscator::builder()
+            ->withProperty('test', $obfuscator)
+            ->withProperty('test', $obfuscator, false)
+            ->withProperty('TEST', $obfuscator);
+
+        $this->expectException(ValueError::class);
+        $this->expectExceptionMessage('Duplicate key: test (case sensitive)');
+
+        $builder->withProperty('test', $obfuscator, true);
+    }
+
+    public function testDuplicateCaseInsensitivePropertyNames(): void
+    {
+        $obfuscator = Obfuscate::fixedLength(3);
+        $builder = PropertyObfuscator::builder()
+            ->withProperty('test', $obfuscator)
+            ->withProperty('test', $obfuscator, false);
+
+        $this->expectException(ValueError::class);
+        $this->expectExceptionMessage('Duplicate key: TEST (case insensitive)');
+
+        $builder->withProperty('TEST', $obfuscator, false);
+    }
+
     #[DataProvider('obfuscatePropertyGloballyCaseSensitiveParameters')]
     public function testObfuscatePropertyGloballyCaseSensitive(string $propertyName, string $value, string $expected): void
     {
@@ -1984,4 +2012,34 @@ public function testObfuscateArrayOverridableInheritedObfuscators(): void
 EOD;
         $this->assertEquals($expectedJson, $obfuscatedJson);
     }
+
+    #[DataProvider('obfuscateScalarsParameters')]
+    public function testObfuscateScalars(mixed $value): void
+    {
+        $obfuscator = Obfuscate::fixedLength(3);
+        $propertyObfuscator = PropertyObfuscator::builder()
+            ->caseSensitiveByDefault()
+            ->withProperty('string', $obfuscator)
+            ->withProperty('notObfuscated', Obfuscate::none())
+                ->forObjects(PropertyObfuscationMode::SKIP)
+                ->forArrays(PropertyObfuscationMode::SKIP)
+            ->build();
+
+        $obfuscated = $propertyObfuscator->obfuscateProperties($value);
+
+        $this->assertEquals($value, $obfuscated);
+    }
+
+    /**
+     * @return array<array<mixed>>
+     */
+    public static function obfuscateScalarsParameters(): array
+    {
+        return [
+            ['foo'],
+            [1],
+            [true],
+            [false],
+        ];
+    }
 }