tests/front/controller/admin/ShaareManageControllerTest/DeleteBookmarkTest.php

   1 <?php
   2
   3 declare(strict_types=1);
   4
   5 namespace Shaarli\Front\Controller\Admin\ShaareManageControllerTest;
   6
   7 use Shaarli\Bookmark\Bookmark;
   8 use Shaarli\Bookmark\Exception\BookmarkNotFoundException;
   9 use Shaarli\Formatter\BookmarkFormatter;
  10 use Shaarli\Formatter\FormatterFactory;
  11 use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper;
  12 use Shaarli\Front\Controller\Admin\ShaareManageController;
  13 use Shaarli\Http\HttpAccess;
  14 use Shaarli\Security\SessionManager;
  15 use Shaarli\TestCase;
  16 use Slim\Http\Request;
  17 use Slim\Http\Response;
  18
  19 class DeleteBookmarkTest extends TestCase
  20 {
  21     use FrontAdminControllerMockHelper;
  22
  23     /** @var ShaareManageController */
  24     protected $controller;
  25
  26     public function setUp(): void
  27     {
  28         $this->createContainer();
  29
  30         $this->container->httpAccess = $this->createMock(HttpAccess::class);
  31         $this->controller = new ShaareManageController($this->container);
  32     }
  33
  34     /**
  35      * Delete bookmark - Single bookmark with valid parameters
  36      */
  37     public function testDeleteSingleBookmark(): void
  38     {
  39         $parameters = ['id' => '123'];
  40
  41         $request = $this->createMock(Request::class);
  42         $request
  43             ->method('getParam')
  44             ->willReturnCallback(function (string $key) use ($parameters): ?string {
  45                 return $parameters[$key] ?? null;
  46             })
  47         ;
  48         $response = new Response();
  49
  50         $bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123');
  51
  52         $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark);
  53         $this->container->bookmarkService->expects(static::once())->method('remove')->with($bookmark, false);
  54         $this->container->bookmarkService->expects(static::once())->method('save');
  55         $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
  56         $this->container->formatterFactory
  57             ->expects(static::once())
  58             ->method('getFormatter')
  59             ->with('raw')
  60             ->willReturnCallback(function () use ($bookmark): BookmarkFormatter {
  61                 $formatter = $this->createMock(BookmarkFormatter::class);
  62                 $formatter
  63                     ->expects(static::once())
  64                     ->method('format')
  65                     ->with($bookmark)
  66                     ->willReturn(['formatted' => $bookmark])
  67                 ;
  68
  69                 return $formatter;
  70             })
  71         ;
  72
  73         // Make sure that PluginManager hook is triggered
  74         $this->container->pluginManager
  75             ->expects(static::once())
  76             ->method('executeHooks')
  77             ->with('delete_link', ['formatted' => $bookmark])
  78         ;
  79
  80         $result = $this->controller->deleteBookmark($request, $response);
  81
  82         static::assertSame(302, $result->getStatusCode());
  83         static::assertSame(['/subfolder/'], $result->getHeader('location'));
  84     }
  85
  86     /**
  87      * Delete bookmark - Multiple bookmarks with valid parameters
  88      */
  89     public function testDeleteMultipleBookmarks(): void
  90     {
  91         $parameters = ['id' => '123 456 789'];
  92
  93         $request = $this->createMock(Request::class);
  94         $request
  95             ->method('getParam')
  96             ->willReturnCallback(function (string $key) use ($parameters): ?string {
  97                 return $parameters[$key] ?? null;
  98             })
  99         ;
 100         $response = new Response();
 101
 102         $bookmarks = [
 103             (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123'),
 104             (new Bookmark())->setId(456)->setUrl('http://domain.tld')->setTitle('Title 456'),
 105             (new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789'),
 106         ];
 107
 108         $this->container->bookmarkService
 109             ->expects(static::exactly(3))
 110             ->method('get')
 111             ->withConsecutive([123], [456], [789])
 112             ->willReturnOnConsecutiveCalls(...$bookmarks)
 113         ;
 114         $this->container->bookmarkService
 115             ->expects(static::exactly(3))
 116             ->method('remove')
 117             ->withConsecutive(...array_map(function (Bookmark $bookmark): array {
 118                 return [$bookmark, false];
 119             }, $bookmarks))
 120         ;
 121         $this->container->bookmarkService->expects(static::once())->method('save');
 122         $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
 123         $this->container->formatterFactory
 124             ->expects(static::once())
 125             ->method('getFormatter')
 126             ->with('raw')
 127             ->willReturnCallback(function () use ($bookmarks): BookmarkFormatter {
 128                 $formatter = $this->createMock(BookmarkFormatter::class);
 129
 130                 $formatter
 131                     ->expects(static::exactly(3))
 132                     ->method('format')
 133                     ->withConsecutive(...array_map(function (Bookmark $bookmark): array {
 134                         return [$bookmark];
 135                     }, $bookmarks))
 136                     ->willReturnOnConsecutiveCalls(...array_map(function (Bookmark $bookmark): array {
 137                         return ['formatted' => $bookmark];
 138                     }, $bookmarks))
 139                 ;
 140
 141                 return $formatter;
 142             })
 143         ;
 144
 145         // Make sure that PluginManager hook is triggered
 146         $this->container->pluginManager
 147             ->expects(static::exactly(3))
 148             ->method('executeHooks')
 149             ->with('delete_link')
 150         ;
 151
 152         $result = $this->controller->deleteBookmark($request, $response);
 153
 154         static::assertSame(302, $result->getStatusCode());
 155         static::assertSame(['/subfolder/'], $result->getHeader('location'));
 156     }
 157
 158     /**
 159      * Delete bookmark - Single bookmark not found in the data store
 160      */
 161     public function testDeleteSingleBookmarkNotFound(): void
 162     {
 163         $parameters = ['id' => '123'];
 164
 165         $request = $this->createMock(Request::class);
 166         $request
 167             ->method('getParam')
 168             ->willReturnCallback(function (string $key) use ($parameters): ?string {
 169                 return $parameters[$key] ?? null;
 170             })
 171         ;
 172         $response = new Response();
 173
 174         $this->container->bookmarkService
 175             ->expects(static::once())
 176             ->method('get')
 177             ->willThrowException(new BookmarkNotFoundException())
 178         ;
 179         $this->container->bookmarkService->expects(static::never())->method('remove');
 180         $this->container->bookmarkService->expects(static::never())->method('save');
 181         $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
 182         $this->container->formatterFactory
 183             ->expects(static::once())
 184             ->method('getFormatter')
 185             ->with('raw')
 186             ->willReturnCallback(function (): BookmarkFormatter {
 187                 $formatter = $this->createMock(BookmarkFormatter::class);
 188
 189                 $formatter->expects(static::never())->method('format');
 190
 191                 return $formatter;
 192             })
 193         ;
 194         // Make sure that PluginManager hook is not triggered
 195         $this->container->pluginManager
 196             ->expects(static::never())
 197             ->method('executeHooks')
 198             ->with('delete_link')
 199         ;
 200
 201         $result = $this->controller->deleteBookmark($request, $response);
 202
 203         static::assertSame(302, $result->getStatusCode());
 204         static::assertSame(['/subfolder/'], $result->getHeader('location'));
 205     }
 206
 207     /**
 208      * Delete bookmark - Multiple bookmarks with one not found in the data store
 209      */
 210     public function testDeleteMultipleBookmarksOneNotFound(): void
 211     {
 212         $parameters = ['id' => '123 456 789'];
 213
 214         $request = $this->createMock(Request::class);
 215         $request
 216             ->method('getParam')
 217             ->willReturnCallback(function (string $key) use ($parameters): ?string {
 218                 return $parameters[$key] ?? null;
 219             })
 220         ;
 221         $response = new Response();
 222
 223         $bookmarks = [
 224             (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123'),
 225             (new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789'),
 226         ];
 227
 228         $this->container->bookmarkService
 229             ->expects(static::exactly(3))
 230             ->method('get')
 231             ->withConsecutive([123], [456], [789])
 232             ->willReturnCallback(function (int $id) use ($bookmarks): Bookmark {
 233                 if ($id === 123) {
 234                     return $bookmarks[0];
 235                 }
 236                 if ($id === 789) {
 237                     return $bookmarks[1];
 238                 }
 239                 throw new BookmarkNotFoundException();
 240             })
 241         ;
 242         $this->container->bookmarkService
 243             ->expects(static::exactly(2))
 244             ->method('remove')
 245             ->withConsecutive(...array_map(function (Bookmark $bookmark): array {
 246                 return [$bookmark, false];
 247             }, $bookmarks))
 248         ;
 249         $this->container->bookmarkService->expects(static::once())->method('save');
 250         $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
 251         $this->container->formatterFactory
 252             ->expects(static::once())
 253             ->method('getFormatter')
 254             ->with('raw')
 255             ->willReturnCallback(function () use ($bookmarks): BookmarkFormatter {
 256                 $formatter = $this->createMock(BookmarkFormatter::class);
 257
 258                 $formatter
 259                     ->expects(static::exactly(2))
 260                     ->method('format')
 261                     ->withConsecutive(...array_map(function (Bookmark $bookmark): array {
 262                         return [$bookmark];
 263                     }, $bookmarks))
 264                     ->willReturnOnConsecutiveCalls(...array_map(function (Bookmark $bookmark): array {
 265                         return ['formatted' => $bookmark];
 266                     }, $bookmarks))
 267                 ;
 268
 269                 return $formatter;
 270             })
 271         ;
 272
 273         // Make sure that PluginManager hook is not triggered
 274         $this->container->pluginManager
 275             ->expects(static::exactly(2))
 276             ->method('executeHooks')
 277             ->with('delete_link')
 278         ;
 279
 280         $this->container->sessionManager
 281             ->expects(static::once())
 282             ->method('setSessionParameter')
 283             ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier 456 could not be found.'])
 284         ;
 285
 286         $result = $this->controller->deleteBookmark($request, $response);
 287
 288         static::assertSame(302, $result->getStatusCode());
 289         static::assertSame(['/subfolder/'], $result->getHeader('location'));
 290     }
 291
 292     /**
 293      * Delete bookmark - Invalid ID
 294      */
 295     public function testDeleteInvalidId(): void
 296     {
 297         $parameters = ['id' => 'nope not an ID'];
 298
 299         $request = $this->createMock(Request::class);
 300         $request
 301             ->method('getParam')
 302             ->willReturnCallback(function (string $key) use ($parameters): ?string {
 303                 return $parameters[$key] ?? null;
 304             })
 305         ;
 306         $response = new Response();
 307
 308         $this->container->sessionManager
 309             ->expects(static::once())
 310             ->method('setSessionParameter')
 311             ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.'])
 312         ;
 313
 314         $result = $this->controller->deleteBookmark($request, $response);
 315
 316         static::assertSame(302, $result->getStatusCode());
 317         static::assertSame(['/subfolder/'], $result->getHeader('location'));
 318     }
 319
 320     /**
 321      * Delete bookmark - Empty ID
 322      */
 323     public function testDeleteEmptyId(): void
 324     {
 325         $request = $this->createMock(Request::class);
 326         $response = new Response();
 327
 328         $this->container->sessionManager
 329             ->expects(static::once())
 330             ->method('setSessionParameter')
 331             ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.'])
 332         ;
 333
 334         $result = $this->controller->deleteBookmark($request, $response);
 335
 336         static::assertSame(302, $result->getStatusCode());
 337         static::assertSame(['/subfolder/'], $result->getHeader('location'));
 338     }
 339
 340     /**
 341      * Delete bookmark - from bookmarklet
 342      */
 343     public function testDeleteBookmarkFromBookmarklet(): void
 344     {
 345         $parameters = [
 346             'id' => '123',
 347             'source' => 'bookmarklet',
 348         ];
 349
 350         $request = $this->createMock(Request::class);
 351         $request
 352             ->method('getParam')
 353             ->willReturnCallback(function (string $key) use ($parameters): ?string {
 354                 return $parameters[$key] ?? null;
 355             })
 356         ;
 357         $response = new Response();
 358
 359         $this->container->bookmarkService->method('get')->with('123')->willReturn(
 360             (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')
 361         );
 362
 363         $this->container->formatterFactory = $this->createMock(FormatterFactory::class);
 364         $this->container->formatterFactory
 365             ->expects(static::once())
 366             ->method('getFormatter')
 367             ->willReturnCallback(function (): BookmarkFormatter {
 368                 $formatter = $this->createMock(BookmarkFormatter::class);
 369                 $formatter->method('format')->willReturn(['formatted']);
 370
 371                 return $formatter;
 372             })
 373         ;
 374
 375         $result = $this->controller->deleteBookmark($request, $response);
 376
 377         static::assertSame(200, $result->getStatusCode());
 378         static::assertSame('<script>self.close();</script>', (string) $result->getBody('location'));
 379     }
 380 }