server/tests/lib/TestCase.php
Thomas Müller 506ccdbd8d
Introduce an event for first time login based on the last login time stamp
Use firstLogin event to trigger creation of default calendar and default address book

Delay login of admin user after setup so that firstLogin event can properly be processed for the admin

Fixing tests ...

Skeleton files are not copied over -> only 3 cache entries are remaining

Use updateLastLoginTimestamp to properly setup lastLogin value for a test user
2016-11-14 14:50:10 +01:00

534 lines
14 KiB
PHP

<?php
/**
* ownCloud
*
* @author Joas Schilling
* @copyright 2014 Joas Schilling nickvergessen@owncloud.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
namespace Test;
use DOMDocument;
use DOMNode;
use OC\Cache\CappedMemoryCache;
use OC\Command\QueueBus;
use OC\Files\Filesystem;
use OC\Template\Base;
use OC_Defaults;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\IDBConnection;
use OCP\IL10N;
use OCP\Security\ISecureRandom;
abstract class TestCase extends \PHPUnit_Framework_TestCase {
/** @var \OC\Command\QueueBus */
private $commandBus;
/** @var IDBConnection */
static protected $realDatabase = null;
/** @var bool */
static private $wasDatabaseAllowed = false;
/** @var array */
protected $services = [];
/**
* Wrapper to be forward compatible to phpunit 5.4+
*
* @param string $originalClassName
* @return \PHPUnit_Framework_MockObject_MockObject
*/
protected function createMock($originalClassName) {
if (is_callable('parent::createMock')) {
return parent::createMock($originalClassName);
}
return $this->getMockBuilder($originalClassName)
->disableOriginalConstructor()
->disableOriginalClone()
->disableArgumentCloning()
->getMock();
}
/**
* @param string $name
* @param mixed $newService
* @return bool
*/
public function overwriteService($name, $newService) {
if (isset($this->services[$name])) {
return false;
}
$this->services[$name] = \OC::$server->query($name);
\OC::$server->registerService($name, function () use ($newService) {
return $newService;
});
return true;
}
/**
* @param string $name
* @return bool
*/
public function restoreService($name) {
if (isset($this->services[$name])) {
$oldService = $this->services[$name];
\OC::$server->registerService($name, function () use ($oldService) {
return $oldService;
});
unset($this->services[$name]);
return true;
}
return false;
}
public function restoreAllServices() {
if (!empty($this->services)) {
if (!empty($this->services)) {
foreach ($this->services as $name => $service) {
$this->restoreService($name);
}
}
}
}
protected function getTestTraits() {
$traits = [];
$class = $this;
do {
$traits = array_merge(class_uses($class), $traits);
} while ($class = get_parent_class($class));
foreach ($traits as $trait => $same) {
$traits = array_merge(class_uses($trait), $traits);
}
$traits = array_unique($traits);
return array_filter($traits, function ($trait) {
return substr($trait, 0, 5) === 'Test\\';
});
}
protected function setUp() {
// overwrite the command bus with one we can run ourselves
$this->commandBus = new QueueBus();
$this->overwriteService('AsyncCommandBus', $this->commandBus);
// detect database access
self::$wasDatabaseAllowed = true;
if (!$this->IsDatabaseAccessAllowed()) {
self::$wasDatabaseAllowed = false;
if (is_null(self::$realDatabase)) {
self::$realDatabase = \OC::$server->getDatabaseConnection();
}
\OC::$server->registerService('DatabaseConnection', function () {
$this->fail('Your test case is not allowed to access the database.');
});
}
$traits = $this->getTestTraits();
foreach ($traits as $trait) {
$methodName = 'setUp' . basename(str_replace('\\', '/', $trait));
if (method_exists($this, $methodName)) {
call_user_func([$this, $methodName]);
}
}
}
protected function onNotSuccessfulTest($e) {
$this->restoreAllServices();
// restore database connection
if (!$this->IsDatabaseAccessAllowed()) {
\OC::$server->registerService('DatabaseConnection', function () {
return self::$realDatabase;
});
}
parent::onNotSuccessfulTest($e);
}
protected function tearDown() {
$this->restoreAllServices();
// restore database connection
if (!$this->IsDatabaseAccessAllowed()) {
\OC::$server->registerService('DatabaseConnection', function () {
return self::$realDatabase;
});
}
// further cleanup
$hookExceptions = \OC_Hook::$thrownExceptions;
\OC_Hook::$thrownExceptions = [];
\OC::$server->getLockingProvider()->releaseAll();
if (!empty($hookExceptions)) {
throw $hookExceptions[0];
}
// fail hard if xml errors have not been cleaned up
$errors = libxml_get_errors();
libxml_clear_errors();
$this->assertEquals([], $errors);
\OC\Files\Cache\Storage::getGlobalCache()->clearCache();
// tearDown the traits
$traits = $this->getTestTraits();
foreach ($traits as $trait) {
$methodName = 'tearDown' . basename(str_replace('\\', '/', $trait));
if (method_exists($this, $methodName)) {
call_user_func([$this, $methodName]);
}
}
}
/**
* Allows us to test private methods/properties
*
* @param $object
* @param $methodName
* @param array $parameters
* @return mixed
*/
protected static function invokePrivate($object, $methodName, array $parameters = array()) {
if (is_string($object)) {
$className = $object;
} else {
$className = get_class($object);
}
$reflection = new \ReflectionClass($className);
if ($reflection->hasMethod($methodName)) {
$method = $reflection->getMethod($methodName);
$method->setAccessible(true);
return $method->invokeArgs($object, $parameters);
} elseif ($reflection->hasProperty($methodName)) {
$property = $reflection->getProperty($methodName);
$property->setAccessible(true);
if (!empty($parameters)) {
$property->setValue($object, array_pop($parameters));
}
return $property->getValue($object);
}
return false;
}
/**
* Returns a unique identifier as uniqid() is not reliable sometimes
*
* @param string $prefix
* @param int $length
* @return string
*/
protected static function getUniqueID($prefix = '', $length = 13) {
return $prefix . \OC::$server->getSecureRandom()->generate(
$length,
// Do not use dots and slashes as we use the value for file names
ISecureRandom::CHAR_DIGITS . ISecureRandom::CHAR_LOWER . ISecureRandom::CHAR_UPPER
);
}
public static function tearDownAfterClass() {
if (!self::$wasDatabaseAllowed && self::$realDatabase !== null) {
// in case an error is thrown in a test, PHPUnit jumps straight to tearDownAfterClass,
// so we need the database again
\OC::$server->registerService('DatabaseConnection', function () {
return self::$realDatabase;
});
}
$dataDir = \OC::$server->getConfig()->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data-autotest');
if (self::$wasDatabaseAllowed && \OC::$server->getDatabaseConnection()) {
$queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
self::tearDownAfterClassCleanShares($queryBuilder);
self::tearDownAfterClassCleanStorages($queryBuilder);
self::tearDownAfterClassCleanFileCache($queryBuilder);
}
self::tearDownAfterClassCleanStrayDataFiles($dataDir);
self::tearDownAfterClassCleanStrayHooks();
self::tearDownAfterClassCleanStrayLocks();
parent::tearDownAfterClass();
}
/**
* Remove all entries from the share table
*
* @param IQueryBuilder $queryBuilder
*/
static protected function tearDownAfterClassCleanShares(IQueryBuilder $queryBuilder) {
$queryBuilder->delete('share')
->execute();
}
/**
* Remove all entries from the storages table
*
* @param IQueryBuilder $queryBuilder
*/
static protected function tearDownAfterClassCleanStorages(IQueryBuilder $queryBuilder) {
$queryBuilder->delete('storages')
->execute();
}
/**
* Remove all entries from the filecache table
*
* @param IQueryBuilder $queryBuilder
*/
static protected function tearDownAfterClassCleanFileCache(IQueryBuilder $queryBuilder) {
$queryBuilder->delete('filecache')
->execute();
}
/**
* Remove all unused files from the data dir
*
* @param string $dataDir
*/
static protected function tearDownAfterClassCleanStrayDataFiles($dataDir) {
$knownEntries = array(
'nextcloud.log' => true,
'owncloud.db' => true,
'.ocdata' => true,
'..' => true,
'.' => true,
);
if ($dh = opendir($dataDir)) {
while (($file = readdir($dh)) !== false) {
if (!isset($knownEntries[$file])) {
self::tearDownAfterClassCleanStrayDataUnlinkDir($dataDir . '/' . $file);
}
}
closedir($dh);
}
}
/**
* Recursive delete files and folders from a given directory
*
* @param string $dir
*/
static protected function tearDownAfterClassCleanStrayDataUnlinkDir($dir) {
if ($dh = @opendir($dir)) {
while (($file = readdir($dh)) !== false) {
if (\OC\Files\Filesystem::isIgnoredDir($file)) {
continue;
}
$path = $dir . '/' . $file;
if (is_dir($path)) {
self::tearDownAfterClassCleanStrayDataUnlinkDir($path);
} else {
@unlink($path);
}
}
closedir($dh);
}
@rmdir($dir);
}
/**
* Clean up the list of hooks
*/
static protected function tearDownAfterClassCleanStrayHooks() {
\OC_Hook::clear();
}
/**
* Clean up the list of locks
*/
static protected function tearDownAfterClassCleanStrayLocks() {
\OC::$server->getLockingProvider()->releaseAll();
}
/**
* Login and setup FS as a given user,
* sets the given user as the current user.
*
* @param string $user user id or empty for a generic FS
*/
static protected function loginAsUser($user = '') {
self::logout();
\OC\Files\Filesystem::tearDown();
\OC_User::setUserId($user);
$userObject = \OC::$server->getUserManager()->get($user);
if (!is_null($userObject)) {
$userObject->updateLastLoginTimestamp();
}
\OC_Util::setupFS($user);
if (\OC_User::userExists($user)) {
\OC::$server->getUserFolder($user);
}
}
/**
* Logout the current user and tear down the filesystem.
*/
static protected function logout() {
\OC_Util::tearDownFS();
\OC_User::setUserId('');
// needed for fully logout
\OC::$server->getUserSession()->setUser(null);
}
/**
* Run all commands pushed to the bus
*/
protected function runCommands() {
// get the user for which the fs is setup
$view = Filesystem::getView();
if ($view) {
list(, $user) = explode('/', $view->getRoot());
} else {
$user = null;
}
\OC_Util::tearDownFS(); // command can't reply on the fs being setup
$this->commandBus->run();
\OC_Util::tearDownFS();
if ($user) {
\OC_Util::setupFS($user);
}
}
/**
* Check if the given path is locked with a given type
*
* @param \OC\Files\View $view view
* @param string $path path to check
* @param int $type lock type
* @param bool $onMountPoint true to check the mount point instead of the
* mounted storage
*
* @return boolean true if the file is locked with the
* given type, false otherwise
*/
protected function isFileLocked($view, $path, $type, $onMountPoint = false) {
// Note: this seems convoluted but is necessary because
// the format of the lock key depends on the storage implementation
// (in our case mostly md5)
if ($type === \OCP\Lock\ILockingProvider::LOCK_SHARED) {
// to check if the file has a shared lock, try acquiring an exclusive lock
$checkType = \OCP\Lock\ILockingProvider::LOCK_EXCLUSIVE;
} else {
// a shared lock cannot be set if exclusive lock is in place
$checkType = \OCP\Lock\ILockingProvider::LOCK_SHARED;
}
try {
$view->lockFile($path, $checkType, $onMountPoint);
// no exception, which means the lock of $type is not set
// clean up
$view->unlockFile($path, $checkType, $onMountPoint);
return false;
} catch (\OCP\Lock\LockedException $e) {
// we could not acquire the counter-lock, which means
// the lock of $type was in place
return true;
}
}
private function IsDatabaseAccessAllowed() {
// on travis-ci.org we allow database access in any case - otherwise
// this will break all apps right away
if (true == getenv('TRAVIS')) {
return true;
}
$annotations = $this->getAnnotations();
if (isset($annotations['class']['group'])) {
if(in_array('DB', $annotations['class']['group']) || in_array('SLOWDB', $annotations['class']['group']) ) {
return true;
}
}
return false;
}
/**
* @param string $expectedHtml
* @param string $template
* @param array $vars
*/
protected function assertTemplate($expectedHtml, $template, $vars = []) {
require_once __DIR__.'/../../lib/private/legacy/template/functions.php';
$requestToken = 12345;
$theme = new OC_Defaults();
/** @var IL10N | \PHPUnit_Framework_MockObject_MockObject $l10n */
$l10n = $this->getMockBuilder('\OCP\IL10N')
->disableOriginalConstructor()->getMock();
$l10n
->expects($this->any())
->method('t')
->will($this->returnCallback(function($text, $parameters = array()) {
return vsprintf($text, $parameters);
}));
$t = new Base($template, $requestToken, $l10n, $theme);
$buf = $t->fetchPage($vars);
$this->assertHtmlStringEqualsHtmlString($expectedHtml, $buf);
}
/**
* @param string $expectedHtml
* @param string $actualHtml
* @param string $message
*/
protected function assertHtmlStringEqualsHtmlString($expectedHtml, $actualHtml, $message = '') {
$expected = new DOMDocument();
$expected->preserveWhiteSpace = false;
$expected->formatOutput = true;
$expected->loadHTML($expectedHtml);
$actual = new DOMDocument();
$actual->preserveWhiteSpace = false;
$actual->formatOutput = true;
$actual->loadHTML($actualHtml);
$this->removeWhitespaces($actual);
$expectedHtml1 = $expected->saveHTML();
$actualHtml1 = $actual->saveHTML();
self::assertEquals($expectedHtml1, $actualHtml1, $message);
}
private function removeWhitespaces(DOMNode $domNode) {
foreach ($domNode->childNodes as $node) {
if($node->hasChildNodes()) {
$this->removeWhitespaces($node);
} else {
if ($node instanceof \DOMText && $node->isWhitespaceInElementContent() ) {
$domNode->removeChild($node);
}
}
}
}
}