<?php
require __DIR__ . '/../vendor/autoload.php';
use FUnit as fu;
use Knlv\Zf2\Validator\VatNumber;
fu::test('Test getValidator returns default composed validator', function () {
$validator = new VatNumber();
fu::ok($validator->getValidator() instanceof Ddeboer\Vatin\Validator);
});
fu::test('Test options are set', function () {
$validator = new VatNumber(array('country' => 'EL', 'checkExistence' => false));
fu::equal('EL', $validator->getCountry());
fu::equal(false, $validator->getCheckExistence());
});
fu::test('Test throws exception on invalid country', function () {
fu::throws(function () {
$validator = new VatNumber(array('country' => 'GR'));
}, array(), 'Zend\\Validator\\Exception\\InvalidArgumentException');
});
fu::test('Test validates same as composed validator', function () {
$data = array(array(false, 'EL', '123456789', true), array(false, 'BE', '0123456789', true), array(true, 'NL', '987654321B01', false), array(true, 'NL', '7654321B01', false), array(true, 'BE', '01234567', false));
$validator = new VatNumber();
fu::all_ok($data, function ($values) use($validator) {
$validator->setCheckExistence($values[0]);
$validator->setCountry($values[1]);
return $validator->isValid($values[2]) === $values[3];
});
});
fu::test('Test messages', function () {
$validator = new VatNumber();
$validator->isValid("EL123456789");
<?php
require __DIR__ . '/../vendor/autoload.php';
use FUnit as fu;
use Knlv\Zf2\Validator\ExplodeWithContext;
use Zend\Validator\Callback;
// Zend\Validator\Callback uses context in isValid method in order to test
fu::setup(function () {
$validator = new ExplodeWithContext();
fu::fixture('validator', $validator);
});
fu::test('Test explode_with_context passes context', function () {
$validator = fu::fixture('validator');
$validator->setValueDelimiter(',');
$validator->setValidator(new Callback(function ($value, $context) {
fu::equal('value', $context, 'Assert context pass');
return false;
}));
$validator->isValid('value 1,value 2,other value', 'value');
});
fu::test('Test explode_with_context validates correctly', function () {
$validator = fu::fixture('validator');
$validator->setValueDelimiter('|');
$validator->setValidator(new Callback(function ($value, $context) {
// value begins with value from context
return 0 === strpos($value, $context);
}));
fu::ok($validator->isValid('value 1|value 2|value 3', 'value'), 'Assert returns true if validates');
fu::not_ok($validator->isValid('value 1|other value 2|value 3', 'value'), 'Assert returns false if one does not validate');
});
<?php
require __DIR__ . '/../vendor/autoload.php';
use FUnit as fu;
use Knlv\Zf2\Validator\NotIdentical;
fu::setup(function () {
$validator = new NotIdentical();
fu::fixture('validator', $validator);
});
fu::test('Test not_identical validates correctly', function () {
$validator = fu::fixture('validator');
$validator->setToken('token');
fu::not_ok($validator->isValid('value', array('token' => 'value')), 'Assert validator returns false on same');
fu::ok($validator->isValid('value', array('token' => 'other')), 'Assert validator retuns true on different');
fu::ok($validator->isValid('value'), 'Assert validator returns true if no context provided');
fu::ok($validator->isValid('value', array('other_token' => 'value')), 'Assert validator returns true if token not found in context');
$validator->setToken(null);
fu::not_ok($validator->isValid('value', array('token' => 'value')), 'Assert validator return false if no token is set');
});
fu::test('Test not_identical messages', function () {
$validator = fu::fixture('validator');
$validator->setToken('token');
$validator->isValid('value', array('token' => 'value'));
fu::has($validator::SAME, $validator->getMessages(), 'Assert same message');
$validator->isValid('value', array('token' => 'other'));
$messages = $validator->getMessages();
fu::ok(empty($messages), 'Assert empty messages if validator validates');
$validator->setToken(null);
$validator->isValid('value', array('token' => 'value'));
fu::has($validator::MISSING_TOKEN, $validator->getMessages(), 'Assert missing token message');
});
$data = array(array('foo' => ' bazbat ', 'bar' => ' 12345 ', 'baz' => ''), array('foo' => ' bazbar ', 'bar' => ' 12345 ', 'baz' => ''));
$expected = array(array('foo' => 'bazbat', 'bar' => '12345', 'baz' => ''), array('foo' => 'bazbar', 'bar' => '12345', 'baz' => ''));
$collectionFilter = fu::fixture('collectionFilter');
$collectionFilter->setData($data);
$collectionFilter->setUniqueFields(array('foo'));
fu::ok($collectionFilter->isValid(), 'Assert inputfilter is valid');
$messages = $collectionFilter->getMessages();
fu::ok(empty($messages), 'Assert inputfilter has no error messages');
fu::equal($expected, $collectionFilter->getValues(), 'Assert inputfilter returns expected values');
$collectionFilter->setUniqueFields(array('bar'));
fu::not_ok($collectionFilter->isValid(), 'Assert inputfilter is invalid');
$messages = $collectionFilter->getMessages();
fu::ok(isset($messages[1]['bar'][$collectionFilter::NOT_UNIQUE]), 'Assert message for not unique isset');
fu::equal($expected, $collectionFilter->getValues(), 'Assert inputfilter returns expected values');
});
fu::test('Test inputfilter validate for unique values in fields on invalid data', function () {
$data = array(array('foo' => ' bazbatfoo ', 'bar' => ' 12345 ', 'baz' => ''), array('foo' => ' bazbatfoo ', 'bar' => ' 54321 ', 'baz' => ''));
$expected = array(array('foo' => 'bazbatfoo', 'bar' => '12345', 'baz' => ''), array('foo' => 'bazbatfoo', 'bar' => '54321', 'baz' => ''));
$collectionFilter = fu::fixture('collectionFilter');
$collectionFilter->setData($data);
$collectionFilter->setUniqueFields(array('bar'));
fu::not_ok($collectionFilter->isValid(), 'Assert inputfilter is invalid');
$messages = $collectionFilter->getMessages();
fu::ok(isset($messages[0]['foo'][Validator\StringLength::TOO_LONG]), 'Assert correct error messages');
fu::equal($expected, $collectionFilter->getValues(), 'Assert inputfilter returns expected values');
$collectionFilter->setUniqueFields(array('foo'));
fu::not_ok($collectionFilter->isValid(), 'Assert inputfilter is invalid');
$messages = $collectionFilter->getMessages();
fu::ok(isset($messages[0]['foo'][Validator\StringLength::TOO_LONG]) && isset($messages[1]['foo'][Validator\StringLength::TOO_LONG]) && isset($messages[1]['foo'][$collectionFilter::NOT_UNIQUE]), 'Assert message for not unique isset along with other');
fu::equal($expected, $collectionFilter->getValues(), 'Assert inputfilter returns expected values');
});
<?php
require __DIR__ . '/../vendor/autoload.php';
use FUnit as fu;
use Knlv\Slim\Middleware\Callback;
date_default_timezone_set('Europe/Athens');
fu::test('Test middleware throws exception on invlalid callable', function () {
try {
new Callback('test');
} catch (Exception $e) {
fu::ok($e instanceof InvalidArgumentException, 'Throws if no callback is given');
}
});
fu::test('Test middleware set callback', function () {
$callback = function () {
};
$middleware = new Callback($callback);
$reflection = new ReflectionObject($middleware);
$propertyReflection = $reflection->getProperty('callback');
$propertyReflection->setAccessible(true);
fu::equal($callback, $propertyReflection->getValue($middleware), 'Callback is set');
});
fu::test('Test middleware call uses callback', function () {
$middleware = new Callback(function ($m) use(&$middleware) {
fu::pass('Callable is called');
fu::equal($middleware, $m, 'Passes itself as callable argument');
});
$middleware->call();
});
<?php
use FUnit as fu;
require_once __DIR__ . '/src/FUnit.php';
fu::setup(function () {
// set a fixture to use in tests
fu::fixture('foobar', array('foo' => 'bar'));
});
fu::teardown(function () {
// this resets the fu::$fixtures array. May not provide clean shutdown
fu::reset_fixtures();
});
fu::test("this is a test", function () {
fu::ok(1, "the integer '1' is okay");
fu::ok(0, "the integer '0' is not okay");
// this will fail!
});
fu::test("another test", function () {
fu::equal(true, 1, "the integer '1' is truthy");
fu::not_strict_equal(true, 1, "the integer '1' is NOT true");
// access a fixture
$foobar = fu::fixture('foobar');
fu::equal($foobar['foo'], 'bar', "the fixture 'foobar' should have a key 'foo' equal to 'baz'");
$fooarr = array('blam' => 'blaz');
fu::has('blam', $fooarr, "\$fooarr has a key named 'blam'");
$fooobj = new \StdClass();
$fooobj->blam = 'blaz';
fu::has('blam', $fooobj, "\$fooobj has a property named 'blam'");
});
fu::test('Checking for exceptions', function () {
$callback = function () {
use Zend\Permissions\Acl\Acl;
use Knlv\Zf2\Permissions\Acl\Assertion\Callback as AclCallback;
fu::setup(function () {
$acl = new Acl();
// add roles
$acl->addRole('guest');
$acl->addRole('member', 'guest');
// add resources
$acl->addResource('article');
// add rules
$acl->allow('guest', 'article', array('read'));
$acl->allow('member', 'article', array('write', 'delete'));
fu::fixture('acl', $acl);
});
fu::test('Test acl callback assertion', function () {
$acl = fu::fixture('acl');
$test = $acl->isAllowed('guest', 'article', 'read') && $acl->isAllowed('member', 'article', 'read') && $acl->isAllowed('member', 'article', 'write') && !$acl->isAllowed('guest', 'article', 'write');
fu::ok($test, 'Test acl without assertions');
$assertTrue = new AclCallback(function () {
return true;
});
$assertFalse = new AclCallback(function () {
return false;
});
$acl->removeAllow('member', 'article', 'write');
$acl->allow('member', 'article', 'write', $assertFalse);
fu::not_ok($acl->isAllowed('member', 'article', 'write'), 'Assert not allowed when callback returns false');
$acl->removeAllow('member', 'article', 'write');
$acl->allow('member', 'article', 'write', $assertTrue);
fu::ok($acl->isAllowed('member', 'article', 'write'), 'Assert allowed when callback returns true');
});
return false;
};
$adapter = new CallbackAdapter($callback);
$adapter->setIdentity('testuser');
$adapter->setCredential('testpass');
$result = $adapter->authenticate();
fu::ok($result instanceof Result, 'Assert Authentication result is instanceof Zend\\Authentication\\Result');
fu::equal(Result::SUCCESS, $result->getCode(), 'Assert success code in result on success');
fu::equal('testuser', $result->getIdentity(), 'Assert identity is returned on success');
$adapter->setCredential('someotherpass');
$result = $adapter->authenticate();
fu::equal(Result::FAILURE, $result->getCode(), 'Assert failure code in result on failure');
fu::equal(null, $result->getIdentity(), 'Assert null is returned on failure');
});
fu::test('Test authentication callback adapter without credentials', function () {
$callbackSuccess = function () {
return 'testuser';
};
$callbackFailure = function () {
return false;
};
$adapter = new CallbackAdapter($callbackSuccess);
$result = $adapter->authenticate();
fu::ok($result instanceof Result, 'Assert Authentication result is instanceof Zend\\Authentication\\Result');
fu::equal(Result::SUCCESS, $result->getCode(), 'Assert success code in result on success');
fu::equal('testuser', $result->getIdentity(), 'Assert identity is returned on success');
$adapter = new CallbackAdapter($callbackFailure);
$result = $adapter->authenticate();
fu::equal(Result::FAILURE, $result->getCode(), 'Assert failure code in result on failure');
fu::equal(null, $result->getIdentity(), 'Assert null is returned on failure');
});
<?php
require __DIR__ . '/../vendor/autoload.php';
use FUnit as fu;
use Zend\Permissions\Rbac\Rbac;
use Knlv\Zf2\Permissions\Rbac\Assertion\Callback as RbacCallback;
fu::setup(function () {
$rbac = new Rbac();
$rbac->addRole('member');
$rbac->addRole('guest', 'member');
$rbac->getRole('guest')->addPermission('read');
$rbac->getRole('member')->addPermission('write');
fu::fixture('rbac', $rbac);
});
fu::test('Test rbac callback assertion', function () {
$rbac = fu::fixture('rbac');
$test = $rbac->isGranted('guest', 'read') && $rbac->isGranted('member', 'read') && !$rbac->isGranted('guest', 'write') && $rbac->isGranted('member', 'write');
fu::ok($test, 'Test rbac without assertions');
$assertTrue = new RbacCallback(function () {
return true;
});
$assertFalse = new RbacCallback(function () {
return false;
});
fu::not_ok($rbac->isGranted('member', 'read', $assertFalse), 'Assert permission not granted when callback returns false');
fu::ok($rbac->isGranted('member', 'write', $assertTrue), 'Assert permission granted when callback returns true');
});
<?php
use FUnit as fu;
require_once __DIR__ . '/../src/FUnit.php';
fu::suite('Fixture test suite');
fu::test('Test adding fixtures', function () {
fu::fixture('a', array(1, 2, 3));
$a = fu::fixture('a');
fu::strict_equal(array(1, 2, 3), $a);
});
fu::test('Test resetting fixtures', function () {
fu::fixture('a', array(1, 2, 3));
$a = fu::fixture('a');
fu::reset_fixtures();
fu::ok(is_null(fu::fixture('a')));
});
fu::run();
<?php
require __DIR__ . '/../vendor/autoload.php';
use FUnit as fu;
fu::test("Test throws Exception on not callable argumet", function () {
try {
$memoized = Knlv\memoize('test string');
} catch (Exception $e) {
fu::ok($e instanceof InvalidArgumentException, 'Throws InvalidArgumentException on invalid argument');
}
});
fu::test("Test memoize works", function () {
$counter = 0;
$function = function ($arg) use(&$counter) {
return $arg . ($counter += 1);
};
fu::equal('test1', $function('test'), 'Call with no memoization increments external counter');
fu::equal('test2', $function('test'), 'Call with no memoization increments external counter');
$memoized = Knlv\memoize($function);
fu::equal('test3', $memoized('test'), '1st call memoized function increments external counter');
fu::equal('test3', $memoized('test'), '2nd Call memoized function returns cached value');
fu::equal(3, $counter, 'Assert counter not changed after 2nd memoized function call');
});
fu::test("Test memoize use separate cache foreach function", function () {
$function1 = function ($arg) {
return $arg . $arg;
};
$function2 = function ($arg) {
return $arg;
};
fu::equal('testtest', $function1('test'), 'Assert not memoized function 1 works');
FUnit::equal($expected, ["name" => $output->getName(), "type" => $output->getType(), "size" => $output->getSize(), "tmp_name" => $output->getTmpName(), "error" => $output->getError()]);
});
FUnit::test("FileMarshal::marshal() testing countable", function () {
$input = array("fieldname2" => array('name' => array("field1", "field2"), 'type' => array("plain/text", "plain/text"), 'size' => array("1024", "1024"), 'tmp_name' => array("asdfqwerty1", "asdfqwerty2"), 'error' => array("0", "0")));
$files = new \FileMarshal\FileMarshal(new FileMarshal\UploadedFileFactory());
$files->marshal($input["fieldname2"]);
Funit::equal(2, count($files));
});
FUnit::test("FileMarshal::marshal() testing iterator via foreach", function () {
$input = array("fieldname2" => array('name' => array("field1", "field2"), 'type' => array("plain/text", "plain/text"), 'size' => array("1024", "1024"), 'tmp_name' => array("asdfqwerty1", "asdfqwerty2"), 'error' => array("0", "0")));
$files = new \FileMarshal\FileMarshal(new FileMarshal\UploadedFileFactory());
$files->marshal($input["fieldname2"]);
foreach ($files as $file) {
FUnit::ok(in_array($file->getName(), $input["fieldname2"]["name"]));
FUnit::ok(in_array($file->getType(), $input["fieldname2"]["type"]));
FUnit::ok(in_array($file->getTmpName(), $input["fieldname2"]["tmp_name"]));
FUnit::ok(in_array($file->getError(), $input["fieldname2"]["error"]));
FUnit::ok(in_array($file->getSize(), $input["fieldname2"]["size"]));
}
});
FUnit::test("UploadedFile::hasError()", function () {
$input["fieldname"] = array('name' => "", 'type' => "", 'size' => "", 'tmp_name' => "", 'error' => UPLOAD_ERR_NO_FILE);
$file = new \FileMarshal\FileMarshal(new FileMarshal\UploadedFileFactory());
try {
$file->marshal($input["fieldname"]);
} catch (\FileMarshal\Exceptions\UploadErrNoFile $e) {
FUnit::ok(1);
} catch (\Exception $e) {
Funit::fail("Wrong exception was thrown");
}
});