def test_duplicate_lemmas_in_supplements(self):
copy_tst_data("S_I_no_dublicates", "S I")
register = VolumeRegister(Volumes()["S I"], Authors())
update_dict = {"lemma": "Abdymon", "previous": "Abd Hadad", "next": "Abeikta"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
compare(11, len(register.lemmas))
def test_fetch_from_properties_self_append(self):
with LogCapture():
copy_tst_data("I_1_self_append", "I_1")
self.page_mock.title_str = "RE:Aal"
self.page_mock.text = """{{REDaten
|BAND=I,1
|VORGÄNGER=Lemma Previous
|NACHFOLGER=Lemma Next
|WP=Aal_wp_link
|WS=Aal_ws_link
|SORTIERUNG=Aal
|VERWEIS=ON
}}
text.
{{REAutor|OFF}}
{{REDaten
|BAND=I,1
|VORGÄNGER=Lemma Previous2
|NACHFOLGER=Lemma Next2
}}
text.
{{REAutor|OFF}}"""
task = SCANTask(None, self.logger)
task.re_page = RePage(self.page_mock)
task._process_from_article_list()
post_lemma = task.registers["I,1"].get_lemma_by_name("Aal")
compare("w:de:Aal_wp_link", post_lemma.lemma_dict["wp_link"])
compare("s:de:Aal_ws_link", post_lemma.lemma_dict["ws_link"])
compare("Aal", post_lemma.lemma_dict["sort_key"])
compare(True, post_lemma.lemma_dict["redirect"])
compare("Lemma Previous", post_lemma.lemma_dict["previous"])
compare("Lemma Next", post_lemma.lemma_dict["next"])
post_lemma_append = task.registers["I,1"].get_lemma_by_name("Aal", self_supplement=True)
compare("Lemma Previous2", post_lemma_append.lemma_dict["previous"])
compare("Lemma Next2", post_lemma_append.lemma_dict["next"])
def test_header_proof_read(self):
copy_tst_data("I_1_base", "I_1")
i1 = VolumeRegister(Volumes()["I,1"], Authors())._get_header().replace("\n", "")
compare(StringComparison(".*SUM=8.*"), i1)
compare(StringComparison(".*UNK=3.*"), i1)
compare(StringComparison(".*KOR=2.*"), i1)
compare(StringComparison(".*FER=3.*"), i1)
def test_get_lemma_by_id(self):
copy_tst_data("I_1_base", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
lemma = register[2]
compare("Aarassos", lemma["previous"])
with self.assertRaises(IndexError):
print(register[8])
def test_update_pre_and_next_not_possible(self):
copy_tst_data("I_1_sorting2", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "B", "previous": "A", "next": "D"}
with self.assertRaisesRegex(RegisterException, "Diff between previous and next aren't 1 or 2"):
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
def test_persist(self):
copy_tst_data("I_1_two_entries", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
register._lemmas[0]._lemma_dict["previous"] = None
register._lemmas[0]._chapters[0]._dict["author"] = "ÄäÖöÜüß"
register.persist()
expect = """[
{
"lemma": "Aal",
"next": "Aarassos",
"proof_read": 3,
"short_description": "Ein Fisch",
"chapters": [
{
"start": 1,
"end": 4,
"author": "ÄäÖöÜüß"
}
]
},
{
"lemma": "Aarassos",
"previous": "Aal",
"proof_read": 2,
"chapters": [
{
"start": 4,
"end": 4,
"author": "Abert"
}
]
}
]"""
with open(DataRepo.get_data_path().joinpath("I_1.json"), mode="r", encoding="utf-8") as register_file:
compare(expect, register_file.read())
def test_prokleides_2(self):
copy_tst_data("prokleides_2_bug", "XXIII_1")
register = VolumeRegister(Volumes()["XXIII,1"], Authors())
update_dict = {"lemma": "Prokleides 2", "previous": "Prokleides", "next": "Prokles"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
compare(None, register.lemmas[0]["previous"])
compare(None, register.lemmas[2]["next"])
def setUp(self):
copy_tst_data("I_1_alpha", "I_1")
copy_tst_data("III_1_alpha", "III_1")
self.authors = Authors()
self.volumes = Volumes()
self.registers = OrderedDict()
self.registers["I,1"] = VolumeRegister(self.volumes["I,1"], self.authors)
self.registers["III,1"] = VolumeRegister(self.volumes["III,1"], self.authors)
def test_update_lemma(self):
copy_tst_data("I_1_base", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "Aal", "redirect": True}
with Updater(register) as updater:
updater.update_lemma(update_dict, ["next"])
post_lemma = register.get_lemma_by_name("Aal")
self.assertTrue(post_lemma["redirect"])
self.assertIsNone(post_lemma["next"])
def test_get_id_of_lemma(self):
copy_tst_data("I_1_self_append", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
compare(0, register.get_index_of_lemma("Aal"))
compare(2, register.get_index_of_lemma("Something"))
compare(3, register.get_index_of_lemma("Aal", self_supplement=True))
lemma = register.get_lemma_by_name("Aal", self_supplement=True)
compare(3, register.get_index_of_lemma(lemma))
compare(None, register.get_index_of_lemma("Lemma not there"))
def test_header_vg_nf(self):
copy_tst_data("I_1_base", "I_1")
i1 = VolumeRegister(Volumes()["I,1"], Authors())._get_header()
self.assertTrue("VG=" in i1)
self.assertTrue("NF=I,2" in i1)
copy_tst_data("I_1_base", "S I")
si = VolumeRegister(Volumes()["S I"], Authors())._get_header()
self.assertTrue("VG=X A" in si)
self.assertTrue("NF=S II" in si)
def test_update_next_and_previous(self):
copy_tst_data("I_1_sorting2", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "O", "previous": "Ä", "next": "Ü"}
with Updater(register) as updater:
updater._try_update_next_and_previous(update_dict, register.get_lemma_by_name("O"))
post_lemma_previous = register.get_lemma_by_name("Ä")
compare("O", post_lemma_previous["next"])
post_lemma_next = register.get_lemma_by_name("Ü")
compare("O", post_lemma_next["previous"])
def test_update_by_sortkey_raise_error(self):
copy_tst_data("I_1_update_previous_wrong", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "Äarassos", "previous": "Aal", "next": "Aba 1", "sort_key": "Aarassos"}
with self.assertRaisesRegex(RegisterException, "!= next lemma name \"Ab 1\""):
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
previous_lemma = register.get_lemma_by_name("Aal")
compare("Aarassos", previous_lemma["next"])
next_lemma = register.get_lemma_by_name("Ab 1")
compare("Aarassos", next_lemma["previous"])
def test_update_no_update_possible(self):
copy_tst_data("I_1_base", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "bubum",
"redirect": True,
"sort_key": "babam",
"previous": "rubbish",
"next": "something"}
with self.assertRaisesRegex(RegisterException, "No strategy available"):
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
def test_get_lemma_self_append(self):
copy_tst_data("I_1_self_append", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
lemma = register.get_lemma_by_name("Aal")
compare(None, lemma["previous"])
lemma = register.get_lemma_by_name("Aal", self_supplement=True)
compare("Something", lemma["previous"])
lemma = register.get_lemma_by_sort_key("AAL", self_supplement=True)
compare("Something", lemma["previous"])
lemma = register.get_lemma_by_name("Something", self_supplement=True)
compare(None, lemma)
def test_init(self):
for volume in Volumes().all_volumes:
copy_tst_data("I_1_base", volume.file_name)
registers = Registers()
iterator = iter(registers.volumes.values())
compare("I,1", next(iterator).volume.name)
for _ in range(83):
last = next(iterator)
compare("R", last.volume.name)
compare(84, len(registers.volumes))
compare("IV,1", registers["IV,1"].volume.name)
def test_acutius_1a(self):
copy_tst_data("acutius_1a_bug", "S I")
register = VolumeRegister(Volumes()["S I"], Authors())
update_dict = {"lemma": "Acutius a", "previous": "Acronoma", "next": "Acutius 1a", "sort_key": "Acutius 0a"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
update_dict = {"lemma": "Acutius 1a", "previous": "Acutius a", "next": "Adaba", "redirect": True}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
# don't create a new lemma, because Acutius a != Acutius 0a
compare(5, len(register.lemmas))
def test_update_lemma_by_sortkey(self):
copy_tst_data("I_1_base", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "Äal", "redirect": True, "sort_key": "Aal", "next": "Aarassos"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
post_lemma = register.get_lemma_by_name("Äal")
compare(True, post_lemma["redirect"])
compare("Aal", post_lemma["sort_key"])
post_lemma_next = register.get_lemma_by_name("Aarassos")
compare("Äal", post_lemma_next["previous"])
def test_persist(self):
copy_tst_data("I_1_alpha", "I_1")
copy_tst_data("III_1_alpha", "III_1")
registers = Registers()
register_I_1 = registers["I,1"]
register_I_1._lemmas[0]._chapters[0]._dict["author"] = "Siegfried"
register_III_1 = registers["III,1"]
register_III_1._lemmas[0]._chapters[0]._dict["author"] = "Siegfried"
registers.persist()
with open(DataRepo.get_data_path().joinpath("I_1.json"), mode="r", encoding="utf-8") as register_file:
self.assertTrue("Siegfried" in register_file.read())
with open(DataRepo.get_data_path().joinpath("III_1.json"), mode="r", encoding="utf-8") as register_file:
self.assertTrue("Siegfried" in register_file.read())
def test_author(self):
copy_tst_data("I_1_author", "I_1")
copy_tst_data("III_1_author", "III_1")
author_registers = iter(Registers().author)
register = next(author_registers)
compare("Herman Abel", register.author.name)
compare(4, len(register))
register = next(author_registers)
compare("Abert", register.author.name)
compare(5, len(register))
register = next(author_registers)
compare("William Abbott", register.author.name)
compare(2, len(register))
def test_update_by_insert_before_next_no_previous(self):
copy_tst_data("I_1_sorting2", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "B", "next": "Ö"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
post_lemma = register.get_lemma_by_name("B")
compare(None, post_lemma["previous"])
compare("Ö", post_lemma["next"])
post_lemma_previous = register.get_lemma_by_name("A")
compare(None, post_lemma_previous["next"])
post_lemma_next = register.get_lemma_by_name("Ö")
compare("B", post_lemma_next["previous"])
post_lemma_next_next = register.get_lemma_by_name("U")
compare("Ö", post_lemma_next_next["previous"])
def test_update_lemma_by_sortkey_pre_and_next_lemma_other_name(self):
copy_tst_data("I_1_sorting2", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "Ö", "sort_key": "O", "previous": "Ä", "next": "Ü"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
post_lemma = register.get_lemma_by_name("Ö")
compare("O", post_lemma["sort_key"])
post_lemma_previous = register.get_lemma_by_name("Ä")
compare("Ö", post_lemma_previous["next"])
post_lemma_next = register.get_lemma_by_name("Ü")
compare("Ö", post_lemma_next["previous"])
post_lemma_start = register.get_lemma_by_name("Vor A")
compare("Ä", post_lemma_start["next"])
post_lemma_end = register.get_lemma_by_name("D")
compare("Ü", post_lemma_end["previous"])
def test_update_by_replace(self):
copy_tst_data("I_1_sorting2", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
update_dict = {"lemma": "B", "previous": "Ä", "next": "Ü"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
post_lemma = register.get_lemma_by_name("B")
compare("Ä", post_lemma["previous"])
compare("Ü", post_lemma["next"])
post_lemma_previous = register.get_lemma_by_name("Ä")
compare("B", post_lemma_previous["next"])
post_lemma_previous_previous = register.get_lemma_by_name("Vor A")
compare("Ä", post_lemma_previous_previous["next"])
post_lemma_next = register.get_lemma_by_name("Ü")
compare("B", post_lemma_next["previous"])
post_lemma_next_next = register.get_lemma_by_name("D")
compare("Ü", post_lemma_next_next["previous"])
def test_bug_to_much_percent(self):
copy_tst_data("I_1_author_bug_percent", "I_1")
copy_tst_data("III_1_author_bug_percent", "III_1")
registers = OrderedDict()
registers["I,1"] = VolumeRegister(self.volumes["I,1"], self.authors)
registers["III,1"] = VolumeRegister(self.volumes["III,1"],
self.authors)
abel_register = AuthorRegister(self.authors.get_author("Herman Abel"),
self.authors, registers)
compare(
"|-\n"
"|data-sort-value=\"Abel, Herman\""
"|[[Paulys Realencyclopädie der classischen Altertumswissenschaft/Register/Herman Abel|Herman Abel]]\n"
"|data-sort-value=\"0005\"|5\n"
"|data-sort-value=\"100.0\"|100.0%\n"
"|<span style=\"color:#669966\">████████████████████</span>"
"<span style=\"color:#556B2F\"></span>"
"<span style=\"color:#AA0000\"></span>",
abel_register.overview_line)
def test_update_create_next_previous_supplement_by_sort_key(self):
copy_tst_data("I_1_sorting2", "S I")
register = VolumeRegister(Volumes()["S I"], Authors())
update_dict = {"lemma": "Ö", "previous": "blub", "next": "Ä"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
compare(8, len(register.lemmas))
update_dict = {"lemma": "Ä", "previous": "Ö", "next": "blab"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
compare(9, len(register.lemmas))
post_lemma = register.get_lemma_by_name("Ö")
compare("blub", post_lemma["previous"])
compare("Ä", post_lemma["next"])
post_lemma = register.get_lemma_by_name("Ä")
compare("Ö", post_lemma["previous"])
compare("blab", post_lemma["next"])
self.assertTrue(register.get_index_of_lemma("Ä") <
register.get_index_of_lemma("blab") <
register.get_index_of_lemma("blub") <
register.get_index_of_lemma("Ö"))
def test_alphabetic(self):
copy_tst_data("I_1_alpha", "I_1")
copy_tst_data("III_1_alpha", "III_1")
i = 0
for i, register in enumerate(Registers().alphabetic):
if register.start == "a":
compare(4, len(register))
continue
if register.start == "b":
compare(2, len(register))
continue
if register.start == "ch":
compare(1, len(register))
continue
if register.start == "d":
compare(1, len(register))
continue
if register.start == "u":
compare(2, len(register))
continue
compare(43, i)
def test_update_create_next_previous_supplement_by_name_next_exists(self):
copy_tst_data("I_1_sorting2", "R")
register = VolumeRegister(Volumes()["R"], Authors())
update_dict = {"lemma": "O", "previous": "N", "next": "Ü"}
with Updater(register) as updater:
updater.update_lemma(update_dict, [])
post_lemma = register.get_lemma_by_name("O")
compare("N", post_lemma["previous"])
compare("Ü", post_lemma["next"])
post_lemma_previous = register.get_lemma_by_name("N")
compare("O", post_lemma_previous["next"])
post_lemma_previous_previous = register.get_lemma_by_name("A")
compare(None, post_lemma_previous_previous["next"])
post_lemma_next = register.get_lemma_by_name("Ü")
compare("O", post_lemma_next["previous"])
post_lemma_next_next = register.get_lemma_by_name("D")
compare("Ü", post_lemma_next_next["previous"])
self.assertTrue(register.get_index_of_lemma("A") <
register.get_index_of_lemma("N") <
register.get_index_of_lemma("O") <
register.get_index_of_lemma("Ü") <
register.get_index_of_lemma("D"))
def test_get_table(self):
copy_tst_data("I_1_two_entries", "I_1")
register = VolumeRegister(Volumes()["I,1"], Authors())
expected_table = """{{RERegister
|BAND=I,1
|VG=
|NF=I,2
|SUM=2
|UNK=1
|KOR=1
|FER=0
}}
{|class="wikitable sortable"
!Artikel
!Kurztext
!Wikilinks
!Seite
!Autor
!Stat
|-
|data-sort-value="aal"|[[RE:Aal|'''{{Anker2|Aal}}''']]
||Ein Fisch
||
|[https://elexikon.ch/meyers/RE/I,1_1.png 1]-4
|Herman Abel
|style="background:#FFCBCB"|2069
|-
|data-sort-value="aarassos"|[[RE:Aarassos|'''{{Anker2|Aarassos}}''']]
||
||
|[https://elexikon.ch/meyers/RE/I,1_5.png 4]
|Abert
|style="background:#556B2F"|KOR
|}
[[Kategorie:RE:Register|!]]"""
compare(expected_table, register.get_register_str())
def setUp(self):
super().setUp()
copy_tst_data("I_1_alpha", "I_1")
copy_tst_data("III_1_alpha", "III_1")
def setUp(self):
super().setUp()
copy_tst_data("I_1_base", "I_1")
copy_tst_data("authors", "authors")
copy_tst_data("authors_mapping", "authors_mapping")
self.task = SCANTask(None, self.logger)
