function mockLocalDriver(PHPUnit_Framework_TestCase $testcase, $root)
{
$driver = $testcase->getMockBuilder(LocalDriver::class)->setConstructorArgs([$root])->setMethods(['instantiateFile', 'instantiateDir'])->getMockForAbstractClass();
$driver->method('instantiateFile')->will($testcase->returnCallback(function ($path) use($driver) {
return new LocalFile($driver, $path);
}));
$driver->method('instantiateDir')->will($testcase->returnCallback(function ($path) use($driver) {
return new LocalDirectory($driver, $path);
}));
return $driver;
}
/**
*
* @param string $username
* @return \Nethgui\Authorization\UserInterface
*/
public static function getAuthenticationSubject(\PHPUnit_Framework_TestCase $testcase, $username = FALSE, $groups = array())
{
$subject = $testcase->getMock('Nethgui\\Authorization\\User', array('authenticate', 'isAuthenticated', 'getCredential', 'hasCredential', 'getLanguageCode', 'asAuthorizationString', 'getAuthorizationAttribute'));
$subject->expects($testcase->any())->method('isAuthenticated')->will($testcase->returnValue(is_string($username)));
$subject->expects($testcase->any())->method('getCredential')->with('username')->will($testcase->returnValue(is_string($username) ? $username : NULL));
$subject->expects($testcase->any())->method('hasCredential')->with('username')->will($testcase->returnValue(is_string($username)));
$getAttribute = function ($attName) use($username, $groups) {
if ($attName === 'username') {
return is_string($username) ? $username : NULL;
} elseif ($attName === 'authenticated') {
return is_string($username) ? TRUE : FALSE;
} elseif ($attName == 'groups') {
return $groups;
}
return NULL;
};
$subject->expects($testcase->any())->method('getAuthorizationAttribute')->withAnyParameters()->will($testcase->returnCallback($getAttribute));
$subject->expects($testcase->any())->method('asAuthorizationString')->will($testcase->returnValue(is_string($username) ? $username : '******'));
$subject->hasCredential('username');
$subject->getCredential('username');
$subject->isAuthenticated();
$subject->getAuthorizationAttribute('username');
$subject->asAuthorizationString();
return $subject;
}
/**
* @param string $methodName
*/
private function buildMethod($methodName)
{
$self = $this;
$callBackFunction = function () use($self, $methodName) {
$inputParams = func_get_args();
$return = $self->getReturn($methodName);
$returnValue = $return['value'];
$returnType = $return['type'];
$self->addInvocation($methodName, $inputParams);
switch ($returnType) {
case 'exception':
throw $returnValue;
break;
case 'value':
return $returnValue;
break;
case 'self':
return $self->getMock();
break;
case 'argument':
return isset($inputParams[$returnValue]) ? $inputParams[$returnValue] : null;
break;
case 'callback':
$inputParams[] = count($self->getInvocations($methodName));
return call_user_func_array($returnValue, $inputParams);
break;
default:
throw new Exception("unknown method return type {$returnType}");
break;
}
};
$method = $this->mock->expects($this->testCase->any());
$method->method($methodName);
$method->will($this->testCase->returnCallback($callBackFunction));
}
/**
* Get data object builder
*
* @param string $className
* @param array $arguments
* @return object
*/
protected function getBuilder($className, array $arguments)
{
$objectFactory = $this->_testObject->getMock('Magento\\Framework\\Api\\ObjectFactory', [], [], '', false);
if (!isset($arguments['objectFactory'])) {
$arguments['objectFactory'] = $objectFactory;
}
$constructArguments = $this->getConstructArguments($className, $arguments);
$reflectionClass = new \ReflectionClass($className);
$builderObject = $reflectionClass->newInstanceArgs($constructArguments);
$objectFactory->expects($this->_testObject->any())->method('populateWithArray')->will($this->_testObject->returnSelf());
$objectFactory->expects($this->_testObject->any())->method('populate')->will($this->_testObject->returnSelf());
$objectFactory->expects($this->_testObject->any())->method('create')->will($this->_testObject->returnCallback(function ($className, $arguments) {
$reflectionClass = new \ReflectionClass($className);
$constructorMethod = $reflectionClass->getConstructor();
$parameters = $constructorMethod->getParameters();
$args = [];
foreach ($parameters as $parameter) {
$parameterName = $parameter->getName();
if (isset($arguments[$parameterName])) {
$args[] = $arguments[$parameterName];
} else {
if ($parameter->isArray()) {
$args[] = [];
} elseif ($parameter->allowsNull()) {
$args[] = null;
} else {
$mock = $this->_getMockWithoutConstructorCall($parameter->getClass()->getName());
$args[] = $mock;
}
}
}
return $reflectionClass->newInstanceArgs($args);
}));
return $builderObject;
}
function mockFileWriter(PHPUnit_Framework_TestCase $testcase, File $file)
{
$in = $testcase->getMockForAbstractClass(FileWriter::class, [$file]);
$in->method('write')->will($testcase->returnCallback(function ($data) {
return strlen($data);
}));
return $in;
}
function mockFileOutputStream(PHPUnit_Framework_TestCase $testcase, File $file)
{
$in = $testcase->getMockForAbstractClass('BapCat\\Interfaces\\Persist\\FileOutputStream', [$file]);
$in->method('write')->will($testcase->returnCallback(function ($data) {
return strlen($data);
}));
return $in;
}
public static function getMysqli(\PHPUnit_Framework_TestCase $testCase)
{
$mysqli = $testCase->getMockBuilder('\\mysqli')->disableOriginalConstructor()->getMock();
$mysqli->method('real_escape_string')->will($testCase->returnCallback(function ($v) {
return addcslashes($v, "\"\n\r\\'");
// not safe implementation!!!
}));
return $mysqli;
}
protected function addMethodExpectation(\ReflectionClass $reflection, MockObject $mock, array $expectation)
{
if (is_null($expectation['will'])) {
return;
}
$expect = $reflection->hasMethod($expectation['method']) && $reflection->getMethod($expectation['method'])->isStatic() ? $mock::staticExpects($expectation['expects']) : $mock->expects($expectation['expects']);
$expect->method($expectation['method'])->will($expectation['will'] instanceof \Closure ? PhpUnitTestCase::returnCallback(version_compare(PHP_VERSION, '5.4.0', '>=') ? $expectation['will']->bindTo($mock, $reflection->getName()) : $expectation['will']) : $expectation['will']);
if (!is_null($expectation['with'])) {
call_user_func_array(array($expect, 'with'), $expectation['with']);
}
}
/**
* Assigns mock callbacks to methods.
*
* This method assumes that the mock callback is named {mock}{method name}.
*
* @param \PHPUnit_Framework_MockObject_MockObject $mockObject The mock object that the callbacks are being assigned to.
* @param \PHPUnit_Framework_TestCase $test The test.
* @param array $array An array of methods names to mock with callbacks.
*
* @return void
*
* @since 2.0
*/
public static function assignMockCallbacks(\PHPUnit_Framework_MockObject_MockObject $mockObject, \PHPUnit_Framework_TestCase $test, $array)
{
foreach ($array as $index => $method) {
if (is_array($method)) {
$methodName = $index;
$callback = $method;
} else {
$methodName = $method;
$callback = array(get_called_class(), 'mock' . $method);
}
$mockObject->expects($test->any())->method($methodName)->will($test->returnCallback($callback));
}
}
public function init()
{
$wikiaAppArgs = array();
$globalRegistryMock = null;
$functionWrapperMock = null;
$globalRegistryMock = $this->testCase->getMock('WikiaGlobalRegistry', array('get', 'set'));
$globalRegistryMock->expects($this->testCase->any())->method('get')->will($this->testCase->returnCallback(array($this, 'getGlobalCallback')));
if (in_array('runFunction', $this->methods)) {
$functionWrapperMock = $this->testCase->getMock('WikiaFunctionWrapper', array_keys($this->mockedFunctions));
foreach ($this->mockedFunctions as $functionName => $functionData) {
$functionWrapperMock->expects($this->testCase->exactly($functionData['calls']))->method($functionName)->will($this->testCase->returnValue($functionData['value']));
}
}
$wikiaAppArgs[] = $globalRegistryMock;
$wikiaAppArgs[] = null;
// WikiaLocalRegistry
$wikiaAppArgs[] = null;
// WikiaHookDispatcher
$wikiaAppArgs[] = $functionWrapperMock;
$this->mock = $this->testCase->getMock('WikiaApp', array('ajax'), $wikiaAppArgs, '');
F::setInstance('App', $this->mock);
}
/**
* Get data object builder
*
* @param string $className
* @param array $arguments
* @return object
*/
protected function getBuilder($className, array $arguments)
{
$objectFactory = $this->_testObject->getMock('Magento\\Framework\\Service\\Data\\ObjectFactory', [], [], '', false);
if (!isset($arguments['objectFactory'])) {
$arguments['objectFactory'] = $objectFactory;
}
$constructArguments = $this->getConstructArguments($className, $arguments);
$reflectionClass = new \ReflectionClass($className);
$builderObject = $reflectionClass->newInstanceArgs($constructArguments);
$objectFactory->expects($this->_testObject->any())->method('create')->will($this->_testObject->returnCallback(function ($className, $arguments) {
$reflectionClass = new \ReflectionClass($className);
return $reflectionClass->newInstanceArgs($arguments);
}));
return $builderObject;
}
/**
* Retrieve mock of core translator model
*
* @return Mage_Core_Model_Translate|PHPUnit_Framework_MockObject_MockObject
*/
protected function _getTranslatorMock()
{
$translator = $this->_testObject->getMockBuilder('Mage_Core_Model_Translate')->disableOriginalConstructor()->setMethods(array('translate'))->getMock();
$translateCallback = function ($arguments) {
$result = '';
if (is_array($arguments) && current($arguments) instanceof Mage_Core_Model_Translate_Expr) {
/** @var Mage_Core_Model_Translate_Expr $expression */
$expression = array_shift($arguments);
$result = vsprintf($expression->getText(), $arguments);
}
return $result;
};
$translator->expects($this->_testObject->any())->method('translate')->will($this->_testObject->returnCallback($translateCallback));
return $translator;
}
/**
* Creates and instance of the mock object.
*
* @param PHPUnit_Framework_TestCase $test A test object.
*
* @return PHPUnit_Framework_MockObject_MockObject
*/
public static function create($test)
{
// Collect all the relevant methods in JDatabase.
$methods = array('getIssueId', 'setIssueId', 'getIssue', 'getIssueProject', 'getIssues');
// Create the mock.
$mockObject = $test->getMock('MonitorModelIssue', $methods, array(), '', false);
self::createSampleData();
$setterCallback = function ($id) {
self::$issueId = $id;
};
$mockObject->expects($test->any())->method('setIssueId')->will($test->returnCallback($setterCallback));
$mockObject->expects($test->any())->method('getIssueId')->will($test->returnValue(self::$issueId));
$mockObject->expects($test->any())->method('getIssue')->will($test->returnValue(self::$data[self::$issueId]));
$mockObject->expects($test->any())->method('getIssueProject')->will($test->returnValue(1));
$mockObject->expects($test->any())->method('getIssues')->will($test->returnValue(self::$data));
return $mockObject;
}
/**
* Creates an instance of the mock JMenu object.
*
* @param PHPUnit_Framework_TestCase $test A test object.
*
* @return PHPUnit_Framework_MockObject_MockObject
*
* @since 3.4
*/
public static function create(PHPUnit_Framework_TestCase $test, $setDefault = true, $setActive = false)
{
// Collect all the relevant methods in JMenu (work in progress).
$methods = array('getItem', 'setDefault', 'getDefault', 'setActive', 'getActive', 'getItems', 'getParams', 'getMenu', 'authorise', 'load');
// Create the mock.
$mockObject = $test->getMock('JMenu', $methods, array(), '', false);
self::createMenuSampleData();
$mockObject->expects($test->any())->method('getItem')->will($test->returnValueMap(self::prepareGetItemData()));
$mockObject->expects($test->any())->method('getItems')->will($test->returnCallback(array(__CLASS__, 'prepareGetItemsData')));
$mockObject->expects($test->any())->method('getMenu')->will($test->returnValue(self::$data));
if ($setDefault) {
$mockObject->expects($test->any())->method('getDefault')->will($test->returnValueMap(self::prepareDefaultData()));
}
if ($setActive) {
$mockObject->expects($test->any())->method('getActive')->will($test->returnValue(self::$data[$setActive]));
}
return $mockObject;
}
/**
* @param Identifies $id
* @param int $version
* @param Metadata|null $metadata
* @return \PHPUnit_Framework_MockObject_MockObject
*/
public function mockEnvelope(Identifies $id, $version, Metadata $metadata = null)
{
$class = 'SimpleES\\EventSourcing\\Event\\EnvelopsEvent';
$envelope = $this->testCase->getMock($class);
$envelope->expects($this->testCase->any())->method('eventId')->will($this->testCase->returnValue($this->mockIdentifier()));
$envelope->expects($this->testCase->any())->method('eventName')->will($this->testCase->returnValue('event_' . ($version + 1)));
$envelope->expects($this->testCase->any())->method('event')->will($this->testCase->returnValue($this->getEventStreamEventOne($id)));
$envelope->expects($this->testCase->any())->method('aggregateId')->will($this->testCase->returnValue($id));
$envelope->expects($this->testCase->any())->method('aggregateVersion')->will($this->testCase->returnValue($version));
$envelope->expects($this->testCase->any())->method('tookPlaceAt')->will($this->testCase->returnValue(Timestamp::now()));
if ($metadata === null) {
$metadata = new Metadata([]);
}
$envelope->expects($this->testCase->any())->method('metadata')->will($this->testCase->returnValue($metadata));
$envelope->expects($this->testCase->any())->method('enrichMetadata')->will($this->testCase->returnCallback(function (Metadata $newMetadata) use($id, $version, $metadata) {
return $this->mockEnvelope($id, $version, $metadata->merge($newMetadata));
}));
return $envelope;
}
/**
* Call API method via API handler.
*
* @param \PHPUnit_Framework_TestCase $testCase Active test case
* @param string $path
* @param array $params Order of items matters as they are passed to call_user_func_array
* @return mixed
*/
public static function call(\PHPUnit_Framework_TestCase $testCase, $path, $params = array())
{
$soapAdapterMock = $testCase->getMock('Magento\\Api\\Model\\Server\\Adapter\\Soap', array('fault'));
$soapAdapterMock->expects($testCase->any())->method('fault')->will($testCase->returnCallback(array(__CLASS__, 'soapAdapterFaultCallback')));
$serverMock = $testCase->getMock('Magento\\Api\\Model\\Server', array('getAdapter'));
$serverMock->expects($testCase->any())->method('getAdapter')->will($testCase->returnValue($soapAdapterMock));
$apiSessionMock = $testCase->getMock('Magento\\Api\\Model\\Session', array('isAllowed', 'isLoggedIn'), array(), '', false);
$apiSessionMock->expects($testCase->any())->method('isAllowed')->will($testCase->returnValue(true));
$apiSessionMock->expects($testCase->any())->method('isLoggedIn')->will($testCase->returnValue(true));
$handlerMock = $testCase->getMock('Magento\\Api\\Model\\Server\\Handler\\Soap', array('_getServer', '_getSession'), array(), '', false);
self::$_previousHandler = set_error_handler(array($handlerMock, 'handlePhpError'));
$handlerMock->expects($testCase->any())->method('_getServer')->will($testCase->returnValue($serverMock));
$handlerMock->expects($testCase->any())->method('_getSession')->will($testCase->returnValue($apiSessionMock));
array_unshift($params, 'sessionId');
/** @var $objectManager \Magento\TestFramework\ObjectManager */
$objectManager = \Magento\TestFramework\Helper\Bootstrap::getObjectManager();
$objectManager->get('Magento\\Framework\\Registry')->unregister('isSecureArea');
$objectManager->get('Magento\\Framework\\Registry')->register('isSecureArea', true);
$result = call_user_func_array(array($handlerMock, $path), $params);
$objectManager->get('Magento\\Framework\\Registry')->unregister('isSecureArea');
$objectManager->get('Magento\\Framework\\Registry')->register('isSecureArea', false);
self::restoreErrorHandler();
return $result;
}
/**
*
*
* @param mixed $callback
* @return PHPUnit_Framework_MockObject_Stub_ReturnCallback
* @since Method available since Release 3.3.0
*/
function returnCallback($callback)
{
return PHPUnit_Framework_TestCase::returnCallback($callback);
}
/**
* @param $placeholderName
* @return \PHPUnit_Framework_MockObject_MockObject | PlaceholderAbstract
*/
public static function getMockCustomPlaceholder($placeholderName)
{
$myPlaceholder = \PHPUnit_Framework_MockObject_Generator::getMockForAbstractClass('\\DbEasy\\Placeholder\\PlaceholderAbstract', [], '', true, true, true, ['getName']);
$myPlaceholder->expects(\PHPUnit_Framework_TestCase::any())->method('getName')->will(\PHPUnit_Framework_TestCase::returnValue($placeholderName));
$myPlaceholder->expects(\PHPUnit_Framework_TestCase::any())->method('transformValue')->will(\PHPUnit_Framework_TestCase::returnCallback(function ($value) {
if ($value === 'in1') {
return 'out1';
}
if ($value === 'in2') {
return 'out2';
}
if ($value === 'in3') {
return 'out3';
}
if ($value === 'in4') {
return 'out4';
}
if ($value === true) {
return true;
}
if ($value === false) {
return false;
}
if ($value === 0) {
return 0;
}
if ($value === '') {
return '';
}
if ($value === 'skip_me_please') {
return Database::SKIP_VALUE;
}
}));
$myPlaceholder->expects(\PHPUnit_Framework_TestCase::any())->method('transformPlaceholder')->will(\PHPUnit_Framework_TestCase::returnCallback(function ($value, $nativePlaceholder) {
if (!empty($nativePlaceholder)) {
if ($value === 'skip_me_please') {
return "SQL_PART_WITHOUT_PARAMS";
}
return $nativePlaceholder;
}
if ($value === 'in1') {
return '"out1"';
}
if ($value === 'in2') {
return '"out2"';
}
if ($value === 'in3') {
return '"out3"';
}
if ($value === 'in4') {
return '"out4"';
}
if ($value === true) {
return 'TRUE';
}
if ($value === false) {
return 'FALSE';
}
if ($value === 0) {
return '0';
}
if ($value === '') {
return '""';
}
}));
return $myPlaceholder;
}
