%PDF-
%PDF-
Mini Shell
Mini Shell
<?php
namespace OCA\Bookmarks\Tests;
use OC;
use OCA\Bookmarks\Controller\BookmarkController;
use OCA\Bookmarks\Db\Bookmark;
use OCA\Bookmarks\Db\BookmarkMapper;
use OCA\Bookmarks\Db\Folder;
use OCA\Bookmarks\Db\FolderMapper;
use OCA\Bookmarks\Db\PublicFolder;
use OCA\Bookmarks\Db\PublicFolderMapper;
use OCA\Bookmarks\Db\Share;
use OCA\Bookmarks\Db\SharedFolder;
use OCA\Bookmarks\Db\SharedFolderMapper;
use OCA\Bookmarks\Db\ShareMapper;
use OCA\Bookmarks\Db\TagMapper;
use OCA\Bookmarks\Db\TreeMapper;
use OCA\Bookmarks\Exception\AlreadyExistsError;
use OCA\Bookmarks\Exception\UnauthenticatedError;
use OCA\Bookmarks\Exception\UnsupportedOperation;
use OCA\Bookmarks\Exception\UrlParseError;
use OCA\Bookmarks\Exception\UserLimitExceededError;
use OCA\Bookmarks\QueryParameters;
use OCA\Bookmarks\Service\Authorizer;
use OCA\Bookmarks\Service\BookmarkService;
use OCA\Bookmarks\Service\FolderService;
use OCA\Bookmarks\Service\HtmlExporter;
use OCA\Bookmarks\Service\LockManager;
use OCP\AppFramework\Db\DoesNotExistException;
use OCP\AppFramework\Db\MultipleObjectsReturnedException;
use OCP\AppFramework\Http;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\Files\IRootFolder;
use OCP\IRequest;
use OCP\IURLGenerator;
use OCP\IUserManager;
use OCP\L10N\IFactory;
use Psr\Log\LoggerInterface;
/**
* Class Test_BookmarkController
*
* @group Controller
*/
class BookmarkControllerTest extends TestCase {
private $userId;
private $otherUser;
/**
* @var \OCP\IRequest
*/
private $request;
/**
* @var \OC\User\Manager
*/
private $userManager;
/**
* @var BookmarkController
*/
private $controller;
/**
* @var BookmarkController
*/
private $publicController;
/**
* @var BookmarkMapper
*/
private $bookmarkMapper;
/**
* @var FolderMapper
*/
private $folderMapper;
/**
* @var TagMapper
*/
private $tagMapper;
/**
* @var PublicFolderMapper
*/
private $publicFolderMapper;
private $bookmark1Id;
private $bookmark2Id;
/**
* @var PublicFolder
*/
private $publicFolder;
/**
* @var Folder
*/
private $folder1;
/**
* @var Folder
*/
private $folder2;
/**
* @var string
*/
private $user;
/**
* @var IRequest
*/
private $publicRequest;
/**
* @var string
*/
private $otherUserId;
/**
* @var ShareMapper
*/
private $shareMapper;
/**
* @var SharedFolderMapper
*/
private $sharedFolderMapper;
/**
* @var BookmarkController
*/
private $otherController;
/**
* @var TreeMapper
*/
private $treeMapper;
/**
* @var SharedFolder
*/
private $sharedFolder;
/**
* @var Share
*/
private $share;
/**
* @var Authorizer
*/
private $authorizer;
/**
* @var BookmarkService
*/
private $bookmarks;
/**
* @var FolderService
*/
private $folders;
/**
* @var LockManager
*/
private $lockManager;
/**
* @throws \OCP\AppFramework\QueryException
*/
protected function setUp(): void {
parent::setUp();
$this->user = 'test';
$this->otherUser = 'otheruser';
$this->request = OC::$server->get(IRequest::class);
$this->otherRequest = OC::$server->get(IRequest::class);
$this->publicRequest = $this->createMock(IRequest::class);
$this->userManager = OC::$server->get(IUserManager::class);
if (!$this->userManager->userExists($this->user)) {
$this->userManager->createUser($this->user, 'password');
}
$this->userId = $this->userManager->get($this->user)->getUID();
if (!$this->userManager->userExists($this->otherUser)) {
$this->userManager->createUser($this->otherUser, 'password');
}
$this->otherUserId = $this->userManager->get($this->otherUser)->getUID();
/** @var IFactory $l10nFactory */
$l10nFactory = OC::$server->get(IFactory::class);
$l = $l10nFactory->get('bookmarks');
$this->bookmarks = OC::$server->get(BookmarkService::class);
$this->bookmarkMapper = OC::$server->get(BookmarkMapper::class);
$this->tagMapper = OC::$server->get(TagMapper::class);
$this->folderMapper = OC::$server->get(FolderMapper::class);
$this->treeMapper = OC::$server->get(TreeMapper::class);
$this->publicFolderMapper = OC::$server->get(PublicFolderMapper::class);
$this->shareMapper = OC::$server->get(ShareMapper::class);
$this->sharedFolderMapper = OC::$server->get(SharedFolderMapper::class);
$timeFactory = OC::$server->get(ITimeFactory::class);
$logger = OC::$server->get(LoggerInterface::class);
$urlGenerator = OC::$server->get(IURLGenerator::class);
$htmlExporter = OC::$server->get(HtmlExporter::class);
$this->authorizer = OC::$server->get(Authorizer::class);
$this->folders = OC::$server->get(FolderService::class);
$this->lockManager = OC::$server->get(LockManager::class);
/** @var IRootFolder $rootFolder */
$rootFolder = OC::$server->get(IRootFolder::class);
$this->controller = new BookmarkController('bookmarks', $this->request, $l, $this->bookmarkMapper, $this->tagMapper, $this->folderMapper, $this->treeMapper, $this->publicFolderMapper, $timeFactory, $logger, $urlGenerator, $htmlExporter, $this->authorizer, $this->bookmarks, $this->folders, $rootFolder, $this->lockManager);
$this->otherController = new BookmarkController('bookmarks', $this->request, $l, $this->bookmarkMapper, $this->tagMapper, $this->folderMapper, $this->treeMapper, $this->publicFolderMapper, $timeFactory, $logger, $urlGenerator, $htmlExporter, $this->authorizer, $this->bookmarks, $this->folders, $rootFolder, $this->lockManager);
$this->publicController = new BookmarkController('bookmarks', $this->publicRequest, $l, $this->bookmarkMapper, $this->tagMapper, $this->folderMapper, $this->treeMapper, $this->publicFolderMapper, $timeFactory, $logger, $urlGenerator, $htmlExporter, $this->authorizer, $this->bookmarks, $this->folders, $rootFolder, $this->lockManager);
}
/**
* @throws AlreadyExistsError
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws MultipleObjectsReturnedException
*/
public function setupBookmarks(): void {
$this->authorizer->setUserId($this->userId);
$bookmark1 = Bookmark::fromArray([
'userId' => $this->userId,
'url' => 'https://www.golem.de',
'title' => 'Golem',
'description' => 'PublicNoTag',
]);
$bookmark1 = $this->bookmarkMapper->insertOrUpdate($bookmark1);
$this->tagMapper->addTo(['four'], $bookmark1->getId());
$bookmark2 = Bookmark::fromArray([
'userId' => $this->userId,
'url' => 'https://9gag.com',
'title' => '9gag',
'description' => 'PublicTag',
]);
$bookmark2 = $this->bookmarkMapper->insertOrUpdate($bookmark2);
$this->tagMapper->addTo(['four'], $bookmark2->getId());
$this->bookmark1Id = $bookmark1->getId();
$this->bookmark2Id = $bookmark2->getId();
$rootFolderId = $this->folderMapper->findRootFolder($this->userId)->getId();
$this->treeMapper->addToFolders(TreeMapper::TYPE_BOOKMARK, $this->bookmark1Id, [$rootFolderId]);
$this->treeMapper->addToFolders(TreeMapper::TYPE_BOOKMARK, $this->bookmark2Id, [$rootFolderId]);
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws DoesNotExistException
* @throws UnsupportedOperation
*/
public function setupBookmarksWithPublicFolder(): void {
$this->setupBookmarks();
$this->authorizer->setUserId($this->userId);
$this->folder1 = new Folder();
$this->folder1->setTitle('foo');
$this->folder1->setUserId($this->userId);
$this->folderMapper->insert($this->folder1);
$this->treeMapper->move(TreeMapper::TYPE_FOLDER, $this->folder1->getId(), $this->folderMapper->findRootFolder($this->userId)->getId());
$this->folder2 = new Folder();
$this->folder2->setTitle('bar');
$this->folder2->setUserId($this->userId);
$this->folderMapper->insert($this->folder2);
$this->treeMapper->move(TreeMapper::TYPE_FOLDER, $this->folder2->getId(), $this->folder1->getId());
$this->publicFolder = new PublicFolder();
$this->publicFolder->setFolderId($this->folder1->getId());
$this->publicFolderMapper->insert($this->publicFolder);
// inject token into public request stub
$this->publicRequest->method('getHeader')
->willReturn('Bearer ' . $this->publicFolder->getId());
$this->treeMapper->addToFolders(TreeMapper::TYPE_BOOKMARK, $this->bookmark1Id, [$this->folder1->getId()]);
$this->treeMapper->addToFolders(TreeMapper::TYPE_BOOKMARK, $this->bookmark2Id, [$this->folder2->getId()]);
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function setupBookmarksWithSharedFolder(): void {
$this->setupBookmarksWithPublicFolder();
$this->authorizer->setUserId($this->userId);
$this->folders->createShare($this->folder1->getId(), $this->otherUserId, \OCP\Share\IShare::TYPE_USER, true, false);
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testRead(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId($this->userId);
$output = $this->controller->getSingleBookmark($this->bookmark2Id);
$data = $output->getData();
$this->assertEquals('success', $data['status'], var_export($data, true));
$this->assertEquals("https://9gag.com/", $data['item']['url']);
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testReadFailure(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId($this->otherUserId);
$output = $this->otherController->getSingleBookmark($this->bookmark1Id);
$data = $output->getData();
$this->assertEquals('error', $data['status'], var_export($data, true));
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testPublicReadFailure(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId(null);
$this->expectException(UnauthenticatedError::class);
$this->publicController->getSingleBookmark($this->bookmark1Id);
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testReadNotFound(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId($this->userId);
$output = $this->controller->getSingleBookmark(987);
$data = $output->getData();
$this->assertSame('error', $data['status'], var_export($data, true));
$this->assertSame(404, $output->getStatus());
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testPrivateget(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId($this->userId);
$output = $this->controller->getBookmarks();
$data = $output->getData();
$this->assertCount(2, $data['data']);
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testCreate(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId($this->userId);
$res = $this->controller->newBookmark('https://www.heise.de', 'Heise', 'Private', ['four']);
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
// the bookmark should exist
$params = new QueryParameters();
$this->assertCount(1, $this->bookmarkMapper->findAll($this->userId, $params->setUrl('https://www.heise.de')));
// user should see this bookmark
$output = $this->controller->getBookmarks();
$data = $output->getData();
$this->assertCount(3, $data['data']);
// others should not see this bookmark
$this->authorizer->setUserId($this->otherUserId);
$output = $this->otherController->getBookmarks(-1);
$data = $output->getData();
$this->assertCount(0, $data['data']);
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testEditBookmark(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId($this->userId);
$res = $this->controller->newBookmark('https://www.heise.de', 'Heise', 'PublicNoTag', ['four']);
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
$id = $res->getData()['item']['id'];
$this->controller->editBookmark($id, 'https://www.heise.de', '');
$bookmark = $this->bookmarkMapper->find($id);
$this->assertEquals('https://www.heise.de/', $bookmark->getUrl()); // normalized URL
$this->assertEquals('', $bookmark->getTitle()); // normalized URL
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testEditBookmarkFolders(): void {
$this->cleanUp();
$this->setupBookmarksWithPublicFolder();
$this->authorizer->setUserId($this->userId);
$res = $this->controller->newBookmark('https://www.heise.de', 'Heise', 'PublicNoTag', ['four'], [$this->folder1->getId()]);
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
$id = $res->getData()['item']['id'];
$this->controller->editBookmark($id, 'https://www.heise.de', '', null, null, [$this->folder2->getId()]);
$bookmark = $this->bookmarkMapper->find($id);
$parents = $this->treeMapper->findParentsOf(TreeMapper::TYPE_BOOKMARK, $id);
$this->assertEquals('https://www.heise.de/', $bookmark->getUrl()); // normalized URL
$this->assertEquals('', $bookmark->getTitle()); // normalized URL
$this->assertEquals([$this->folder2->getId()], array_map(function ($f) {
return $f->getId();
}, $parents)); // has the folders we set
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testDeleteBookmark(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId($this->userId);
$res = $this->controller->newBookmark('https://www.google.com', 'Google', 'PrivateTag', ['one', 'two']);
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
$id = $res->getData()['item']['id'];
$this->controller->deleteBookmark($id);
$params = new QueryParameters();
$this->assertCount(0, $this->bookmarkMapper->findAll($this->userId, $params->setUrl('https://www.google.com')));
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testClick(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId($this->userId);
$r = $this->controller->clickBookmark('https://www.golem.de');
$this->assertSame(Http::STATUS_OK, $r->getStatus());
}
/**
* @throws AlreadyExistsError
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
*/
public function testClickFail(): void {
$this->cleanUp();
$this->setupBookmarks();
$this->authorizer->setUserId(null);
$r = $this->publicController->clickBookmark('https://www.golem.de');
$this->assertNotSame(Http::STATUS_OK, $r->getStatus());
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testPublicRead(): void {
$this->cleanUp();
$this->setupBookmarksWithPublicFolder();
$this->authorizer->setUserId(null);
$res = $this->publicController->getSingleBookmark($this->bookmark2Id);
$data = $res->getData();
$this->assertEquals('success', $data['status'], var_export($data, true));
$this->assertEquals('https://9gag.com/', $data['item']['url']);
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testPublicReadNotFound(): void {
$this->cleanUp();
$this->setupBookmarksWithPublicFolder();
$this->authorizer->setUserId(null);
$output = $this->publicController->getSingleBookmark(987);
$data = $output->getData();
$this->assertSame('error', $data['status'], var_export($data, true));
$this->assertSame(403, $output->getStatus());
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testPublicget(): void {
$this->cleanUp();
$this->setupBookmarksWithPublicFolder();
$this->authorizer->setUserId(null);
$output = $this->publicController->getBookmarks(-1, null, 'or', '', [], 10, false, $this->folder2->getId());
$data = $output->getData();
$this->assertEquals('success', $data['status'], var_export($data, true));
$this->assertCount(1, $data['data']); // TODO: 1-level search Limit!
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testPublicCreateFail(): void {
$this->cleanUp();
$this->setupBookmarksWithPublicFolder();
$this->authorizer->setUserId(null);
$res = $this->publicController->newBookmark('https://www.heise.de', 'Heise', 'Private', ['four'], [$this->folder2->getId()]);
$this->assertEquals('error', $res->getData()['status'], var_export($res->getData(), true));
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testPublicEditBookmarkFail(): void {
$this->cleanUp();
$this->setupBookmarksWithPublicFolder();
$this->authorizer->setUserId(null);
$res = $this->publicController->editBookmark($this->bookmark1Id, 'https://www.heise.de', '');
$this->assertEquals('error', $res->getData()['status'], var_export($res->getData(), true));
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testPublicDeleteBookmarkFail(): void {
$this->cleanUp();
$this->setupBookmarksWithPublicFolder();
$this->authorizer->setUserId(null);
$res = $this->publicController->deleteBookmark($this->bookmark1Id);
$this->assertEquals('error', $res->getData()['status'], var_export($res->getData(), true));
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testReadShared(): void {
$this->cleanUp();
$this->setupBookmarksWithSharedFolder();
$this->authorizer->setUserId($this->otherUserId);
$output = $this->otherController->getSingleBookmark($this->bookmark2Id);
$data = $output->getData();
$this->assertEquals('success', $data['status'], var_export($data, true));
$this->assertEquals('https://9gag.com/', $data['item']['url']);
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testQueryShared(): void {
$this->cleanUp();
$this->setupBookmarksWithSharedFolder();
$this->authorizer->setUserId($this->otherUserId);
$output = $this->otherController->getBookmarks();
$data = $output->getData();
$this->assertCount(2, $data['data'], var_export($data, true));
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testCreateShared(): void {
$this->cleanUp();
$this->setupBookmarksWithSharedFolder();
$this->authorizer->setUserId($this->otherUserId);
$res = $this->otherController->newBookmark('https://www.heise.de', 'Heise', 'Private', ['four'], [$this->folder1->getId()]);
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
// the bookmark should exist
$params = new QueryParameters();
$this->assertCount(1, $this->bookmarkMapper->findAll($this->userId, $params->setUrl('https://www.heise.de')));
// user should see this bookmark
$this->authorizer->setUserId($this->userId);
$output = $this->controller->getBookmarks();
$data = $output->getData();
$this->assertCount(3, $data['data']);
// others should see this bookmark
$this->authorizer->setUserId($this->otherUserId);
$output = $this->otherController->getBookmarks();
$data = $output->getData();
$this->assertCount(3, $data['data']);
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testEditBookmarkShared(): void {
$this->cleanUp();
$this->setupBookmarksWithSharedFolder();
$this->authorizer->setUserId($this->userId);
$res = $this->controller->newBookmark('https://www.heise.de', 'Heise', 'PublicNoTag', ['four'], [$this->folder1->getId()]);
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
$id = $res->getData()['item']['id'];
$this->authorizer->setUserId($this->otherUserId);
$res = $this->otherController->editBookmark($id, 'https://www.heise.de', '');
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
$bookmark = $this->bookmarkMapper->find($id);
$this->assertEquals('https://www.heise.de/', $bookmark->getUrl()); // normalized URL
$this->assertEquals("", $bookmark->getTitle());
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testDeleteBookmarkShared(): void {
$this->cleanUp();
$this->setupBookmarksWithSharedFolder();
$this->authorizer->setUserId($this->userId);
$res = $this->controller->newBookmark('https://www.google.com', 'Google', 'PrivateTag', ['one', 'two'], [$this->folder1->getId()]);
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
$id = $res->getData()['item']['id'];
$this->authorizer->setUserId($this->otherUserId);
$res = $this->otherController->deleteBookmark($id);
$this->assertEquals('success', $res->getData()['status'], var_export($res->getData(), true));
$params = new QueryParameters();
$this->assertCount(0, $this->bookmarkMapper->findAll($this->userId, $params->setUrl('https://www.google.com')));
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testClickSharedFail(): void {
$this->cleanUp();
$this->setupBookmarksWithSharedFolder();
$this->authorizer->setUserId($this->otherUserId);
$r = $this->otherController->clickBookmark('https://www.golem.de');
$this->assertNotSame(Http::STATUS_OK, $r->getStatus());
}
/**
* @throws AlreadyExistsError
* @throws DoesNotExistException
* @throws MultipleObjectsReturnedException
* @throws UrlParseError
* @throws UserLimitExceededError
* @throws UnsupportedOperation
*/
public function testLock(): void {
$this->cleanUp();
$this->setupBookmarksWithSharedFolder();
$this->authorizer->setUserId($this->userId);
// First come, gets the lock
$output = $this->controller->acquireLock();
$this->assertEquals(Http::STATUS_OK, $output->getStatus());
// Second gets an error
$output = $this->controller->acquireLock();
$this->assertEquals(Http::STATUS_LOCKED, $output->getStatus());
// Releasing...
$output = $this->controller->releaseLock();
$this->assertEquals(Http::STATUS_OK, $output->getStatus());
// Then we get the lock again
$output = $this->controller->acquireLock();
$this->assertEquals(Http::STATUS_OK, $output->getStatus());
// other users can lock independently
$this->authorizer->setUserId($this->otherUserId);
$output = $this->otherController->acquireLock();
$this->assertEquals(Http::STATUS_OK, $output->getStatus());
}
}
Zerion Mini Shell 1.0