diff options
Diffstat (limited to 'tests/front/controller/admin')
20 files changed, 3740 insertions, 0 deletions
diff --git a/tests/front/controller/admin/ConfigureControllerTest.php b/tests/front/controller/admin/ConfigureControllerTest.php new file mode 100644 index 00000000..aca6cff3 --- /dev/null +++ b/tests/front/controller/admin/ConfigureControllerTest.php | |||
@@ -0,0 +1,252 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Config\ConfigManager; | ||
8 | use Shaarli\Front\Exception\WrongTokenException; | ||
9 | use Shaarli\Security\SessionManager; | ||
10 | use Shaarli\TestCase; | ||
11 | use Shaarli\Thumbnailer; | ||
12 | use Slim\Http\Request; | ||
13 | use Slim\Http\Response; | ||
14 | |||
15 | class ConfigureControllerTest extends TestCase | ||
16 | { | ||
17 | use FrontAdminControllerMockHelper; | ||
18 | |||
19 | /** @var ConfigureController */ | ||
20 | protected $controller; | ||
21 | |||
22 | public function setUp(): void | ||
23 | { | ||
24 | $this->createContainer(); | ||
25 | |||
26 | $this->controller = new ConfigureController($this->container); | ||
27 | } | ||
28 | |||
29 | /** | ||
30 | * Test displaying configure page - it should display all config variables | ||
31 | */ | ||
32 | public function testIndex(): void | ||
33 | { | ||
34 | $assignedVariables = []; | ||
35 | $this->assignTemplateVars($assignedVariables); | ||
36 | |||
37 | $request = $this->createMock(Request::class); | ||
38 | $response = new Response(); | ||
39 | |||
40 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
41 | $this->container->conf->method('get')->willReturnCallback(function (string $key) { | ||
42 | return $key; | ||
43 | }); | ||
44 | |||
45 | $result = $this->controller->index($request, $response); | ||
46 | |||
47 | static::assertSame(200, $result->getStatusCode()); | ||
48 | static::assertSame('configure', (string) $result->getBody()); | ||
49 | |||
50 | static::assertSame('Configure - general.title', $assignedVariables['pagetitle']); | ||
51 | static::assertSame('general.title', $assignedVariables['title']); | ||
52 | static::assertSame('resource.theme', $assignedVariables['theme']); | ||
53 | static::assertEmpty($assignedVariables['theme_available']); | ||
54 | static::assertSame(['default', 'markdown'], $assignedVariables['formatter_available']); | ||
55 | static::assertNotEmpty($assignedVariables['continents']); | ||
56 | static::assertNotEmpty($assignedVariables['cities']); | ||
57 | static::assertSame('general.retrieve_description', $assignedVariables['retrieve_description']); | ||
58 | static::assertSame('privacy.default_private_links', $assignedVariables['private_links_default']); | ||
59 | static::assertSame('security.session_protection_disabled', $assignedVariables['session_protection_disabled']); | ||
60 | static::assertSame('feed.rss_permalinks', $assignedVariables['enable_rss_permalinks']); | ||
61 | static::assertSame('updates.check_updates', $assignedVariables['enable_update_check']); | ||
62 | static::assertSame('privacy.hide_public_links', $assignedVariables['hide_public_links']); | ||
63 | static::assertSame('api.enabled', $assignedVariables['api_enabled']); | ||
64 | static::assertSame('api.secret', $assignedVariables['api_secret']); | ||
65 | static::assertCount(5, $assignedVariables['languages']); | ||
66 | static::assertArrayHasKey('gd_enabled', $assignedVariables); | ||
67 | static::assertSame('thumbnails.mode', $assignedVariables['thumbnails_mode']); | ||
68 | } | ||
69 | |||
70 | /** | ||
71 | * Test posting a new config - make sure that everything is saved properly, without errors. | ||
72 | */ | ||
73 | public function testSaveNewConfig(): void | ||
74 | { | ||
75 | $session = []; | ||
76 | $this->assignSessionVars($session); | ||
77 | |||
78 | $parameters = [ | ||
79 | 'token' => 'token', | ||
80 | 'continent' => 'Europe', | ||
81 | 'city' => 'Moscow', | ||
82 | 'title' => 'Shaarli', | ||
83 | 'titleLink' => './', | ||
84 | 'retrieveDescription' => 'on', | ||
85 | 'theme' => 'vintage', | ||
86 | 'disablesessionprotection' => null, | ||
87 | 'privateLinkByDefault' => true, | ||
88 | 'enableRssPermalinks' => true, | ||
89 | 'updateCheck' => false, | ||
90 | 'hidePublicLinks' => 'on', | ||
91 | 'enableApi' => 'on', | ||
92 | 'apiSecret' => 'abcdef', | ||
93 | 'formatter' => 'markdown', | ||
94 | 'language' => 'fr', | ||
95 | 'enableThumbnails' => Thumbnailer::MODE_NONE, | ||
96 | ]; | ||
97 | |||
98 | $parametersConfigMapping = [ | ||
99 | 'general.timezone' => $parameters['continent'] . '/' . $parameters['city'], | ||
100 | 'general.title' => $parameters['title'], | ||
101 | 'general.header_link' => $parameters['titleLink'], | ||
102 | 'general.retrieve_description' => !!$parameters['retrieveDescription'], | ||
103 | 'resource.theme' => $parameters['theme'], | ||
104 | 'security.session_protection_disabled' => !!$parameters['disablesessionprotection'], | ||
105 | 'privacy.default_private_links' => !!$parameters['privateLinkByDefault'], | ||
106 | 'feed.rss_permalinks' => !!$parameters['enableRssPermalinks'], | ||
107 | 'updates.check_updates' => !!$parameters['updateCheck'], | ||
108 | 'privacy.hide_public_links' => !!$parameters['hidePublicLinks'], | ||
109 | 'api.enabled' => !!$parameters['enableApi'], | ||
110 | 'api.secret' => $parameters['apiSecret'], | ||
111 | 'formatter' => $parameters['formatter'], | ||
112 | 'translation.language' => $parameters['language'], | ||
113 | 'thumbnails.mode' => $parameters['enableThumbnails'], | ||
114 | ]; | ||
115 | |||
116 | $request = $this->createMock(Request::class); | ||
117 | $request | ||
118 | ->expects(static::atLeastOnce()) | ||
119 | ->method('getParam')->willReturnCallback(function (string $key) use ($parameters) { | ||
120 | if (false === array_key_exists($key, $parameters)) { | ||
121 | static::fail('unknown key: ' . $key); | ||
122 | } | ||
123 | |||
124 | return $parameters[$key]; | ||
125 | } | ||
126 | ); | ||
127 | |||
128 | $response = new Response(); | ||
129 | |||
130 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
131 | $this->container->conf | ||
132 | ->expects(static::atLeastOnce()) | ||
133 | ->method('set') | ||
134 | ->willReturnCallback(function (string $key, $value) use ($parametersConfigMapping): void { | ||
135 | if (false === array_key_exists($key, $parametersConfigMapping)) { | ||
136 | static::fail('unknown key: ' . $key); | ||
137 | } | ||
138 | |||
139 | static::assertSame($parametersConfigMapping[$key], $value); | ||
140 | } | ||
141 | ); | ||
142 | |||
143 | $result = $this->controller->save($request, $response); | ||
144 | static::assertSame(302, $result->getStatusCode()); | ||
145 | static::assertSame(['/subfolder/admin/configure'], $result->getHeader('Location')); | ||
146 | |||
147 | static::assertArrayNotHasKey(SessionManager::KEY_WARNING_MESSAGES, $session); | ||
148 | static::assertArrayNotHasKey(SessionManager::KEY_ERROR_MESSAGES, $session); | ||
149 | static::assertArrayHasKey(SessionManager::KEY_SUCCESS_MESSAGES, $session); | ||
150 | static::assertSame(['Configuration was saved.'], $session[SessionManager::KEY_SUCCESS_MESSAGES]); | ||
151 | } | ||
152 | |||
153 | /** | ||
154 | * Test posting a new config - wrong token. | ||
155 | */ | ||
156 | public function testSaveNewConfigWrongToken(): void | ||
157 | { | ||
158 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
159 | $this->container->sessionManager->method('checkToken')->willReturn(false); | ||
160 | |||
161 | $this->container->conf->expects(static::never())->method('set'); | ||
162 | $this->container->conf->expects(static::never())->method('write'); | ||
163 | |||
164 | $request = $this->createMock(Request::class); | ||
165 | $response = new Response(); | ||
166 | |||
167 | $this->expectException(WrongTokenException::class); | ||
168 | |||
169 | $this->controller->save($request, $response); | ||
170 | } | ||
171 | |||
172 | /** | ||
173 | * Test posting a new config - thumbnail activation. | ||
174 | */ | ||
175 | public function testSaveNewConfigThumbnailsActivation(): void | ||
176 | { | ||
177 | $session = []; | ||
178 | $this->assignSessionVars($session); | ||
179 | |||
180 | $request = $this->createMock(Request::class); | ||
181 | $request | ||
182 | ->expects(static::atLeastOnce()) | ||
183 | ->method('getParam')->willReturnCallback(function (string $key) { | ||
184 | if ('enableThumbnails' === $key) { | ||
185 | return Thumbnailer::MODE_ALL; | ||
186 | } | ||
187 | |||
188 | return $key; | ||
189 | }) | ||
190 | ; | ||
191 | $response = new Response(); | ||
192 | |||
193 | $result = $this->controller->save($request, $response); | ||
194 | |||
195 | static::assertSame(302, $result->getStatusCode()); | ||
196 | static::assertSame(['/subfolder/admin/configure'], $result->getHeader('Location')); | ||
197 | |||
198 | static::assertArrayNotHasKey(SessionManager::KEY_ERROR_MESSAGES, $session); | ||
199 | static::assertArrayHasKey(SessionManager::KEY_WARNING_MESSAGES, $session); | ||
200 | static::assertStringContainsString( | ||
201 | 'You have enabled or changed thumbnails mode', | ||
202 | $session[SessionManager::KEY_WARNING_MESSAGES][0] | ||
203 | ); | ||
204 | static::assertArrayHasKey(SessionManager::KEY_SUCCESS_MESSAGES, $session); | ||
205 | static::assertSame(['Configuration was saved.'], $session[SessionManager::KEY_SUCCESS_MESSAGES]); | ||
206 | } | ||
207 | |||
208 | /** | ||
209 | * Test posting a new config - thumbnail activation. | ||
210 | */ | ||
211 | public function testSaveNewConfigThumbnailsAlreadyActive(): void | ||
212 | { | ||
213 | $session = []; | ||
214 | $this->assignSessionVars($session); | ||
215 | |||
216 | $request = $this->createMock(Request::class); | ||
217 | $request | ||
218 | ->expects(static::atLeastOnce()) | ||
219 | ->method('getParam')->willReturnCallback(function (string $key) { | ||
220 | if ('enableThumbnails' === $key) { | ||
221 | return Thumbnailer::MODE_ALL; | ||
222 | } | ||
223 | |||
224 | return $key; | ||
225 | }) | ||
226 | ; | ||
227 | $response = new Response(); | ||
228 | |||
229 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
230 | $this->container->conf | ||
231 | ->expects(static::atLeastOnce()) | ||
232 | ->method('get') | ||
233 | ->willReturnCallback(function (string $key): string { | ||
234 | if ('thumbnails.mode' === $key) { | ||
235 | return Thumbnailer::MODE_ALL; | ||
236 | } | ||
237 | |||
238 | return $key; | ||
239 | }) | ||
240 | ; | ||
241 | |||
242 | $result = $this->controller->save($request, $response); | ||
243 | |||
244 | static::assertSame(302, $result->getStatusCode()); | ||
245 | static::assertSame(['/subfolder/admin/configure'], $result->getHeader('Location')); | ||
246 | |||
247 | static::assertArrayNotHasKey(SessionManager::KEY_ERROR_MESSAGES, $session); | ||
248 | static::assertArrayNotHasKey(SessionManager::KEY_WARNING_MESSAGES, $session); | ||
249 | static::assertArrayHasKey(SessionManager::KEY_SUCCESS_MESSAGES, $session); | ||
250 | static::assertSame(['Configuration was saved.'], $session[SessionManager::KEY_SUCCESS_MESSAGES]); | ||
251 | } | ||
252 | } | ||
diff --git a/tests/front/controller/admin/ExportControllerTest.php b/tests/front/controller/admin/ExportControllerTest.php new file mode 100644 index 00000000..0e6f2762 --- /dev/null +++ b/tests/front/controller/admin/ExportControllerTest.php | |||
@@ -0,0 +1,163 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Bookmark\Bookmark; | ||
8 | use Shaarli\Formatter\BookmarkFormatter; | ||
9 | use Shaarli\Formatter\BookmarkRawFormatter; | ||
10 | use Shaarli\Netscape\NetscapeBookmarkUtils; | ||
11 | use Shaarli\Security\SessionManager; | ||
12 | use Shaarli\TestCase; | ||
13 | use Slim\Http\Request; | ||
14 | use Slim\Http\Response; | ||
15 | |||
16 | class ExportControllerTest extends TestCase | ||
17 | { | ||
18 | use FrontAdminControllerMockHelper; | ||
19 | |||
20 | /** @var ExportController */ | ||
21 | protected $controller; | ||
22 | |||
23 | public function setUp(): void | ||
24 | { | ||
25 | $this->createContainer(); | ||
26 | |||
27 | $this->controller = new ExportController($this->container); | ||
28 | } | ||
29 | |||
30 | /** | ||
31 | * Test displaying export page | ||
32 | */ | ||
33 | public function testIndex(): void | ||
34 | { | ||
35 | $assignedVariables = []; | ||
36 | $this->assignTemplateVars($assignedVariables); | ||
37 | |||
38 | $request = $this->createMock(Request::class); | ||
39 | $response = new Response(); | ||
40 | |||
41 | $result = $this->controller->index($request, $response); | ||
42 | |||
43 | static::assertSame(200, $result->getStatusCode()); | ||
44 | static::assertSame('export', (string) $result->getBody()); | ||
45 | |||
46 | static::assertSame('Export - Shaarli', $assignedVariables['pagetitle']); | ||
47 | } | ||
48 | |||
49 | /** | ||
50 | * Test posting an export request | ||
51 | */ | ||
52 | public function testExportDefault(): void | ||
53 | { | ||
54 | $assignedVariables = []; | ||
55 | $this->assignTemplateVars($assignedVariables); | ||
56 | |||
57 | $parameters = [ | ||
58 | 'selection' => 'all', | ||
59 | 'prepend_note_url' => 'on', | ||
60 | ]; | ||
61 | |||
62 | $request = $this->createMock(Request::class); | ||
63 | $request->method('getParam')->willReturnCallback(function (string $key) use ($parameters) { | ||
64 | return $parameters[$key] ?? null; | ||
65 | }); | ||
66 | $response = new Response(); | ||
67 | |||
68 | $bookmarks = [ | ||
69 | (new Bookmark())->setUrl('http://link1.tld')->setTitle('Title 1'), | ||
70 | (new Bookmark())->setUrl('http://link2.tld')->setTitle('Title 2'), | ||
71 | ]; | ||
72 | |||
73 | $this->container->netscapeBookmarkUtils = $this->createMock(NetscapeBookmarkUtils::class); | ||
74 | $this->container->netscapeBookmarkUtils | ||
75 | ->expects(static::once()) | ||
76 | ->method('filterAndFormat') | ||
77 | ->willReturnCallback( | ||
78 | function ( | ||
79 | BookmarkFormatter $formatter, | ||
80 | string $selection, | ||
81 | bool $prependNoteUrl, | ||
82 | string $indexUrl | ||
83 | ) use ($parameters, $bookmarks): array { | ||
84 | static::assertInstanceOf(BookmarkRawFormatter::class, $formatter); | ||
85 | static::assertSame($parameters['selection'], $selection); | ||
86 | static::assertTrue($prependNoteUrl); | ||
87 | static::assertSame('http://shaarli/subfolder/', $indexUrl); | ||
88 | |||
89 | return $bookmarks; | ||
90 | } | ||
91 | ) | ||
92 | ; | ||
93 | |||
94 | $result = $this->controller->export($request, $response); | ||
95 | |||
96 | static::assertSame(200, $result->getStatusCode()); | ||
97 | static::assertSame('export.bookmarks', (string) $result->getBody()); | ||
98 | static::assertSame(['text/html; charset=utf-8'], $result->getHeader('content-type')); | ||
99 | static::assertRegExp( | ||
100 | '/attachment; filename=bookmarks_all_[\d]{8}_[\d]{6}\.html/', | ||
101 | $result->getHeader('content-disposition')[0] | ||
102 | ); | ||
103 | |||
104 | static::assertNotEmpty($assignedVariables['date']); | ||
105 | static::assertSame(PHP_EOL, $assignedVariables['eol']); | ||
106 | static::assertSame('all', $assignedVariables['selection']); | ||
107 | static::assertSame($bookmarks, $assignedVariables['links']); | ||
108 | } | ||
109 | |||
110 | /** | ||
111 | * Test posting an export request - without selection parameter | ||
112 | */ | ||
113 | public function testExportSelectionMissing(): void | ||
114 | { | ||
115 | $request = $this->createMock(Request::class); | ||
116 | $response = new Response(); | ||
117 | |||
118 | $this->container->sessionManager | ||
119 | ->expects(static::once()) | ||
120 | ->method('setSessionParameter') | ||
121 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Please select an export mode.']) | ||
122 | ; | ||
123 | |||
124 | $result = $this->controller->export($request, $response); | ||
125 | |||
126 | static::assertSame(302, $result->getStatusCode()); | ||
127 | static::assertSame(['/subfolder/admin/export'], $result->getHeader('location')); | ||
128 | } | ||
129 | |||
130 | /** | ||
131 | * Test posting an export request - without selection parameter | ||
132 | */ | ||
133 | public function testExportErrorEncountered(): void | ||
134 | { | ||
135 | $parameters = [ | ||
136 | 'selection' => 'all', | ||
137 | ]; | ||
138 | |||
139 | $request = $this->createMock(Request::class); | ||
140 | $request->method('getParam')->willReturnCallback(function (string $key) use ($parameters) { | ||
141 | return $parameters[$key] ?? null; | ||
142 | }); | ||
143 | $response = new Response(); | ||
144 | |||
145 | $this->container->netscapeBookmarkUtils = $this->createMock(NetscapeBookmarkUtils::class); | ||
146 | $this->container->netscapeBookmarkUtils | ||
147 | ->expects(static::once()) | ||
148 | ->method('filterAndFormat') | ||
149 | ->willThrowException(new \Exception($message = 'error message')); | ||
150 | ; | ||
151 | |||
152 | $this->container->sessionManager | ||
153 | ->expects(static::once()) | ||
154 | ->method('setSessionParameter') | ||
155 | ->with(SessionManager::KEY_ERROR_MESSAGES, [$message]) | ||
156 | ; | ||
157 | |||
158 | $result = $this->controller->export($request, $response); | ||
159 | |||
160 | static::assertSame(302, $result->getStatusCode()); | ||
161 | static::assertSame(['/subfolder/admin/export'], $result->getHeader('location')); | ||
162 | } | ||
163 | } | ||
diff --git a/tests/front/controller/admin/FrontAdminControllerMockHelper.php b/tests/front/controller/admin/FrontAdminControllerMockHelper.php new file mode 100644 index 00000000..2b9f2ef1 --- /dev/null +++ b/tests/front/controller/admin/FrontAdminControllerMockHelper.php | |||
@@ -0,0 +1,56 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Container\ShaarliTestContainer; | ||
8 | use Shaarli\Front\Controller\Visitor\FrontControllerMockHelper; | ||
9 | use Shaarli\History; | ||
10 | |||
11 | /** | ||
12 | * Trait FrontControllerMockHelper | ||
13 | * | ||
14 | * Helper trait used to initialize the ShaarliContainer and mock its services for admin controller tests. | ||
15 | * | ||
16 | * @property ShaarliTestContainer $container | ||
17 | */ | ||
18 | trait FrontAdminControllerMockHelper | ||
19 | { | ||
20 | use FrontControllerMockHelper { | ||
21 | FrontControllerMockHelper::createContainer as parentCreateContainer; | ||
22 | } | ||
23 | |||
24 | /** | ||
25 | * Mock the container instance | ||
26 | */ | ||
27 | protected function createContainer(): void | ||
28 | { | ||
29 | $this->parentCreateContainer(); | ||
30 | |||
31 | $this->container->history = $this->createMock(History::class); | ||
32 | |||
33 | $this->container->loginManager->method('isLoggedIn')->willReturn(true); | ||
34 | $this->container->sessionManager->method('checkToken')->willReturn(true); | ||
35 | } | ||
36 | |||
37 | |||
38 | /** | ||
39 | * Pass a reference of an array which will be populated by `sessionManager->setSessionParameter` | ||
40 | * calls during execution. | ||
41 | * | ||
42 | * @param mixed $variables Array reference to populate. | ||
43 | */ | ||
44 | protected function assignSessionVars(array &$variables): void | ||
45 | { | ||
46 | $this->container->sessionManager | ||
47 | ->expects(static::atLeastOnce()) | ||
48 | ->method('setSessionParameter') | ||
49 | ->willReturnCallback(function ($key, $value) use (&$variables) { | ||
50 | $variables[$key] = $value; | ||
51 | |||
52 | return $this->container->sessionManager; | ||
53 | }) | ||
54 | ; | ||
55 | } | ||
56 | } | ||
diff --git a/tests/front/controller/admin/ImportControllerTest.php b/tests/front/controller/admin/ImportControllerTest.php new file mode 100644 index 00000000..c266caa5 --- /dev/null +++ b/tests/front/controller/admin/ImportControllerTest.php | |||
@@ -0,0 +1,148 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Psr\Http\Message\UploadedFileInterface; | ||
8 | use Shaarli\Netscape\NetscapeBookmarkUtils; | ||
9 | use Shaarli\Security\SessionManager; | ||
10 | use Shaarli\TestCase; | ||
11 | use Slim\Http\Request; | ||
12 | use Slim\Http\Response; | ||
13 | use Slim\Http\UploadedFile; | ||
14 | |||
15 | class ImportControllerTest extends TestCase | ||
16 | { | ||
17 | use FrontAdminControllerMockHelper; | ||
18 | |||
19 | /** @var ImportController */ | ||
20 | protected $controller; | ||
21 | |||
22 | public function setUp(): void | ||
23 | { | ||
24 | $this->createContainer(); | ||
25 | |||
26 | $this->controller = new ImportController($this->container); | ||
27 | } | ||
28 | |||
29 | /** | ||
30 | * Test displaying import page | ||
31 | */ | ||
32 | public function testIndex(): void | ||
33 | { | ||
34 | $assignedVariables = []; | ||
35 | $this->assignTemplateVars($assignedVariables); | ||
36 | |||
37 | $request = $this->createMock(Request::class); | ||
38 | $response = new Response(); | ||
39 | |||
40 | $result = $this->controller->index($request, $response); | ||
41 | |||
42 | static::assertSame(200, $result->getStatusCode()); | ||
43 | static::assertSame('import', (string) $result->getBody()); | ||
44 | |||
45 | static::assertSame('Import - Shaarli', $assignedVariables['pagetitle']); | ||
46 | static::assertIsInt($assignedVariables['maxfilesize']); | ||
47 | static::assertRegExp('/\d+[KM]iB/', $assignedVariables['maxfilesizeHuman']); | ||
48 | } | ||
49 | |||
50 | /** | ||
51 | * Test importing a file with default and valid parameters | ||
52 | */ | ||
53 | public function testImportDefault(): void | ||
54 | { | ||
55 | $parameters = [ | ||
56 | 'abc' => 'def', | ||
57 | 'other' => 'param', | ||
58 | ]; | ||
59 | |||
60 | $requestFile = new UploadedFile('file', 'name', 'type', 123); | ||
61 | |||
62 | $request = $this->createMock(Request::class); | ||
63 | $request->method('getParams')->willReturnCallback(function () use ($parameters) { | ||
64 | return $parameters; | ||
65 | }); | ||
66 | $request->method('getUploadedFiles')->willReturn(['filetoupload' => $requestFile]); | ||
67 | $response = new Response(); | ||
68 | |||
69 | $this->container->netscapeBookmarkUtils = $this->createMock(NetscapeBookmarkUtils::class); | ||
70 | $this->container->netscapeBookmarkUtils | ||
71 | ->expects(static::once()) | ||
72 | ->method('import') | ||
73 | ->willReturnCallback( | ||
74 | function ( | ||
75 | array $post, | ||
76 | UploadedFileInterface $file | ||
77 | ) use ($parameters, $requestFile): string { | ||
78 | static::assertSame($parameters, $post); | ||
79 | static::assertSame($requestFile, $file); | ||
80 | |||
81 | return 'status'; | ||
82 | } | ||
83 | ) | ||
84 | ; | ||
85 | |||
86 | $this->container->sessionManager | ||
87 | ->expects(static::once()) | ||
88 | ->method('setSessionParameter') | ||
89 | ->with(SessionManager::KEY_SUCCESS_MESSAGES, ['status']) | ||
90 | ; | ||
91 | |||
92 | $result = $this->controller->import($request, $response); | ||
93 | |||
94 | static::assertSame(302, $result->getStatusCode()); | ||
95 | static::assertSame(['/subfolder/admin/import'], $result->getHeader('location')); | ||
96 | } | ||
97 | |||
98 | /** | ||
99 | * Test posting an import request - without import file | ||
100 | */ | ||
101 | public function testImportFileMissing(): void | ||
102 | { | ||
103 | $request = $this->createMock(Request::class); | ||
104 | $response = new Response(); | ||
105 | |||
106 | $this->container->sessionManager | ||
107 | ->expects(static::once()) | ||
108 | ->method('setSessionParameter') | ||
109 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['No import file provided.']) | ||
110 | ; | ||
111 | |||
112 | $result = $this->controller->import($request, $response); | ||
113 | |||
114 | static::assertSame(302, $result->getStatusCode()); | ||
115 | static::assertSame(['/subfolder/admin/import'], $result->getHeader('location')); | ||
116 | } | ||
117 | |||
118 | /** | ||
119 | * Test posting an import request - with an empty file | ||
120 | */ | ||
121 | public function testImportEmptyFile(): void | ||
122 | { | ||
123 | $requestFile = new UploadedFile('file', 'name', 'type', 0); | ||
124 | |||
125 | $request = $this->createMock(Request::class); | ||
126 | $request->method('getUploadedFiles')->willReturn(['filetoupload' => $requestFile]); | ||
127 | $response = new Response(); | ||
128 | |||
129 | $this->container->netscapeBookmarkUtils = $this->createMock(NetscapeBookmarkUtils::class); | ||
130 | $this->container->netscapeBookmarkUtils->expects(static::never())->method('filterAndFormat'); | ||
131 | |||
132 | $this->container->sessionManager | ||
133 | ->expects(static::once()) | ||
134 | ->method('setSessionParameter') | ||
135 | ->willReturnCallback(function (string $key, array $value): SessionManager { | ||
136 | static::assertSame(SessionManager::KEY_ERROR_MESSAGES, $key); | ||
137 | static::assertStringStartsWith('The file you are trying to upload is probably bigger', $value[0]); | ||
138 | |||
139 | return $this->container->sessionManager; | ||
140 | }) | ||
141 | ; | ||
142 | |||
143 | $result = $this->controller->import($request, $response); | ||
144 | |||
145 | static::assertSame(302, $result->getStatusCode()); | ||
146 | static::assertSame(['/subfolder/admin/import'], $result->getHeader('location')); | ||
147 | } | ||
148 | } | ||
diff --git a/tests/front/controller/admin/LogoutControllerTest.php b/tests/front/controller/admin/LogoutControllerTest.php new file mode 100644 index 00000000..94e53019 --- /dev/null +++ b/tests/front/controller/admin/LogoutControllerTest.php | |||
@@ -0,0 +1,50 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Security\CookieManager; | ||
8 | use Shaarli\Security\SessionManager; | ||
9 | use Shaarli\TestCase; | ||
10 | use Slim\Http\Request; | ||
11 | use Slim\Http\Response; | ||
12 | |||
13 | class LogoutControllerTest extends TestCase | ||
14 | { | ||
15 | use FrontAdminControllerMockHelper; | ||
16 | |||
17 | /** @var LogoutController */ | ||
18 | protected $controller; | ||
19 | |||
20 | public function setUp(): void | ||
21 | { | ||
22 | $this->createContainer(); | ||
23 | |||
24 | $this->controller = new LogoutController($this->container); | ||
25 | } | ||
26 | |||
27 | public function testValidControllerInvoke(): void | ||
28 | { | ||
29 | $request = $this->createMock(Request::class); | ||
30 | $response = new Response(); | ||
31 | |||
32 | $this->container->pageCacheManager->expects(static::once())->method('invalidateCaches'); | ||
33 | |||
34 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
35 | $this->container->sessionManager->expects(static::once())->method('logout'); | ||
36 | |||
37 | $this->container->cookieManager = $this->createMock(CookieManager::class); | ||
38 | $this->container->cookieManager | ||
39 | ->expects(static::once()) | ||
40 | ->method('setCookieParameter') | ||
41 | ->with(CookieManager::STAY_SIGNED_IN, 'false', 0, '/subfolder/') | ||
42 | ; | ||
43 | |||
44 | $result = $this->controller->index($request, $response); | ||
45 | |||
46 | static::assertInstanceOf(Response::class, $result); | ||
47 | static::assertSame(302, $result->getStatusCode()); | ||
48 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
49 | } | ||
50 | } | ||
diff --git a/tests/front/controller/admin/ManageShaareControllerTest/AddShaareTest.php b/tests/front/controller/admin/ManageShaareControllerTest/AddShaareTest.php new file mode 100644 index 00000000..0f27ec2f --- /dev/null +++ b/tests/front/controller/admin/ManageShaareControllerTest/AddShaareTest.php | |||
@@ -0,0 +1,47 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest; | ||
6 | |||
7 | use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper; | ||
8 | use Shaarli\Front\Controller\Admin\ManageShaareController; | ||
9 | use Shaarli\Http\HttpAccess; | ||
10 | use Shaarli\TestCase; | ||
11 | use Slim\Http\Request; | ||
12 | use Slim\Http\Response; | ||
13 | |||
14 | class AddShaareTest extends TestCase | ||
15 | { | ||
16 | use FrontAdminControllerMockHelper; | ||
17 | |||
18 | /** @var ManageShaareController */ | ||
19 | protected $controller; | ||
20 | |||
21 | public function setUp(): void | ||
22 | { | ||
23 | $this->createContainer(); | ||
24 | |||
25 | $this->container->httpAccess = $this->createMock(HttpAccess::class); | ||
26 | $this->controller = new ManageShaareController($this->container); | ||
27 | } | ||
28 | |||
29 | /** | ||
30 | * Test displaying add link page | ||
31 | */ | ||
32 | public function testAddShaare(): void | ||
33 | { | ||
34 | $assignedVariables = []; | ||
35 | $this->assignTemplateVars($assignedVariables); | ||
36 | |||
37 | $request = $this->createMock(Request::class); | ||
38 | $response = new Response(); | ||
39 | |||
40 | $result = $this->controller->addShaare($request, $response); | ||
41 | |||
42 | static::assertSame(200, $result->getStatusCode()); | ||
43 | static::assertSame('addlink', (string) $result->getBody()); | ||
44 | |||
45 | static::assertSame('Shaare a new link - Shaarli', $assignedVariables['pagetitle']); | ||
46 | } | ||
47 | } | ||
diff --git a/tests/front/controller/admin/ManageShaareControllerTest/ChangeVisibilityBookmarkTest.php b/tests/front/controller/admin/ManageShaareControllerTest/ChangeVisibilityBookmarkTest.php new file mode 100644 index 00000000..096d0774 --- /dev/null +++ b/tests/front/controller/admin/ManageShaareControllerTest/ChangeVisibilityBookmarkTest.php | |||
@@ -0,0 +1,418 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest; | ||
6 | |||
7 | use Shaarli\Bookmark\Bookmark; | ||
8 | use Shaarli\Bookmark\Exception\BookmarkNotFoundException; | ||
9 | use Shaarli\Formatter\BookmarkFormatter; | ||
10 | use Shaarli\Formatter\BookmarkRawFormatter; | ||
11 | use Shaarli\Formatter\FormatterFactory; | ||
12 | use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper; | ||
13 | use Shaarli\Front\Controller\Admin\ManageShaareController; | ||
14 | use Shaarli\Http\HttpAccess; | ||
15 | use Shaarli\Security\SessionManager; | ||
16 | use Shaarli\TestCase; | ||
17 | use Slim\Http\Request; | ||
18 | use Slim\Http\Response; | ||
19 | |||
20 | class ChangeVisibilityBookmarkTest extends TestCase | ||
21 | { | ||
22 | use FrontAdminControllerMockHelper; | ||
23 | |||
24 | /** @var ManageShaareController */ | ||
25 | protected $controller; | ||
26 | |||
27 | public function setUp(): void | ||
28 | { | ||
29 | $this->createContainer(); | ||
30 | |||
31 | $this->container->httpAccess = $this->createMock(HttpAccess::class); | ||
32 | $this->controller = new ManageShaareController($this->container); | ||
33 | } | ||
34 | |||
35 | /** | ||
36 | * Change bookmark visibility - Set private - Single public bookmark with valid parameters | ||
37 | */ | ||
38 | public function testSetSingleBookmarkPrivate(): void | ||
39 | { | ||
40 | $parameters = ['id' => '123', 'newVisibility' => 'private']; | ||
41 | |||
42 | $request = $this->createMock(Request::class); | ||
43 | $request | ||
44 | ->method('getParam') | ||
45 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
46 | return $parameters[$key] ?? null; | ||
47 | }) | ||
48 | ; | ||
49 | $response = new Response(); | ||
50 | |||
51 | $bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(false); | ||
52 | |||
53 | static::assertFalse($bookmark->isPrivate()); | ||
54 | |||
55 | $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark); | ||
56 | $this->container->bookmarkService->expects(static::once())->method('set')->with($bookmark, false); | ||
57 | $this->container->bookmarkService->expects(static::once())->method('save'); | ||
58 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | ||
59 | $this->container->formatterFactory | ||
60 | ->expects(static::once()) | ||
61 | ->method('getFormatter') | ||
62 | ->with('raw') | ||
63 | ->willReturnCallback(function () use ($bookmark): BookmarkFormatter { | ||
64 | return new BookmarkRawFormatter($this->container->conf, true); | ||
65 | }) | ||
66 | ; | ||
67 | |||
68 | // Make sure that PluginManager hook is triggered | ||
69 | $this->container->pluginManager | ||
70 | ->expects(static::once()) | ||
71 | ->method('executeHooks') | ||
72 | ->with('save_link') | ||
73 | ; | ||
74 | |||
75 | $result = $this->controller->changeVisibility($request, $response); | ||
76 | |||
77 | static::assertTrue($bookmark->isPrivate()); | ||
78 | |||
79 | static::assertSame(302, $result->getStatusCode()); | ||
80 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
81 | } | ||
82 | |||
83 | /** | ||
84 | * Change bookmark visibility - Set public - Single private bookmark with valid parameters | ||
85 | */ | ||
86 | public function testSetSingleBookmarkPublic(): void | ||
87 | { | ||
88 | $parameters = ['id' => '123', 'newVisibility' => 'public']; | ||
89 | |||
90 | $request = $this->createMock(Request::class); | ||
91 | $request | ||
92 | ->method('getParam') | ||
93 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
94 | return $parameters[$key] ?? null; | ||
95 | }) | ||
96 | ; | ||
97 | $response = new Response(); | ||
98 | |||
99 | $bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(true); | ||
100 | |||
101 | static::assertTrue($bookmark->isPrivate()); | ||
102 | |||
103 | $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark); | ||
104 | $this->container->bookmarkService->expects(static::once())->method('set')->with($bookmark, false); | ||
105 | $this->container->bookmarkService->expects(static::once())->method('save'); | ||
106 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | ||
107 | $this->container->formatterFactory | ||
108 | ->expects(static::once()) | ||
109 | ->method('getFormatter') | ||
110 | ->with('raw') | ||
111 | ->willReturn(new BookmarkRawFormatter($this->container->conf, true)) | ||
112 | ; | ||
113 | |||
114 | // Make sure that PluginManager hook is triggered | ||
115 | $this->container->pluginManager | ||
116 | ->expects(static::once()) | ||
117 | ->method('executeHooks') | ||
118 | ->with('save_link') | ||
119 | ; | ||
120 | |||
121 | $result = $this->controller->changeVisibility($request, $response); | ||
122 | |||
123 | static::assertFalse($bookmark->isPrivate()); | ||
124 | |||
125 | static::assertSame(302, $result->getStatusCode()); | ||
126 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
127 | } | ||
128 | |||
129 | /** | ||
130 | * Change bookmark visibility - Set private on single already private bookmark | ||
131 | */ | ||
132 | public function testSetSinglePrivateBookmarkPrivate(): void | ||
133 | { | ||
134 | $parameters = ['id' => '123', 'newVisibility' => 'private']; | ||
135 | |||
136 | $request = $this->createMock(Request::class); | ||
137 | $request | ||
138 | ->method('getParam') | ||
139 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
140 | return $parameters[$key] ?? null; | ||
141 | }) | ||
142 | ; | ||
143 | $response = new Response(); | ||
144 | |||
145 | $bookmark = (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(true); | ||
146 | |||
147 | static::assertTrue($bookmark->isPrivate()); | ||
148 | |||
149 | $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark); | ||
150 | $this->container->bookmarkService->expects(static::once())->method('set')->with($bookmark, false); | ||
151 | $this->container->bookmarkService->expects(static::once())->method('save'); | ||
152 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | ||
153 | $this->container->formatterFactory | ||
154 | ->expects(static::once()) | ||
155 | ->method('getFormatter') | ||
156 | ->with('raw') | ||
157 | ->willReturn(new BookmarkRawFormatter($this->container->conf, true)) | ||
158 | ; | ||
159 | |||
160 | // Make sure that PluginManager hook is triggered | ||
161 | $this->container->pluginManager | ||
162 | ->expects(static::once()) | ||
163 | ->method('executeHooks') | ||
164 | ->with('save_link') | ||
165 | ; | ||
166 | |||
167 | $result = $this->controller->changeVisibility($request, $response); | ||
168 | |||
169 | static::assertTrue($bookmark->isPrivate()); | ||
170 | |||
171 | static::assertSame(302, $result->getStatusCode()); | ||
172 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
173 | } | ||
174 | |||
175 | /** | ||
176 | * Change bookmark visibility - Set multiple bookmarks private | ||
177 | */ | ||
178 | public function testSetMultipleBookmarksPrivate(): void | ||
179 | { | ||
180 | $parameters = ['id' => '123 456 789', 'newVisibility' => 'private']; | ||
181 | |||
182 | $request = $this->createMock(Request::class); | ||
183 | $request | ||
184 | ->method('getParam') | ||
185 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
186 | return $parameters[$key] ?? null; | ||
187 | }) | ||
188 | ; | ||
189 | $response = new Response(); | ||
190 | |||
191 | $bookmarks = [ | ||
192 | (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(false), | ||
193 | (new Bookmark())->setId(456)->setUrl('http://domain.tld')->setTitle('Title 456')->setPrivate(true), | ||
194 | (new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789')->setPrivate(false), | ||
195 | ]; | ||
196 | |||
197 | $this->container->bookmarkService | ||
198 | ->expects(static::exactly(3)) | ||
199 | ->method('get') | ||
200 | ->withConsecutive([123], [456], [789]) | ||
201 | ->willReturnOnConsecutiveCalls(...$bookmarks) | ||
202 | ; | ||
203 | $this->container->bookmarkService | ||
204 | ->expects(static::exactly(3)) | ||
205 | ->method('set') | ||
206 | ->withConsecutive(...array_map(function (Bookmark $bookmark): array { | ||
207 | return [$bookmark, false]; | ||
208 | }, $bookmarks)) | ||
209 | ; | ||
210 | $this->container->bookmarkService->expects(static::once())->method('save'); | ||
211 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | ||
212 | $this->container->formatterFactory | ||
213 | ->expects(static::once()) | ||
214 | ->method('getFormatter') | ||
215 | ->with('raw') | ||
216 | ->willReturn(new BookmarkRawFormatter($this->container->conf, true)) | ||
217 | ; | ||
218 | |||
219 | // Make sure that PluginManager hook is triggered | ||
220 | $this->container->pluginManager | ||
221 | ->expects(static::exactly(3)) | ||
222 | ->method('executeHooks') | ||
223 | ->with('save_link') | ||
224 | ; | ||
225 | |||
226 | $result = $this->controller->changeVisibility($request, $response); | ||
227 | |||
228 | static::assertTrue($bookmarks[0]->isPrivate()); | ||
229 | static::assertTrue($bookmarks[1]->isPrivate()); | ||
230 | static::assertTrue($bookmarks[2]->isPrivate()); | ||
231 | |||
232 | static::assertSame(302, $result->getStatusCode()); | ||
233 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
234 | } | ||
235 | |||
236 | /** | ||
237 | * Change bookmark visibility - Single bookmark not found. | ||
238 | */ | ||
239 | public function testChangeVisibilitySingleBookmarkNotFound(): void | ||
240 | { | ||
241 | $parameters = ['id' => '123', 'newVisibility' => 'private']; | ||
242 | |||
243 | $request = $this->createMock(Request::class); | ||
244 | $request | ||
245 | ->method('getParam') | ||
246 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
247 | return $parameters[$key] ?? null; | ||
248 | }) | ||
249 | ; | ||
250 | $response = new Response(); | ||
251 | |||
252 | $this->container->bookmarkService | ||
253 | ->expects(static::once()) | ||
254 | ->method('get') | ||
255 | ->willThrowException(new BookmarkNotFoundException()) | ||
256 | ; | ||
257 | $this->container->bookmarkService->expects(static::never())->method('set'); | ||
258 | $this->container->bookmarkService->expects(static::never())->method('save'); | ||
259 | $this->container->formatterFactory = $this->createMock(FormatterFactory::class); | ||
260 | $this->container->formatterFactory | ||
261 | ->expects(static::once()) | ||
262 | ->method('getFormatter') | ||
263 | ->with('raw') | ||
264 | ->willReturn(new BookmarkRawFormatter($this->container->conf, true)) | ||
265 | ; | ||
266 | |||
267 | // Make sure that PluginManager hook is not triggered | ||
268 | $this->container->pluginManager | ||
269 | ->expects(static::never()) | ||
270 | ->method('executeHooks') | ||
271 | ->with('save_link') | ||
272 | ; | ||
273 | |||
274 | $result = $this->controller->changeVisibility($request, $response); | ||
275 | |||
276 | static::assertSame(302, $result->getStatusCode()); | ||
277 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
278 | } | ||
279 | |||
280 | /** | ||
281 | * Change bookmark visibility - Multiple bookmarks with one not found. | ||
282 | */ | ||
283 | public function testChangeVisibilityMultipleBookmarksOneNotFound(): void | ||
284 | { | ||
285 | $parameters = ['id' => '123 456 789', 'newVisibility' => 'public']; | ||
286 | |||
287 | $request = $this->createMock(Request::class); | ||
288 | $request | ||
289 | ->method('getParam') | ||
290 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
291 | return $parameters[$key] ?? null; | ||
292 | }) | ||
293 | ; | ||
294 | $response = new Response(); | ||
295 | |||
296 | $bookmarks = [ | ||
297 | (new Bookmark())->setId(123)->setUrl('http://domain.tld')->setTitle('Title 123')->setPrivate(true), | ||
298 | (new Bookmark())->setId(789)->setUrl('http://domain.tld')->setTitle('Title 789')->setPrivate(false), | ||
299 | ]; | ||
300 | |||
301 | $this->container->bookmarkService | ||
302 | ->expects(static::exactly(3)) | ||
303 | ->method('get') | ||
304 | ->withConsecutive([123], [456], [789]) | ||
305 | ->willReturnCallback(function (int $id) use ($bookmarks): Bookmark { | ||
306 | if ($id === 123) { | ||
307 | return $bookmarks[0]; | ||
308 | } | ||
309 | if ($id === 789) { | ||
310 | return $bookmarks[1]; | ||
311 | } | ||
312 | throw new BookmarkNotFoundException(); | ||
313 | }) | ||
314 | ; | ||
315 | $this->container->bookmarkService | ||
316 | ->expects(static::exactly(2)) | ||
317 | ->method('set') | ||
318 | ->withConsecutive(...array_map(function (Bookmark $bookmark): array { | ||
319 | return [$bookmark, false]; | ||
320 | }, $bookmarks)) | ||
321 | ; | ||
322 | $this->container->bookmarkService->expects(static::once())->method('save'); | ||
323 | |||
324 | // Make sure that PluginManager hook is not triggered | ||
325 | $this->container->pluginManager | ||
326 | ->expects(static::exactly(2)) | ||
327 | ->method('executeHooks') | ||
328 | ->with('save_link') | ||
329 | ; | ||
330 | |||
331 | $this->container->sessionManager | ||
332 | ->expects(static::once()) | ||
333 | ->method('setSessionParameter') | ||
334 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier 456 could not be found.']) | ||
335 | ; | ||
336 | |||
337 | $result = $this->controller->changeVisibility($request, $response); | ||
338 | |||
339 | static::assertSame(302, $result->getStatusCode()); | ||
340 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
341 | } | ||
342 | |||
343 | /** | ||
344 | * Change bookmark visibility - Invalid ID | ||
345 | */ | ||
346 | public function testChangeVisibilityInvalidId(): void | ||
347 | { | ||
348 | $parameters = ['id' => 'nope not an ID', 'newVisibility' => 'private']; | ||
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->sessionManager | ||
360 | ->expects(static::once()) | ||
361 | ->method('setSessionParameter') | ||
362 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.']) | ||
363 | ; | ||
364 | |||
365 | $result = $this->controller->changeVisibility($request, $response); | ||
366 | |||
367 | static::assertSame(302, $result->getStatusCode()); | ||
368 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
369 | } | ||
370 | |||
371 | /** | ||
372 | * Change bookmark visibility - Empty ID | ||
373 | */ | ||
374 | public function testChangeVisibilityEmptyId(): void | ||
375 | { | ||
376 | $request = $this->createMock(Request::class); | ||
377 | $response = new Response(); | ||
378 | |||
379 | $this->container->sessionManager | ||
380 | ->expects(static::once()) | ||
381 | ->method('setSessionParameter') | ||
382 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid bookmark ID provided.']) | ||
383 | ; | ||
384 | |||
385 | $result = $this->controller->changeVisibility($request, $response); | ||
386 | |||
387 | static::assertSame(302, $result->getStatusCode()); | ||
388 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
389 | } | ||
390 | |||
391 | /** | ||
392 | * Change bookmark visibility - with invalid visibility | ||
393 | */ | ||
394 | public function testChangeVisibilityWithInvalidVisibility(): void | ||
395 | { | ||
396 | $parameters = ['id' => '123', 'newVisibility' => 'invalid']; | ||
397 | |||
398 | $request = $this->createMock(Request::class); | ||
399 | $request | ||
400 | ->method('getParam') | ||
401 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
402 | return $parameters[$key] ?? null; | ||
403 | }) | ||
404 | ; | ||
405 | $response = new Response(); | ||
406 | |||
407 | $this->container->sessionManager | ||
408 | ->expects(static::once()) | ||
409 | ->method('setSessionParameter') | ||
410 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Invalid visibility provided.']) | ||
411 | ; | ||
412 | |||
413 | $result = $this->controller->changeVisibility($request, $response); | ||
414 | |||
415 | static::assertSame(302, $result->getStatusCode()); | ||
416 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
417 | } | ||
418 | } | ||
diff --git a/tests/front/controller/admin/ManageShaareControllerTest/DeleteBookmarkTest.php b/tests/front/controller/admin/ManageShaareControllerTest/DeleteBookmarkTest.php new file mode 100644 index 00000000..ba774e21 --- /dev/null +++ b/tests/front/controller/admin/ManageShaareControllerTest/DeleteBookmarkTest.php | |||
@@ -0,0 +1,376 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest; | ||
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\ManageShaareController; | ||
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 ManageShaareController */ | ||
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 ManageShaareController($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->formatterFactory = $this->createMock(FormatterFactory::class); | ||
360 | $this->container->formatterFactory | ||
361 | ->expects(static::once()) | ||
362 | ->method('getFormatter') | ||
363 | ->willReturnCallback(function (): BookmarkFormatter { | ||
364 | $formatter = $this->createMock(BookmarkFormatter::class); | ||
365 | $formatter->method('format')->willReturn(['formatted']); | ||
366 | |||
367 | return $formatter; | ||
368 | }) | ||
369 | ; | ||
370 | |||
371 | $result = $this->controller->deleteBookmark($request, $response); | ||
372 | |||
373 | static::assertSame(200, $result->getStatusCode()); | ||
374 | static::assertSame('<script>self.close();</script>', (string) $result->getBody('location')); | ||
375 | } | ||
376 | } | ||
diff --git a/tests/front/controller/admin/ManageShaareControllerTest/DisplayCreateFormTest.php b/tests/front/controller/admin/ManageShaareControllerTest/DisplayCreateFormTest.php new file mode 100644 index 00000000..2eb95251 --- /dev/null +++ b/tests/front/controller/admin/ManageShaareControllerTest/DisplayCreateFormTest.php | |||
@@ -0,0 +1,317 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest; | ||
6 | |||
7 | use Shaarli\Bookmark\Bookmark; | ||
8 | use Shaarli\Config\ConfigManager; | ||
9 | use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper; | ||
10 | use Shaarli\Front\Controller\Admin\ManageShaareController; | ||
11 | use Shaarli\Http\HttpAccess; | ||
12 | use Shaarli\TestCase; | ||
13 | use Slim\Http\Request; | ||
14 | use Slim\Http\Response; | ||
15 | |||
16 | class DisplayCreateFormTest extends TestCase | ||
17 | { | ||
18 | use FrontAdminControllerMockHelper; | ||
19 | |||
20 | /** @var ManageShaareController */ | ||
21 | protected $controller; | ||
22 | |||
23 | public function setUp(): void | ||
24 | { | ||
25 | $this->createContainer(); | ||
26 | |||
27 | $this->container->httpAccess = $this->createMock(HttpAccess::class); | ||
28 | $this->controller = new ManageShaareController($this->container); | ||
29 | } | ||
30 | |||
31 | /** | ||
32 | * Test displaying bookmark create form | ||
33 | * Ensure that every step of the standard workflow works properly. | ||
34 | */ | ||
35 | public function testDisplayCreateFormWithUrl(): void | ||
36 | { | ||
37 | $this->container->environment = [ | ||
38 | 'HTTP_REFERER' => $referer = 'http://shaarli/subfolder/controller/?searchtag=abc' | ||
39 | ]; | ||
40 | |||
41 | $assignedVariables = []; | ||
42 | $this->assignTemplateVars($assignedVariables); | ||
43 | |||
44 | $url = 'http://url.tld/other?part=3&utm_ad=pay#hash'; | ||
45 | $expectedUrl = str_replace('&utm_ad=pay', '', $url); | ||
46 | $remoteTitle = 'Remote Title'; | ||
47 | $remoteDesc = 'Sometimes the meta description is relevant.'; | ||
48 | $remoteTags = 'abc def'; | ||
49 | |||
50 | $request = $this->createMock(Request::class); | ||
51 | $request->method('getParam')->willReturnCallback(function (string $key) use ($url): ?string { | ||
52 | return $key === 'post' ? $url : null; | ||
53 | }); | ||
54 | $response = new Response(); | ||
55 | |||
56 | $this->container->httpAccess | ||
57 | ->expects(static::once()) | ||
58 | ->method('getCurlDownloadCallback') | ||
59 | ->willReturnCallback( | ||
60 | function (&$charset, &$title, &$description, &$tags) use ( | ||
61 | $remoteTitle, | ||
62 | $remoteDesc, | ||
63 | $remoteTags | ||
64 | ): callable { | ||
65 | return function () use ( | ||
66 | &$charset, | ||
67 | &$title, | ||
68 | &$description, | ||
69 | &$tags, | ||
70 | $remoteTitle, | ||
71 | $remoteDesc, | ||
72 | $remoteTags | ||
73 | ): void { | ||
74 | $charset = 'ISO-8859-1'; | ||
75 | $title = $remoteTitle; | ||
76 | $description = $remoteDesc; | ||
77 | $tags = $remoteTags; | ||
78 | }; | ||
79 | } | ||
80 | ) | ||
81 | ; | ||
82 | $this->container->httpAccess | ||
83 | ->expects(static::once()) | ||
84 | ->method('getHttpResponse') | ||
85 | ->with($expectedUrl, 30, 4194304) | ||
86 | ->willReturnCallback(function($url, $timeout, $maxBytes, $callback): void { | ||
87 | $callback(); | ||
88 | }) | ||
89 | ; | ||
90 | |||
91 | $this->container->bookmarkService | ||
92 | ->expects(static::once()) | ||
93 | ->method('bookmarksCountPerTag') | ||
94 | ->willReturn($tags = ['tag1' => 2, 'tag2' => 1]) | ||
95 | ; | ||
96 | |||
97 | // Make sure that PluginManager hook is triggered | ||
98 | $this->container->pluginManager | ||
99 | ->expects(static::atLeastOnce()) | ||
100 | ->method('executeHooks') | ||
101 | ->withConsecutive(['render_editlink'], ['render_includes']) | ||
102 | ->willReturnCallback(function (string $hook, array $data) use ($remoteTitle, $remoteDesc): array { | ||
103 | if ('render_editlink' === $hook) { | ||
104 | static::assertSame($remoteTitle, $data['link']['title']); | ||
105 | static::assertSame($remoteDesc, $data['link']['description']); | ||
106 | } | ||
107 | |||
108 | return $data; | ||
109 | }) | ||
110 | ; | ||
111 | |||
112 | $result = $this->controller->displayCreateForm($request, $response); | ||
113 | |||
114 | static::assertSame(200, $result->getStatusCode()); | ||
115 | static::assertSame('editlink', (string) $result->getBody()); | ||
116 | |||
117 | static::assertSame('Shaare - Shaarli', $assignedVariables['pagetitle']); | ||
118 | |||
119 | static::assertSame($expectedUrl, $assignedVariables['link']['url']); | ||
120 | static::assertSame($remoteTitle, $assignedVariables['link']['title']); | ||
121 | static::assertSame($remoteDesc, $assignedVariables['link']['description']); | ||
122 | static::assertSame($remoteTags, $assignedVariables['link']['tags']); | ||
123 | static::assertFalse($assignedVariables['link']['private']); | ||
124 | |||
125 | static::assertTrue($assignedVariables['link_is_new']); | ||
126 | static::assertSame($referer, $assignedVariables['http_referer']); | ||
127 | static::assertSame($tags, $assignedVariables['tags']); | ||
128 | static::assertArrayHasKey('source', $assignedVariables); | ||
129 | static::assertArrayHasKey('default_private_links', $assignedVariables); | ||
130 | } | ||
131 | |||
132 | /** | ||
133 | * Test displaying bookmark create form | ||
134 | * Ensure all available query parameters are handled properly. | ||
135 | */ | ||
136 | public function testDisplayCreateFormWithFullParameters(): void | ||
137 | { | ||
138 | $assignedVariables = []; | ||
139 | $this->assignTemplateVars($assignedVariables); | ||
140 | |||
141 | $parameters = [ | ||
142 | 'post' => 'http://url.tld/other?part=3&utm_ad=pay#hash', | ||
143 | 'title' => 'Provided Title', | ||
144 | 'description' => 'Provided description.', | ||
145 | 'tags' => 'abc def', | ||
146 | 'private' => '1', | ||
147 | 'source' => 'apps', | ||
148 | ]; | ||
149 | $expectedUrl = str_replace('&utm_ad=pay', '', $parameters['post']); | ||
150 | |||
151 | $request = $this->createMock(Request::class); | ||
152 | $request | ||
153 | ->method('getParam') | ||
154 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
155 | return $parameters[$key] ?? null; | ||
156 | }); | ||
157 | $response = new Response(); | ||
158 | |||
159 | $result = $this->controller->displayCreateForm($request, $response); | ||
160 | |||
161 | static::assertSame(200, $result->getStatusCode()); | ||
162 | static::assertSame('editlink', (string) $result->getBody()); | ||
163 | |||
164 | static::assertSame('Shaare - Shaarli', $assignedVariables['pagetitle']); | ||
165 | |||
166 | static::assertSame($expectedUrl, $assignedVariables['link']['url']); | ||
167 | static::assertSame($parameters['title'], $assignedVariables['link']['title']); | ||
168 | static::assertSame($parameters['description'], $assignedVariables['link']['description']); | ||
169 | static::assertSame($parameters['tags'], $assignedVariables['link']['tags']); | ||
170 | static::assertTrue($assignedVariables['link']['private']); | ||
171 | static::assertTrue($assignedVariables['link_is_new']); | ||
172 | static::assertSame($parameters['source'], $assignedVariables['source']); | ||
173 | } | ||
174 | |||
175 | /** | ||
176 | * Test displaying bookmark create form | ||
177 | * Without any parameter. | ||
178 | */ | ||
179 | public function testDisplayCreateFormEmpty(): void | ||
180 | { | ||
181 | $assignedVariables = []; | ||
182 | $this->assignTemplateVars($assignedVariables); | ||
183 | |||
184 | $request = $this->createMock(Request::class); | ||
185 | $response = new Response(); | ||
186 | |||
187 | $this->container->httpAccess->expects(static::never())->method('getHttpResponse'); | ||
188 | $this->container->httpAccess->expects(static::never())->method('getCurlDownloadCallback'); | ||
189 | |||
190 | $result = $this->controller->displayCreateForm($request, $response); | ||
191 | |||
192 | static::assertSame(200, $result->getStatusCode()); | ||
193 | static::assertSame('editlink', (string) $result->getBody()); | ||
194 | static::assertSame('', $assignedVariables['link']['url']); | ||
195 | static::assertSame('Note: ', $assignedVariables['link']['title']); | ||
196 | static::assertSame('', $assignedVariables['link']['description']); | ||
197 | static::assertSame('', $assignedVariables['link']['tags']); | ||
198 | static::assertFalse($assignedVariables['link']['private']); | ||
199 | static::assertTrue($assignedVariables['link_is_new']); | ||
200 | } | ||
201 | |||
202 | /** | ||
203 | * Test displaying bookmark create form | ||
204 | * URL not using HTTP protocol: do not try to retrieve the title | ||
205 | */ | ||
206 | public function testDisplayCreateFormNotHttp(): void | ||
207 | { | ||
208 | $assignedVariables = []; | ||
209 | $this->assignTemplateVars($assignedVariables); | ||
210 | |||
211 | $url = 'magnet://kubuntu.torrent'; | ||
212 | $request = $this->createMock(Request::class); | ||
213 | $request | ||
214 | ->method('getParam') | ||
215 | ->willReturnCallback(function (string $key) use ($url): ?string { | ||
216 | return $key === 'post' ? $url : null; | ||
217 | }); | ||
218 | $response = new Response(); | ||
219 | |||
220 | $this->container->httpAccess->expects(static::never())->method('getHttpResponse'); | ||
221 | $this->container->httpAccess->expects(static::never())->method('getCurlDownloadCallback'); | ||
222 | |||
223 | $result = $this->controller->displayCreateForm($request, $response); | ||
224 | |||
225 | static::assertSame(200, $result->getStatusCode()); | ||
226 | static::assertSame('editlink', (string) $result->getBody()); | ||
227 | static::assertSame($url, $assignedVariables['link']['url']); | ||
228 | static::assertTrue($assignedVariables['link_is_new']); | ||
229 | } | ||
230 | |||
231 | /** | ||
232 | * Test displaying bookmark create form | ||
233 | * When markdown formatter is enabled, the no markdown tag should be added to existing tags. | ||
234 | */ | ||
235 | public function testDisplayCreateFormWithMarkdownEnabled(): void | ||
236 | { | ||
237 | $assignedVariables = []; | ||
238 | $this->assignTemplateVars($assignedVariables); | ||
239 | |||
240 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
241 | $this->container->conf | ||
242 | ->expects(static::atLeastOnce()) | ||
243 | ->method('get')->willReturnCallback(function (string $key): ?string { | ||
244 | if ($key === 'formatter') { | ||
245 | return 'markdown'; | ||
246 | } | ||
247 | |||
248 | return $key; | ||
249 | }) | ||
250 | ; | ||
251 | |||
252 | $request = $this->createMock(Request::class); | ||
253 | $response = new Response(); | ||
254 | |||
255 | $result = $this->controller->displayCreateForm($request, $response); | ||
256 | |||
257 | static::assertSame(200, $result->getStatusCode()); | ||
258 | static::assertSame('editlink', (string) $result->getBody()); | ||
259 | static::assertSame(['nomarkdown' => 1], $assignedVariables['tags']); | ||
260 | } | ||
261 | |||
262 | /** | ||
263 | * Test displaying bookmark create form | ||
264 | * When an existing URL is submitted, we want to edit the existing link. | ||
265 | */ | ||
266 | public function testDisplayCreateFormWithExistingUrl(): void | ||
267 | { | ||
268 | $assignedVariables = []; | ||
269 | $this->assignTemplateVars($assignedVariables); | ||
270 | |||
271 | $url = 'http://url.tld/other?part=3&utm_ad=pay#hash'; | ||
272 | $expectedUrl = str_replace('&utm_ad=pay', '', $url); | ||
273 | |||
274 | $request = $this->createMock(Request::class); | ||
275 | $request | ||
276 | ->method('getParam') | ||
277 | ->willReturnCallback(function (string $key) use ($url): ?string { | ||
278 | return $key === 'post' ? $url : null; | ||
279 | }); | ||
280 | $response = new Response(); | ||
281 | |||
282 | $this->container->httpAccess->expects(static::never())->method('getHttpResponse'); | ||
283 | $this->container->httpAccess->expects(static::never())->method('getCurlDownloadCallback'); | ||
284 | |||
285 | $this->container->bookmarkService | ||
286 | ->expects(static::once()) | ||
287 | ->method('findByUrl') | ||
288 | ->with($expectedUrl) | ||
289 | ->willReturn( | ||
290 | (new Bookmark()) | ||
291 | ->setId($id = 23) | ||
292 | ->setUrl($expectedUrl) | ||
293 | ->setTitle($title = 'Bookmark Title') | ||
294 | ->setDescription($description = 'Bookmark description.') | ||
295 | ->setTags($tags = ['abc', 'def']) | ||
296 | ->setPrivate(true) | ||
297 | ->setCreated($createdAt = new \DateTime('2020-06-10 18:45:44')) | ||
298 | ) | ||
299 | ; | ||
300 | |||
301 | $result = $this->controller->displayCreateForm($request, $response); | ||
302 | |||
303 | static::assertSame(200, $result->getStatusCode()); | ||
304 | static::assertSame('editlink', (string) $result->getBody()); | ||
305 | |||
306 | static::assertSame('Edit Shaare - Shaarli', $assignedVariables['pagetitle']); | ||
307 | static::assertFalse($assignedVariables['link_is_new']); | ||
308 | |||
309 | static::assertSame($id, $assignedVariables['link']['id']); | ||
310 | static::assertSame($expectedUrl, $assignedVariables['link']['url']); | ||
311 | static::assertSame($title, $assignedVariables['link']['title']); | ||
312 | static::assertSame($description, $assignedVariables['link']['description']); | ||
313 | static::assertSame(implode(' ', $tags), $assignedVariables['link']['tags']); | ||
314 | static::assertTrue($assignedVariables['link']['private']); | ||
315 | static::assertSame($createdAt, $assignedVariables['link']['created']); | ||
316 | } | ||
317 | } | ||
diff --git a/tests/front/controller/admin/ManageShaareControllerTest/DisplayEditFormTest.php b/tests/front/controller/admin/ManageShaareControllerTest/DisplayEditFormTest.php new file mode 100644 index 00000000..2dc3f41c --- /dev/null +++ b/tests/front/controller/admin/ManageShaareControllerTest/DisplayEditFormTest.php | |||
@@ -0,0 +1,155 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest; | ||
6 | |||
7 | use Shaarli\Bookmark\Bookmark; | ||
8 | use Shaarli\Bookmark\Exception\BookmarkNotFoundException; | ||
9 | use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper; | ||
10 | use Shaarli\Front\Controller\Admin\ManageShaareController; | ||
11 | use Shaarli\Http\HttpAccess; | ||
12 | use Shaarli\Security\SessionManager; | ||
13 | use Shaarli\TestCase; | ||
14 | use Slim\Http\Request; | ||
15 | use Slim\Http\Response; | ||
16 | |||
17 | class DisplayEditFormTest extends TestCase | ||
18 | { | ||
19 | use FrontAdminControllerMockHelper; | ||
20 | |||
21 | /** @var ManageShaareController */ | ||
22 | protected $controller; | ||
23 | |||
24 | public function setUp(): void | ||
25 | { | ||
26 | $this->createContainer(); | ||
27 | |||
28 | $this->container->httpAccess = $this->createMock(HttpAccess::class); | ||
29 | $this->controller = new ManageShaareController($this->container); | ||
30 | } | ||
31 | |||
32 | /** | ||
33 | * Test displaying bookmark edit form | ||
34 | * When an existing ID is provided, ensure that default workflow works properly. | ||
35 | */ | ||
36 | public function testDisplayEditFormDefault(): void | ||
37 | { | ||
38 | $assignedVariables = []; | ||
39 | $this->assignTemplateVars($assignedVariables); | ||
40 | |||
41 | $id = 11; | ||
42 | |||
43 | $request = $this->createMock(Request::class); | ||
44 | $response = new Response(); | ||
45 | |||
46 | $this->container->httpAccess->expects(static::never())->method('getHttpResponse'); | ||
47 | $this->container->httpAccess->expects(static::never())->method('getCurlDownloadCallback'); | ||
48 | |||
49 | $this->container->bookmarkService | ||
50 | ->expects(static::once()) | ||
51 | ->method('get') | ||
52 | ->with($id) | ||
53 | ->willReturn( | ||
54 | (new Bookmark()) | ||
55 | ->setId($id) | ||
56 | ->setUrl($url = 'http://domain.tld') | ||
57 | ->setTitle($title = 'Bookmark Title') | ||
58 | ->setDescription($description = 'Bookmark description.') | ||
59 | ->setTags($tags = ['abc', 'def']) | ||
60 | ->setPrivate(true) | ||
61 | ->setCreated($createdAt = new \DateTime('2020-06-10 18:45:44')) | ||
62 | ) | ||
63 | ; | ||
64 | |||
65 | $result = $this->controller->displayEditForm($request, $response, ['id' => (string) $id]); | ||
66 | |||
67 | static::assertSame(200, $result->getStatusCode()); | ||
68 | static::assertSame('editlink', (string) $result->getBody()); | ||
69 | |||
70 | static::assertSame('Edit Shaare - Shaarli', $assignedVariables['pagetitle']); | ||
71 | static::assertFalse($assignedVariables['link_is_new']); | ||
72 | |||
73 | static::assertSame($id, $assignedVariables['link']['id']); | ||
74 | static::assertSame($url, $assignedVariables['link']['url']); | ||
75 | static::assertSame($title, $assignedVariables['link']['title']); | ||
76 | static::assertSame($description, $assignedVariables['link']['description']); | ||
77 | static::assertSame(implode(' ', $tags), $assignedVariables['link']['tags']); | ||
78 | static::assertTrue($assignedVariables['link']['private']); | ||
79 | static::assertSame($createdAt, $assignedVariables['link']['created']); | ||
80 | } | ||
81 | |||
82 | /** | ||
83 | * Test displaying bookmark edit form | ||
84 | * Invalid ID provided. | ||
85 | */ | ||
86 | public function testDisplayEditFormInvalidId(): void | ||
87 | { | ||
88 | $id = 'invalid'; | ||
89 | |||
90 | $request = $this->createMock(Request::class); | ||
91 | $response = new Response(); | ||
92 | |||
93 | $this->container->sessionManager | ||
94 | ->expects(static::once()) | ||
95 | ->method('setSessionParameter') | ||
96 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier invalid could not be found.']) | ||
97 | ; | ||
98 | |||
99 | $result = $this->controller->displayEditForm($request, $response, ['id' => $id]); | ||
100 | |||
101 | static::assertSame(302, $result->getStatusCode()); | ||
102 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
103 | } | ||
104 | |||
105 | /** | ||
106 | * Test displaying bookmark edit form | ||
107 | * ID not provided. | ||
108 | */ | ||
109 | public function testDisplayEditFormIdNotProvided(): void | ||
110 | { | ||
111 | $request = $this->createMock(Request::class); | ||
112 | $response = new Response(); | ||
113 | |||
114 | $this->container->sessionManager | ||
115 | ->expects(static::once()) | ||
116 | ->method('setSessionParameter') | ||
117 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier could not be found.']) | ||
118 | ; | ||
119 | |||
120 | $result = $this->controller->displayEditForm($request, $response, []); | ||
121 | |||
122 | static::assertSame(302, $result->getStatusCode()); | ||
123 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
124 | } | ||
125 | |||
126 | /** | ||
127 | * Test displaying bookmark edit form | ||
128 | * Bookmark not found. | ||
129 | */ | ||
130 | public function testDisplayEditFormBookmarkNotFound(): void | ||
131 | { | ||
132 | $id = 123; | ||
133 | |||
134 | $request = $this->createMock(Request::class); | ||
135 | $response = new Response(); | ||
136 | |||
137 | $this->container->bookmarkService | ||
138 | ->expects(static::once()) | ||
139 | ->method('get') | ||
140 | ->with($id) | ||
141 | ->willThrowException(new BookmarkNotFoundException()) | ||
142 | ; | ||
143 | |||
144 | $this->container->sessionManager | ||
145 | ->expects(static::once()) | ||
146 | ->method('setSessionParameter') | ||
147 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier 123 could not be found.']) | ||
148 | ; | ||
149 | |||
150 | $result = $this->controller->displayEditForm($request, $response, ['id' => (string) $id]); | ||
151 | |||
152 | static::assertSame(302, $result->getStatusCode()); | ||
153 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
154 | } | ||
155 | } | ||
diff --git a/tests/front/controller/admin/ManageShaareControllerTest/PinBookmarkTest.php b/tests/front/controller/admin/ManageShaareControllerTest/PinBookmarkTest.php new file mode 100644 index 00000000..50ce7df1 --- /dev/null +++ b/tests/front/controller/admin/ManageShaareControllerTest/PinBookmarkTest.php | |||
@@ -0,0 +1,145 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest; | ||
6 | |||
7 | use Shaarli\Bookmark\Bookmark; | ||
8 | use Shaarli\Bookmark\Exception\BookmarkNotFoundException; | ||
9 | use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper; | ||
10 | use Shaarli\Front\Controller\Admin\ManageShaareController; | ||
11 | use Shaarli\Http\HttpAccess; | ||
12 | use Shaarli\Security\SessionManager; | ||
13 | use Shaarli\TestCase; | ||
14 | use Slim\Http\Request; | ||
15 | use Slim\Http\Response; | ||
16 | |||
17 | class PinBookmarkTest extends TestCase | ||
18 | { | ||
19 | use FrontAdminControllerMockHelper; | ||
20 | |||
21 | /** @var ManageShaareController */ | ||
22 | protected $controller; | ||
23 | |||
24 | public function setUp(): void | ||
25 | { | ||
26 | $this->createContainer(); | ||
27 | |||
28 | $this->container->httpAccess = $this->createMock(HttpAccess::class); | ||
29 | $this->controller = new ManageShaareController($this->container); | ||
30 | } | ||
31 | |||
32 | /** | ||
33 | * Test pin bookmark - with valid input | ||
34 | * | ||
35 | * @dataProvider initialStickyValuesProvider() | ||
36 | */ | ||
37 | public function testPinBookmarkIsStickyNull(?bool $sticky, bool $expectedValue): void | ||
38 | { | ||
39 | $id = 123; | ||
40 | |||
41 | $request = $this->createMock(Request::class); | ||
42 | $response = new Response(); | ||
43 | |||
44 | $bookmark = (new Bookmark()) | ||
45 | ->setId(123) | ||
46 | ->setUrl('http://domain.tld') | ||
47 | ->setTitle('Title 123') | ||
48 | ->setSticky($sticky) | ||
49 | ; | ||
50 | |||
51 | $this->container->bookmarkService->expects(static::once())->method('get')->with(123)->willReturn($bookmark); | ||
52 | $this->container->bookmarkService->expects(static::once())->method('set')->with($bookmark, true); | ||
53 | |||
54 | // Make sure that PluginManager hook is triggered | ||
55 | $this->container->pluginManager | ||
56 | ->expects(static::once()) | ||
57 | ->method('executeHooks') | ||
58 | ->with('save_link') | ||
59 | ; | ||
60 | |||
61 | $result = $this->controller->pinBookmark($request, $response, ['id' => (string) $id]); | ||
62 | |||
63 | static::assertSame(302, $result->getStatusCode()); | ||
64 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
65 | |||
66 | static::assertSame($expectedValue, $bookmark->isSticky()); | ||
67 | } | ||
68 | |||
69 | public function initialStickyValuesProvider(): array | ||
70 | { | ||
71 | // [initialStickyState, isStickyAfterPin] | ||
72 | return [[null, true], [false, true], [true, false]]; | ||
73 | } | ||
74 | |||
75 | /** | ||
76 | * Test pin bookmark - invalid bookmark ID | ||
77 | */ | ||
78 | public function testDisplayEditFormInvalidId(): void | ||
79 | { | ||
80 | $id = 'invalid'; | ||
81 | |||
82 | $request = $this->createMock(Request::class); | ||
83 | $response = new Response(); | ||
84 | |||
85 | $this->container->sessionManager | ||
86 | ->expects(static::once()) | ||
87 | ->method('setSessionParameter') | ||
88 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier invalid could not be found.']) | ||
89 | ; | ||
90 | |||
91 | $result = $this->controller->pinBookmark($request, $response, ['id' => $id]); | ||
92 | |||
93 | static::assertSame(302, $result->getStatusCode()); | ||
94 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
95 | } | ||
96 | |||
97 | /** | ||
98 | * Test pin bookmark - Bookmark ID not provided | ||
99 | */ | ||
100 | public function testDisplayEditFormIdNotProvided(): void | ||
101 | { | ||
102 | $request = $this->createMock(Request::class); | ||
103 | $response = new Response(); | ||
104 | |||
105 | $this->container->sessionManager | ||
106 | ->expects(static::once()) | ||
107 | ->method('setSessionParameter') | ||
108 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier could not be found.']) | ||
109 | ; | ||
110 | |||
111 | $result = $this->controller->pinBookmark($request, $response, []); | ||
112 | |||
113 | static::assertSame(302, $result->getStatusCode()); | ||
114 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
115 | } | ||
116 | |||
117 | /** | ||
118 | * Test pin bookmark - bookmark not found | ||
119 | */ | ||
120 | public function testDisplayEditFormBookmarkNotFound(): void | ||
121 | { | ||
122 | $id = 123; | ||
123 | |||
124 | $request = $this->createMock(Request::class); | ||
125 | $response = new Response(); | ||
126 | |||
127 | $this->container->bookmarkService | ||
128 | ->expects(static::once()) | ||
129 | ->method('get') | ||
130 | ->with($id) | ||
131 | ->willThrowException(new BookmarkNotFoundException()) | ||
132 | ; | ||
133 | |||
134 | $this->container->sessionManager | ||
135 | ->expects(static::once()) | ||
136 | ->method('setSessionParameter') | ||
137 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['Bookmark with identifier 123 could not be found.']) | ||
138 | ; | ||
139 | |||
140 | $result = $this->controller->pinBookmark($request, $response, ['id' => (string) $id]); | ||
141 | |||
142 | static::assertSame(302, $result->getStatusCode()); | ||
143 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
144 | } | ||
145 | } | ||
diff --git a/tests/front/controller/admin/ManageShaareControllerTest/SaveBookmarkTest.php b/tests/front/controller/admin/ManageShaareControllerTest/SaveBookmarkTest.php new file mode 100644 index 00000000..f7a68226 --- /dev/null +++ b/tests/front/controller/admin/ManageShaareControllerTest/SaveBookmarkTest.php | |||
@@ -0,0 +1,308 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin\ManageShaareControllerTest; | ||
6 | |||
7 | use Shaarli\Bookmark\Bookmark; | ||
8 | use Shaarli\Config\ConfigManager; | ||
9 | use Shaarli\Front\Controller\Admin\FrontAdminControllerMockHelper; | ||
10 | use Shaarli\Front\Controller\Admin\ManageShaareController; | ||
11 | use Shaarli\Front\Exception\WrongTokenException; | ||
12 | use Shaarli\Http\HttpAccess; | ||
13 | use Shaarli\Security\SessionManager; | ||
14 | use Shaarli\TestCase; | ||
15 | use Shaarli\Thumbnailer; | ||
16 | use Slim\Http\Request; | ||
17 | use Slim\Http\Response; | ||
18 | |||
19 | class SaveBookmarkTest extends TestCase | ||
20 | { | ||
21 | use FrontAdminControllerMockHelper; | ||
22 | |||
23 | /** @var ManageShaareController */ | ||
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 ManageShaareController($this->container); | ||
32 | } | ||
33 | |||
34 | /** | ||
35 | * Test save a new bookmark | ||
36 | */ | ||
37 | public function testSaveBookmark(): void | ||
38 | { | ||
39 | $id = 21; | ||
40 | $parameters = [ | ||
41 | 'lf_url' => 'http://url.tld/other?part=3#hash', | ||
42 | 'lf_title' => 'Provided Title', | ||
43 | 'lf_description' => 'Provided description.', | ||
44 | 'lf_tags' => 'abc def', | ||
45 | 'lf_private' => '1', | ||
46 | 'returnurl' => 'http://shaarli/subfolder/admin/add-shaare' | ||
47 | ]; | ||
48 | |||
49 | $request = $this->createMock(Request::class); | ||
50 | $request | ||
51 | ->method('getParam') | ||
52 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
53 | return $parameters[$key] ?? null; | ||
54 | }) | ||
55 | ; | ||
56 | $response = new Response(); | ||
57 | |||
58 | $checkBookmark = function (Bookmark $bookmark) use ($parameters) { | ||
59 | static::assertSame($parameters['lf_url'], $bookmark->getUrl()); | ||
60 | static::assertSame($parameters['lf_title'], $bookmark->getTitle()); | ||
61 | static::assertSame($parameters['lf_description'], $bookmark->getDescription()); | ||
62 | static::assertSame($parameters['lf_tags'], $bookmark->getTagsString()); | ||
63 | static::assertTrue($bookmark->isPrivate()); | ||
64 | }; | ||
65 | |||
66 | $this->container->bookmarkService | ||
67 | ->expects(static::once()) | ||
68 | ->method('addOrSet') | ||
69 | ->willReturnCallback(function (Bookmark $bookmark, bool $save) use ($checkBookmark, $id): void { | ||
70 | static::assertFalse($save); | ||
71 | |||
72 | $checkBookmark($bookmark); | ||
73 | |||
74 | $bookmark->setId($id); | ||
75 | }) | ||
76 | ; | ||
77 | $this->container->bookmarkService | ||
78 | ->expects(static::once()) | ||
79 | ->method('set') | ||
80 | ->willReturnCallback(function (Bookmark $bookmark, bool $save) use ($checkBookmark, $id): void { | ||
81 | static::assertTrue($save); | ||
82 | |||
83 | $checkBookmark($bookmark); | ||
84 | |||
85 | static::assertSame($id, $bookmark->getId()); | ||
86 | }) | ||
87 | ; | ||
88 | |||
89 | // Make sure that PluginManager hook is triggered | ||
90 | $this->container->pluginManager | ||
91 | ->expects(static::atLeastOnce()) | ||
92 | ->method('executeHooks') | ||
93 | ->withConsecutive(['save_link']) | ||
94 | ->willReturnCallback(function (string $hook, array $data) use ($parameters, $id): array { | ||
95 | if ('save_link' === $hook) { | ||
96 | static::assertSame($id, $data['id']); | ||
97 | static::assertSame($parameters['lf_url'], $data['url']); | ||
98 | static::assertSame($parameters['lf_title'], $data['title']); | ||
99 | static::assertSame($parameters['lf_description'], $data['description']); | ||
100 | static::assertSame($parameters['lf_tags'], $data['tags']); | ||
101 | static::assertTrue($data['private']); | ||
102 | } | ||
103 | |||
104 | return $data; | ||
105 | }) | ||
106 | ; | ||
107 | |||
108 | $result = $this->controller->save($request, $response); | ||
109 | |||
110 | static::assertSame(302, $result->getStatusCode()); | ||
111 | static::assertRegExp('@/subfolder/#[\w\-]{6}@', $result->getHeader('location')[0]); | ||
112 | } | ||
113 | |||
114 | |||
115 | /** | ||
116 | * Test save an existing bookmark | ||
117 | */ | ||
118 | public function testSaveExistingBookmark(): void | ||
119 | { | ||
120 | $id = 21; | ||
121 | $parameters = [ | ||
122 | 'lf_id' => (string) $id, | ||
123 | 'lf_url' => 'http://url.tld/other?part=3#hash', | ||
124 | 'lf_title' => 'Provided Title', | ||
125 | 'lf_description' => 'Provided description.', | ||
126 | 'lf_tags' => 'abc def', | ||
127 | 'lf_private' => '1', | ||
128 | 'returnurl' => 'http://shaarli/subfolder/?page=2' | ||
129 | ]; | ||
130 | |||
131 | $request = $this->createMock(Request::class); | ||
132 | $request | ||
133 | ->method('getParam') | ||
134 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
135 | return $parameters[$key] ?? null; | ||
136 | }) | ||
137 | ; | ||
138 | $response = new Response(); | ||
139 | |||
140 | $checkBookmark = function (Bookmark $bookmark) use ($parameters, $id) { | ||
141 | static::assertSame($id, $bookmark->getId()); | ||
142 | static::assertSame($parameters['lf_url'], $bookmark->getUrl()); | ||
143 | static::assertSame($parameters['lf_title'], $bookmark->getTitle()); | ||
144 | static::assertSame($parameters['lf_description'], $bookmark->getDescription()); | ||
145 | static::assertSame($parameters['lf_tags'], $bookmark->getTagsString()); | ||
146 | static::assertTrue($bookmark->isPrivate()); | ||
147 | }; | ||
148 | |||
149 | $this->container->bookmarkService->expects(static::atLeastOnce())->method('exists')->willReturn(true); | ||
150 | $this->container->bookmarkService | ||
151 | ->expects(static::once()) | ||
152 | ->method('get') | ||
153 | ->willReturn((new Bookmark())->setId($id)->setUrl('http://other.url')) | ||
154 | ; | ||
155 | $this->container->bookmarkService | ||
156 | ->expects(static::once()) | ||
157 | ->method('addOrSet') | ||
158 | ->willReturnCallback(function (Bookmark $bookmark, bool $save) use ($checkBookmark, $id): void { | ||
159 | static::assertFalse($save); | ||
160 | |||
161 | $checkBookmark($bookmark); | ||
162 | }) | ||
163 | ; | ||
164 | $this->container->bookmarkService | ||
165 | ->expects(static::once()) | ||
166 | ->method('set') | ||
167 | ->willReturnCallback(function (Bookmark $bookmark, bool $save) use ($checkBookmark, $id): void { | ||
168 | static::assertTrue($save); | ||
169 | |||
170 | $checkBookmark($bookmark); | ||
171 | |||
172 | static::assertSame($id, $bookmark->getId()); | ||
173 | }) | ||
174 | ; | ||
175 | |||
176 | // Make sure that PluginManager hook is triggered | ||
177 | $this->container->pluginManager | ||
178 | ->expects(static::atLeastOnce()) | ||
179 | ->method('executeHooks') | ||
180 | ->withConsecutive(['save_link']) | ||
181 | ->willReturnCallback(function (string $hook, array $data) use ($parameters, $id): array { | ||
182 | if ('save_link' === $hook) { | ||
183 | static::assertSame($id, $data['id']); | ||
184 | static::assertSame($parameters['lf_url'], $data['url']); | ||
185 | static::assertSame($parameters['lf_title'], $data['title']); | ||
186 | static::assertSame($parameters['lf_description'], $data['description']); | ||
187 | static::assertSame($parameters['lf_tags'], $data['tags']); | ||
188 | static::assertTrue($data['private']); | ||
189 | } | ||
190 | |||
191 | return $data; | ||
192 | }) | ||
193 | ; | ||
194 | |||
195 | $result = $this->controller->save($request, $response); | ||
196 | |||
197 | static::assertSame(302, $result->getStatusCode()); | ||
198 | static::assertRegExp('@/subfolder/\?page=2#[\w\-]{6}@', $result->getHeader('location')[0]); | ||
199 | } | ||
200 | |||
201 | /** | ||
202 | * Test save a bookmark - try to retrieve the thumbnail | ||
203 | */ | ||
204 | public function testSaveBookmarkWithThumbnail(): void | ||
205 | { | ||
206 | $parameters = ['lf_url' => 'http://url.tld/other?part=3#hash']; | ||
207 | |||
208 | $request = $this->createMock(Request::class); | ||
209 | $request | ||
210 | ->method('getParam') | ||
211 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
212 | return $parameters[$key] ?? null; | ||
213 | }) | ||
214 | ; | ||
215 | $response = new Response(); | ||
216 | |||
217 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
218 | $this->container->conf->method('get')->willReturnCallback(function (string $key, $default) { | ||
219 | return $key === 'thumbnails.mode' ? Thumbnailer::MODE_ALL : $default; | ||
220 | }); | ||
221 | |||
222 | $this->container->thumbnailer = $this->createMock(Thumbnailer::class); | ||
223 | $this->container->thumbnailer | ||
224 | ->expects(static::once()) | ||
225 | ->method('get') | ||
226 | ->with($parameters['lf_url']) | ||
227 | ->willReturn($thumb = 'http://thumb.url') | ||
228 | ; | ||
229 | |||
230 | $this->container->bookmarkService | ||
231 | ->expects(static::once()) | ||
232 | ->method('addOrSet') | ||
233 | ->willReturnCallback(function (Bookmark $bookmark, bool $save) use ($thumb): void { | ||
234 | static::assertSame($thumb, $bookmark->getThumbnail()); | ||
235 | }) | ||
236 | ; | ||
237 | |||
238 | $result = $this->controller->save($request, $response); | ||
239 | |||
240 | static::assertSame(302, $result->getStatusCode()); | ||
241 | } | ||
242 | |||
243 | /** | ||
244 | * Test save a bookmark - with ID #0 | ||
245 | */ | ||
246 | public function testSaveBookmarkWithIdZero(): void | ||
247 | { | ||
248 | $parameters = ['lf_id' => '0']; | ||
249 | |||
250 | $request = $this->createMock(Request::class); | ||
251 | $request | ||
252 | ->method('getParam') | ||
253 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
254 | return $parameters[$key] ?? null; | ||
255 | }) | ||
256 | ; | ||
257 | $response = new Response(); | ||
258 | |||
259 | $this->container->bookmarkService->expects(static::once())->method('exists')->with(0)->willReturn(true); | ||
260 | $this->container->bookmarkService->expects(static::once())->method('get')->with(0)->willReturn(new Bookmark()); | ||
261 | |||
262 | $result = $this->controller->save($request, $response); | ||
263 | |||
264 | static::assertSame(302, $result->getStatusCode()); | ||
265 | } | ||
266 | |||
267 | /** | ||
268 | * Change the password with a wrong existing password | ||
269 | */ | ||
270 | public function testSaveBookmarkFromBookmarklet(): void | ||
271 | { | ||
272 | $parameters = ['source' => 'bookmarklet']; | ||
273 | |||
274 | $request = $this->createMock(Request::class); | ||
275 | $request | ||
276 | ->method('getParam') | ||
277 | ->willReturnCallback(function (string $key) use ($parameters): ?string { | ||
278 | return $parameters[$key] ?? null; | ||
279 | }) | ||
280 | ; | ||
281 | $response = new Response(); | ||
282 | |||
283 | $result = $this->controller->save($request, $response); | ||
284 | |||
285 | static::assertSame(200, $result->getStatusCode()); | ||
286 | static::assertSame('<script>self.close();</script>', (string) $result->getBody()); | ||
287 | } | ||
288 | |||
289 | /** | ||
290 | * Change the password with a wrong existing password | ||
291 | */ | ||
292 | public function testSaveBookmarkWrongToken(): void | ||
293 | { | ||
294 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
295 | $this->container->sessionManager->method('checkToken')->willReturn(false); | ||
296 | |||
297 | $this->container->bookmarkService->expects(static::never())->method('addOrSet'); | ||
298 | $this->container->bookmarkService->expects(static::never())->method('set'); | ||
299 | |||
300 | $request = $this->createMock(Request::class); | ||
301 | $response = new Response(); | ||
302 | |||
303 | $this->expectException(WrongTokenException::class); | ||
304 | |||
305 | $this->controller->save($request, $response); | ||
306 | } | ||
307 | |||
308 | } | ||
diff --git a/tests/front/controller/admin/ManageTagControllerTest.php b/tests/front/controller/admin/ManageTagControllerTest.php new file mode 100644 index 00000000..8a0ff7a9 --- /dev/null +++ b/tests/front/controller/admin/ManageTagControllerTest.php | |||
@@ -0,0 +1,272 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Bookmark\Bookmark; | ||
8 | use Shaarli\Bookmark\BookmarkFilter; | ||
9 | use Shaarli\Front\Exception\WrongTokenException; | ||
10 | use Shaarli\Security\SessionManager; | ||
11 | use Shaarli\TestCase; | ||
12 | use Slim\Http\Request; | ||
13 | use Slim\Http\Response; | ||
14 | |||
15 | class ManageTagControllerTest extends TestCase | ||
16 | { | ||
17 | use FrontAdminControllerMockHelper; | ||
18 | |||
19 | /** @var ManageTagController */ | ||
20 | protected $controller; | ||
21 | |||
22 | public function setUp(): void | ||
23 | { | ||
24 | $this->createContainer(); | ||
25 | |||
26 | $this->controller = new ManageTagController($this->container); | ||
27 | } | ||
28 | |||
29 | /** | ||
30 | * Test displaying manage tag page | ||
31 | */ | ||
32 | public function testIndex(): void | ||
33 | { | ||
34 | $assignedVariables = []; | ||
35 | $this->assignTemplateVars($assignedVariables); | ||
36 | |||
37 | $request = $this->createMock(Request::class); | ||
38 | $request->method('getParam')->with('fromtag')->willReturn('fromtag'); | ||
39 | $response = new Response(); | ||
40 | |||
41 | $result = $this->controller->index($request, $response); | ||
42 | |||
43 | static::assertSame(200, $result->getStatusCode()); | ||
44 | static::assertSame('changetag', (string) $result->getBody()); | ||
45 | |||
46 | static::assertSame('fromtag', $assignedVariables['fromtag']); | ||
47 | static::assertSame('Manage tags - Shaarli', $assignedVariables['pagetitle']); | ||
48 | } | ||
49 | |||
50 | /** | ||
51 | * Test posting a tag update - rename tag - valid info provided. | ||
52 | */ | ||
53 | public function testSaveRenameTagValid(): void | ||
54 | { | ||
55 | $session = []; | ||
56 | $this->assignSessionVars($session); | ||
57 | |||
58 | $requestParameters = [ | ||
59 | 'renametag' => 'rename', | ||
60 | 'fromtag' => 'old-tag', | ||
61 | 'totag' => 'new-tag', | ||
62 | ]; | ||
63 | $request = $this->createMock(Request::class); | ||
64 | $request | ||
65 | ->expects(static::atLeastOnce()) | ||
66 | ->method('getParam') | ||
67 | ->willReturnCallback(function (string $key) use ($requestParameters): ?string { | ||
68 | return $requestParameters[$key] ?? null; | ||
69 | }) | ||
70 | ; | ||
71 | $response = new Response(); | ||
72 | |||
73 | $bookmark1 = $this->createMock(Bookmark::class); | ||
74 | $bookmark2 = $this->createMock(Bookmark::class); | ||
75 | $this->container->bookmarkService | ||
76 | ->expects(static::once()) | ||
77 | ->method('search') | ||
78 | ->with(['searchtags' => 'old-tag'], BookmarkFilter::$ALL, true) | ||
79 | ->willReturnCallback(function () use ($bookmark1, $bookmark2): array { | ||
80 | $bookmark1->expects(static::once())->method('renameTag')->with('old-tag', 'new-tag'); | ||
81 | $bookmark2->expects(static::once())->method('renameTag')->with('old-tag', 'new-tag'); | ||
82 | |||
83 | return [$bookmark1, $bookmark2]; | ||
84 | }) | ||
85 | ; | ||
86 | $this->container->bookmarkService | ||
87 | ->expects(static::exactly(2)) | ||
88 | ->method('set') | ||
89 | ->withConsecutive([$bookmark1, false], [$bookmark2, false]) | ||
90 | ; | ||
91 | $this->container->bookmarkService->expects(static::once())->method('save'); | ||
92 | |||
93 | $result = $this->controller->save($request, $response); | ||
94 | |||
95 | static::assertSame(302, $result->getStatusCode()); | ||
96 | static::assertSame(['/subfolder/?searchtags=new-tag'], $result->getHeader('location')); | ||
97 | |||
98 | static::assertArrayNotHasKey(SessionManager::KEY_ERROR_MESSAGES, $session); | ||
99 | static::assertArrayNotHasKey(SessionManager::KEY_WARNING_MESSAGES, $session); | ||
100 | static::assertArrayHasKey(SessionManager::KEY_SUCCESS_MESSAGES, $session); | ||
101 | static::assertSame(['The tag was renamed in 2 bookmarks.'], $session[SessionManager::KEY_SUCCESS_MESSAGES]); | ||
102 | } | ||
103 | |||
104 | /** | ||
105 | * Test posting a tag update - delete tag - valid info provided. | ||
106 | */ | ||
107 | public function testSaveDeleteTagValid(): void | ||
108 | { | ||
109 | $session = []; | ||
110 | $this->assignSessionVars($session); | ||
111 | |||
112 | $requestParameters = [ | ||
113 | 'deletetag' => 'delete', | ||
114 | 'fromtag' => 'old-tag', | ||
115 | ]; | ||
116 | $request = $this->createMock(Request::class); | ||
117 | $request | ||
118 | ->expects(static::atLeastOnce()) | ||
119 | ->method('getParam') | ||
120 | ->willReturnCallback(function (string $key) use ($requestParameters): ?string { | ||
121 | return $requestParameters[$key] ?? null; | ||
122 | }) | ||
123 | ; | ||
124 | $response = new Response(); | ||
125 | |||
126 | $bookmark1 = $this->createMock(Bookmark::class); | ||
127 | $bookmark2 = $this->createMock(Bookmark::class); | ||
128 | $this->container->bookmarkService | ||
129 | ->expects(static::once()) | ||
130 | ->method('search') | ||
131 | ->with(['searchtags' => 'old-tag'], BookmarkFilter::$ALL, true) | ||
132 | ->willReturnCallback(function () use ($bookmark1, $bookmark2): array { | ||
133 | $bookmark1->expects(static::once())->method('deleteTag')->with('old-tag'); | ||
134 | $bookmark2->expects(static::once())->method('deleteTag')->with('old-tag'); | ||
135 | |||
136 | return [$bookmark1, $bookmark2]; | ||
137 | }) | ||
138 | ; | ||
139 | $this->container->bookmarkService | ||
140 | ->expects(static::exactly(2)) | ||
141 | ->method('set') | ||
142 | ->withConsecutive([$bookmark1, false], [$bookmark2, false]) | ||
143 | ; | ||
144 | $this->container->bookmarkService->expects(static::once())->method('save'); | ||
145 | |||
146 | $result = $this->controller->save($request, $response); | ||
147 | |||
148 | static::assertSame(302, $result->getStatusCode()); | ||
149 | static::assertSame(['/subfolder/admin/tags'], $result->getHeader('location')); | ||
150 | |||
151 | static::assertArrayNotHasKey(SessionManager::KEY_ERROR_MESSAGES, $session); | ||
152 | static::assertArrayNotHasKey(SessionManager::KEY_WARNING_MESSAGES, $session); | ||
153 | static::assertArrayHasKey(SessionManager::KEY_SUCCESS_MESSAGES, $session); | ||
154 | static::assertSame(['The tag was removed from 2 bookmarks.'], $session[SessionManager::KEY_SUCCESS_MESSAGES]); | ||
155 | } | ||
156 | |||
157 | /** | ||
158 | * Test posting a tag update - wrong token. | ||
159 | */ | ||
160 | public function testSaveWrongToken(): void | ||
161 | { | ||
162 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
163 | $this->container->sessionManager->method('checkToken')->willReturn(false); | ||
164 | |||
165 | $this->container->conf->expects(static::never())->method('set'); | ||
166 | $this->container->conf->expects(static::never())->method('write'); | ||
167 | |||
168 | $request = $this->createMock(Request::class); | ||
169 | $response = new Response(); | ||
170 | |||
171 | $this->expectException(WrongTokenException::class); | ||
172 | |||
173 | $this->controller->save($request, $response); | ||
174 | } | ||
175 | |||
176 | /** | ||
177 | * Test posting a tag update - rename tag - missing "FROM" tag. | ||
178 | */ | ||
179 | public function testSaveRenameTagMissingFrom(): void | ||
180 | { | ||
181 | $session = []; | ||
182 | $this->assignSessionVars($session); | ||
183 | |||
184 | $requestParameters = [ | ||
185 | 'renametag' => 'rename', | ||
186 | ]; | ||
187 | $request = $this->createMock(Request::class); | ||
188 | $request | ||
189 | ->expects(static::atLeastOnce()) | ||
190 | ->method('getParam') | ||
191 | ->willReturnCallback(function (string $key) use ($requestParameters): ?string { | ||
192 | return $requestParameters[$key] ?? null; | ||
193 | }) | ||
194 | ; | ||
195 | $response = new Response(); | ||
196 | |||
197 | $result = $this->controller->save($request, $response); | ||
198 | |||
199 | static::assertSame(302, $result->getStatusCode()); | ||
200 | static::assertSame(['/subfolder/admin/tags'], $result->getHeader('location')); | ||
201 | |||
202 | static::assertArrayNotHasKey(SessionManager::KEY_ERROR_MESSAGES, $session); | ||
203 | static::assertArrayHasKey(SessionManager::KEY_WARNING_MESSAGES, $session); | ||
204 | static::assertArrayNotHasKey(SessionManager::KEY_SUCCESS_MESSAGES, $session); | ||
205 | static::assertSame(['Invalid tags provided.'], $session[SessionManager::KEY_WARNING_MESSAGES]); | ||
206 | } | ||
207 | |||
208 | /** | ||
209 | * Test posting a tag update - delete tag - missing "FROM" tag. | ||
210 | */ | ||
211 | public function testSaveDeleteTagMissingFrom(): void | ||
212 | { | ||
213 | $session = []; | ||
214 | $this->assignSessionVars($session); | ||
215 | |||
216 | $requestParameters = [ | ||
217 | 'deletetag' => 'delete', | ||
218 | ]; | ||
219 | $request = $this->createMock(Request::class); | ||
220 | $request | ||
221 | ->expects(static::atLeastOnce()) | ||
222 | ->method('getParam') | ||
223 | ->willReturnCallback(function (string $key) use ($requestParameters): ?string { | ||
224 | return $requestParameters[$key] ?? null; | ||
225 | }) | ||
226 | ; | ||
227 | $response = new Response(); | ||
228 | |||
229 | $result = $this->controller->save($request, $response); | ||
230 | |||
231 | static::assertSame(302, $result->getStatusCode()); | ||
232 | static::assertSame(['/subfolder/admin/tags'], $result->getHeader('location')); | ||
233 | |||
234 | static::assertArrayNotHasKey(SessionManager::KEY_ERROR_MESSAGES, $session); | ||
235 | static::assertArrayHasKey(SessionManager::KEY_WARNING_MESSAGES, $session); | ||
236 | static::assertArrayNotHasKey(SessionManager::KEY_SUCCESS_MESSAGES, $session); | ||
237 | static::assertSame(['Invalid tags provided.'], $session[SessionManager::KEY_WARNING_MESSAGES]); | ||
238 | } | ||
239 | |||
240 | /** | ||
241 | * Test posting a tag update - rename tag - missing "TO" tag. | ||
242 | */ | ||
243 | public function testSaveRenameTagMissingTo(): void | ||
244 | { | ||
245 | $session = []; | ||
246 | $this->assignSessionVars($session); | ||
247 | |||
248 | $requestParameters = [ | ||
249 | 'renametag' => 'rename', | ||
250 | 'fromtag' => 'old-tag' | ||
251 | ]; | ||
252 | $request = $this->createMock(Request::class); | ||
253 | $request | ||
254 | ->expects(static::atLeastOnce()) | ||
255 | ->method('getParam') | ||
256 | ->willReturnCallback(function (string $key) use ($requestParameters): ?string { | ||
257 | return $requestParameters[$key] ?? null; | ||
258 | }) | ||
259 | ; | ||
260 | $response = new Response(); | ||
261 | |||
262 | $result = $this->controller->save($request, $response); | ||
263 | |||
264 | static::assertSame(302, $result->getStatusCode()); | ||
265 | static::assertSame(['/subfolder/admin/tags'], $result->getHeader('location')); | ||
266 | |||
267 | static::assertArrayNotHasKey(SessionManager::KEY_ERROR_MESSAGES, $session); | ||
268 | static::assertArrayHasKey(SessionManager::KEY_WARNING_MESSAGES, $session); | ||
269 | static::assertArrayNotHasKey(SessionManager::KEY_SUCCESS_MESSAGES, $session); | ||
270 | static::assertSame(['Invalid tags provided.'], $session[SessionManager::KEY_WARNING_MESSAGES]); | ||
271 | } | ||
272 | } | ||
diff --git a/tests/front/controller/admin/PasswordControllerTest.php b/tests/front/controller/admin/PasswordControllerTest.php new file mode 100644 index 00000000..58f47b49 --- /dev/null +++ b/tests/front/controller/admin/PasswordControllerTest.php | |||
@@ -0,0 +1,203 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Config\ConfigManager; | ||
8 | use Shaarli\Front\Exception\OpenShaarliPasswordException; | ||
9 | use Shaarli\Front\Exception\WrongTokenException; | ||
10 | use Shaarli\Security\SessionManager; | ||
11 | use Shaarli\TestCase; | ||
12 | use Slim\Http\Request; | ||
13 | use Slim\Http\Response; | ||
14 | |||
15 | class PasswordControllerTest extends TestCase | ||
16 | { | ||
17 | use FrontAdminControllerMockHelper; | ||
18 | |||
19 | /** @var PasswordController */ | ||
20 | protected $controller; | ||
21 | |||
22 | /** @var mixed[] Variables assigned to the template */ | ||
23 | protected $assignedVariables = []; | ||
24 | |||
25 | public function setUp(): void | ||
26 | { | ||
27 | $this->createContainer(); | ||
28 | $this->assignTemplateVars($this->assignedVariables); | ||
29 | |||
30 | $this->controller = new PasswordController($this->container); | ||
31 | } | ||
32 | |||
33 | /** | ||
34 | * Test displaying the change password page. | ||
35 | */ | ||
36 | public function testGetPage(): void | ||
37 | { | ||
38 | $request = $this->createMock(Request::class); | ||
39 | $response = new Response(); | ||
40 | |||
41 | $result = $this->controller->index($request, $response); | ||
42 | |||
43 | static::assertSame(200, $result->getStatusCode()); | ||
44 | static::assertSame('changepassword', (string) $result->getBody()); | ||
45 | static::assertSame('Change password - Shaarli', $this->assignedVariables['pagetitle']); | ||
46 | } | ||
47 | |||
48 | /** | ||
49 | * Change the password with valid parameters | ||
50 | */ | ||
51 | public function testPostNewPasswordDefault(): void | ||
52 | { | ||
53 | $request = $this->createMock(Request::class); | ||
54 | $request->method('getParam')->willReturnCallback(function (string $key): string { | ||
55 | if ('oldpassword' === $key) { | ||
56 | return 'old'; | ||
57 | } | ||
58 | if ('setpassword' === $key) { | ||
59 | return 'new'; | ||
60 | } | ||
61 | |||
62 | return $key; | ||
63 | }); | ||
64 | $response = new Response(); | ||
65 | |||
66 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
67 | $this->container->conf->method('get')->willReturnCallback(function (string $key, $default) { | ||
68 | if ('credentials.hash' === $key) { | ||
69 | return sha1('old' . 'credentials.login' . 'credentials.salt'); | ||
70 | } | ||
71 | |||
72 | return strpos($key, 'credentials') !== false ? $key : $default; | ||
73 | }); | ||
74 | $this->container->conf->expects(static::once())->method('write')->with(true); | ||
75 | |||
76 | $this->container->conf | ||
77 | ->method('set') | ||
78 | ->willReturnCallback(function (string $key, string $value) { | ||
79 | if ('credentials.hash' === $key) { | ||
80 | static::assertSame(sha1('new' . 'credentials.login' . 'credentials.salt'), $value); | ||
81 | } | ||
82 | }) | ||
83 | ; | ||
84 | |||
85 | $result = $this->controller->change($request, $response); | ||
86 | |||
87 | static::assertSame(200, $result->getStatusCode()); | ||
88 | static::assertSame('changepassword', (string) $result->getBody()); | ||
89 | static::assertSame('Change password - Shaarli', $this->assignedVariables['pagetitle']); | ||
90 | } | ||
91 | |||
92 | /** | ||
93 | * Change the password with a wrong existing password | ||
94 | */ | ||
95 | public function testPostNewPasswordWrongOldPassword(): void | ||
96 | { | ||
97 | $request = $this->createMock(Request::class); | ||
98 | $request->method('getParam')->willReturnCallback(function (string $key): string { | ||
99 | if ('oldpassword' === $key) { | ||
100 | return 'wrong'; | ||
101 | } | ||
102 | if ('setpassword' === $key) { | ||
103 | return 'new'; | ||
104 | } | ||
105 | |||
106 | return $key; | ||
107 | }); | ||
108 | $response = new Response(); | ||
109 | |||
110 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
111 | $this->container->conf->method('get')->willReturnCallback(function (string $key, $default) { | ||
112 | if ('credentials.hash' === $key) { | ||
113 | return sha1('old' . 'credentials.login' . 'credentials.salt'); | ||
114 | } | ||
115 | |||
116 | return strpos($key, 'credentials') !== false ? $key : $default; | ||
117 | }); | ||
118 | |||
119 | $this->container->conf->expects(static::never())->method('set'); | ||
120 | $this->container->conf->expects(static::never())->method('write'); | ||
121 | |||
122 | $this->container->sessionManager | ||
123 | ->expects(static::once()) | ||
124 | ->method('setSessionParameter') | ||
125 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['The old password is not correct.']) | ||
126 | ; | ||
127 | |||
128 | $result = $this->controller->change($request, $response); | ||
129 | |||
130 | static::assertSame(400, $result->getStatusCode()); | ||
131 | static::assertSame('changepassword', (string) $result->getBody()); | ||
132 | static::assertSame('Change password - Shaarli', $this->assignedVariables['pagetitle']); | ||
133 | } | ||
134 | |||
135 | /** | ||
136 | * Change the password with a wrong existing password | ||
137 | */ | ||
138 | public function testPostNewPasswordWrongToken(): void | ||
139 | { | ||
140 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
141 | $this->container->sessionManager->method('checkToken')->willReturn(false); | ||
142 | |||
143 | $this->container->conf->expects(static::never())->method('set'); | ||
144 | $this->container->conf->expects(static::never())->method('write'); | ||
145 | |||
146 | $request = $this->createMock(Request::class); | ||
147 | $response = new Response(); | ||
148 | |||
149 | $this->expectException(WrongTokenException::class); | ||
150 | |||
151 | $this->controller->change($request, $response); | ||
152 | } | ||
153 | |||
154 | /** | ||
155 | * Change the password with an empty new password | ||
156 | */ | ||
157 | public function testPostNewEmptyPassword(): void | ||
158 | { | ||
159 | $this->container->sessionManager | ||
160 | ->expects(static::once()) | ||
161 | ->method('setSessionParameter') | ||
162 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['You must provide the current and new password to change it.']) | ||
163 | ; | ||
164 | |||
165 | $this->container->conf->expects(static::never())->method('set'); | ||
166 | $this->container->conf->expects(static::never())->method('write'); | ||
167 | |||
168 | $request = $this->createMock(Request::class); | ||
169 | $request->method('getParam')->willReturnCallback(function (string $key): string { | ||
170 | if ('oldpassword' === $key) { | ||
171 | return 'old'; | ||
172 | } | ||
173 | if ('setpassword' === $key) { | ||
174 | return ''; | ||
175 | } | ||
176 | |||
177 | return $key; | ||
178 | }); | ||
179 | $response = new Response(); | ||
180 | |||
181 | $result = $this->controller->change($request, $response); | ||
182 | |||
183 | static::assertSame(400, $result->getStatusCode()); | ||
184 | static::assertSame('changepassword', (string) $result->getBody()); | ||
185 | static::assertSame('Change password - Shaarli', $this->assignedVariables['pagetitle']); | ||
186 | } | ||
187 | |||
188 | /** | ||
189 | * Change the password on an open shaarli | ||
190 | */ | ||
191 | public function testPostNewPasswordOnOpenShaarli(): void | ||
192 | { | ||
193 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
194 | $this->container->conf->method('get')->with('security.open_shaarli')->willReturn(true); | ||
195 | |||
196 | $request = $this->createMock(Request::class); | ||
197 | $response = new Response(); | ||
198 | |||
199 | $this->expectException(OpenShaarliPasswordException::class); | ||
200 | |||
201 | $this->controller->change($request, $response); | ||
202 | } | ||
203 | } | ||
diff --git a/tests/front/controller/admin/PluginsControllerTest.php b/tests/front/controller/admin/PluginsControllerTest.php new file mode 100644 index 00000000..974d614d --- /dev/null +++ b/tests/front/controller/admin/PluginsControllerTest.php | |||
@@ -0,0 +1,205 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Config\ConfigManager; | ||
8 | use Shaarli\Front\Exception\WrongTokenException; | ||
9 | use Shaarli\Plugin\PluginManager; | ||
10 | use Shaarli\Security\SessionManager; | ||
11 | use Shaarli\TestCase; | ||
12 | use Slim\Http\Request; | ||
13 | use Slim\Http\Response; | ||
14 | |||
15 | class PluginsControllerTest extends TestCase | ||
16 | { | ||
17 | use FrontAdminControllerMockHelper; | ||
18 | |||
19 | const PLUGIN_NAMES = ['plugin1', 'plugin2', 'plugin3', 'plugin4']; | ||
20 | |||
21 | /** @var PluginsController */ | ||
22 | protected $controller; | ||
23 | |||
24 | public function setUp(): void | ||
25 | { | ||
26 | $this->createContainer(); | ||
27 | |||
28 | $this->controller = new PluginsController($this->container); | ||
29 | |||
30 | mkdir($path = __DIR__ . '/folder'); | ||
31 | PluginManager::$PLUGINS_PATH = $path; | ||
32 | array_map(function (string $plugin) use ($path) { touch($path . '/' . $plugin); }, static::PLUGIN_NAMES); | ||
33 | } | ||
34 | |||
35 | public function tearDown(): void | ||
36 | { | ||
37 | $path = __DIR__ . '/folder'; | ||
38 | array_map(function (string $plugin) use ($path) { unlink($path . '/' . $plugin); }, static::PLUGIN_NAMES); | ||
39 | rmdir($path); | ||
40 | } | ||
41 | |||
42 | /** | ||
43 | * Test displaying plugins admin page | ||
44 | */ | ||
45 | public function testIndex(): void | ||
46 | { | ||
47 | $assignedVariables = []; | ||
48 | $this->assignTemplateVars($assignedVariables); | ||
49 | |||
50 | $request = $this->createMock(Request::class); | ||
51 | $response = new Response(); | ||
52 | |||
53 | $data = [ | ||
54 | 'plugin1' => ['order' => 2, 'other' => 'field'], | ||
55 | 'plugin2' => ['order' => 1], | ||
56 | 'plugin3' => ['order' => false, 'abc' => 'def'], | ||
57 | 'plugin4' => [], | ||
58 | ]; | ||
59 | |||
60 | $this->container->pluginManager | ||
61 | ->expects(static::once()) | ||
62 | ->method('getPluginsMeta') | ||
63 | ->willReturn($data); | ||
64 | |||
65 | $result = $this->controller->index($request, $response); | ||
66 | |||
67 | static::assertSame(200, $result->getStatusCode()); | ||
68 | static::assertSame('pluginsadmin', (string) $result->getBody()); | ||
69 | |||
70 | static::assertSame('Plugin Administration - Shaarli', $assignedVariables['pagetitle']); | ||
71 | static::assertSame( | ||
72 | ['plugin2' => $data['plugin2'], 'plugin1' => $data['plugin1']], | ||
73 | $assignedVariables['enabledPlugins'] | ||
74 | ); | ||
75 | static::assertSame( | ||
76 | ['plugin3' => $data['plugin3'], 'plugin4' => $data['plugin4']], | ||
77 | $assignedVariables['disabledPlugins'] | ||
78 | ); | ||
79 | } | ||
80 | |||
81 | /** | ||
82 | * Test save plugins admin page | ||
83 | */ | ||
84 | public function testSaveEnabledPlugins(): void | ||
85 | { | ||
86 | $parameters = [ | ||
87 | 'plugin1' => 'on', | ||
88 | 'order_plugin1' => '2', | ||
89 | 'plugin2' => 'on', | ||
90 | ]; | ||
91 | |||
92 | $request = $this->createMock(Request::class); | ||
93 | $request | ||
94 | ->expects(static::atLeastOnce()) | ||
95 | ->method('getParams') | ||
96 | ->willReturnCallback(function () use ($parameters): array { | ||
97 | return $parameters; | ||
98 | }) | ||
99 | ; | ||
100 | $response = new Response(); | ||
101 | |||
102 | $this->container->pluginManager | ||
103 | ->expects(static::once()) | ||
104 | ->method('executeHooks') | ||
105 | ->with('save_plugin_parameters', $parameters) | ||
106 | ; | ||
107 | $this->container->conf | ||
108 | ->expects(static::atLeastOnce()) | ||
109 | ->method('set') | ||
110 | ->with('general.enabled_plugins', ['plugin1', 'plugin2']) | ||
111 | ; | ||
112 | |||
113 | $result = $this->controller->save($request, $response); | ||
114 | |||
115 | static::assertSame(302, $result->getStatusCode()); | ||
116 | static::assertSame(['/subfolder/admin/plugins'], $result->getHeader('location')); | ||
117 | } | ||
118 | |||
119 | /** | ||
120 | * Test save plugin parameters | ||
121 | */ | ||
122 | public function testSavePluginParameters(): void | ||
123 | { | ||
124 | $parameters = [ | ||
125 | 'parameters_form' => true, | ||
126 | 'parameter1' => 'blip', | ||
127 | 'parameter2' => 'blop', | ||
128 | 'token' => 'this parameter should not be saved' | ||
129 | ]; | ||
130 | |||
131 | $request = $this->createMock(Request::class); | ||
132 | $request | ||
133 | ->expects(static::atLeastOnce()) | ||
134 | ->method('getParams') | ||
135 | ->willReturnCallback(function () use ($parameters): array { | ||
136 | return $parameters; | ||
137 | }) | ||
138 | ; | ||
139 | $response = new Response(); | ||
140 | |||
141 | $this->container->pluginManager | ||
142 | ->expects(static::once()) | ||
143 | ->method('executeHooks') | ||
144 | ->with('save_plugin_parameters', $parameters) | ||
145 | ; | ||
146 | $this->container->conf | ||
147 | ->expects(static::exactly(2)) | ||
148 | ->method('set') | ||
149 | ->withConsecutive(['plugins.parameter1', 'blip'], ['plugins.parameter2', 'blop']) | ||
150 | ; | ||
151 | |||
152 | $result = $this->controller->save($request, $response); | ||
153 | |||
154 | static::assertSame(302, $result->getStatusCode()); | ||
155 | static::assertSame(['/subfolder/admin/plugins'], $result->getHeader('location')); | ||
156 | } | ||
157 | |||
158 | /** | ||
159 | * Test save plugin parameters - error encountered | ||
160 | */ | ||
161 | public function testSaveWithError(): void | ||
162 | { | ||
163 | $request = $this->createMock(Request::class); | ||
164 | $response = new Response(); | ||
165 | |||
166 | $this->container->conf = $this->createMock(ConfigManager::class); | ||
167 | $this->container->conf | ||
168 | ->expects(static::atLeastOnce()) | ||
169 | ->method('write') | ||
170 | ->willThrowException(new \Exception($message = 'error message')) | ||
171 | ; | ||
172 | |||
173 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
174 | $this->container->sessionManager->method('checkToken')->willReturn(true); | ||
175 | $this->container->sessionManager | ||
176 | ->expects(static::once()) | ||
177 | ->method('setSessionParameter') | ||
178 | ->with( | ||
179 | SessionManager::KEY_ERROR_MESSAGES, | ||
180 | ['Error while saving plugin configuration: ' . PHP_EOL . $message] | ||
181 | ) | ||
182 | ; | ||
183 | |||
184 | $result = $this->controller->save($request, $response); | ||
185 | |||
186 | static::assertSame(302, $result->getStatusCode()); | ||
187 | static::assertSame(['/subfolder/admin/plugins'], $result->getHeader('location')); | ||
188 | } | ||
189 | |||
190 | /** | ||
191 | * Test save plugin parameters - wrong token | ||
192 | */ | ||
193 | public function testSaveWrongToken(): void | ||
194 | { | ||
195 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
196 | $this->container->sessionManager->method('checkToken')->willReturn(false); | ||
197 | |||
198 | $request = $this->createMock(Request::class); | ||
199 | $response = new Response(); | ||
200 | |||
201 | $this->expectException(WrongTokenException::class); | ||
202 | |||
203 | $this->controller->save($request, $response); | ||
204 | } | ||
205 | } | ||
diff --git a/tests/front/controller/admin/SessionFilterControllerTest.php b/tests/front/controller/admin/SessionFilterControllerTest.php new file mode 100644 index 00000000..712a625b --- /dev/null +++ b/tests/front/controller/admin/SessionFilterControllerTest.php | |||
@@ -0,0 +1,177 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Security\LoginManager; | ||
8 | use Shaarli\Security\SessionManager; | ||
9 | use Shaarli\TestCase; | ||
10 | use Slim\Http\Request; | ||
11 | use Slim\Http\Response; | ||
12 | |||
13 | class SessionFilterControllerTest extends TestCase | ||
14 | { | ||
15 | use FrontAdminControllerMockHelper; | ||
16 | |||
17 | /** @var SessionFilterController */ | ||
18 | protected $controller; | ||
19 | |||
20 | public function setUp(): void | ||
21 | { | ||
22 | $this->createContainer(); | ||
23 | |||
24 | $this->controller = new SessionFilterController($this->container); | ||
25 | } | ||
26 | |||
27 | /** | ||
28 | * Visibility - Default call for private filter while logged in without current value | ||
29 | */ | ||
30 | public function testVisibility(): void | ||
31 | { | ||
32 | $arg = ['visibility' => 'private']; | ||
33 | |||
34 | $this->container->environment['HTTP_REFERER'] = 'http://shaarli/subfolder/controller/?searchtag=abc'; | ||
35 | |||
36 | $this->container->loginManager->method('isLoggedIn')->willReturn(true); | ||
37 | $this->container->sessionManager | ||
38 | ->expects(static::once()) | ||
39 | ->method('setSessionParameter') | ||
40 | ->with(SessionManager::KEY_VISIBILITY, 'private') | ||
41 | ; | ||
42 | |||
43 | $request = $this->createMock(Request::class); | ||
44 | $response = new Response(); | ||
45 | |||
46 | $result = $this->controller->visibility($request, $response, $arg); | ||
47 | |||
48 | static::assertInstanceOf(Response::class, $result); | ||
49 | static::assertSame(302, $result->getStatusCode()); | ||
50 | static::assertSame(['/subfolder/controller/?searchtag=abc'], $result->getHeader('location')); | ||
51 | } | ||
52 | |||
53 | /** | ||
54 | * Visibility - Toggle off private visibility | ||
55 | */ | ||
56 | public function testVisibilityToggleOff(): void | ||
57 | { | ||
58 | $arg = ['visibility' => 'private']; | ||
59 | |||
60 | $this->container->environment['HTTP_REFERER'] = 'http://shaarli/subfolder/controller/?searchtag=abc'; | ||
61 | |||
62 | $this->container->loginManager->method('isLoggedIn')->willReturn(true); | ||
63 | $this->container->sessionManager | ||
64 | ->method('getSessionParameter') | ||
65 | ->with(SessionManager::KEY_VISIBILITY) | ||
66 | ->willReturn('private') | ||
67 | ; | ||
68 | $this->container->sessionManager | ||
69 | ->expects(static::never()) | ||
70 | ->method('setSessionParameter') | ||
71 | ; | ||
72 | $this->container->sessionManager | ||
73 | ->expects(static::once()) | ||
74 | ->method('deleteSessionParameter') | ||
75 | ->with(SessionManager::KEY_VISIBILITY) | ||
76 | ; | ||
77 | |||
78 | $request = $this->createMock(Request::class); | ||
79 | $response = new Response(); | ||
80 | |||
81 | $result = $this->controller->visibility($request, $response, $arg); | ||
82 | |||
83 | static::assertInstanceOf(Response::class, $result); | ||
84 | static::assertSame(302, $result->getStatusCode()); | ||
85 | static::assertSame(['/subfolder/controller/?searchtag=abc'], $result->getHeader('location')); | ||
86 | } | ||
87 | |||
88 | /** | ||
89 | * Visibility - Change private to public | ||
90 | */ | ||
91 | public function testVisibilitySwitch(): void | ||
92 | { | ||
93 | $arg = ['visibility' => 'private']; | ||
94 | |||
95 | $this->container->loginManager->method('isLoggedIn')->willReturn(true); | ||
96 | $this->container->sessionManager | ||
97 | ->method('getSessionParameter') | ||
98 | ->with(SessionManager::KEY_VISIBILITY) | ||
99 | ->willReturn('public') | ||
100 | ; | ||
101 | $this->container->sessionManager | ||
102 | ->expects(static::once()) | ||
103 | ->method('setSessionParameter') | ||
104 | ->with(SessionManager::KEY_VISIBILITY, 'private') | ||
105 | ; | ||
106 | |||
107 | $request = $this->createMock(Request::class); | ||
108 | $response = new Response(); | ||
109 | |||
110 | $result = $this->controller->visibility($request, $response, $arg); | ||
111 | |||
112 | static::assertInstanceOf(Response::class, $result); | ||
113 | static::assertSame(302, $result->getStatusCode()); | ||
114 | static::assertSame(['/subfolder/'], $result->getHeader('location')); | ||
115 | } | ||
116 | |||
117 | /** | ||
118 | * Visibility - With invalid value - should remove any visibility setting | ||
119 | */ | ||
120 | public function testVisibilityInvalidValue(): void | ||
121 | { | ||
122 | $arg = ['visibility' => 'test']; | ||
123 | |||
124 | $this->container->environment['HTTP_REFERER'] = 'http://shaarli/subfolder/controller/?searchtag=abc'; | ||
125 | |||
126 | $this->container->loginManager->method('isLoggedIn')->willReturn(true); | ||
127 | $this->container->sessionManager | ||
128 | ->expects(static::never()) | ||
129 | ->method('setSessionParameter') | ||
130 | ; | ||
131 | $this->container->sessionManager | ||
132 | ->expects(static::once()) | ||
133 | ->method('deleteSessionParameter') | ||
134 | ->with(SessionManager::KEY_VISIBILITY) | ||
135 | ; | ||
136 | |||
137 | $request = $this->createMock(Request::class); | ||
138 | $response = new Response(); | ||
139 | |||
140 | $result = $this->controller->visibility($request, $response, $arg); | ||
141 | |||
142 | static::assertInstanceOf(Response::class, $result); | ||
143 | static::assertSame(302, $result->getStatusCode()); | ||
144 | static::assertSame(['/subfolder/controller/?searchtag=abc'], $result->getHeader('location')); | ||
145 | } | ||
146 | |||
147 | /** | ||
148 | * Visibility - Try to change visibility while logged out | ||
149 | */ | ||
150 | public function testVisibilityLoggedOut(): void | ||
151 | { | ||
152 | $arg = ['visibility' => 'test']; | ||
153 | |||
154 | $this->container->environment['HTTP_REFERER'] = 'http://shaarli/subfolder/controller/?searchtag=abc'; | ||
155 | |||
156 | $this->container->loginManager = $this->createMock(LoginManager::class); | ||
157 | $this->container->loginManager->method('isLoggedIn')->willReturn(false); | ||
158 | $this->container->sessionManager | ||
159 | ->expects(static::never()) | ||
160 | ->method('setSessionParameter') | ||
161 | ; | ||
162 | $this->container->sessionManager | ||
163 | ->expects(static::never()) | ||
164 | ->method('deleteSessionParameter') | ||
165 | ->with(SessionManager::KEY_VISIBILITY) | ||
166 | ; | ||
167 | |||
168 | $request = $this->createMock(Request::class); | ||
169 | $response = new Response(); | ||
170 | |||
171 | $result = $this->controller->visibility($request, $response, $arg); | ||
172 | |||
173 | static::assertInstanceOf(Response::class, $result); | ||
174 | static::assertSame(302, $result->getStatusCode()); | ||
175 | static::assertSame(['/subfolder/controller/?searchtag=abc'], $result->getHeader('location')); | ||
176 | } | ||
177 | } | ||
diff --git a/tests/front/controller/admin/ShaarliAdminControllerTest.php b/tests/front/controller/admin/ShaarliAdminControllerTest.php new file mode 100644 index 00000000..486d5d2d --- /dev/null +++ b/tests/front/controller/admin/ShaarliAdminControllerTest.php | |||
@@ -0,0 +1,184 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Front\Exception\WrongTokenException; | ||
8 | use Shaarli\Security\SessionManager; | ||
9 | use Shaarli\TestCase; | ||
10 | use Slim\Http\Request; | ||
11 | |||
12 | /** | ||
13 | * Class ShaarliControllerTest | ||
14 | * | ||
15 | * This class is used to test default behavior of ShaarliAdminController abstract class. | ||
16 | * It uses a dummy non abstract controller. | ||
17 | */ | ||
18 | class ShaarliAdminControllerTest extends TestCase | ||
19 | { | ||
20 | use FrontAdminControllerMockHelper; | ||
21 | |||
22 | /** @var ShaarliAdminController */ | ||
23 | protected $controller; | ||
24 | |||
25 | public function setUp(): void | ||
26 | { | ||
27 | $this->createContainer(); | ||
28 | |||
29 | $this->controller = new class($this->container) extends ShaarliAdminController | ||
30 | { | ||
31 | public function checkToken(Request $request): bool | ||
32 | { | ||
33 | return parent::checkToken($request); | ||
34 | } | ||
35 | |||
36 | public function saveSuccessMessage(string $message): void | ||
37 | { | ||
38 | parent::saveSuccessMessage($message); | ||
39 | } | ||
40 | |||
41 | public function saveWarningMessage(string $message): void | ||
42 | { | ||
43 | parent::saveWarningMessage($message); | ||
44 | } | ||
45 | |||
46 | public function saveErrorMessage(string $message): void | ||
47 | { | ||
48 | parent::saveErrorMessage($message); | ||
49 | } | ||
50 | }; | ||
51 | } | ||
52 | |||
53 | /** | ||
54 | * Trigger controller's checkToken with a valid token. | ||
55 | */ | ||
56 | public function testCheckTokenWithValidToken(): void | ||
57 | { | ||
58 | $request = $this->createMock(Request::class); | ||
59 | $request->method('getParam')->with('token')->willReturn($token = '12345'); | ||
60 | |||
61 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
62 | $this->container->sessionManager->method('checkToken')->with($token)->willReturn(true); | ||
63 | |||
64 | static::assertTrue($this->controller->checkToken($request)); | ||
65 | } | ||
66 | |||
67 | /** | ||
68 | * Trigger controller's checkToken with na valid token should raise an exception. | ||
69 | */ | ||
70 | public function testCheckTokenWithNotValidToken(): void | ||
71 | { | ||
72 | $request = $this->createMock(Request::class); | ||
73 | $request->method('getParam')->with('token')->willReturn($token = '12345'); | ||
74 | |||
75 | $this->container->sessionManager = $this->createMock(SessionManager::class); | ||
76 | $this->container->sessionManager->method('checkToken')->with($token)->willReturn(false); | ||
77 | |||
78 | $this->expectException(WrongTokenException::class); | ||
79 | |||
80 | $this->controller->checkToken($request); | ||
81 | } | ||
82 | |||
83 | /** | ||
84 | * Test saveSuccessMessage() with a first message. | ||
85 | */ | ||
86 | public function testSaveSuccessMessage(): void | ||
87 | { | ||
88 | $this->container->sessionManager | ||
89 | ->expects(static::once()) | ||
90 | ->method('setSessionParameter') | ||
91 | ->with(SessionManager::KEY_SUCCESS_MESSAGES, [$message = 'bravo!']) | ||
92 | ; | ||
93 | |||
94 | $this->controller->saveSuccessMessage($message); | ||
95 | } | ||
96 | |||
97 | /** | ||
98 | * Test saveSuccessMessage() with existing messages. | ||
99 | */ | ||
100 | public function testSaveSuccessMessageWithExistingMessages(): void | ||
101 | { | ||
102 | $this->container->sessionManager | ||
103 | ->expects(static::once()) | ||
104 | ->method('getSessionParameter') | ||
105 | ->with(SessionManager::KEY_SUCCESS_MESSAGES) | ||
106 | ->willReturn(['success1', 'success2']) | ||
107 | ; | ||
108 | $this->container->sessionManager | ||
109 | ->expects(static::once()) | ||
110 | ->method('setSessionParameter') | ||
111 | ->with(SessionManager::KEY_SUCCESS_MESSAGES, ['success1', 'success2', $message = 'bravo!']) | ||
112 | ; | ||
113 | |||
114 | $this->controller->saveSuccessMessage($message); | ||
115 | } | ||
116 | |||
117 | /** | ||
118 | * Test saveWarningMessage() with a first message. | ||
119 | */ | ||
120 | public function testSaveWarningMessage(): void | ||
121 | { | ||
122 | $this->container->sessionManager | ||
123 | ->expects(static::once()) | ||
124 | ->method('setSessionParameter') | ||
125 | ->with(SessionManager::KEY_WARNING_MESSAGES, [$message = 'warning!']) | ||
126 | ; | ||
127 | |||
128 | $this->controller->saveWarningMessage($message); | ||
129 | } | ||
130 | |||
131 | /** | ||
132 | * Test saveWarningMessage() with existing messages. | ||
133 | */ | ||
134 | public function testSaveWarningMessageWithExistingMessages(): void | ||
135 | { | ||
136 | $this->container->sessionManager | ||
137 | ->expects(static::once()) | ||
138 | ->method('getSessionParameter') | ||
139 | ->with(SessionManager::KEY_WARNING_MESSAGES) | ||
140 | ->willReturn(['warning1', 'warning2']) | ||
141 | ; | ||
142 | $this->container->sessionManager | ||
143 | ->expects(static::once()) | ||
144 | ->method('setSessionParameter') | ||
145 | ->with(SessionManager::KEY_WARNING_MESSAGES, ['warning1', 'warning2', $message = 'warning!']) | ||
146 | ; | ||
147 | |||
148 | $this->controller->saveWarningMessage($message); | ||
149 | } | ||
150 | |||
151 | /** | ||
152 | * Test saveErrorMessage() with a first message. | ||
153 | */ | ||
154 | public function testSaveErrorMessage(): void | ||
155 | { | ||
156 | $this->container->sessionManager | ||
157 | ->expects(static::once()) | ||
158 | ->method('setSessionParameter') | ||
159 | ->with(SessionManager::KEY_ERROR_MESSAGES, [$message = 'error!']) | ||
160 | ; | ||
161 | |||
162 | $this->controller->saveErrorMessage($message); | ||
163 | } | ||
164 | |||
165 | /** | ||
166 | * Test saveErrorMessage() with existing messages. | ||
167 | */ | ||
168 | public function testSaveErrorMessageWithExistingMessages(): void | ||
169 | { | ||
170 | $this->container->sessionManager | ||
171 | ->expects(static::once()) | ||
172 | ->method('getSessionParameter') | ||
173 | ->with(SessionManager::KEY_ERROR_MESSAGES) | ||
174 | ->willReturn(['error1', 'error2']) | ||
175 | ; | ||
176 | $this->container->sessionManager | ||
177 | ->expects(static::once()) | ||
178 | ->method('setSessionParameter') | ||
179 | ->with(SessionManager::KEY_ERROR_MESSAGES, ['error1', 'error2', $message = 'error!']) | ||
180 | ; | ||
181 | |||
182 | $this->controller->saveErrorMessage($message); | ||
183 | } | ||
184 | } | ||
diff --git a/tests/front/controller/admin/ThumbnailsControllerTest.php b/tests/front/controller/admin/ThumbnailsControllerTest.php new file mode 100644 index 00000000..f4a8acff --- /dev/null +++ b/tests/front/controller/admin/ThumbnailsControllerTest.php | |||
@@ -0,0 +1,154 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\Bookmark\Bookmark; | ||
8 | use Shaarli\Bookmark\Exception\BookmarkNotFoundException; | ||
9 | use Shaarli\TestCase; | ||
10 | use Shaarli\Thumbnailer; | ||
11 | use Slim\Http\Request; | ||
12 | use Slim\Http\Response; | ||
13 | |||
14 | class ThumbnailsControllerTest extends TestCase | ||
15 | { | ||
16 | use FrontAdminControllerMockHelper; | ||
17 | |||
18 | /** @var ThumbnailsController */ | ||
19 | protected $controller; | ||
20 | |||
21 | public function setUp(): void | ||
22 | { | ||
23 | $this->createContainer(); | ||
24 | |||
25 | $this->controller = new ThumbnailsController($this->container); | ||
26 | } | ||
27 | |||
28 | /** | ||
29 | * Test displaying the thumbnails update page | ||
30 | * Note that only non-note and HTTP bookmarks should be returned. | ||
31 | */ | ||
32 | public function testIndex(): void | ||
33 | { | ||
34 | $assignedVariables = []; | ||
35 | $this->assignTemplateVars($assignedVariables); | ||
36 | |||
37 | $request = $this->createMock(Request::class); | ||
38 | $response = new Response(); | ||
39 | |||
40 | $this->container->bookmarkService | ||
41 | ->expects(static::once()) | ||
42 | ->method('search') | ||
43 | ->willReturn([ | ||
44 | (new Bookmark())->setId(1)->setUrl('http://url1.tld')->setTitle('Title 1'), | ||
45 | (new Bookmark())->setId(2)->setUrl('?abcdef')->setTitle('Note 1'), | ||
46 | (new Bookmark())->setId(3)->setUrl('http://url2.tld')->setTitle('Title 2'), | ||
47 | (new Bookmark())->setId(4)->setUrl('ftp://domain.tld', ['ftp'])->setTitle('FTP'), | ||
48 | ]) | ||
49 | ; | ||
50 | |||
51 | $result = $this->controller->index($request, $response); | ||
52 | |||
53 | static::assertSame(200, $result->getStatusCode()); | ||
54 | static::assertSame('thumbnails', (string) $result->getBody()); | ||
55 | |||
56 | static::assertSame('Thumbnails update - Shaarli', $assignedVariables['pagetitle']); | ||
57 | static::assertSame([1, 3], $assignedVariables['ids']); | ||
58 | } | ||
59 | |||
60 | /** | ||
61 | * Test updating a bookmark thumbnail with valid parameters | ||
62 | */ | ||
63 | public function testAjaxUpdateValid(): void | ||
64 | { | ||
65 | $request = $this->createMock(Request::class); | ||
66 | $response = new Response(); | ||
67 | |||
68 | $bookmark = (new Bookmark()) | ||
69 | ->setId($id = 123) | ||
70 | ->setUrl($url = 'http://url1.tld') | ||
71 | ->setTitle('Title 1') | ||
72 | ->setThumbnail(false) | ||
73 | ; | ||
74 | |||
75 | $this->container->thumbnailer = $this->createMock(Thumbnailer::class); | ||
76 | $this->container->thumbnailer | ||
77 | ->expects(static::once()) | ||
78 | ->method('get') | ||
79 | ->with($url) | ||
80 | ->willReturn($thumb = 'http://img.tld/pic.png') | ||
81 | ; | ||
82 | |||
83 | $this->container->bookmarkService | ||
84 | ->expects(static::once()) | ||
85 | ->method('get') | ||
86 | ->with($id) | ||
87 | ->willReturn($bookmark) | ||
88 | ; | ||
89 | $this->container->bookmarkService | ||
90 | ->expects(static::once()) | ||
91 | ->method('set') | ||
92 | ->willReturnCallback(function (Bookmark $bookmark) use ($thumb) { | ||
93 | static::assertSame($thumb, $bookmark->getThumbnail()); | ||
94 | }) | ||
95 | ; | ||
96 | |||
97 | $result = $this->controller->ajaxUpdate($request, $response, ['id' => (string) $id]); | ||
98 | |||
99 | static::assertSame(200, $result->getStatusCode()); | ||
100 | |||
101 | $payload = json_decode((string) $result->getBody(), true); | ||
102 | |||
103 | static::assertSame($id, $payload['id']); | ||
104 | static::assertSame($url, $payload['url']); | ||
105 | static::assertSame($thumb, $payload['thumbnail']); | ||
106 | } | ||
107 | |||
108 | /** | ||
109 | * Test updating a bookmark thumbnail - Invalid ID | ||
110 | */ | ||
111 | public function testAjaxUpdateInvalidId(): void | ||
112 | { | ||
113 | $request = $this->createMock(Request::class); | ||
114 | $response = new Response(); | ||
115 | |||
116 | $result = $this->controller->ajaxUpdate($request, $response, ['id' => 'nope']); | ||
117 | |||
118 | static::assertSame(400, $result->getStatusCode()); | ||
119 | } | ||
120 | |||
121 | /** | ||
122 | * Test updating a bookmark thumbnail - No ID | ||
123 | */ | ||
124 | public function testAjaxUpdateNoId(): void | ||
125 | { | ||
126 | $request = $this->createMock(Request::class); | ||
127 | $response = new Response(); | ||
128 | |||
129 | $result = $this->controller->ajaxUpdate($request, $response, []); | ||
130 | |||
131 | static::assertSame(400, $result->getStatusCode()); | ||
132 | } | ||
133 | |||
134 | /** | ||
135 | * Test updating a bookmark thumbnail with valid parameters | ||
136 | */ | ||
137 | public function testAjaxUpdateBookmarkNotFound(): void | ||
138 | { | ||
139 | $id = 123; | ||
140 | $request = $this->createMock(Request::class); | ||
141 | $response = new Response(); | ||
142 | |||
143 | $this->container->bookmarkService | ||
144 | ->expects(static::once()) | ||
145 | ->method('get') | ||
146 | ->with($id) | ||
147 | ->willThrowException(new BookmarkNotFoundException()) | ||
148 | ; | ||
149 | |||
150 | $result = $this->controller->ajaxUpdate($request, $response, ['id' => (string) $id]); | ||
151 | |||
152 | static::assertSame(404, $result->getStatusCode()); | ||
153 | } | ||
154 | } | ||
diff --git a/tests/front/controller/admin/TokenControllerTest.php b/tests/front/controller/admin/TokenControllerTest.php new file mode 100644 index 00000000..d2f0907f --- /dev/null +++ b/tests/front/controller/admin/TokenControllerTest.php | |||
@@ -0,0 +1,41 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\TestCase; | ||
8 | use Slim\Http\Request; | ||
9 | use Slim\Http\Response; | ||
10 | |||
11 | class TokenControllerTest extends TestCase | ||
12 | { | ||
13 | use FrontAdminControllerMockHelper; | ||
14 | |||
15 | /** @var TokenController */ | ||
16 | protected $controller; | ||
17 | |||
18 | public function setUp(): void | ||
19 | { | ||
20 | $this->createContainer(); | ||
21 | |||
22 | $this->controller = new TokenController($this->container); | ||
23 | } | ||
24 | |||
25 | public function testGetToken(): void | ||
26 | { | ||
27 | $request = $this->createMock(Request::class); | ||
28 | $response = new Response(); | ||
29 | |||
30 | $this->container->sessionManager | ||
31 | ->expects(static::once()) | ||
32 | ->method('generateToken') | ||
33 | ->willReturn($token = 'token1234') | ||
34 | ; | ||
35 | |||
36 | $result = $this->controller->getToken($request, $response); | ||
37 | |||
38 | static::assertSame(200, $result->getStatusCode()); | ||
39 | static::assertSame($token, (string) $result->getBody()); | ||
40 | } | ||
41 | } | ||
diff --git a/tests/front/controller/admin/ToolsControllerTest.php b/tests/front/controller/admin/ToolsControllerTest.php new file mode 100644 index 00000000..e82f8b14 --- /dev/null +++ b/tests/front/controller/admin/ToolsControllerTest.php | |||
@@ -0,0 +1,69 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller\Admin; | ||
6 | |||
7 | use Shaarli\TestCase; | ||
8 | use Slim\Http\Request; | ||
9 | use Slim\Http\Response; | ||
10 | |||
11 | class ToolsControllerTest extends TestCase | ||
12 | { | ||
13 | use FrontAdminControllerMockHelper; | ||
14 | |||
15 | /** @var ToolsController */ | ||
16 | protected $controller; | ||
17 | |||
18 | public function setUp(): void | ||
19 | { | ||
20 | $this->createContainer(); | ||
21 | |||
22 | $this->controller = new ToolsController($this->container); | ||
23 | } | ||
24 | |||
25 | public function testDefaultInvokeWithHttps(): void | ||
26 | { | ||
27 | $request = $this->createMock(Request::class); | ||
28 | $response = new Response(); | ||
29 | |||
30 | $this->container->environment = [ | ||
31 | 'SERVER_NAME' => 'shaarli', | ||
32 | 'SERVER_PORT' => 443, | ||
33 | 'HTTPS' => 'on', | ||
34 | ]; | ||
35 | |||
36 | // Save RainTPL assigned variables | ||
37 | $assignedVariables = []; | ||
38 | $this->assignTemplateVars($assignedVariables); | ||
39 | |||
40 | $result = $this->controller->index($request, $response); | ||
41 | |||
42 | static::assertSame(200, $result->getStatusCode()); | ||
43 | static::assertSame('tools', (string) $result->getBody()); | ||
44 | static::assertSame('https://shaarli/', $assignedVariables['pageabsaddr']); | ||
45 | static::assertTrue($assignedVariables['sslenabled']); | ||
46 | } | ||
47 | |||
48 | public function testDefaultInvokeWithoutHttps(): void | ||
49 | { | ||
50 | $request = $this->createMock(Request::class); | ||
51 | $response = new Response(); | ||
52 | |||
53 | $this->container->environment = [ | ||
54 | 'SERVER_NAME' => 'shaarli', | ||
55 | 'SERVER_PORT' => 80, | ||
56 | ]; | ||
57 | |||
58 | // Save RainTPL assigned variables | ||
59 | $assignedVariables = []; | ||
60 | $this->assignTemplateVars($assignedVariables); | ||
61 | |||
62 | $result = $this->controller->index($request, $response); | ||
63 | |||
64 | static::assertSame(200, $result->getStatusCode()); | ||
65 | static::assertSame('tools', (string) $result->getBody()); | ||
66 | static::assertSame('http://shaarli/', $assignedVariables['pageabsaddr']); | ||
67 | static::assertFalse($assignedVariables['sslenabled']); | ||
68 | } | ||
69 | } | ||