src/catalogue/tests/book_import.py

   1 # -*- coding: utf-8 -*-
   2 # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later.
   3 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
   4 #
   5 from django.core.files.base import ContentFile
   6 from catalogue.test_utils import *
   7 from catalogue import models
   8 from librarian import WLURI
   9
  10 from nose.tools import raises
  11 from os import path, makedirs
  12
  13
  14 class BookImportLogicTests(WLTestCase):
  15
  16     def setUp(self):
  17         WLTestCase.setUp(self)
  18         self.book_info = BookInfoStub(
  19             url=WLURI.from_slug(u"default-book"),
  20             about=u"http://wolnelektury.pl/example/URI/default_book",
  21             title=u"Default Book",
  22             author=PersonStub(("Jim",), "Lazy"),
  23             kind="X-Kind",
  24             genre="X-Genre",
  25             epoch="X-Epoch",
  26             language=u"pol",
  27         )
  28
  29         self.expected_tags = [
  30            ('author', 'jim-lazy'),
  31            ('genre', 'x-genre'),
  32            ('epoch', 'x-epoch'),
  33            ('kind', 'x-kind'),
  34         ]
  35         self.expected_tags.sort()
  36
  37     def test_empty_book(self):
  38         book_text = "<utwor />"
  39         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
  40
  41         self.assertEqual(book.title, "Default Book")
  42         self.assertEqual(book.slug, "default-book")
  43         self.assert_(book.parent is None)
  44         self.assertFalse(book.has_html_file())
  45
  46         # no fragments generated
  47         self.assertEqual(book.fragments.count(), 0)
  48
  49         # TODO: this should be filled out probably...
  50         self.assertEqual(book.wiki_link, '')
  51         self.assertEqual(book.gazeta_link, '')
  52         self.assertEqual(book.description, '')
  53
  54         tags = [(tag.category, tag.slug) for tag in book.tags]
  55         tags.sort()
  56
  57         self.assertEqual(tags, self.expected_tags)
  58
  59     def test_not_quite_empty_book(self):
  60         """ Not empty, but without any real text.
  61
  62         Should work like any other non-empty book.
  63         """
  64
  65         book_text = """<utwor>
  66         <liryka_l>
  67             <nazwa_utworu>Nic</nazwa_utworu>
  68         </liryka_l></utwor>
  69         """
  70
  71         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
  72         self.assertTrue(book.has_html_file())
  73
  74     def test_book_with_fragment(self):
  75         book_text = """<utwor>
  76         <opowiadanie>
  77             <akap><begin id="m01" /><motyw id="m01">Love</motyw>Ala ma kota<end id="m01" /></akap>
  78         </opowiadanie></utwor>
  79         """
  80
  81         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
  82         self.assertTrue(book.has_html_file())
  83
  84         self.assertEqual(book.fragments.count(), 1)
  85         self.assertEqual(book.fragments.all()[0].text, u'<p class="paragraph">Ala ma kota</p>\n')
  86
  87         self.assert_(('theme', 'love') in [(tag.category, tag.slug) for tag in book.fragments.all()[0].tags])
  88
  89     def test_book_with_empty_theme(self):
  90         """ empty themes should be ignored """
  91
  92         book_text = """<utwor>
  93         <opowiadanie>
  94             <akap><begin id="m01" /><motyw id="m01"> , Love , , </motyw>Ala ma kota<end id="m01" /></akap>
  95         </opowiadanie></utwor>
  96         """
  97
  98         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
  99         self.assert_([('theme', 'love')],
 100                      book.fragments.all()[0].tags.filter(category='theme').values_list('category', 'slug'))
 101
 102     def test_book_with_no_theme(self):
 103         """ fragments with no themes shouldn't be created at all """
 104
 105         book_text = """<utwor>
 106         <opowiadanie>
 107             <akap><begin id="m01" /><motyw id="m01"></motyw>Ala ma kota<end id="m01" /></akap>
 108         </opowiadanie></utwor>
 109         """
 110
 111         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
 112         self.assertEqual(book.fragments.count(), 0)
 113         self.assertEqual(book.tags.filter(category='theme').count(), 0)
 114
 115     @raises(ValueError)
 116     def test_book_with_invalid_slug(self):
 117         """ Book with invalid characters in slug shouldn't be imported """
 118         self.book_info.url = WLURI.from_slug(u"default_book")
 119         book_text = "<utwor />"
 120         models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
 121
 122     def test_book_replace_title(self):
 123         book_text = """<utwor />"""
 124         models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
 125         self.book_info.title = u"Extraordinary"
 126         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info, overwrite=True)
 127
 128         tags = [(tag.category, tag.slug) for tag in book.tags]
 129         tags.sort()
 130
 131         self.assertEqual(tags, self.expected_tags)
 132
 133     def test_book_replace_author(self):
 134         book_text = """<utwor />"""
 135         models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
 136         self.book_info.author = PersonStub(("Hans", "Christian"), "Andersen")
 137         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info, overwrite=True)
 138
 139         tags = [(tag.category, tag.slug) for tag in book.tags]
 140         tags.sort()
 141
 142         self.expected_tags.remove(('author', 'jim-lazy'))
 143         self.expected_tags.append(('author', 'hans-christian-andersen'))
 144         self.expected_tags.sort()
 145
 146         self.assertEqual(tags, self.expected_tags)
 147
 148         # the old tag shouldn't disappear
 149         models.Tag.objects.get(slug="jim-lazy", category="author")
 150
 151     def test_book_remove_fragment(self):
 152         book_text = """<utwor>
 153         <opowiadanie>
 154             <akap>
 155                 <begin id="m01" /><motyw id="m01">Love</motyw>Ala ma kota<end id="m01" />
 156                 <begin id="m02" /><motyw id="m02">Hatred</motyw>To kot Ali<end id="m02" />
 157             </akap>
 158         </opowiadanie></utwor>
 159         """
 160         book_text_after = """<utwor>
 161         <opowiadanie>
 162             <akap>
 163                 <begin id="m01" /><motyw id="m01">Love</motyw>Ala ma kota<end id="m01" />
 164                 To kot Ali
 165             </akap>
 166         </opowiadanie></utwor>
 167         """
 168
 169         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
 170         self.assertEqual(book.fragments.count(), 2)
 171         book = models.Book.from_text_and_meta(ContentFile(book_text_after), self.book_info, overwrite=True)
 172         self.assertEqual(book.fragments.count(), 1)
 173
 174     def test_multiple_tags(self):
 175         book_text = """<utwor />"""
 176         self.book_info.authors = self.book_info.author, PersonStub(("Joe",), "Dilligent"),
 177         self.book_info.kinds = self.book_info.kind, 'Y-Kind',
 178         self.book_info.genres = self.book_info.genre, 'Y-Genre',
 179         self.book_info.epochs = self.book_info.epoch, 'Y-Epoch',
 180
 181         self.expected_tags.extend([
 182            ('author', 'joe-dilligent'),
 183            ('genre', 'y-genre'),
 184            ('epoch', 'y-epoch'),
 185            ('kind', 'y-kind'),
 186         ])
 187         self.expected_tags.sort()
 188
 189         book = models.Book.from_text_and_meta(ContentFile(book_text), self.book_info)
 190         tags = [(tag.category, tag.slug) for tag in book.tags]
 191         tags.sort()
 192
 193         self.assertEqual(tags, self.expected_tags)
 194
 195
 196 class ChildImportTests(WLTestCase):
 197
 198     def setUp(self):
 199         WLTestCase.setUp(self)
 200         self.child_info = BookInfoStub(
 201             genre='X-Genre',
 202             epoch='X-Epoch',
 203             kind='X-Kind',
 204             author=PersonStub(("Joe",), "Doe"),
 205             **info_args("Child")
 206         )
 207
 208         self.parent_info = BookInfoStub(
 209             genre='X-Genre',
 210             epoch='X-Epoch',
 211             kind='X-Kind',
 212             author=PersonStub(("Jim",), "Lazy"),
 213             parts=[self.child_info.url],
 214             **info_args("Parent")
 215         )
 216
 217     def test_child(self):
 218         text = """<utwor />"""
 219         child = models.Book.from_text_and_meta(ContentFile(text), self.child_info)
 220         parent = models.Book.from_text_and_meta(ContentFile(text), self.parent_info)
 221         author = parent.tags.get(category='author')
 222         books = self.client.get(author.get_absolute_url()).context['object_list']
 223         self.assertEqual(len(books), 1, "Only parent book should be visible on author's page")
 224
 225     def test_child_replace(self):
 226         parent_text = """<utwor />"""
 227         child_text = """<utwor>
 228         <opowiadanie>
 229             <akap><begin id="m01" /><motyw id="m01">Pies</motyw>Ala ma kota<end id="m01" /></akap>
 230         </opowiadanie></utwor>
 231         """
 232         child = models.Book.from_text_and_meta(ContentFile(child_text), self.child_info)
 233         parent = models.Book.from_text_and_meta(ContentFile(parent_text), self.parent_info)
 234         child_text = """<utwor>
 235         <opowiadanie>
 236             <akap><begin id="m01" /><motyw id="m01">Kot</motyw>Ala ma kota<end id="m01" /></akap>
 237         </opowiadanie></utwor>
 238         """
 239         child = models.Book.from_text_and_meta(ContentFile(child_text), self.child_info, overwrite=True)
 240         themes = parent.related_themes()
 241         self.assertEqual(['Kot'], [tag.name for tag in themes], 'wrong related theme list')
 242
 243
 244 class TreeImportTest(WLTestCase):
 245     def setUp(self):
 246         WLTestCase.setUp(self)
 247         self.child_info = BookInfoStub(
 248             genre='X-Genre',
 249             epoch='X-Epoch',
 250             kind='X-Kind',
 251             author=PersonStub(("Joe",), "Doe"),
 252             **info_args("Child")
 253         )
 254         self.CHILD_TEXT = """<utwor>
 255         <opowiadanie>
 256             <akap><begin id="m01" /><motyw id="m01">Pies</motyw>
 257                 Ala ma kota<end id="m01" /></akap>
 258         </opowiadanie></utwor>
 259         """
 260         self.child = models.Book.from_text_and_meta(
 261             ContentFile(self.CHILD_TEXT), self.child_info)
 262
 263         self.book_info = BookInfoStub(
 264             genre='X-Genre',
 265             epoch='X-Epoch',
 266             kind='X-Kind',
 267             author=PersonStub(("Joe",), "Doe"),
 268             parts=[self.child_info.url],
 269             **info_args("Book")
 270         )
 271         self.BOOK_TEXT = """<utwor />"""
 272         self.book = models.Book.from_text_and_meta(
 273             ContentFile(self.BOOK_TEXT), self.book_info)
 274
 275         self.parent_info = BookInfoStub(
 276             genre='X-Genre',
 277             epoch='X-Epoch',
 278             kind='X-Kind',
 279             author=PersonStub(("Jim",), "Lazy"),
 280             parts=[self.book_info.url],
 281             **info_args("Parent")
 282         )
 283         self.PARENT_TEXT = """<utwor />"""
 284         self.parent = models.Book.from_text_and_meta(
 285             ContentFile(self.PARENT_TEXT), self.parent_info)
 286
 287     def test_ok(self):
 288         self.assertEqual(
 289                 list(self.client.get('/katalog/gatunek/x-genre/').context['object_list']),
 290                 [self.parent],
 291                 u"There should be only parent on common tag page."
 292             )
 293         # pies = models.Tag.objects.get(slug='pies')
 294         themes = self.parent.related_themes()
 295         self.assertEqual(len(themes), 1, u"There should be child theme in parent theme counter.")
 296         # TODO: book_count is deprecated, update here.
 297         # epoch = models.Tag.objects.get(slug='x-epoch')
 298         # self.assertEqual(epoch.book_count, 1, u"There should be only parent in common tag's counter.")
 299
 300     def test_child_republish(self):
 301         child_text = """<utwor>
 302         <opowiadanie>
 303             <akap><begin id="m01" /><motyw id="m01">Pies, Kot</motyw>
 304                 Ala ma kota<end id="m01" /></akap>
 305         </opowiadanie></utwor>
 306         """
 307         models.Book.from_text_and_meta(
 308             ContentFile(child_text), self.child_info, overwrite=True)
 309         self.assertEqual(
 310                 list(self.client.get('/katalog/gatunek/x-genre/').context['object_list']),
 311                 [self.parent],
 312                 u"There should only be parent on common tag page."
 313             )
 314         # pies = models.Tag.objects.get(slug='pies')
 315         # kot = models.Tag.objects.get(slug='kot')
 316         self.assertEqual(len(self.parent.related_themes()), 2,
 317                          u"There should be child themes in parent theme counter.")
 318         # TODO: book_count is deprecated, update here.
 319         # epoch = models.Tag.objects.get(slug='x-epoch')
 320         # self.assertEqual(epoch.book_count, 1, u"There should only be parent in common tag's counter.")
 321
 322     def test_book_change_child(self):
 323         second_child_info = BookInfoStub(
 324             genre='X-Genre',
 325             epoch='X-Epoch',
 326             kind='Other-Kind',
 327             author=PersonStub(("Joe",), "Doe"),
 328             **info_args("Second Child")
 329         )
 330         second_child_text = """<utwor>
 331         <opowiadanie>
 332             <akap><begin id="m01" /><motyw id="m01">Kot</motyw>
 333                 Ala ma kota<end id="m01" /></akap>
 334         </opowiadanie></utwor>
 335         """
 336         # Import a second child.
 337         second_child = models.Book.from_text_and_meta(
 338             ContentFile(second_child_text), second_child_info)
 339         # The book has only this new child now.
 340         self.book_info.parts = [second_child_info.url]
 341         self.book = models.Book.from_text_and_meta(
 342             ContentFile(self.BOOK_TEXT), self.book_info, overwrite=True)
 343
 344         self.assertEqual(
 345             set(self.client.get('/katalog/gatunek/x-genre/').context['object_list']),
 346             {self.parent, self.child},
 347             u"There should be parent and old child on common tag page."
 348         )
 349         # kot = models.Tag.objects.get(slug='kot')
 350         self.assertEqual(len(self.parent.related_themes()), 1,
 351                          u"There should only be new child themes in parent theme counter.")
 352         # # book_count deprecated, update test.
 353         # epoch = models.Tag.objects.get(slug='x-epoch')
 354         # self.assertEqual(epoch.book_count, 2,
 355         #                  u"There should be parent and old child in common tag's counter.")
 356         self.assertEqual(
 357             list(self.client.get('/katalog/lektura/parent/motyw/kot/').context['fragments']),
 358             [second_child.fragments.all()[0]],
 359             u"There should be new child's fragments on parent's theme page."
 360         )
 361         self.assertEqual(
 362             list(self.client.get('/katalog/lektura/parent/motyw/pies/').context['fragments']),
 363             [],
 364             u"There should be no old child's fragments on parent's theme page."
 365         )
 366
 367
 368 class MultilingualBookImportTest(WLTestCase):
 369     def setUp(self):
 370         WLTestCase.setUp(self)
 371         common_uri = WLURI.from_slug('common-slug')
 372
 373         self.pol_info = BookInfoStub(
 374             genre='X-Genre',
 375             epoch='X-Epoch',
 376             kind='X-Kind',
 377             author=PersonStub(("Joe",), "Doe"),
 378             variant_of=common_uri,
 379             **info_args(u"Książka")
 380         )
 381
 382         self.eng_info = BookInfoStub(
 383             genre='X-Genre',
 384             epoch='X-Epoch',
 385             kind='X-Kind',
 386             author=PersonStub(("Joe",), "Doe"),
 387             variant_of=common_uri,
 388             **info_args("A book", "eng")
 389         )
 390
 391     def test_multilingual_import(self):
 392         book_text = """<utwor><opowiadanie><akap>A</akap></opowiadanie></utwor>"""
 393
 394         models.Book.from_text_and_meta(ContentFile(book_text), self.pol_info)
 395         models.Book.from_text_and_meta(ContentFile(book_text), self.eng_info)
 396
 397         self.assertEqual(
 398             set([b.language for b in models.Book.objects.all()]),
 399             {'pol', 'eng'},
 400             'Books imported in wrong languages.'
 401         )
 402
 403
 404 class BookImportGenerateTest(WLTestCase):
 405     def setUp(self):
 406         WLTestCase.setUp(self)
 407         xml = path.join(path.dirname(__file__), 'files/fraszka-do-anusie.xml')
 408         self.book = models.Book.from_xml_file(xml)
 409
 410     def test_gen_pdf(self):
 411         self.book.pdf_file.build()
 412         book = models.Book.objects.get(pk=self.book.pk)
 413         self.assertTrue(path.exists(book.pdf_file.path))
 414
 415     def test_gen_pdf_parent(self):
 416         """This book contains a child."""
 417         xml = path.join(path.dirname(__file__), "files/fraszki.xml")
 418         parent = models.Book.from_xml_file(xml)
 419         parent.pdf_file.build()
 420         parent = models.Book.objects.get(pk=parent.pk)
 421         self.assertTrue(path.exists(parent.pdf_file.path))
 422
 423     def test_custom_pdf(self):
 424         from catalogue.tasks import build_custom_pdf
 425         out = 'test-custom.pdf'
 426         absoulute_path = path.join(settings.MEDIA_ROOT, out)
 427
 428         if not path.exists(path.dirname(absoulute_path)):
 429             makedirs(path.dirname(absoulute_path))
 430
 431         build_custom_pdf(self.book.id, customizations=['nofootnotes', '13pt', 'a4paper'], file_name=out)
 432         self.assertTrue(path.exists(absoulute_path))