Fix loop validation input context is mutable.

Fix #16

Author: Maks3w

src/BaseInputFilter.php

@@ -236,6 +236,8 @@ protected function validateInputs(array $inputs, $data = [], $context = null)
             $data = $this->getRawValues();
         }
 
+        $inputContext = $context ?: (array_merge($this->getRawValues(), (array) $data));
+
         $this->validInputs   = [];
         $this->invalidInputs = [];
         $valid               = true;
@@ -289,14 +291,7 @@ protected function validateInputs(array $inputs, $data = [], $context = null)
                 continue;
             }
 
-            // Make sure we have a value (empty) for validation of context
-            if (!array_key_exists($name, $data)) {
-                $data[$name] = null;
-            }
-
             // Validate an input
-            $inputContext = $context ?: $data;
-
             if (!$input->isValid($inputContext)) {
                 // Validation failure
                 $this->invalidInputs[$name] = $input;

test/BaseInputFilterTest.php

@@ -10,9 +10,11 @@
 namespace ZendTest\InputFilter;
 
 use ArrayObject;
+use PHPUnit_Framework_MockObject_MockObject as MockObject;
 use PHPUnit_Framework_TestCase as TestCase;
 use stdClass;
 use Zend\InputFilter\Input;
+use Zend\InputFilter\InputInterface;
 use Zend\InputFilter\FileInput;
 use Zend\InputFilter\BaseInputFilter as InputFilter;
 use Zend\Filter;
@@ -433,44 +435,77 @@ public function testCanGetValidationMessages()
         }
     }
 
-    /**
-     * Idea for this one is that one input may only need to be validated if another input is present.
-     *
-     * Commenting out for now, as validation context may make this irrelevant, and unsure what API to expose.
-    public function testCanConditionallyInvokeValidators()
+    /*
+     * Idea for this one is that validation may need to rely on context -- e.g., a "password confirmation"
+     * field may need to know what the original password entered was in order to compare.
+     */
+
+    public function contextProvider()
     {
-        $this->markTestIncomplete();
+        $data = ['fooInput' => 'fooValue'];
+        $arrayAccessData = new ArrayObject(['fooInput' => 'fooValue']);
+        $expectedFromData = ['fooInput' => 'fooValue'];
+
+        return [
+            // Description => [$data, $customContext, $expectedContext]
+            'by default get context from data (array)' => [$data, null, $expectedFromData],
+            'by default get context from data (ArrayAccess)' => [$arrayAccessData, null, $expectedFromData],
+            'use custom context' => [[], 'fooContext', 'fooContext'],
+        ];
     }
-     */
 
     /**
-     * Idea for this one is that validation may need to rely on context -- e.g., a "password confirmation"
-     * field may need to know what the original password entered was in order to compare.
+     * @dataProvider contextProvider
+     *
+     * @param mixed $data
+     * @param mixed $customContext
+     * @param mixed $expectedContext
      */
-    public function testValidationCanUseContext()
+    public function testValidationContext($data, $customContext, $expectedContext)
     {
         $filter = new InputFilter();
 
-        $store = new stdClass;
-        $foo   = new Input();
-        $foo->getValidatorChain()->attach(new Validator\Callback(function ($value, $context) use ($store) {
-            $store->value   = $value;
-            $store->context = $context;
-            return true;
-        }));
+        $input = $this->createInputInterfaceMock(true, $expectedContext);
+        $filter->add($input, 'fooInput');
 
-        $bar = new Input();
-        $bar->getValidatorChain()->attach(new Validator\Digits());
+        $filter->setData($data);
 
-        $filter->add($foo, 'foo')
-               ->add($bar, 'bar');
+        $this->assertTrue($filter->isValid($customContext), json_encode($filter->getMessages()));
+    }
+
+    public function testBuildValidationContextUsingInputGetRawValue()
+    {
+        $data = [];
+        $expectedContext = ['fooInput' => 'fooRawValue'];
+        $filter = new InputFilter();
+
+        $input = $this->createInputInterfaceMock(true, $expectedContext, 'fooRawValue');
+        $filter->add($input, 'fooInput');
 
-        $data = ['foo' => 'foo', 'bar' => 123];
         $filter->setData($data);
 
-        $this->assertTrue($filter->isValid());
-        $this->assertEquals('foo', $store->value);
-        $this->assertEquals($data, $store->context);
+        $this->assertTrue($filter->isValid(), json_encode($filter->getMessages()));
+    }
+
+    public function testContextIsTheSameWhenARequiredInputIsGivenAndOptionalInputIsMissing()
+    {
+        $data = [
+            'inputRequired' => 'inputRequiredValue',
+        ];
+        $expectedContext = [
+            'inputRequired' => 'inputRequiredValue',
+            'inputOptional' => null,
+        ];
+        $inputRequired = $this->createInputInterfaceMock(true, $expectedContext);
+        $inputOptional = $this->createInputInterfaceMock(true, $expectedContext);
+
+        $filter = new InputFilter();
+        $filter->add($inputRequired, 'inputRequired');
+        $filter->add($inputOptional, 'inputOptional');
+
+        $filter->setData($data);
+
+        $this->assertTrue($filter->isValid(), json_encode($filter->getMessages()));
     }
 
     /**
@@ -627,48 +662,6 @@ public function testValidationMarksInputInvalidWhenRequiredAndAllowEmptyFlagIsFa
         $this->assertFalse($filter->isValid());
     }
 
-    public static function contextDataProvider()
-    {
-        return [
-            ['', 'y', true],
-            ['', 'n', false],
-        ];
-    }
-
-    /**
-     * Idea here is that an empty field may or may not be valid based on
-     * context.
-     */
-    /**
-     * @dataProvider contextDataProvider()
-     */
-    // @codingStandardsIgnoreStart
-    public function testValidationMarksInputValidWhenAllowEmptyFlagIsTrueAndContinueIfEmptyIsTrueAndContextValidatesEmptyField($allowEmpty, $blankIsValid, $valid)
-    {
-        // @codingStandardsIgnoreEnd
-        $filter = new InputFilter();
-
-        $data = [
-            'allowEmpty' => $allowEmpty,
-            'blankIsValid' => $blankIsValid,
-        ];
-
-        $allowEmpty = new Input();
-        $allowEmpty->setAllowEmpty(true)
-                   ->setContinueIfEmpty(true);
-
-        $blankIsValid = new Input();
-        $blankIsValid->getValidatorChain()->attach(new Validator\Callback(function ($value, $context) {
-            return ('y' === $value && empty($context['allowEmpty']));
-        }));
-
-        $filter->add($allowEmpty, 'allowEmpty')
-               ->add($blankIsValid, 'blankIsValid');
-        $filter->setData($data);
-
-        $this->assertSame($valid, $filter->isValid());
-    }
-
     public function testCanRetrieveRawValuesIndividuallyWithoutValidating()
     {
         if (!extension_loaded('intl')) {
@@ -1114,4 +1107,33 @@ public function testAllowsValidatingArrayAccessData()
         $filter->setData($data);
         $this->assertTrue($filter->isValid());
     }
+
+    /**
+     * @param null|bool $isValid
+     * @param mixed $expectedContext
+     * @param mixed $getRawValue
+     *
+     * @return MockObject|InputInterface
+     */
+    protected function createInputInterfaceMock($isValid = null, $expectedContext = 'not-set', $getRawValue = 'not-set')
+    {
+        /** @var InputInterface|MockObject $input */
+        $input = $this->getMock(InputInterface::class);
+        if ($getRawValue !== 'not-set') {
+            $input->method('getRawValue')
+                ->willReturn($getRawValue)
+            ;
+        }
+        if ($isValid !== null) {
+            $mockMethod = $input->expects($this->once())
+                ->method('isValid')
+                ->willReturn($isValid)
+            ;
+            if ($expectedContext !== 'not-set') {
+                $mockMethod->with($expectedContext);
+            }
+        }
+
+        return $input;
+    }
 }