]> BookStack Code Mirror - bookstack/blob - tests/ImageTest.php
Merge branch 'ezzra-german_informal'
[bookstack] / tests / ImageTest.php
1 <?php namespace Tests;
2
3 use BookStack\Entities\Repos\PageRepo;
4 use BookStack\Uploads\Image;
5 use BookStack\Entities\Page;
6 use BookStack\Entities\Repos\EntityRepo;
7 use BookStack\Uploads\ImageService;
8
9 class ImageTest extends TestCase
10 {
11     /**
12      * Get the path to our basic test image.
13      * @return string
14      */
15     protected function getTestImageFilePath()
16     {
17         return base_path('tests/test-data/test-image.png');
18     }
19
20     /**
21      * Get a test image that can be uploaded
22      * @param $fileName
23      * @return \Illuminate\Http\UploadedFile
24      */
25     protected function getTestImage($fileName)
26     {
27         return new \Illuminate\Http\UploadedFile($this->getTestImageFilePath(), $fileName, 'image/png', 5238);
28     }
29
30     /**
31      * Get the path for a test image.
32      * @param $type
33      * @param $fileName
34      * @return string
35      */
36     protected function getTestImagePath($type, $fileName)
37     {
38         return '/uploads/images/' . $type . '/' . Date('Y-m-M') . '/' . $fileName;
39     }
40
41     /**
42      * Uploads an image with the given name.
43      * @param $name
44      * @param int $uploadedTo
45      * @return \Illuminate\Foundation\Testing\TestResponse
46      */
47     protected function uploadImage($name, $uploadedTo = 0)
48     {
49         $file = $this->getTestImage($name);
50         return $this->call('POST', '/images/gallery/upload', ['uploaded_to' => $uploadedTo], [], ['file' => $file], []);
51     }
52
53     /**
54      * Delete an uploaded image.
55      * @param $relPath
56      */
57     protected function deleteImage($relPath)
58     {
59         $path = public_path($relPath);
60         if (file_exists($path)) {
61             unlink($path);
62         }
63     }
64
65
66     public function test_image_upload()
67     {
68         $page = Page::first();
69         $admin = $this->getAdmin();
70         $this->actingAs($admin);
71
72         $imageName = 'first-image.png';
73         $relPath = $this->getTestImagePath('gallery', $imageName);
74         $this->deleteImage($relPath);
75
76         $upload = $this->uploadImage($imageName, $page->id);
77         $upload->assertStatus(200);
78
79         $this->assertTrue(file_exists(public_path($relPath)), 'Uploaded image not found at path: '. public_path($relPath));
80
81         $this->deleteImage($relPath);
82
83         $this->assertDatabaseHas('images', [
84             'url' => $this->baseUrl . $relPath,
85             'type' => 'gallery',
86             'uploaded_to' => $page->id,
87             'path' => $relPath,
88             'created_by' => $admin->id,
89             'updated_by' => $admin->id,
90             'name' => $imageName
91         ]);
92     }
93
94     public function test_secure_images_uploads_to_correct_place()
95     {
96         config()->set('filesystems.default', 'local_secure');
97         $this->asEditor();
98         $galleryFile = $this->getTestImage('my-secure-test-upload');
99         $page = Page::first();
100         $expectedPath = storage_path('uploads/images/gallery/' . Date('Y-m-M') . '/my-secure-test-upload');
101
102         $upload = $this->call('POST', '/images/gallery/upload', ['uploaded_to' => $page->id], [], ['file' => $galleryFile], []);
103         $upload->assertStatus(200);
104
105         $this->assertTrue(file_exists($expectedPath), 'Uploaded image not found at path: '. $expectedPath);
106
107         if (file_exists($expectedPath)) {
108             unlink($expectedPath);
109         }
110     }
111
112     public function test_secure_images_included_in_exports()
113     {
114         config()->set('filesystems.default', 'local_secure');
115         $this->asEditor();
116         $galleryFile = $this->getTestImage('my-secure-test-upload');
117         $page = Page::first();
118         $expectedPath = storage_path('uploads/images/gallery/' . Date('Y-m-M') . '/my-secure-test-upload');
119
120         $upload = $this->call('POST', '/images/gallery/upload', ['uploaded_to' => $page->id], [], ['file' => $galleryFile], []);
121         $imageUrl = json_decode($upload->getContent(), true)['url'];
122         $page->html .= "<img src=\"{$imageUrl}\">";
123         $page->save();
124         $upload->assertStatus(200);
125
126         $encodedImageContent = base64_encode(file_get_contents($expectedPath));
127         $export = $this->get($page->getUrl('/export/html'));
128         $this->assertTrue(str_contains($export->getContent(), $encodedImageContent), 'Uploaded image in export content');
129
130         if (file_exists($expectedPath)) {
131             unlink($expectedPath);
132         }
133     }
134
135     public function test_system_images_remain_public()
136     {
137         config()->set('filesystems.default', 'local_secure');
138         $this->asEditor();
139         $galleryFile = $this->getTestImage('my-system-test-upload');
140         $page = Page::first();
141         $expectedPath = public_path('uploads/images/system/' . Date('Y-m-M') . '/my-system-test-upload');
142
143         $upload = $this->call('POST', '/images/system/upload', ['uploaded_to' => $page->id], [], ['file' => $galleryFile], []);
144         $upload->assertStatus(200);
145
146         $this->assertTrue(file_exists($expectedPath), 'Uploaded image not found at path: '. $expectedPath);
147
148         if (file_exists($expectedPath)) {
149             unlink($expectedPath);
150         }
151     }
152
153     public function test_image_delete()
154     {
155         $page = Page::first();
156         $this->asAdmin();
157         $imageName = 'first-image.png';
158
159         $this->uploadImage($imageName, $page->id);
160         $image = Image::first();
161         $relPath = $this->getTestImagePath('gallery', $imageName);
162
163         $delete = $this->delete( '/images/' . $image->id);
164         $delete->assertStatus(200);
165
166         $this->assertDatabaseMissing('images', [
167             'url' => $this->baseUrl . $relPath,
168             'type' => 'gallery'
169         ]);
170
171         $this->assertFalse(file_exists(public_path($relPath)), 'Uploaded image has not been deleted as expected');
172     }
173
174     public function testBase64Get()
175     {
176         $page = Page::first();
177         $this->asAdmin();
178         $imageName = 'first-image.png';
179
180         $this->uploadImage($imageName, $page->id);
181         $image = Image::first();
182
183         $imageGet = $this->getJson("/images/base64/{$image->id}");
184         $imageGet->assertJson([
185             'content' => 'iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAIAAAACDbGyAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4gEcDCo5iYNs+gAAAB1pVFh0Q29tbWVudAAAAAAAQ3JlYXRlZCB3aXRoIEdJTVBkLmUHAAAAFElEQVQI12O0jN/KgASYGFABqXwAZtoBV6Sl3hIAAAAASUVORK5CYII='
186         ]);
187     }
188
189     public function test_drawing_base64_upload()
190     {
191         $page = Page::first();
192         $editor = $this->getEditor();
193         $this->actingAs($editor);
194
195         $upload = $this->postJson('images/drawing/upload', [
196             'uploaded_to' => $page->id,
197             'image' => 'image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAIAAAACDbGyAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4gEcDCo5iYNs+gAAAB1pVFh0Q29tbWVudAAAAAAAQ3JlYXRlZCB3aXRoIEdJTVBkLmUHAAAAFElEQVQI12O0jN/KgASYGFABqXwAZtoBV6Sl3hIAAAAASUVORK5CYII='
198         ]);
199
200         $upload->assertStatus(200);
201         $upload->assertJson([
202             'type' => 'drawio',
203             'uploaded_to' => $page->id,
204             'created_by' => $editor->id,
205             'updated_by' => $editor->id,
206         ]);
207
208         $image = Image::where('type', '=', 'drawio')->first();
209         $this->assertTrue(file_exists(public_path($image->path)), 'Uploaded image not found at path: '. public_path($image->path));
210
211         $testImageData = file_get_contents($this->getTestImageFilePath());
212         $uploadedImageData = file_get_contents(public_path($image->path));
213         $this->assertTrue($testImageData === $uploadedImageData, "Uploaded image file data does not match our test image as expected");
214     }
215
216     public function test_user_images_deleted_on_user_deletion()
217     {
218         $editor = $this->getEditor();
219         $this->actingAs($editor);
220
221         $imageName = 'profile.png';
222         $relPath = $this->getTestImagePath('gallery', $imageName);
223         $this->deleteImage($relPath);
224
225         $file = $this->getTestImage($imageName);
226         $this->call('POST', '/images/user/upload', [], [], ['file' => $file], []);
227         $this->call('POST', '/images/user/upload', [], [], ['file' => $file], []);
228
229         $profileImages = Image::where('type', '=', 'user')->where('created_by', '=', $editor->id)->get();
230         $this->assertTrue($profileImages->count() === 2, "Found profile images does not match upload count");
231
232         $userDelete = $this->asAdmin()->delete("/settings/users/{$editor->id}");
233         $userDelete->assertStatus(302);
234         $this->assertDatabaseMissing('images', [
235             'type' => 'user',
236             'created_by' => $editor->id
237         ]);
238     }
239
240     public function test_deleted_unused_images()
241     {
242         $page = Page::first();
243         $admin = $this->getAdmin();
244         $this->actingAs($admin);
245
246         $imageName = 'unused-image.png';
247         $relPath = $this->getTestImagePath('gallery', $imageName);
248         $this->deleteImage($relPath);
249
250         $upload = $this->uploadImage($imageName, $page->id);
251         $upload->assertStatus(200);
252         $image = Image::where('type', '=', 'gallery')->first();
253
254         $pageRepo = app(PageRepo::class);
255         $pageRepo->updatePage($page, $page->book_id, [
256             'name' => $page->name,
257             'html' => $page->html . "<img src=\"{$image->url}\">",
258             'summary' => ''
259         ]);
260
261         // Ensure no images are reported as deletable
262         $imageService = app(ImageService::class);
263         $toDelete = $imageService->deleteUnusedImages(true, true);
264         $this->assertCount(0, $toDelete);
265
266         // Save a revision of our page without the image;
267         $pageRepo->updatePage($page, $page->book_id, [
268             'name' => $page->name,
269             'html' => "<p>Hello</p>",
270             'summary' => ''
271         ]);
272
273         // Ensure revision images are picked up okay
274         $imageService = app(ImageService::class);
275         $toDelete = $imageService->deleteUnusedImages(true, true);
276         $this->assertCount(0, $toDelete);
277         $toDelete = $imageService->deleteUnusedImages(false, true);
278         $this->assertCount(1, $toDelete);
279
280         // Check image is found when revisions are destroyed
281         $page->revisions()->delete();
282         $toDelete = $imageService->deleteUnusedImages(true, true);
283         $this->assertCount(1, $toDelete);
284
285         // Check the image is deleted
286         $absPath = public_path($relPath);
287         $this->assertTrue(file_exists($absPath), "Existing uploaded file at path {$absPath} exists");
288         $toDelete = $imageService->deleteUnusedImages(true, false);
289         $this->assertCount(1, $toDelete);
290         $this->assertFalse(file_exists($absPath));
291
292         $this->deleteImage($relPath);
293     }
294
295 }