diff options
author | ArthurHoaro <arthur@hoa.ro> | 2020-01-26 11:41:10 +0100 |
---|---|---|
committer | GitHub <noreply@github.com> | 2020-01-26 11:41:10 +0100 |
commit | c653ae3bfb11f663a52f55817e6d02a66d0852c8 (patch) | |
tree | d5a03a3e425180f1fafb646c8ec68a4b8458d0b3 /tests/front | |
parent | 1410dce2db310e71b5e683b0871c2f28d8807844 (diff) | |
parent | 27ceea2aeeed69b43fef4ebff35ec8004fcc2e45 (diff) | |
download | Shaarli-c653ae3bfb11f663a52f55817e6d02a66d0852c8.tar.gz Shaarli-c653ae3bfb11f663a52f55817e6d02a66d0852c8.tar.zst Shaarli-c653ae3bfb11f663a52f55817e6d02a66d0852c8.zip |
Render login page through Slim controller (#1401)
Render login page through Slim controller
Diffstat (limited to 'tests/front')
-rw-r--r-- | tests/front/ShaarliMiddlewareTest.php | 70 | ||||
-rw-r--r-- | tests/front/controller/LoginControllerTest.php | 178 | ||||
-rw-r--r-- | tests/front/controller/ShaarliControllerTest.php | 116 |
3 files changed, 364 insertions, 0 deletions
diff --git a/tests/front/ShaarliMiddlewareTest.php b/tests/front/ShaarliMiddlewareTest.php new file mode 100644 index 00000000..80974f37 --- /dev/null +++ b/tests/front/ShaarliMiddlewareTest.php | |||
@@ -0,0 +1,70 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front; | ||
6 | |||
7 | use PHPUnit\Framework\TestCase; | ||
8 | use Shaarli\Config\ConfigManager; | ||
9 | use Shaarli\Container\ShaarliContainer; | ||
10 | use Shaarli\Front\Exception\LoginBannedException; | ||
11 | use Shaarli\Render\PageBuilder; | ||
12 | use Slim\Http\Request; | ||
13 | use Slim\Http\Response; | ||
14 | |||
15 | class ShaarliMiddlewareTest extends TestCase | ||
16 | { | ||
17 | /** @var ShaarliContainer */ | ||
18 | protected $container; | ||
19 | |||
20 | /** @var ShaarliMiddleware */ | ||
21 | protected $middleware; | ||
22 | |||
23 | public function setUp(): void | ||
24 | { | ||
25 | $this->container = $this->createMock(ShaarliContainer::class); | ||
26 | $this->middleware = new ShaarliMiddleware($this->container); | ||
27 | } | ||
28 | |||
29 | public function testMiddlewareExecution(): void | ||
30 | { | ||
31 | $request = $this->createMock(Request::class); | ||
32 | $response = new Response(); | ||
33 | $controller = function (Request $request, Response $response): Response { | ||
34 | return $response->withStatus(418); // I'm a tea pot | ||
35 | }; | ||
36 | |||
37 | /** @var Response $result */ | ||
38 | $result = $this->middleware->__invoke($request, $response, $controller); | ||
39 | |||
40 | static::assertInstanceOf(Response::class, $result); | ||
41 | static::assertSame(418, $result->getStatusCode()); | ||
42 | } | ||
43 | |||
44 | public function testMiddlewareExecutionWithException(): void | ||
45 | { | ||
46 | $request = $this->createMock(Request::class); | ||
47 | $response = new Response(); | ||
48 | $controller = function (): void { | ||
49 | $exception = new LoginBannedException(); | ||
50 | |||
51 | throw new $exception; | ||
52 | }; | ||
53 | |||
54 | $pageBuilder = $this->createMock(PageBuilder::class); | ||
55 | $pageBuilder->method('render')->willReturnCallback(function (string $message): string { | ||
56 | return $message; | ||
57 | }); | ||
58 | $this->container->pageBuilder = $pageBuilder; | ||
59 | |||
60 | $conf = $this->createMock(ConfigManager::class); | ||
61 | $this->container->conf = $conf; | ||
62 | |||
63 | /** @var Response $result */ | ||
64 | $result = $this->middleware->__invoke($request, $response, $controller); | ||
65 | |||
66 | static::assertInstanceOf(Response::class, $result); | ||
67 | static::assertSame(401, $result->getStatusCode()); | ||
68 | static::assertContains('error', (string) $result->getBody()); | ||
69 | } | ||
70 | } | ||
diff --git a/tests/front/controller/LoginControllerTest.php b/tests/front/controller/LoginControllerTest.php new file mode 100644 index 00000000..8cf8ece7 --- /dev/null +++ b/tests/front/controller/LoginControllerTest.php | |||
@@ -0,0 +1,178 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller; | ||
6 | |||
7 | use PHPUnit\Framework\TestCase; | ||
8 | use Shaarli\Bookmark\BookmarkServiceInterface; | ||
9 | use Shaarli\Config\ConfigManager; | ||
10 | use Shaarli\Container\ShaarliContainer; | ||
11 | use Shaarli\Front\Exception\LoginBannedException; | ||
12 | use Shaarli\Plugin\PluginManager; | ||
13 | use Shaarli\Render\PageBuilder; | ||
14 | use Shaarli\Security\LoginManager; | ||
15 | use Slim\Http\Request; | ||
16 | use Slim\Http\Response; | ||
17 | |||
18 | class LoginControllerTest extends TestCase | ||
19 | { | ||
20 | /** @var ShaarliContainer */ | ||
21 | protected $container; | ||
22 | |||
23 | /** @var LoginController */ | ||
24 | protected $controller; | ||
25 | |||
26 | public function setUp(): void | ||
27 | { | ||
28 | $this->container = $this->createMock(ShaarliContainer::class); | ||
29 | $this->controller = new LoginController($this->container); | ||
30 | } | ||
31 | |||
32 | public function testValidControllerInvoke(): void | ||
33 | { | ||
34 | $this->createValidContainerMockSet(); | ||
35 | |||
36 | $request = $this->createMock(Request::class); | ||
37 | $request->expects(static::once())->method('getServerParam')->willReturn('> referer'); | ||
38 | $response = new Response(); | ||
39 | |||
40 | $assignedVariables = []; | ||
41 | $this->container->pageBuilder | ||
42 | ->method('assign') | ||
43 | ->willReturnCallback(function ($key, $value) use (&$assignedVariables) { | ||
44 | $assignedVariables[$key] = $value; | ||
45 | |||
46 | return $this; | ||
47 | }) | ||
48 | ; | ||
49 | |||
50 | $result = $this->controller->index($request, $response); | ||
51 | |||
52 | static::assertInstanceOf(Response::class, $result); | ||
53 | static::assertSame(200, $result->getStatusCode()); | ||
54 | static::assertSame('loginform', (string) $result->getBody()); | ||
55 | |||
56 | static::assertSame('> referer', $assignedVariables['returnurl']); | ||
57 | static::assertSame(true, $assignedVariables['remember_user_default']); | ||
58 | static::assertSame('Login - Shaarli', $assignedVariables['pagetitle']); | ||
59 | } | ||
60 | |||
61 | public function testValidControllerInvokeWithUserName(): void | ||
62 | { | ||
63 | $this->createValidContainerMockSet(); | ||
64 | |||
65 | $request = $this->createMock(Request::class); | ||
66 | $request->expects(static::once())->method('getServerParam')->willReturn('> referer'); | ||
67 | $request->expects(static::exactly(2))->method('getParam')->willReturn('myUser>'); | ||
68 | $response = new Response(); | ||
69 | |||
70 | $assignedVariables = []; | ||
71 | $this->container->pageBuilder | ||
72 | ->method('assign') | ||
73 | ->willReturnCallback(function ($key, $value) use (&$assignedVariables) { | ||
74 | $assignedVariables[$key] = $value; | ||
75 | |||
76 | return $this; | ||
77 | }) | ||
78 | ; | ||
79 | |||
80 | $result = $this->controller->index($request, $response); | ||
81 | |||
82 | static::assertInstanceOf(Response::class, $result); | ||
83 | static::assertSame(200, $result->getStatusCode()); | ||
84 | static::assertSame('loginform', (string) $result->getBody()); | ||
85 | |||
86 | static::assertSame('myUser>', $assignedVariables['username']); | ||
87 | static::assertSame('> referer', $assignedVariables['returnurl']); | ||
88 | static::assertSame(true, $assignedVariables['remember_user_default']); | ||
89 | static::assertSame('Login - Shaarli', $assignedVariables['pagetitle']); | ||
90 | } | ||
91 | |||
92 | public function testLoginControllerWhileLoggedIn(): void | ||
93 | { | ||
94 | $request = $this->createMock(Request::class); | ||
95 | $response = new Response(); | ||
96 | |||
97 | $loginManager = $this->createMock(LoginManager::class); | ||
98 | $loginManager->expects(static::once())->method('isLoggedIn')->willReturn(true); | ||
99 | $this->container->loginManager = $loginManager; | ||
100 | |||
101 | $result = $this->controller->index($request, $response); | ||
102 | |||
103 | static::assertInstanceOf(Response::class, $result); | ||
104 | static::assertSame(302, $result->getStatusCode()); | ||
105 | static::assertSame(['./'], $result->getHeader('Location')); | ||
106 | } | ||
107 | |||
108 | public function testLoginControllerOpenShaarli(): void | ||
109 | { | ||
110 | $this->createValidContainerMockSet(); | ||
111 | |||
112 | $request = $this->createMock(Request::class); | ||
113 | $response = new Response(); | ||
114 | |||
115 | $conf = $this->createMock(ConfigManager::class); | ||
116 | $conf->method('get')->willReturnCallback(function (string $parameter, $default) { | ||
117 | if ($parameter === 'security.open_shaarli') { | ||
118 | return true; | ||
119 | } | ||
120 | return $default; | ||
121 | }); | ||
122 | $this->container->conf = $conf; | ||
123 | |||
124 | $result = $this->controller->index($request, $response); | ||
125 | |||
126 | static::assertInstanceOf(Response::class, $result); | ||
127 | static::assertSame(302, $result->getStatusCode()); | ||
128 | static::assertSame(['./'], $result->getHeader('Location')); | ||
129 | } | ||
130 | |||
131 | public function testLoginControllerWhileBanned(): void | ||
132 | { | ||
133 | $this->createValidContainerMockSet(); | ||
134 | |||
135 | $request = $this->createMock(Request::class); | ||
136 | $response = new Response(); | ||
137 | |||
138 | $loginManager = $this->createMock(LoginManager::class); | ||
139 | $loginManager->method('isLoggedIn')->willReturn(false); | ||
140 | $loginManager->method('canLogin')->willReturn(false); | ||
141 | $this->container->loginManager = $loginManager; | ||
142 | |||
143 | $this->expectException(LoginBannedException::class); | ||
144 | |||
145 | $this->controller->index($request, $response); | ||
146 | } | ||
147 | |||
148 | protected function createValidContainerMockSet(): void | ||
149 | { | ||
150 | // User logged out | ||
151 | $loginManager = $this->createMock(LoginManager::class); | ||
152 | $loginManager->method('isLoggedIn')->willReturn(false); | ||
153 | $loginManager->method('canLogin')->willReturn(true); | ||
154 | $this->container->loginManager = $loginManager; | ||
155 | |||
156 | // Config | ||
157 | $conf = $this->createMock(ConfigManager::class); | ||
158 | $conf->method('get')->willReturnCallback(function (string $parameter, $default) { | ||
159 | return $default; | ||
160 | }); | ||
161 | $this->container->conf = $conf; | ||
162 | |||
163 | // PageBuilder | ||
164 | $pageBuilder = $this->createMock(PageBuilder::class); | ||
165 | $pageBuilder | ||
166 | ->method('render') | ||
167 | ->willReturnCallback(function (string $template): string { | ||
168 | return $template; | ||
169 | }) | ||
170 | ; | ||
171 | $this->container->pageBuilder = $pageBuilder; | ||
172 | |||
173 | $pluginManager = $this->createMock(PluginManager::class); | ||
174 | $this->container->pluginManager = $pluginManager; | ||
175 | $bookmarkService = $this->createMock(BookmarkServiceInterface::class); | ||
176 | $this->container->bookmarkService = $bookmarkService; | ||
177 | } | ||
178 | } | ||
diff --git a/tests/front/controller/ShaarliControllerTest.php b/tests/front/controller/ShaarliControllerTest.php new file mode 100644 index 00000000..6fa3feb9 --- /dev/null +++ b/tests/front/controller/ShaarliControllerTest.php | |||
@@ -0,0 +1,116 @@ | |||
1 | <?php | ||
2 | |||
3 | declare(strict_types=1); | ||
4 | |||
5 | namespace Shaarli\Front\Controller; | ||
6 | |||
7 | use PHPUnit\Framework\TestCase; | ||
8 | use Shaarli\Bookmark\BookmarkFilter; | ||
9 | use Shaarli\Bookmark\BookmarkServiceInterface; | ||
10 | use Shaarli\Container\ShaarliContainer; | ||
11 | use Shaarli\Plugin\PluginManager; | ||
12 | use Shaarli\Render\PageBuilder; | ||
13 | use Shaarli\Security\LoginManager; | ||
14 | |||
15 | /** | ||
16 | * Class ShaarliControllerTest | ||
17 | * | ||
18 | * This class is used to test default behavior of ShaarliController abstract class. | ||
19 | * It uses a dummy non abstract controller. | ||
20 | */ | ||
21 | class ShaarliControllerTest extends TestCase | ||
22 | { | ||
23 | /** @var ShaarliContainer */ | ||
24 | protected $container; | ||
25 | |||
26 | /** @var LoginController */ | ||
27 | protected $controller; | ||
28 | |||
29 | /** @var mixed[] List of variable assigned to the template */ | ||
30 | protected $assignedValues; | ||
31 | |||
32 | public function setUp(): void | ||
33 | { | ||
34 | $this->container = $this->createMock(ShaarliContainer::class); | ||
35 | $this->controller = new class($this->container) extends ShaarliController | ||
36 | { | ||
37 | public function assignView(string $key, $value): ShaarliController | ||
38 | { | ||
39 | return parent::assignView($key, $value); | ||
40 | } | ||
41 | |||
42 | public function render(string $template): string | ||
43 | { | ||
44 | return parent::render($template); | ||
45 | } | ||
46 | }; | ||
47 | $this->assignedValues = []; | ||
48 | } | ||
49 | |||
50 | public function testAssignView(): void | ||
51 | { | ||
52 | $this->createValidContainerMockSet(); | ||
53 | |||
54 | $self = $this->controller->assignView('variableName', 'variableValue'); | ||
55 | |||
56 | static::assertInstanceOf(ShaarliController::class, $self); | ||
57 | static::assertSame('variableValue', $this->assignedValues['variableName']); | ||
58 | } | ||
59 | |||
60 | public function testRender(): void | ||
61 | { | ||
62 | $this->createValidContainerMockSet(); | ||
63 | |||
64 | $render = $this->controller->render('templateName'); | ||
65 | |||
66 | static::assertSame('templateName', $render); | ||
67 | |||
68 | static::assertSame(10, $this->assignedValues['linkcount']); | ||
69 | static::assertSame(5, $this->assignedValues['privateLinkcount']); | ||
70 | static::assertSame(['error'], $this->assignedValues['plugin_errors']); | ||
71 | |||
72 | static::assertSame('templateName', $this->assignedValues['plugins_includes']['render_includes']['target']); | ||
73 | static::assertTrue($this->assignedValues['plugins_includes']['render_includes']['loggedin']); | ||
74 | static::assertSame('templateName', $this->assignedValues['plugins_header']['render_header']['target']); | ||
75 | static::assertTrue($this->assignedValues['plugins_header']['render_header']['loggedin']); | ||
76 | static::assertSame('templateName', $this->assignedValues['plugins_footer']['render_footer']['target']); | ||
77 | static::assertTrue($this->assignedValues['plugins_footer']['render_footer']['loggedin']); | ||
78 | } | ||
79 | |||
80 | protected function createValidContainerMockSet(): void | ||
81 | { | ||
82 | $pageBuilder = $this->createMock(PageBuilder::class); | ||
83 | $pageBuilder | ||
84 | ->method('assign') | ||
85 | ->willReturnCallback(function (string $key, $value): void { | ||
86 | $this->assignedValues[$key] = $value; | ||
87 | }); | ||
88 | $pageBuilder | ||
89 | ->method('render') | ||
90 | ->willReturnCallback(function (string $template): string { | ||
91 | return $template; | ||
92 | }); | ||
93 | $this->container->pageBuilder = $pageBuilder; | ||
94 | |||
95 | $bookmarkService = $this->createMock(BookmarkServiceInterface::class); | ||
96 | $bookmarkService | ||
97 | ->method('count') | ||
98 | ->willReturnCallback(function (string $visibility): int { | ||
99 | return $visibility === BookmarkFilter::$PRIVATE ? 5 : 10; | ||
100 | }); | ||
101 | $this->container->bookmarkService = $bookmarkService; | ||
102 | |||
103 | $pluginManager = $this->createMock(PluginManager::class); | ||
104 | $pluginManager | ||
105 | ->method('executeHooks') | ||
106 | ->willReturnCallback(function (string $hook, array &$data, array $params): array { | ||
107 | return $data[$hook] = $params; | ||
108 | }); | ||
109 | $pluginManager->method('getErrors')->willReturn(['error']); | ||
110 | $this->container->pluginManager = $pluginManager; | ||
111 | |||
112 | $loginManager = $this->createMock(LoginManager::class); | ||
113 | $loginManager->method('isLoggedIn')->willReturn(true); | ||
114 | $this->container->loginManager = $loginManager; | ||
115 | } | ||
116 | } | ||