Mock dependencies to Zend\Validator

Author: Maks3w

test/ArrayInputTest.php

@@ -97,6 +97,16 @@ protected function createValidatorChainMock($isValid = null, $value = null, $con
         return parent::createValidatorChainMock($isValid, $value, $context, $messages);
     }
 
+    protected function createNonEmptyValidatorMock($isValid, $value, $context =  null)
+    {
+        // ArrayInput validates per each array value
+        if (is_array($value)) {
+            $value = current($value);
+        }
+
+        return parent::createNonEmptyValidatorMock($isValid, $value, $context);
+    }
+
     protected function getDummyValue($raw = true)
     {
         return [parent::getDummyValue($raw)];

test/InputTest.php

@@ -15,9 +15,9 @@
 use Zend\Filter\FilterChain;
 use Zend\InputFilter\Input;
 use Zend\InputFilter\InputInterface;
-use Zend\Validator;
-use Zend\Validator\NotEmpty;
+use Zend\Validator\NotEmpty as NotEmptyValidator;
 use Zend\Validator\ValidatorChain;
+use Zend\Validator\ValidatorInterface;
 
 /**
  * @covers Zend\InputFilter\Input
@@ -34,18 +34,18 @@ public function setUp()
         $this->input = new Input('foo');
     }
 
-    public function assertRequiredValidationErrorMessage($input, $message = '')
+    public function assertRequiredValidationErrorMessage(Input $input, $message = '')
     {
         $message  = $message ?: 'Expected failure message for required input';
         $message .= ';';
 
         $messages = $input->getMessages();
         $this->assertInternalType('array', $messages, $message . ' non-array messages array');
 
-        $notEmpty         = new NotEmpty();
+        $notEmpty         = new NotEmptyValidator();
         $messageTemplates = $notEmpty->getOption('messageTemplates');
         $this->assertSame([
-            NotEmpty::IS_EMPTY => $messageTemplates[NotEmpty::IS_EMPTY],
+            NotEmptyValidator::IS_EMPTY => $messageTemplates[NotEmptyValidator::IS_EMPTY],
         ], $messages, $message . ' missing NotEmpty::IS_EMPTY key and/or contains additional messages');
     }
 
@@ -64,7 +64,7 @@ public function testInputHasEmptyFilterChainByDefault()
     public function testInputHasEmptyValidatorChainByDefault()
     {
         $validators = $this->input->getValidatorChain();
-        $this->assertInstanceOf(Validator\ValidatorChain::class, $validators);
+        $this->assertInstanceOf(ValidatorChain::class, $validators);
         $this->assertEquals(0, count($validators));
     }
 
@@ -77,7 +77,7 @@ public function testCanInjectFilterChain()
 
     public function testCanInjectValidatorChain()
     {
-        $chain = new Validator\ValidatorChain();
+        $chain = $this->createValidatorChainMock();
         $this->input->setValidatorChain($chain);
         $this->assertSame($chain, $this->input->getValidatorChain());
     }
@@ -326,18 +326,6 @@ public function testValidationOperatesOnFilteredValue()
         );
     }
 
-    public function testSpecifyingMessagesToInputReturnsThoseOnFailedValidation()
-    {
-        $this->input->setValue($this->getDummyValue());
-        $validator = new Validator\Digits();
-        $this->input->getValidatorChain()->attach($validator);
-        $this->input->setErrorMessage('Please enter only digits');
-        $this->assertFalse($this->input->isValid());
-        $messages = $this->input->getMessages();
-        $this->assertArrayNotHasKey(Validator\Digits::NOT_DIGITS, $messages);
-        $this->assertContains('Please enter only digits', $messages);
-    }
-
     public function testBreakOnFailureFlagIsOffByDefault()
     {
         $this->assertFalse($this->input->breakOnFailure());
@@ -374,14 +362,10 @@ public function testNotEmptyValidatorAddedWhenIsValidIsCalled($value)
      */
     public function testRequiredNotEmptyValidatorNotAddedWhenOneExists($value)
     {
-        $this->assertTrue($this->input->isRequired());
+        $this->input->setRequired(true);
         $this->input->setValue($value);
 
-        /** @var Validator\NotEmpty|MockObject $notEmptyMock */
-        $notEmptyMock = $this->getMock(Validator\NotEmpty::class, ['isValid']);
-        $notEmptyMock->expects($this->exactly(1))
-                     ->method('isValid')
-                     ->will($this->returnValue(false));
+        $notEmptyMock = $this->createNonEmptyValidatorMock(false, $value);
 
         $validatorChain = $this->input->getValidatorChain();
         $validatorChain->prependValidator($notEmptyMock);
@@ -395,20 +379,20 @@ public function testRequiredNotEmptyValidatorNotAddedWhenOneExists($value)
     /**
      * @dataProvider emptyValueProvider
      */
-    public function testDoNotInjectNotEmptyValidatorIfAnywhereInChain($value)
+    public function testDoNotInjectNotEmptyValidatorIfAnywhereInChain($valueRaw, $valueFiltered)
     {
-        $this->assertTrue($this->input->isRequired());
-        $this->input->setValue($value);
+        $filterChain = $this->createFilterChainMock($valueRaw, $valueFiltered);
+        $validatorChain = $this->input->getValidatorChain();
 
-        /** @var Validator\NotEmpty|MockObject $notEmptyMock */
-        $notEmptyMock = $this->getMock(Validator\NotEmpty::class, ['isValid']);
-        $notEmptyMock->expects($this->exactly(1))
-                     ->method('isValid')
-                     ->will($this->returnValue(false));
+        $this->input->setRequired(true);
+        $this->input->setFilterChain($filterChain);
+        $this->input->setValue($valueRaw);
 
-        $validatorChain = $this->input->getValidatorChain();
-        $validatorChain->attach(new Validator\Digits());
+        $notEmptyMock = $this->createNonEmptyValidatorMock(false, $valueFiltered);
+
+        $validatorChain->attach($this->createValidatorMock(true));
         $validatorChain->attach($notEmptyMock);
+
         $this->assertFalse($this->input->isValid());
 
         $validators = $validatorChain->getValidators();
@@ -836,25 +820,26 @@ protected function createValidatorChainMock($isValid = null, $value = null, $con
      * @param mixed $context
      * @param string[] $messages
      *
-     * @return Validator\ValidatorInterface|MockObject
+     * @return ValidatorInterface|MockObject
      */
-    protected function createValidatorMock($isValid, $value, $context = null, $messages = [])
+    protected function createValidatorMock($isValid, $value = 'not-set', $context = null, $messages = [])
     {
-        /** @var Validator\ValidatorInterface|MockObject $validator */
-        $validator = $this->getMock(Validator\ValidatorInterface::class);
+        /** @var ValidatorInterface|MockObject $validator */
+        $validator = $this->getMock(ValidatorInterface::class);
 
         if (($isValid === false) || ($isValid === true)) {
-            $validator->expects($this->once())
+            $isValidMethod = $validator->expects($this->once())
                 ->method('isValid')
-                ->with($value, $context)
                 ->willReturn($isValid)
             ;
         } else {
-            $validator->expects($this->never())
+            $isValidMethod = $validator->expects($this->never())
                 ->method('isValid')
-                ->with($value, $context)
             ;
         }
+        if ($value !== 'not-set') {
+            $isValidMethod->with($value, $context);
+        }
 
         $validator->method('getMessages')
             ->willReturn($messages)
@@ -863,6 +848,26 @@ protected function createValidatorMock($isValid, $value, $context = null, $messa
         return $validator;
     }
 
+    /**
+     * @param bool $isValid
+     * @param mixed $value
+     * @param mixed $context
+     *
+     * @return NotEmptyValidator|MockObject
+     */
+    protected function createNonEmptyValidatorMock($isValid, $value, $context =  null)
+    {
+        /** @var NotEmptyValidator|MockObject $notEmptyMock */
+        $notEmptyMock = $this->getMock(NotEmptyValidator::class, ['isValid']);
+        $notEmptyMock->expects($this->once())
+            ->method('isValid')
+            ->with($value, $context)
+            ->willReturn($isValid)
+        ;
+
+        return $notEmptyMock;
+    }
+
     protected function getDummyValue($raw = true)
     {
         if ($raw) {