<?php

use Mockery as m;

use Illuminate\Validation\Validator;

use Symfony\Component\HttpFoundation\File\File;

class ValidationValidatorTest extends PHPUnit_Framework_TestCase

{

public function tearDown()

{

m::close();

}

public function testSometimesWorksOnNestedArrays()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => ['bar' => ['baz' => '']]], ['foo.bar.baz' => 'sometimes|required']);

$this->assertFalse($v->passes());

$this->assertEquals(['foo.bar.baz' => ['Required' => []]], $v->failed());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => ['bar' => ['baz' => 'nonEmpty']]], ['foo.bar.baz' => 'sometimes|required']);

$this->assertTrue($v->passes());

}

public function testAfterCallbacksAreCalledWithValidatorInstance()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'bar', 'baz' => 'boom'], ['foo' => 'Same:baz']);

$v->setContainer(new Illuminate\Container\Container);

$v->after(function ($validator) {

$_SERVER['__validator.after.test'] = true;

});

$this->assertFalse($v->passes());

$this->assertTrue($_SERVER['__validator.after.test']);

unset($_SERVER['__validator.after.test']);

}

public function testSometimesWorksOnArrays()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => ['bar', 'baz', 'moo']], ['foo' => 'sometimes|required|between:5,10']);

$this->assertFalse($v->passes());

$this->assertNotEmpty($v->failed());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => ['bar', 'baz', 'moo', 'pew', 'boom']], ['foo' => 'sometimes|required|between:5,10']);

$this->assertTrue($v->passes());

}

public function testHasFailedValidationRules()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'bar', 'baz' => 'boom'], ['foo' => 'Same:baz']);

$this->assertFalse($v->passes());

$this->assertEquals(['foo' => ['Same' => ['baz']]], $v->failed());

}

public function testHasNotFailedValidationRules()

{

$trans = $this->getTranslator();

$trans->shouldReceive('trans')->never();

$v = new Validator($trans, ['foo' => 'taylor'], ['name' => 'Confirmed']);

$this->assertTrue($v->passes());

$this->assertEmpty($v->failed());

}

public function testSometimesCanSkipRequiredRules()

{

$trans = $this->getTranslator();

$trans->shouldReceive('trans')->never();

$v = new Validator($trans, [], ['name' => 'sometimes|required']);

$this->assertTrue($v->passes());

$this->assertEmpty($v->failed());

}

public function testInValidatableRulesReturnsValid()

{

$trans = $this->getTranslator();

$trans->shouldReceive('trans')->never();

$v = new Validator($trans, ['foo' => 'taylor'], ['name' => 'Confirmed']);

$this->assertTrue($v->passes());

}

public function testProperLanguageLineIsSet()

{

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required' => 'required!'], 'en', 'messages');

$v = new Validator($trans, ['name' => ''], ['name' => 'Required']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('required!', $v->messages()->first('name'));

}

public function testCustomReplacersAreCalled()

{

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required' => 'foo bar'], 'en', 'messages');

$v = new Validator($trans, ['name' => ''], ['name' => 'Required']);

$v->addReplacer('required', function ($message, $attribute, $rule, $parameters) { return str_replace('bar', 'taylor', $message); });

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('foo taylor', $v->messages()->first('name'));

}

public function testClassBasedCustomReplacers()

{

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.foo' => 'foo!'], 'en', 'messages');

$v = new Validator($trans, [], ['name' => 'required']);

$v->setContainer($container = m::mock('Illuminate\Container\Container'));

$v->addReplacer('required', 'Foo@bar');

$container->shouldReceive('make')->once()->with('Foo')->andReturn($foo = m::mock('StdClass'));

$foo->shouldReceive('bar')->once()->andReturn('replaced!');

$v->passes();

$v->messages()->setFormat(':message');

$this->assertEquals('replaced!', $v->messages()->first('name'));

}

public function testAttributeNamesAreReplaced()

{

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required' => ':attribute is required!'], 'en', 'messages');

$v = new Validator($trans, ['name' => ''], ['name' => 'Required']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('name is required!', $v->messages()->first('name'));

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required' => ':attribute is required!', 'validation.attributes.name' => 'Name'], 'en', 'messages');

$v = new Validator($trans, ['name' => ''], ['name' => 'Required']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('Name is required!', $v->messages()->first('name'));

//set customAttributes by setter

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required' => ':attribute is required!'], 'en', 'messages');

$customAttributes = ['name' => 'Name'];

$v = new Validator($trans, ['name' => ''], ['name' => 'Required']);

$v->addCustomAttributes($customAttributes);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('Name is required!', $v->messages()->first('name'));

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required' => ':attribute is required!'], 'en', 'messages');

$v = new Validator($trans, ['name' => ''], ['name' => 'Required']);

$v->setAttributeNames(['name' => 'Name']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('Name is required!', $v->messages()->first('name'));

}

public function testDisplayableValuesAreReplaced()

{

//required_if:foo,bar

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required_if' => 'The :attribute field is required when :other is :value.'], 'en', 'messages');

$trans->addResource('array', ['validation.values.color.1' => 'red'], 'en', 'messages');

$v = new Validator($trans, ['color' => '1', 'bar' => ''], ['bar' => 'RequiredIf:color,1']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('The bar field is required when color is red.', $v->messages()->first('bar'));

//in:foo,bar,...

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.in' => ':attribute must be included in :values.'], 'en', 'messages');

$trans->addResource('array', ['validation.values.type.5' => 'Short'], 'en', 'messages');

$trans->addResource('array', ['validation.values.type.300' => 'Long'], 'en', 'messages');

$v = new Validator($trans, ['type' => '4'], ['type' => 'in:5,300']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('type must be included in Short, Long.', $v->messages()->first('type'));

// test addCustomValues

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.in' => ':attribute must be included in :values.'], 'en', 'messages');

$customValues = [

'type' => [

'5' => 'Short',

'300' => 'Long',

],

];

$v = new Validator($trans, ['type' => '4'], ['type' => 'in:5,300']);

$v->addCustomValues($customValues);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('type must be included in Short, Long.', $v->messages()->first('type'));

// set custom values by setter

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.in' => ':attribute must be included in :values.'], 'en', 'messages');

$customValues = [

'type' => [

'5' => 'Short',

'300' => 'Long',

],

];

$v = new Validator($trans, ['type' => '4'], ['type' => 'in:5,300']);

$v->setValueNames($customValues);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('type must be included in Short, Long.', $v->messages()->first('type'));

}

public function testCustomValidationLinesAreRespected()

{

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required' => 'required!', 'validation.custom.name.required' => 'really required!'], 'en', 'messages');

$v = new Validator($trans, ['name' => ''], ['name' => 'Required']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('really required!', $v->messages()->first('name'));

}

public function testInlineValidationMessagesAreRespected()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['name' => ''], ['name' => 'Required'], ['name.required' => 'require it please!']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('require it please!', $v->messages()->first('name'));

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['name' => ''], ['name' => 'Required'], ['required' => 'require it please!']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('require it please!', $v->messages()->first('name'));

}

public function testSeveralSameInlineValidationMessagesAreRespected()

{

$trans = $this->getRealTranslator();

$data = [

'name' => '',

'foo' => 'bar',

'laravel' => 'framework',

];

$rules = [

'name' => 'Required',

'foo' => 'Boolean',

'laravel' => 'Numeric',

];

$messages = [

'name.required' => 'validation failed',

'foo.boolean' => 'validation failed',

'laravel.numeric' => 'another failure',

];

$v = new Validator($trans, $data, $rules, $messages);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('validation failed', $v->messages()->first('name'));

$this->assertEquals('validation failed', $v->messages()->first('foo'));

$this->assertEquals('another failure', $v->messages()->first('laravel'));

}

public function testValidateRequired()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, [], ['name' => 'Required']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['name' => ''], ['name' => 'Required']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['name' => 'foo'], ['name' => 'Required']);

$this->assertTrue($v->passes());

$file = new File('', false);

$v = new Validator($trans, ['name' => $file], ['name' => 'Required']);

$this->assertFalse($v->passes());

$file = new File(__FILE__, false);

$v = new Validator($trans, ['name' => $file], ['name' => 'Required']);

$this->assertTrue($v->passes());

}

public function testValidateRequiredWith()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'Taylor'], ['last' => 'required_with:first']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['first' => 'Taylor', 'last' => ''], ['last' => 'required_with:first']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['first' => ''], ['last' => 'required_with:first']);

$this->assertTrue($v->passes());

$v = new Validator($trans, [], ['last' => 'required_with:first']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['first' => 'Taylor', 'last' => 'Otwell'], ['last' => 'required_with:first']);

$this->assertTrue($v->passes());

$file = new File('', false);

$v = new Validator($trans, ['file' => $file, 'foo' => ''], ['foo' => 'required_with:file']);

$this->assertTrue($v->passes());

$file = new File(__FILE__, false);

$foo = new File(__FILE__, false);

$v = new Validator($trans, ['file' => $file, 'foo' => $foo], ['foo' => 'required_with:file']);

$this->assertTrue($v->passes());

$file = new File(__FILE__, false);

$foo = new File('', false);

$v = new Validator($trans, ['file' => $file, 'foo' => $foo], ['foo' => 'required_with:file']);

$this->assertFalse($v->passes());

}

public function testRequiredWithAll()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'foo'], ['last' => 'required_with_all:first,foo']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['first' => 'foo'], ['last' => 'required_with_all:first']);

$this->assertFalse($v->passes());

}

public function testValidateRequiredWithout()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'Taylor'], ['last' => 'required_without:first']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['first' => 'Taylor', 'last' => ''], ['last' => 'required_without:first']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['first' => ''], ['last' => 'required_without:first']);

$this->assertFalse($v->passes());

$v = new Validator($trans, [], ['last' => 'required_without:first']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['first' => 'Taylor', 'last' => 'Otwell'], ['last' => 'required_without:first']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['last' => 'Otwell'], ['last' => 'required_without:first']);

$this->assertTrue($v->passes());

$file = new File('', false);

$v = new Validator($trans, ['file' => $file], ['foo' => 'required_without:file']);

$this->assertFalse($v->passes());

$foo = new File('', false);

$v = new Validator($trans, ['foo' => $foo], ['foo' => 'required_without:file']);

$this->assertFalse($v->passes());

$foo = new File(__FILE__, false);

$v = new Validator($trans, ['foo' => $foo], ['foo' => 'required_without:file']);

$this->assertTrue($v->passes());

$file = new File(__FILE__, false);

$foo = new File(__FILE__, false);

$v = new Validator($trans, ['file' => $file, 'foo' => $foo], ['foo' => 'required_without:file']);

$this->assertTrue($v->passes());

$file = new File(__FILE__, false);

$foo = new File('', false);

$v = new Validator($trans, ['file' => $file, 'foo' => $foo], ['foo' => 'required_without:file']);

$this->assertTrue($v->passes());

$file = new File('', false);

$foo = new File(__FILE__, false);

$v = new Validator($trans, ['file' => $file, 'foo' => $foo], ['foo' => 'required_without:file']);

$this->assertTrue($v->passes());

$file = new File('', false);

$foo = new File('', false);

$v = new Validator($trans, ['file' => $file, 'foo' => $foo], ['foo' => 'required_without:file']);

$this->assertFalse($v->passes());

}

public function testRequiredWithoutMultiple()

{

$trans = $this->getRealTranslator();

$rules = [

'f1' => 'required_without:f2,f3',

'f2' => 'required_without:f1,f3',

'f3' => 'required_without:f1,f2',

];

$v = new Validator($trans, [], $rules);

$this->assertTrue($v->fails());

$v = new Validator($trans, ['f1' => 'foo'], $rules);

$this->assertTrue($v->fails());

$v = new Validator($trans, ['f2' => 'foo'], $rules);

$this->assertTrue($v->fails());

$v = new Validator($trans, ['f3' => 'foo'], $rules);

$this->assertTrue($v->fails());

$v = new Validator($trans, ['f1' => 'foo', 'f2' => 'bar'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f1' => 'foo', 'f3' => 'bar'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f2' => 'foo', 'f3' => 'bar'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f1' => 'foo', 'f2' => 'bar', 'f3' => 'baz'], $rules);

$this->assertTrue($v->passes());

}

public function testRequiredWithoutAll()

{

$trans = $this->getRealTranslator();

$rules = [

'f1' => 'required_without_all:f2,f3',

'f2' => 'required_without_all:f1,f3',

'f3' => 'required_without_all:f1,f2',

];

$v = new Validator($trans, [], $rules);

$this->assertTrue($v->fails());

$v = new Validator($trans, ['f1' => 'foo'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f2' => 'foo'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f3' => 'foo'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f1' => 'foo', 'f2' => 'bar'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f1' => 'foo', 'f3' => 'bar'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f2' => 'foo', 'f3' => 'bar'], $rules);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['f1' => 'foo', 'f2' => 'bar', 'f3' => 'baz'], $rules);

$this->assertTrue($v->passes());

}

public function testRequiredIf()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'taylor'], ['last' => 'required_if:first,taylor']);

$this->assertTrue($v->fails());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'taylor', 'last' => 'otwell'], ['last' => 'required_if:first,taylor']);

$this->assertTrue($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'taylor', 'last' => 'otwell'], ['last' => 'required_if:first,taylor,dayle']);

$this->assertTrue($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'dayle', 'last' => 'rees'], ['last' => 'required_if:first,taylor,dayle']);

$this->assertTrue($v->passes());

// error message when passed multiple values (required_if:foo,bar,baz)

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required_if' => 'The :attribute field is required when :other is :value.'], 'en', 'messages');

$v = new Validator($trans, ['first' => 'dayle', 'last' => ''], ['last' => 'RequiredIf:first,taylor,dayle']);

$this->assertFalse($v->passes());

$this->assertEquals('The last field is required when first is dayle.', $v->messages()->first('last'));

}

public function testRequiredUnless()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'sven'], ['last' => 'required_unless:first,taylor']);

$this->assertTrue($v->fails());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'taylor'], ['last' => 'required_unless:first,taylor']);

$this->assertTrue($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'sven', 'last' => 'wittevrongel'], ['last' => 'required_unless:first,taylor']);

$this->assertTrue($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'taylor'], ['last' => 'required_unless:first,taylor,sven']);

$this->assertTrue($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['first' => 'sven'], ['last' => 'required_unless:first,taylor,sven']);

$this->assertTrue($v->passes());

// error message when passed multiple values (required_unless:foo,bar,baz)

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.required_unless' => 'The :attribute field is required unless :other is in :values.'], 'en', 'messages');

$v = new Validator($trans, ['first' => 'dayle', 'last' => ''], ['last' => 'RequiredUnless:first,taylor,sven']);

$this->assertFalse($v->passes());

$this->assertEquals('The last field is required unless first is in taylor, sven.', $v->messages()->first('last'));

}

public function testValidateConfirmed()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['password' => 'foo'], ['password' => 'Confirmed']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['password' => 'foo', 'password_confirmation' => 'bar'], ['password' => 'Confirmed']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['password' => 'foo', 'password_confirmation' => 'foo'], ['password' => 'Confirmed']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['password' => '1e2', 'password_confirmation' => '100'], ['password' => 'Confirmed']);

$this->assertFalse($v->passes());

}

public function testValidateSame()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'bar', 'baz' => 'boom'], ['foo' => 'Same:baz']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'bar'], ['foo' => 'Same:baz']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'bar', 'baz' => 'bar'], ['foo' => 'Same:baz']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '1e2', 'baz' => '100'], ['foo' => 'Same:baz']);

$this->assertFalse($v->passes());

}

public function testValidateDifferent()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'bar', 'baz' => 'boom'], ['foo' => 'Different:baz']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 'bar'], ['foo' => 'Different:baz']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'bar', 'baz' => 'bar'], ['foo' => 'Different:baz']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '1e2', 'baz' => '100'], ['foo' => 'Different:baz']);

$this->assertTrue($v->passes());

}

public function testValidateAccepted()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'no'], ['foo' => 'Accepted']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => null], ['foo' => 'Accepted']);

$this->assertFalse($v->passes());

$v = new Validator($trans, [], ['foo' => 'Accepted']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 0], ['foo' => 'Accepted']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => false], ['foo' => 'Accepted']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'false'], ['foo' => 'Accepted']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'yes'], ['foo' => 'Accepted']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 'on'], ['foo' => 'Accepted']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '1'], ['foo' => 'Accepted']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 1], ['foo' => 'Accepted']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => true], ['foo' => 'Accepted']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 'true'], ['foo' => 'Accepted']);

$this->assertTrue($v->passes());

}

public function testValidateString()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['x' => 'aslsdlks'], ['x' => 'string']);

$this->assertTrue($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['x' => ['blah' => 'test']], ['x' => 'string']);

$this->assertFalse($v->passes());

}

public function testValidateJson()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'aslksd'], ['foo' => 'json']);

$this->assertFalse($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => '[]'], ['foo' => 'json']);

$this->assertTrue($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => '{"name":"John","age":"34"}'], ['foo' => 'json']);

$this->assertTrue($v->passes());

}

public function testValidateBoolean()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'no'], ['foo' => 'Boolean']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'yes'], ['foo' => 'Boolean']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'false'], ['foo' => 'Boolean']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'true'], ['foo' => 'Boolean']);

$this->assertFalse($v->passes());

$v = new Validator($trans, [], ['foo' => 'Boolean']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => false], ['foo' => 'Boolean']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => true], ['foo' => 'Boolean']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '1'], ['foo' => 'Boolean']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 1], ['foo' => 'Boolean']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '0'], ['foo' => 'Boolean']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 0], ['foo' => 'Boolean']);

$this->assertTrue($v->passes());

}

public function testValidateBool()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'no'], ['foo' => 'Bool']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'yes'], ['foo' => 'Bool']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'false'], ['foo' => 'Bool']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'true'], ['foo' => 'Bool']);

$this->assertFalse($v->passes());

$v = new Validator($trans, [], ['foo' => 'Bool']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => false], ['foo' => 'Bool']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => true], ['foo' => 'Bool']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '1'], ['foo' => 'Bool']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 1], ['foo' => 'Bool']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '0'], ['foo' => 'Bool']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 0], ['foo' => 'Bool']);

$this->assertTrue($v->passes());

}

public function testValidateNumeric()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'asdad'], ['foo' => 'Numeric']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '1.23'], ['foo' => 'Numeric']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '-1'], ['foo' => 'Numeric']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '1'], ['foo' => 'Numeric']);

$this->assertTrue($v->passes());

}

public function testValidateInteger()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'asdad'], ['foo' => 'Integer']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '1.23'], ['foo' => 'Integer']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '-1'], ['foo' => 'Integer']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '1'], ['foo' => 'Integer']);

$this->assertTrue($v->passes());

}

public function testValidateInt()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'asdad'], ['foo' => 'Int']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '1.23'], ['foo' => 'Int']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '-1'], ['foo' => 'Int']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '1'], ['foo' => 'Int']);

$this->assertTrue($v->passes());

}

public function testValidateDigits()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => '12345'], ['foo' => 'Digits:5']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '123'], ['foo' => 'Digits:200']);

$this->assertFalse($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => '12345'], ['foo' => 'digits_between:1,6']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 'bar'], ['foo' => 'digits_between:1,10']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '123'], ['foo' => 'digits_between:4,5']);

$this->assertFalse($v->passes());

}

public function testValidateSize()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'asdad'], ['foo' => 'Size:3']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'anc'], ['foo' => 'Size:3']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '123'], ['foo' => 'Numeric|Size:3']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '3'], ['foo' => 'Numeric|Size:3']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => [1, 2, 3]], ['foo' => 'Array|Size:3']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => [1, 2, 3]], ['foo' => 'Array|Size:4']);

$this->assertFalse($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\File', ['getSize'], [__FILE__, false]);

$file->expects($this->any())->method('getSize')->will($this->returnValue(3072));

$v = new Validator($trans, [], ['photo' => 'Size:3']);

$v->setFiles(['photo' => $file]);

$this->assertTrue($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\File', ['getSize'], [__FILE__, false]);

$file->expects($this->any())->method('getSize')->will($this->returnValue(4072));

$v = new Validator($trans, [], ['photo' => 'Size:3']);

$v->setFiles(['photo' => $file]);

$this->assertFalse($v->passes());

}

public function testValidateBetween()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'asdad'], ['foo' => 'Between:3,4']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'anc'], ['foo' => 'Between:3,5']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 'ancf'], ['foo' => 'Between:3,5']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => 'ancfs'], ['foo' => 'Between:3,5']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '123'], ['foo' => 'Numeric|Between:50,100']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '3'], ['foo' => 'Numeric|Between:1,5']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => [1, 2, 3]], ['foo' => 'Array|Between:1,5']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => [1, 2, 3]], ['foo' => 'Array|Between:1,2']);

$this->assertFalse($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\File', ['getSize'], [__FILE__, false]);

$file->expects($this->any())->method('getSize')->will($this->returnValue(3072));

$v = new Validator($trans, [], ['photo' => 'Between:1,5']);

$v->setFiles(['photo' => $file]);

$this->assertTrue($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\File', ['getSize'], [__FILE__, false]);

$file->expects($this->any())->method('getSize')->will($this->returnValue(4072));

$v = new Validator($trans, [], ['photo' => 'Between:1,2']);

$v->setFiles(['photo' => $file]);

$this->assertFalse($v->passes());

}

public function testValidateMin()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => '3'], ['foo' => 'Min:3']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'anc'], ['foo' => 'Min:3']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '2'], ['foo' => 'Numeric|Min:3']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '5'], ['foo' => 'Numeric|Min:3']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => [1, 2, 3, 4]], ['foo' => 'Array|Min:3']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => [1, 2]], ['foo' => 'Array|Min:3']);

$this->assertFalse($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\File', ['getSize'], [__FILE__, false]);

$file->expects($this->any())->method('getSize')->will($this->returnValue(3072));

$v = new Validator($trans, [], ['photo' => 'Min:2']);

$v->setFiles(['photo' => $file]);

$this->assertTrue($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\File', ['getSize'], [__FILE__, false]);

$file->expects($this->any())->method('getSize')->will($this->returnValue(4072));

$v = new Validator($trans, [], ['photo' => 'Min:10']);

$v->setFiles(['photo' => $file]);

$this->assertFalse($v->passes());

}

public function testValidateMax()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['foo' => 'aslksd'], ['foo' => 'Max:3']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => 'anc'], ['foo' => 'Max:3']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => '211'], ['foo' => 'Numeric|Max:100']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['foo' => '22'], ['foo' => 'Numeric|Max:33']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => [1, 2, 3]], ['foo' => 'Array|Max:4']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['foo' => [1, 2, 3]], ['foo' => 'Array|Max:2']);

$this->assertFalse($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\UploadedFile', ['isValid', 'getSize'], [__FILE__, basename(__FILE__)]);

$file->expects($this->at(0))->method('isValid')->will($this->returnValue(true));

$file->expects($this->at(1))->method('getSize')->will($this->returnValue(3072));

$v = new Validator($trans, [], ['photo' => 'Max:10']);

$v->setFiles(['photo' => $file]);

$this->assertTrue($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\UploadedFile', ['isValid', 'getSize'], [__FILE__, basename(__FILE__)]);

$file->expects($this->at(0))->method('isValid')->will($this->returnValue(true));

$file->expects($this->at(1))->method('getSize')->will($this->returnValue(4072));

$v = new Validator($trans, [], ['photo' => 'Max:2']);

$v->setFiles(['photo' => $file]);

$this->assertFalse($v->passes());

$file = $this->getMock('Symfony\Component\HttpFoundation\File\UploadedFile', ['isValid'], [__FILE__, basename(__FILE__)]);

$file->expects($this->any())->method('isValid')->will($this->returnValue(false));

$v = new Validator($trans, [], ['photo' => 'Max:10']);

$v->setFiles(['photo' => $file]);

$this->assertFalse($v->passes());

}

public function testProperMessagesAreReturnedForSizes()

{

$trans = $this->getRealTranslator();

$trans->addResource('array', ['validation.min.numeric' => 'numeric', 'validation.size.string' => 'string', 'validation.max.file' => 'file'], 'en', 'messages');

$v = new Validator($trans, ['name' => '3'], ['name' => 'Numeric|Min:5']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('numeric', $v->messages()->first('name'));

$v = new Validator($trans, ['name' => 'asasdfadsfd'], ['name' => 'Size:2']);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('string', $v->messages()->first('name'));

$file = $this->getMock('Symfony\Component\HttpFoundation\File\File', ['getSize'], [__FILE__, false]);

$file->expects($this->any())->method('getSize')->will($this->returnValue(4072));

$v = new Validator($trans, [], ['photo' => 'Max:3']);

$v->setFiles(['photo' => $file]);

$this->assertFalse($v->passes());

$v->messages()->setFormat(':message');

$this->assertEquals('file', $v->messages()->first('photo'));

}

public function testValidateIn()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['name' => 'foo'], ['name' => 'In:bar,baz']);

$this->assertFalse($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['name' => 0], ['name' => 'In:bar,baz']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['name' => 'foo'], ['name' => 'In:foo,baz']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['name' => ['foo', 'bar']], ['name' => 'Array|In:foo,baz']);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['name' => ['foo', 'qux']], ['name' => 'Array|In:foo,baz,qux']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['name' => ['foo', 'bar']], ['name' => 'Alpha|In:foo,bar']);

$this->assertFalse($v->passes());

}

public function testValidateNotIn()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['name' => 'foo'], ['name' => 'NotIn:bar,baz']);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['name' => 'foo'], ['name' => 'NotIn:foo,baz']);

$this->assertFalse($v->passes());

}

public function testValidateUnique()

{

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['email' => 'foo'], ['email' => 'Unique:users']);

$mock = m::mock('Illuminate\Validation\PresenceVerifierInterface');

$mock->shouldReceive('getCount')->once()->with('users', 'email', 'foo', null, null, [])->andReturn(0);

$v->setPresenceVerifier($mock);

$this->assertTrue($v->passes());

$trans = $this->getRealTranslator();

$v = new Validator($trans, ['email' => 'foo'], ['email' => 'Unique:connection.users']);

$mock = m::mock('Illuminate\Validation\PresenceVerifierInterface');

$mock->shouldReceive('setConnection')->once()->with('connection');

$mock->shouldReceive('getCount')->once()->with('users', 'email', 'foo', null, null, [])->andReturn(0);

$v->setPresenceVerifier($mock);

$this->assertTrue($v->passes());

$v = new Validator($trans, ['email' => 'foo'], ['email' => 'Unique:users,email_addr,1']);

$mock2 = m::mock('Illuminate\Validation\PresenceVerifierInterface');

$mock2->shouldReceive('getCount')->once()->with('users', 'email_addr', 'foo', '1', 'id', [])->andReturn(1);

$v->setPresenceVerifier($mock2);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['email' => 'foo'], ['email' => 'Unique:users,email_addr,1,id_col']);

$mock3 = m::mock('Illuminate\Validation\PresenceVerifierInterface');

$mock3->shouldReceive('getCount')->once()->with('users', 'email_addr', 'foo', '1', 'id_col', [])->andReturn(2);

$v->setPresenceVerifier($mock3);

$this->assertFalse($v->passes());

$v = new Validator($trans, ['email' => 'foo'], ['email' => 'Unique:users,email_addr,NULL,id_col,foo,bar']);