BookStack Code Mirror - bookstack/blob - tests/Exports/ZipExportTest.php

   1 <?php
   2
   3 namespace Tests\Exports;
   4
   5 use BookStack\Activity\Models\Tag;
   6 use BookStack\Entities\Repos\BookRepo;
   7 use BookStack\Entities\Tools\PageContent;
   8 use BookStack\Uploads\Attachment;
   9 use BookStack\Uploads\Image;
  10 use Illuminate\Support\Carbon;
  11 use Illuminate\Testing\TestResponse;
  12 use Tests\TestCase;
  13 use ZipArchive;
  14
  15 class ZipExportTest extends TestCase
  16 {
  17     public function test_export_results_in_zip_format()
  18     {
  19         $page = $this->entities->page();
  20         $response = $this->asEditor()->get($page->getUrl("/export/zip"));
  21
  22         $zipData = $response->streamedContent();
  23         $zipFile = tempnam(sys_get_temp_dir(), 'bstesta-');
  24         file_put_contents($zipFile, $zipData);
  25         $zip = new ZipArchive();
  26         $zip->open($zipFile, ZipArchive::RDONLY);
  27
  28         $this->assertNotFalse($zip->locateName('data.json'));
  29         $this->assertNotFalse($zip->locateName('files/'));
  30
  31         $data = json_decode($zip->getFromName('data.json'), true);
  32         $this->assertIsArray($data);
  33         $this->assertGreaterThan(0, count($data));
  34
  35         $zip->close();
  36         unlink($zipFile);
  37     }
  38
  39     public function test_export_metadata()
  40     {
  41         $page = $this->entities->page();
  42         $zipResp = $this->asEditor()->get($page->getUrl("/export/zip"));
  43         $zip = $this->extractZipResponse($zipResp);
  44
  45         $this->assertEquals($page->id, $zip->data['page']['id'] ?? null);
  46         $this->assertArrayNotHasKey('book', $zip->data);
  47         $this->assertArrayNotHasKey('chapter', $zip->data);
  48
  49         $now = time();
  50         $date = Carbon::parse($zip->data['exported_at'])->unix();
  51         $this->assertLessThan($now + 2, $date);
  52         $this->assertGreaterThan($now - 2, $date);
  53
  54         $version = trim(file_get_contents(base_path('version')));
  55         $this->assertEquals($version, $zip->data['instance']['version']);
  56
  57         $zipInstanceId = $zip->data['instance']['id'];
  58         $instanceId = setting('instance-id');
  59         $this->assertNotEmpty($instanceId);
  60         $this->assertEquals($instanceId, $zipInstanceId);
  61     }
  62
  63     public function test_page_export()
  64     {
  65         $page = $this->entities->page();
  66         $zipResp = $this->asEditor()->get($page->getUrl("/export/zip"));
  67         $zip = $this->extractZipResponse($zipResp);
  68
  69         $pageData = $zip->data['page'];
  70         $this->assertEquals([
  71             'id' => $page->id,
  72             'name' => $page->name,
  73             'html' => (new PageContent($page))->render(),
  74             'priority' => $page->priority,
  75             'attachments' => [],
  76             'images' => [],
  77             'tags' => [],
  78         ], $pageData);
  79     }
  80
  81     public function test_page_export_with_markdown()
  82     {
  83         $page = $this->entities->page();
  84         $markdown = "# My page\n\nwritten in markdown for export\n";
  85         $page->markdown = $markdown;
  86         $page->save();
  87
  88         $zipResp = $this->asEditor()->get($page->getUrl("/export/zip"));
  89         $zip = $this->extractZipResponse($zipResp);
  90
  91         $pageData = $zip->data['page'];
  92         $this->assertEquals($markdown, $pageData['markdown']);
  93         $this->assertNotEmpty($pageData['html']);
  94     }
  95
  96     public function test_page_export_with_tags()
  97     {
  98         $page = $this->entities->page();
  99         $page->tags()->saveMany([
 100             new Tag(['name' => 'Exporty', 'value' => 'Content', 'order' => 1]),
 101             new Tag(['name' => 'Another', 'value' => '', 'order' => 2]),
 102         ]);
 103
 104         $zipResp = $this->asEditor()->get($page->getUrl("/export/zip"));
 105         $zip = $this->extractZipResponse($zipResp);
 106
 107         $pageData = $zip->data['page'];
 108         $this->assertEquals([
 109             [
 110                 'name' => 'Exporty',
 111                 'value' => 'Content',
 112             ],
 113             [
 114                 'name' => 'Another',
 115                 'value' => '',
 116             ]
 117         ], $pageData['tags']);
 118     }
 119
 120     public function test_page_export_with_images()
 121     {
 122         $this->asEditor();
 123         $page = $this->entities->page();
 124         $result = $this->files->uploadGalleryImageToPage($this, $page);
 125         $displayThumb = $result['response']->thumbs->gallery ?? '';
 126         $page->html = '<p><img src="' . $displayThumb . '" alt="My image"></p>';
 127         $page->save();
 128         $image = Image::findOrFail($result['response']->id);
 129
 130         $zipResp = $this->asEditor()->get($page->getUrl("/export/zip"));
 131         $zip = $this->extractZipResponse($zipResp);
 132         $pageData = $zip->data['page'];
 133
 134         $this->assertCount(1, $pageData['images']);
 135         $imageData = $pageData['images'][0];
 136         $this->assertEquals($image->id, $imageData['id']);
 137         $this->assertEquals($image->name, $imageData['name']);
 138         $this->assertEquals('gallery', $imageData['type']);
 139         $this->assertNotEmpty($imageData['file']);
 140
 141         $filePath = $zip->extractPath("files/{$imageData['file']}");
 142         $this->assertFileExists($filePath);
 143         $this->assertEquals(file_get_contents(public_path($image->path)), file_get_contents($filePath));
 144
 145         $this->assertEquals('<p><img src="[[bsexport:image:' . $imageData['id'] . ']]" alt="My image"></p>', $pageData['html']);
 146     }
 147
 148     public function test_page_export_file_attachments()
 149     {
 150         $contents = 'My great attachment content!';
 151
 152         $page = $this->entities->page();
 153         $this->asAdmin();
 154         $attachment = $this->files->uploadAttachmentDataToPage($this, $page, 'PageAttachmentExport.txt', $contents, 'text/plain');
 155
 156         $zipResp = $this->get($page->getUrl("/export/zip"));
 157         $zip = $this->extractZipResponse($zipResp);
 158
 159         $pageData = $zip->data['page'];
 160         $this->assertCount(1, $pageData['attachments']);
 161
 162         $attachmentData = $pageData['attachments'][0];
 163         $this->assertEquals('PageAttachmentExport.txt', $attachmentData['name']);
 164         $this->assertEquals($attachment->id, $attachmentData['id']);
 165         $this->assertArrayNotHasKey('link', $attachmentData);
 166         $this->assertNotEmpty($attachmentData['file']);
 167
 168         $fileRef = $attachmentData['file'];
 169         $filePath = $zip->extractPath("/files/$fileRef");
 170         $this->assertFileExists($filePath);
 171         $this->assertEquals($contents, file_get_contents($filePath));
 172     }
 173
 174     public function test_page_export_link_attachments()
 175     {
 176         $page = $this->entities->page();
 177         $this->asEditor();
 178         $attachment = Attachment::factory()->create([
 179             'name' => 'My link attachment for export',
 180             'path' => 'https://example.com/cats',
 181             'external' => true,
 182             'uploaded_to' => $page->id,
 183             'order' => 1,
 184         ]);
 185
 186         $zipResp = $this->get($page->getUrl("/export/zip"));
 187         $zip = $this->extractZipResponse($zipResp);
 188
 189         $pageData = $zip->data['page'];
 190         $this->assertCount(1, $pageData['attachments']);
 191
 192         $attachmentData = $pageData['attachments'][0];
 193         $this->assertEquals('My link attachment for export', $attachmentData['name']);
 194         $this->assertEquals($attachment->id, $attachmentData['id']);
 195         $this->assertEquals('https://example.com/cats', $attachmentData['link']);
 196         $this->assertArrayNotHasKey('file', $attachmentData);
 197     }
 198
 199     public function test_book_export()
 200     {
 201         $book = $this->entities->book();
 202         $book->tags()->saveMany(Tag::factory()->count(2)->make());
 203
 204         $zipResp = $this->asEditor()->get($book->getUrl("/export/zip"));
 205         $zip = $this->extractZipResponse($zipResp);
 206         $this->assertArrayHasKey('book', $zip->data);
 207
 208         $bookData = $zip->data['book'];
 209         $this->assertEquals($book->id, $bookData['id']);
 210         $this->assertEquals($book->name, $bookData['name']);
 211         $this->assertEquals($book->descriptionHtml(), $bookData['description_html']);
 212         $this->assertCount(2, $bookData['tags']);
 213         $this->assertCount($book->directPages()->count(), $bookData['pages']);
 214         $this->assertCount($book->chapters()->count(), $bookData['chapters']);
 215         $this->assertArrayNotHasKey('cover', $bookData);
 216     }
 217
 218     public function test_book_export_with_cover_image()
 219     {
 220         $book = $this->entities->book();
 221         $bookRepo = $this->app->make(BookRepo::class);
 222         $coverImageFile = $this->files->uploadedImage('cover.png');
 223         $bookRepo->updateCoverImage($book, $coverImageFile);
 224         $coverImage = $book->cover()->first();
 225
 226         $zipResp = $this->asEditor()->get($book->getUrl("/export/zip"));
 227         $zip = $this->extractZipResponse($zipResp);
 228
 229         $this->assertArrayHasKey('cover', $zip->data['book']);
 230         $coverRef = $zip->data['book']['cover'];
 231         $coverPath = $zip->extractPath("/files/$coverRef");
 232         $this->assertFileExists($coverPath);
 233         $this->assertEquals(file_get_contents(public_path($coverImage->path)), file_get_contents($coverPath));
 234     }
 235
 236     public function test_chapter_export()
 237     {
 238         $chapter = $this->entities->chapter();
 239         $chapter->tags()->saveMany(Tag::factory()->count(2)->make());
 240
 241         $zipResp = $this->asEditor()->get($chapter->getUrl("/export/zip"));
 242         $zip = $this->extractZipResponse($zipResp);
 243         $this->assertArrayHasKey('chapter', $zip->data);
 244
 245         $chapterData = $zip->data['chapter'];
 246         $this->assertEquals($chapter->id, $chapterData['id']);
 247         $this->assertEquals($chapter->name, $chapterData['name']);
 248         $this->assertEquals($chapter->descriptionHtml(), $chapterData['description_html']);
 249         $this->assertCount(2, $chapterData['tags']);
 250         $this->assertEquals($chapter->priority, $chapterData['priority']);
 251         $this->assertCount($chapter->pages()->count(), $chapterData['pages']);
 252     }
 253
 254
 255     public function test_cross_reference_links_are_converted()
 256     {
 257         $book = $this->entities->bookHasChaptersAndPages();
 258         $chapter = $book->chapters()->first();
 259         $page = $chapter->pages()->first();
 260
 261         $book->description_html = '<p><a href="' . $chapter->getUrl() . '">Link to chapter</a></p>';
 262         $book->save();
 263         $chapter->description_html = '<p><a href="' . $page->getUrl() . '#section2">Link to page</a></p>';
 264         $chapter->save();
 265         $page->html = '<p><a href="' . $book->getUrl() . '?view=true">Link to book</a></p>';
 266         $page->save();
 267
 268         $zipResp = $this->asEditor()->get($book->getUrl("/export/zip"));
 269         $zip = $this->extractZipResponse($zipResp);
 270         $bookData = $zip->data['book'];
 271         $chapterData = $bookData['chapters'][0];
 272         $pageData = $chapterData['pages'][0];
 273
 274         $this->assertStringContainsString('href="[[bsexport:chapter:' . $chapter->id . ']]"', $bookData['description_html']);
 275         $this->assertStringContainsString('href="[[bsexport:page:' . $page->id . ']]#section2"', $chapterData['description_html']);
 276         $this->assertStringContainsString('href="[[bsexport:book:' . $book->id . ']]?view=true"', $pageData['html']);
 277     }
 278
 279     public function test_book_and_chapter_description_links_to_images_in_pages_are_converted()
 280     {
 281         $book = $this->entities->bookHasChaptersAndPages();
 282         $chapter = $book->chapters()->first();
 283         $page = $chapter->pages()->first();
 284
 285         $this->asEditor();
 286         $this->files->uploadGalleryImageToPage($this, $page);
 287         /** @var Image $image */
 288         $image = Image::query()->where('type', '=', 'gallery')
 289             ->where('uploaded_to', '=', $page->id)->first();
 290
 291         $book->description_html = '<p><a href="' . $image->url . '">Link to image</a></p>';
 292         $book->save();
 293         $chapter->description_html = '<p><a href="' . $image->url . '">Link to image</a></p>';
 294         $chapter->save();
 295
 296         $zipResp = $this->get($book->getUrl("/export/zip"));
 297         $zip = $this->extractZipResponse($zipResp);
 298         $bookData = $zip->data['book'];
 299         $chapterData = $bookData['chapters'][0];
 300
 301         $this->assertStringContainsString('href="[[bsexport:image:' . $image->id . ']]"', $bookData['description_html']);
 302         $this->assertStringContainsString('href="[[bsexport:image:' . $image->id . ']]"', $chapterData['description_html']);
 303     }
 304
 305     public function test_image_links_are_handled_when_using_external_storage_url()
 306     {
 307         $page = $this->entities->page();
 308
 309         $this->asEditor();
 310         $this->files->uploadGalleryImageToPage($this, $page);
 311         /** @var Image $image */
 312         $image = Image::query()->where('type', '=', 'gallery')
 313             ->where('uploaded_to', '=', $page->id)->first();
 314
 315         config()->set('filesystems.url', 'https://i.example.com/content');
 316
 317         $storageUrl = 'https://i.example.com/content/' . ltrim($image->path, '/');
 318         $page->html = '<p><a href="' . $image->url . '">Original URL</a><a href="' . $storageUrl . '">Storage URL</a></p>';
 319         $page->save();
 320
 321         $zipResp = $this->get($page->getUrl("/export/zip"));
 322         $zip = $this->extractZipResponse($zipResp);
 323         $pageData = $zip->data['page'];
 324
 325         $ref = '[[bsexport:image:' . $image->id . ']]';
 326         $this->assertStringContainsString("<a href=\"{$ref}\">Original URL</a><a href=\"{$ref}\">Storage URL</a>", $pageData['html']);
 327     }
 328
 329     public function test_cross_reference_links_external_to_export_are_not_converted()
 330     {
 331         $page = $this->entities->page();
 332         $page->html = '<p><a href="' . $page->book->getUrl() . '">Link to book</a></p>';
 333         $page->save();
 334
 335         $zipResp = $this->asEditor()->get($page->getUrl("/export/zip"));
 336         $zip = $this->extractZipResponse($zipResp);
 337         $pageData = $zip->data['page'];
 338
 339         $this->assertStringContainsString('href="' . $page->book->getUrl() . '"', $pageData['html']);
 340     }
 341
 342     public function test_attachments_links_are_converted()
 343     {
 344         $page = $this->entities->page();
 345         $attachment = Attachment::factory()->create([
 346             'name' => 'My link attachment for export reference',
 347             'path' => 'https://example.com/cats/ref',
 348             'external' => true,
 349             'uploaded_to' => $page->id,
 350             'order' => 1,
 351         ]);
 352
 353         $page->html = '<p><a href="' . url("/attachments/{$attachment->id}") . '?open=true">Link to attachment</a></p>';
 354         $page->save();
 355
 356         $zipResp = $this->asEditor()->get($page->getUrl("/export/zip"));
 357         $zip = $this->extractZipResponse($zipResp);
 358         $pageData = $zip->data['page'];
 359
 360         $this->assertStringContainsString('href="[[bsexport:attachment:' . $attachment->id . ']]?open=true"', $pageData['html']);
 361     }
 362
 363     public function test_links_in_markdown_are_parsed()
 364     {
 365         $chapter = $this->entities->chapterHasPages();
 366         $page = $chapter->pages()->first();
 367
 368         $page->markdown = "[Link to chapter]({$chapter->getUrl()})";
 369         $page->save();
 370
 371         $zipResp = $this->asEditor()->get($chapter->getUrl("/export/zip"));
 372         $zip = $this->extractZipResponse($zipResp);
 373         $pageData = $zip->data['chapter']['pages'][0];
 374
 375         $this->assertStringContainsString("[Link to chapter]([[bsexport:chapter:{$chapter->id}]])", $pageData['markdown']);
 376     }
 377
 378     protected function extractZipResponse(TestResponse $response): ZipResultData
 379     {
 380         $zipData = $response->streamedContent();
 381         $zipFile = tempnam(sys_get_temp_dir(), 'bstest-');
 382
 383         file_put_contents($zipFile, $zipData);
 384         $extractDir = tempnam(sys_get_temp_dir(), 'bstestextracted-');
 385         if (file_exists($extractDir)) {
 386             unlink($extractDir);
 387         }
 388         mkdir($extractDir);
 389
 390         $zip = new ZipArchive();
 391         $zip->open($zipFile, ZipArchive::RDONLY);
 392         $zip->extractTo($extractDir);
 393
 394         $dataJson = file_get_contents($extractDir . DIRECTORY_SEPARATOR . "data.json");
 395         $data = json_decode($dataJson, true);
 396
 397         return new ZipResultData(
 398             $zipFile,
 399             $extractDir,
 400             $data,
 401         );
 402     }
 403 }