From 6a529e51cc98770db9f24d50c36315bc9b814584 Mon Sep 17 00:00:00 2001 From: Arthur Milchior Date: Fri, 17 Jul 2020 06:08:33 +0200 Subject: [PATCH 1/6] note->n Next commit will transform f into note, and this lead to a variable clash here --- pylib/tests/test_cards.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pylib/tests/test_cards.py b/pylib/tests/test_cards.py index 1760e838e..55bd8908a 100644 --- a/pylib/tests/test_cards.py +++ b/pylib/tests/test_cards.py @@ -52,8 +52,8 @@ def test_genrem(): t["qfmt"] = "{{Back}}" mm.save(m, templates=True) rep = d.backend.get_empty_cards() - for note in rep.notes: - d.remove_cards_and_orphaned_notes(note.card_ids) + for n in rep.notes: + d.remove_cards_and_orphaned_notes(n.card_ids) assert len(f.cards()) == 1 # if we add to the note, a card should be automatically generated f.load() From 4c25835d278e93ee2cfdaae7456358f89c20863b Mon Sep 17 00:00:00 2001 From: Arthur Milchior Date: Fri, 17 Jul 2020 05:18:09 +0200 Subject: [PATCH 2/6] f->note in test Obtained by sed -i "s/\bf\b/note/g" pylib/tests/*py qt/tests/*py --- pylib/tests/test_cards.py | 70 +++---- pylib/tests/test_collection.py | 52 ++--- pylib/tests/test_decks.py | 10 +- pylib/tests/test_exporting.py | 52 ++--- pylib/tests/test_find.py | 104 +++++----- pylib/tests/test_importing.py | 32 +-- pylib/tests/test_latex.py | 40 ++-- pylib/tests/test_media.py | 28 +-- pylib/tests/test_models.py | 236 +++++++++++----------- pylib/tests/test_schedv1.py | 300 ++++++++++++++-------------- pylib/tests/test_schedv2.py | 352 ++++++++++++++++----------------- pylib/tests/test_stats.py | 12 +- pylib/tests/test_template.py | 10 +- pylib/tests/test_undo.py | 18 +- 14 files changed, 660 insertions(+), 656 deletions(-) diff --git a/pylib/tests/test_cards.py b/pylib/tests/test_cards.py index 55bd8908a..74123c164 100644 --- a/pylib/tests/test_cards.py +++ b/pylib/tests/test_cards.py @@ -5,11 +5,11 @@ from tests.shared import getEmptyCol def test_delete(): deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "1" - f["Back"] = "2" - deck.addNote(f) - cid = f.cards()[0].id + note = deck.newNote() + note["Front"] = "1" + note["Back"] = "2" + deck.addNote(note) + cid = note.cards()[0].id deck.reset() deck.sched.answerCard(deck.sched.getCard(), 2) deck.remove_cards_and_orphaned_notes([cid]) @@ -22,22 +22,22 @@ def test_delete(): def test_misc(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "1" - f["Back"] = "2" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "1" + note["Back"] = "2" + d.addNote(note) + c = note.cards()[0] id = d.models.current()["id"] assert c.template()["ord"] == 0 def test_genrem(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "1" - f["Back"] = "" - d.addNote(f) - assert len(f.cards()) == 1 + note = d.newNote() + note["Front"] = "1" + note["Back"] = "" + d.addNote(note) + assert len(note.cards()) == 1 m = d.models.current() mm = d.models # adding a new template should automatically create cards @@ -46,7 +46,7 @@ def test_genrem(): t["afmt"] = "" mm.addTemplate(m, t) mm.save(m, templates=True) - assert len(f.cards()) == 2 + assert len(note.cards()) == 2 # if the template is changed to remove cards, they'll be removed t = m["tmpls"][1] t["qfmt"] = "{{Back}}" @@ -54,40 +54,40 @@ def test_genrem(): rep = d.backend.get_empty_cards() for n in rep.notes: d.remove_cards_and_orphaned_notes(n.card_ids) - assert len(f.cards()) == 1 + assert len(note.cards()) == 1 # if we add to the note, a card should be automatically generated - f.load() - f["Back"] = "1" - f.flush() - assert len(f.cards()) == 2 + note.load() + note["Back"] = "1" + note.flush() + assert len(note.cards()) == 2 def test_gendeck(): d = getEmptyCol() cloze = d.models.byName("Cloze") d.models.setCurrent(cloze) - f = d.newNote() - f["Text"] = "{{c1::one}}" - d.addNote(f) + note = d.newNote() + note["Text"] = "{{c1::one}}" + d.addNote(note) assert d.cardCount() == 1 - assert f.cards()[0].did == 1 + assert note.cards()[0].did == 1 # set the model to a new default deck newId = d.decks.id("new") cloze["did"] = newId d.models.save(cloze, updateReqs=False) # a newly generated card should share the first card's deck - f["Text"] += "{{c2::two}}" - f.flush() - assert f.cards()[1].did == 1 + note["Text"] += "{{c2::two}}" + note.flush() + assert note.cards()[1].did == 1 # and same with multiple cards - f["Text"] += "{{c3::three}}" - f.flush() - assert f.cards()[2].did == 1 + note["Text"] += "{{c3::three}}" + note.flush() + assert note.cards()[2].did == 1 # if one of the cards is in a different deck, it should revert to the # model default - c = f.cards()[1] + c = note.cards()[1] c.did = newId c.flush() - f["Text"] += "{{c4::four}}" - f.flush() - assert f.cards()[3].did == newId + note["Text"] += "{{c4::four}}" + note.flush() + assert note.cards()[3].did == newId diff --git a/pylib/tests/test_collection.py b/pylib/tests/test_collection.py index e0915db1e..59a09ce43 100644 --- a/pylib/tests/test_collection.py +++ b/pylib/tests/test_collection.py @@ -47,10 +47,10 @@ def test_create_open(): def test_noteAddDelete(): deck = getEmptyCol() # add a note - f = deck.newNote() - f["Front"] = "one" - f["Back"] = "two" - n = deck.addNote(f) + note = deck.newNote() + note["Front"] = "one" + note["Back"] = "two" + n = deck.addNote(note) assert n == 1 # test multiple cards - add another template m = deck.models.current() @@ -62,17 +62,17 @@ def test_noteAddDelete(): mm.save(m) assert deck.cardCount() == 2 # creating new notes should use both cards - f = deck.newNote() - f["Front"] = "three" - f["Back"] = "four" - n = deck.addNote(f) + note = deck.newNote() + note["Front"] = "three" + note["Back"] = "four" + n = deck.addNote(note) assert n == 2 assert deck.cardCount() == 4 # check q/a generation - c0 = f.cards()[0] + c0 = note.cards()[0] assert "three" in c0.q() # it should not be a duplicate - assert not f.dupeOrEmpty() + assert not note.dupeOrEmpty() # now let's make a duplicate f2 = deck.newNote() f2["Front"] = "one" @@ -85,36 +85,36 @@ def test_noteAddDelete(): def test_fieldChecksum(): deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "new" - f["Back"] = "new2" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "new" + note["Back"] = "new2" + deck.addNote(note) assert deck.db.scalar("select csum from notes") == int("c2a6b03f", 16) # changing the val should change the checksum - f["Front"] = "newx" - f.flush() + note["Front"] = "newx" + note.flush() assert deck.db.scalar("select csum from notes") == int("302811ae", 16) def test_addDelTags(): deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "1" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "1" + deck.addNote(note) f2 = deck.newNote() f2["Front"] = "2" deck.addNote(f2) # adding for a given id - deck.tags.bulkAdd([f.id], "foo") - f.load() + deck.tags.bulkAdd([note.id], "foo") + note.load() f2.load() - assert "foo" in f.tags + assert "foo" in note.tags assert "foo" not in f2.tags # should be canonified - deck.tags.bulkAdd([f.id], "foo aaa") - f.load() - assert f.tags[0] == "aaa" - assert len(f.tags) == 2 + deck.tags.bulkAdd([note.id], "foo aaa") + note.load() + assert note.tags[0] == "aaa" + assert len(note.tags) == 2 def test_timestamps(): diff --git a/pylib/tests/test_decks.py b/pylib/tests/test_decks.py index cdd74fb6a..a441b9d57 100644 --- a/pylib/tests/test_decks.py +++ b/pylib/tests/test_decks.py @@ -47,11 +47,11 @@ def test_remove(): deck = getEmptyCol() # create a new deck, and add a note/card to it g1 = deck.decks.id("g1") - f = deck.newNote() - f["Front"] = "1" - f.model()["did"] = g1 - deck.addNote(f) - c = f.cards()[0] + note = deck.newNote() + note["Front"] = "1" + note.model()["did"] = g1 + deck.addNote(note) + c = note.cards()[0] assert c.did == g1 assert deck.cardCount() == 1 deck.decks.rem(g1) diff --git a/pylib/tests/test_exporting.py b/pylib/tests/test_exporting.py index f8903cf72..a74d5af74 100644 --- a/pylib/tests/test_exporting.py +++ b/pylib/tests/test_exporting.py @@ -24,17 +24,17 @@ testDir = os.path.dirname(__file__) def setup1(): global deck deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "foo" - f["Back"] = "bar
" - f.tags = ["tag", "tag2"] - deck.addNote(f) + note = deck.newNote() + note["Front"] = "foo" + note["Back"] = "bar
" + note.tags = ["tag", "tag2"] + deck.addNote(note) # with a different deck - f = deck.newNote() - f["Front"] = "baz" - f["Back"] = "qux" - f.model()["did"] = deck.decks.id("new deck") - deck.addNote(f) + note = deck.newNote() + note["Front"] = "baz" + note["Back"] = "qux" + note.model()["did"] = deck.decks.id("new deck") + deck.addNote(note) ########################################################################## @@ -85,8 +85,8 @@ def test_export_anki(): def test_export_ankipkg(): setup1() # add a test file to the media folder - with open(os.path.join(deck.media.dir(), "今日.mp3"), "w") as f: - f.write("test") + with open(os.path.join(deck.media.dir(), "今日.mp3"), "w") as note: + note.write("test") n = deck.newNote() n["Front"] = "[sound:今日.mp3]" deck.addNote(n) @@ -102,9 +102,9 @@ def test_export_ankipkg(): def test_export_anki_due(): setup1() deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "foo" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "foo" + deck.addNote(note) deck.crt -= 86400 * 10 deck.flush() deck.sched.reset() @@ -136,27 +136,27 @@ def test_export_anki_due(): # def test_export_textcard(): # setup1() # e = TextCardExporter(deck) -# f = unicode(tempfile.mkstemp(prefix="ankitest")[1]) -# os.unlink(f) -# e.exportInto(f) +# note = unicode(tempfile.mkstemp(prefix="ankitest")[1]) +# os.unlink(note) +# e.exportInto(note) # e.includeTags = True -# e.exportInto(f) +# e.exportInto(note) def test_export_textnote(): setup1() e = TextNoteExporter(deck) - fd, f = tempfile.mkstemp(prefix="ankitest") - f = str(f) + fd, note = tempfile.mkstemp(prefix="ankitest") + note = str(note) os.close(fd) - os.unlink(f) - e.exportInto(f) - with open(f) as file: + os.unlink(note) + e.exportInto(note) + with open(note) as file: assert file.readline() == "foo\tbar
\ttag tag2\n" e.includeTags = False e.includeHTML = False - e.exportInto(f) - with open(f) as file: + e.exportInto(note) + with open(note) as file: assert file.readline() == "foo\tbar\n" diff --git a/pylib/tests/test_find.py b/pylib/tests/test_find.py index b8ea1c055..dbb387282 100644 --- a/pylib/tests/test_find.py +++ b/pylib/tests/test_find.py @@ -13,24 +13,24 @@ class DummyCollection: def test_findCards(): deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "dog" - f["Back"] = "cat" - f.tags.append("monkey animal_1 * %") - deck.addNote(f) - f1id = f.id - firstCardId = f.cards()[0].id - f = deck.newNote() - f["Front"] = "goats are fun" - f["Back"] = "sheep" - f.tags.append("sheep goat horse animal11") - deck.addNote(f) - f2id = f.id - f = deck.newNote() - f["Front"] = "cat" - f["Back"] = "sheep" - deck.addNote(f) - catCard = f.cards()[0] + note = deck.newNote() + note["Front"] = "dog" + note["Back"] = "cat" + note.tags.append("monkey animal_1 * %") + deck.addNote(note) + f1id = note.id + firstCardId = note.cards()[0].id + note = deck.newNote() + note["Front"] = "goats are fun" + note["Back"] = "sheep" + note.tags.append("sheep goat horse animal11") + deck.addNote(note) + f2id = note.id + note = deck.newNote() + note["Front"] = "cat" + note["Back"] = "sheep" + deck.addNote(note) + catCard = note.cards()[0] m = deck.models.current() m = deck.models.copy(m) mm = deck.models @@ -39,12 +39,12 @@ def test_findCards(): t["afmt"] = "{{Front}}" mm.addTemplate(m, t) mm.save(m) - f = deck.newNote() - f["Front"] = "test" - f["Back"] = "foo bar" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "test" + note["Back"] = "foo bar" + deck.addNote(note) deck.save() - latestCardIds = [c.id for c in f.cards()] + latestCardIds = [c.id for c in note.cards()] # tag searches assert len(deck.findCards("tag:*")) == 5 assert len(deck.findCards("tag:\\*")) == 1 @@ -72,7 +72,7 @@ def test_findCards(): assert len(deck.findCards('"are goats"')) == 0 assert len(deck.findCards('"goats are"')) == 1 # card states - c = f.cards()[0] + c = note.cards()[0] c.queue = c.type = CARD_TYPE_REV assert deck.findCards("is:review") == [] c.flush() @@ -90,7 +90,7 @@ def test_findCards(): assert deck.findCards("is:suspended") == [c.id] # nids assert deck.findCards("nid:54321") == [] - assert len(deck.findCards("nid:%d" % f.id)) == 2 + assert len(deck.findCards("nid:%d" % note.id)) == 2 assert len(deck.findCards("nid:%d,%d" % (f1id, f2id))) == 2 # templates assert len(deck.findCards("card:foo")) == 0 @@ -142,16 +142,16 @@ def test_findCards(): assert len(deck.findCards("deck:*EFAULT")) == 5 assert len(deck.findCards("deck:*cefault")) == 0 # full search - f = deck.newNote() - f["Front"] = "helloworld" - f["Back"] = "abc" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "helloworld" + note["Back"] = "abc" + deck.addNote(note) # as it's the sort field, it matches assert len(deck.findCards("helloworld")) == 2 # assert len(deck.findCards("helloworld", full=True)) == 2 # if we put it on the back, it won't - (f["Front"], f["Back"]) = (f["Back"], f["Front"]) - f.flush() + (note["Front"], note["Back"]) = (note["Back"], note["Front"]) + note.flush() assert len(deck.findCards("helloworld")) == 0 # assert len(deck.findCards("helloworld", full=True)) == 2 # assert len(deck.findCards("back:helloworld", full=True)) == 2 @@ -213,10 +213,10 @@ def test_findCards(): print("some find tests disabled near cutoff") # empty field assert len(deck.findCards("front:")) == 0 - f = deck.newNote() - f["Front"] = "" - f["Back"] = "abc2" - assert deck.addNote(f) == 1 + note = deck.newNote() + note["Front"] = "" + note["Back"] = "abc2" + assert deck.addNote(note) == 1 assert len(deck.findCards("front:")) == 1 # OR searches and nesting assert len(deck.findCards("tag:monkey or tag:sheep")) == 2 @@ -231,44 +231,44 @@ def test_findCards(): def test_findReplace(): deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "foo" - f["Back"] = "bar" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "foo" + note["Back"] = "bar" + deck.addNote(note) f2 = deck.newNote() f2["Front"] = "baz" f2["Back"] = "foo" deck.addNote(f2) - nids = [f.id, f2.id] + nids = [note.id, f2.id] # should do nothing assert deck.findReplace(nids, "abc", "123") == 0 # global replace assert deck.findReplace(nids, "foo", "qux") == 2 - f.load() - assert f["Front"] == "qux" + note.load() + assert note["Front"] == "qux" f2.load() assert f2["Back"] == "qux" # single field replace assert deck.findReplace(nids, "qux", "foo", field="Front") == 1 - f.load() - assert f["Front"] == "foo" + note.load() + assert note["Front"] == "foo" f2.load() assert f2["Back"] == "qux" # regex replace assert deck.findReplace(nids, "B.r", "reg") == 0 - f.load() - assert f["Back"] != "reg" + note.load() + assert note["Back"] != "reg" assert deck.findReplace(nids, "B.r", "reg", regex=True) == 1 - f.load() - assert f["Back"] == "reg" + note.load() + assert note["Back"] == "reg" def test_findDupes(): deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "foo" - f["Back"] = "bar" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "foo" + note["Back"] = "bar" + deck.addNote(note) f2 = deck.newNote() f2["Front"] = "baz" f2["Back"] = "bar" diff --git a/pylib/tests/test_importing.py b/pylib/tests/test_importing.py index 234a836aa..43c9f5a20 100644 --- a/pylib/tests/test_importing.py +++ b/pylib/tests/test_importing.py @@ -37,8 +37,8 @@ def test_anki2_mediadupes(): mid = n.model()["id"] tmp.addNote(n) # add that sound to media folder - with open(os.path.join(tmp.media.dir(), "foo.mp3"), "w") as f: - f.write("foo") + with open(os.path.join(tmp.media.dir(), "foo.mp3"), "w") as note: + note.write("foo") tmp.close() # it should be imported correctly into an empty deck empty = getEmptyCol() @@ -55,8 +55,8 @@ def test_anki2_mediadupes(): # if the local file content is different, and import should trigger a # rename empty.remove_cards_and_orphaned_notes(empty.db.list("select id from cards")) - with open(os.path.join(empty.media.dir(), "foo.mp3"), "w") as f: - f.write("bar") + with open(os.path.join(empty.media.dir(), "foo.mp3"), "w") as note: + note.write("bar") imp = Anki2Importer(empty, tmp.path) imp.run() assert sorted(os.listdir(empty.media.dir())) == ["foo.mp3", "foo_%s.mp3" % mid] @@ -65,8 +65,8 @@ def test_anki2_mediadupes(): # if the localized media file already exists, we rewrite the note and # media empty.remove_cards_and_orphaned_notes(empty.db.list("select id from cards")) - with open(os.path.join(empty.media.dir(), "foo.mp3"), "w") as f: - f.write("bar") + with open(os.path.join(empty.media.dir(), "foo.mp3"), "w") as note: + note.write("bar") imp = Anki2Importer(empty, tmp.path) imp.run() assert sorted(os.listdir(empty.media.dir())) == ["foo.mp3", "foo_%s.mp3" % mid] @@ -89,8 +89,8 @@ def test_apkg(): assert os.listdir(tmp.media.dir()) == ["foo.wav"] # but if the local file has different data, it will rename tmp.remove_cards_and_orphaned_notes(tmp.db.list("select id from cards")) - with open(os.path.join(tmp.media.dir(), "foo.wav"), "w") as f: - f.write("xyz") + with open(os.path.join(tmp.media.dir(), "foo.wav"), "w") as note: + note.write("xyz") imp = AnkiPackageImporter(tmp, apkg) imp.run() assert len(os.listdir(tmp.media.dir())) == 2 @@ -185,8 +185,8 @@ def test_csv2(): deck = getEmptyCol() mm = deck.models m = mm.current() - f = mm.newField("Three") - mm.addField(m, f) + note = mm.newField("Three") + mm.addField(m, note) mm.save(m) n = deck.newNote() n["Front"] = "1" @@ -209,8 +209,8 @@ def test_tsv_tag_modified(): deck = getEmptyCol() mm = deck.models m = mm.current() - f = mm.newField("Top") - mm.addField(m, f) + note = mm.newField("Top") + mm.addField(m, note) mm.save(m) n = deck.newNote() n["Front"] = "1" @@ -245,8 +245,8 @@ def test_tsv_tag_multiple_tags(): deck = getEmptyCol() mm = deck.models m = mm.current() - f = mm.newField("Top") - mm.addField(m, f) + note = mm.newField("Top") + mm.addField(m, note) mm.save(m) n = deck.newNote() n["Front"] = "1" @@ -279,8 +279,8 @@ def test_csv_tag_only_if_modified(): deck = getEmptyCol() mm = deck.models m = mm.current() - f = mm.newField("Left") - mm.addField(m, f) + note = mm.newField("Left") + mm.addField(m, note) mm.save(m) n = deck.newNote() n["Front"] = "1" diff --git a/pylib/tests/test_latex.py b/pylib/tests/test_latex.py index 699909ab7..e21022f55 100644 --- a/pylib/tests/test_latex.py +++ b/pylib/tests/test_latex.py @@ -13,13 +13,13 @@ def test_latex(): anki.latex.pngCommands[0][0] = "nolatex" # add a note with latex - f = d.newNote() - f["Front"] = "[latex]hello[/latex]" - d.addNote(f) + note = d.newNote() + note["Front"] = "[latex]hello[/latex]" + d.addNote(note) # but since latex couldn't run, there's nothing there assert len(os.listdir(d.media.dir())) == 0 # check the error message - msg = f.cards()[0].q() + msg = note.cards()[0].q() assert "executing nolatex" in msg assert "installed" in msg # check if we have latex installed, and abort test if we don't @@ -31,26 +31,26 @@ def test_latex(): # check media db should cause latex to be generated d.media.render_all_latex() assert len(os.listdir(d.media.dir())) == 1 - assert ".png" in f.cards()[0].q() + assert ".png" in note.cards()[0].q() # adding new notes should cause generation on question display - f = d.newNote() - f["Front"] = "[latex]world[/latex]" - d.addNote(f) - f.cards()[0].q() + note = d.newNote() + note["Front"] = "[latex]world[/latex]" + d.addNote(note) + note.cards()[0].q() assert len(os.listdir(d.media.dir())) == 2 # another note with the same media should reuse - f = d.newNote() - f["Front"] = " [latex]world[/latex]" - d.addNote(f) + note = d.newNote() + note["Front"] = " [latex]world[/latex]" + d.addNote(note) assert len(os.listdir(d.media.dir())) == 2 - oldcard = f.cards()[0] + oldcard = note.cards()[0] assert ".png" in oldcard.q() # if we turn off building, then previous cards should work, but cards with # missing media will show a broken image anki.latex.build = False - f = d.newNote() - f["Front"] = "[latex]foo[/latex]" - d.addNote(f) + note = d.newNote() + note["Front"] = "[latex]foo[/latex]" + d.addNote(note) assert len(os.listdir(d.media.dir())) == 2 assert ".png" in oldcard.q() # turn it on again so other test don't suffer @@ -88,8 +88,8 @@ def test_latex(): def _test_includes_bad_command(bad): d = getEmptyCol() - f = d.newNote() - f["Front"] = "[latex]%s[/latex]" % bad - d.addNote(f) - q = f.cards()[0].q() + note = d.newNote() + note["Front"] = "[latex]%s[/latex]" % bad + d.addNote(note) + q = note.cards()[0].q() return ("'%s' is not allowed on cards" % bad in q, "Card content: %s" % q) diff --git a/pylib/tests/test_media.py b/pylib/tests/test_media.py index d5b7c454f..d7fc6b332 100644 --- a/pylib/tests/test_media.py +++ b/pylib/tests/test_media.py @@ -11,15 +11,15 @@ def test_add(): d = getEmptyCol() dir = tempfile.mkdtemp(prefix="anki") path = os.path.join(dir, "foo.jpg") - with open(path, "w") as f: - f.write("hello") + with open(path, "w") as note: + note.write("hello") # new file, should preserve name assert d.media.addFile(path) == "foo.jpg" # adding the same file again should not create a duplicate assert d.media.addFile(path) == "foo.jpg" # but if it has a different sha1, it should - with open(path, "w") as f: - f.write("world") + with open(path, "w") as note: + note.write("world") assert d.media.addFile(path) == "foo-7c211433f02071597741e6ff5a8ea34789abbf43.jpg" @@ -60,18 +60,18 @@ def test_deckIntegration(): file = str(os.path.join(testDir, "support/fake.png")) d.media.addFile(file) # add a note which references it - f = d.newNote() - f["Front"] = "one" - f["Back"] = "" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "" + d.addNote(note) # and one which references a non-existent file - f = d.newNote() - f["Front"] = "one" - f["Back"] = "" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "" + d.addNote(note) # and add another file which isn't used - with open(os.path.join(d.media.dir(), "foo.jpg"), "w") as f: - f.write("test") + with open(os.path.join(d.media.dir(), "foo.jpg"), "w") as note: + note.write("test") # check media ret = d.media.check() assert ret.missing == ["fake2.png"] diff --git a/pylib/tests/test_models.py b/pylib/tests/test_models.py index 0b4c7148d..9d14f580c 100644 --- a/pylib/tests/test_models.py +++ b/pylib/tests/test_models.py @@ -9,10 +9,10 @@ from tests.shared import getEmptyCol def test_modelDelete(): deck = getEmptyCol() - f = deck.newNote() - f["Front"] = "1" - f["Back"] = "2" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "1" + note["Back"] = "2" + deck.addNote(note) assert deck.cardCount() == 1 deck.models.rem(deck.models.current()) assert deck.cardCount() == 0 @@ -34,23 +34,23 @@ def test_modelCopy(): def test_fields(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "1" - f["Back"] = "2" - d.addNote(f) + note = d.newNote() + note["Front"] = "1" + note["Back"] = "2" + d.addNote(note) m = d.models.current() # make sure renaming a field updates the templates d.models.renameField(m, m["flds"][0], "NewFront") assert "{{NewFront}}" in m["tmpls"][0]["qfmt"] h = d.models.scmhash(m) # add a field - f = d.models.newField("foo") - d.models.addField(m, f) + note = d.models.newField("foo") + d.models.addField(m, note) assert d.getNote(d.models.nids(m)[0]).fields == ["1", "2", ""] assert d.models.scmhash(m) != h # rename it - f = m["flds"][2] - d.models.renameField(m, f, "bar") + note = m["flds"][2] + d.models.renameField(m, note, "bar") assert d.getNote(d.models.nids(m)[0])["bar"] == "" # delete back d.models.remField(m, m["flds"][1]) @@ -62,11 +62,11 @@ def test_fields(): d.models.moveField(m, m["flds"][1], 0) assert d.getNote(d.models.nids(m)[0]).fields == ["1", ""] # add another and put in middle - f = d.models.newField("baz") - d.models.addField(m, f) - f = d.getNote(d.models.nids(m)[0]) - f["baz"] = "2" - f.flush() + note = d.models.newField("baz") + d.models.addField(m, note) + note = d.getNote(d.models.nids(m)[0]) + note["baz"] = "2" + note.flush() assert d.getNote(d.models.nids(m)[0]).fields == ["1", "", "2"] # move 2 -> 1 d.models.moveField(m, m["flds"][2], 1) @@ -88,12 +88,12 @@ def test_templates(): t["afmt"] = "{{Front}}" mm.addTemplate(m, t) mm.save(m) - f = d.newNote() - f["Front"] = "1" - f["Back"] = "2" - d.addNote(f) + note = d.newNote() + note["Front"] = "1" + note["Back"] = "2" + d.addNote(note) assert d.cardCount() == 2 - (c, c2) = f.cards() + (c, c2) = note.cards() # first card should have first ord assert c.ord == 0 assert c2.ord == 1 @@ -107,7 +107,7 @@ def test_templates(): d.models.remTemplate(m, m["tmpls"][0]) assert d.cardCount() == 1 # and should have updated the other cards' ordinals - c = f.cards()[0] + c = note.cards()[0] assert c.ord == 0 assert stripHTML(c.q()) == "1" # it shouldn't be possible to orphan notes by removing templates @@ -134,11 +134,11 @@ def test_cloze_ordinals(): mm.save(m) d.models.remTemplate(m, m["tmpls"][0]) - f = d.newNote() - f["Text"] = "{{c1::firstQ::firstA}}{{c2::secondQ::secondA}}" - d.addNote(f) + note = d.newNote() + note["Text"] = "{{c1::firstQ::firstA}}{{c2::secondQ::secondA}}" + d.addNote(note) assert d.cardCount() == 2 - (c, c2) = f.cards() + (c, c2) = note.cards() # first card should have first ord assert c.ord == 0 assert c2.ord == 1 @@ -149,79 +149,83 @@ def test_text(): m = d.models.current() m["tmpls"][0]["qfmt"] = "{{text:Front}}" d.models.save(m) - f = d.newNote() - f["Front"] = "helloworld" - d.addNote(f) - assert "helloworld" in f.cards()[0].q() + note = d.newNote() + note["Front"] = "helloworld" + d.addNote(note) + assert "helloworld" in note.cards()[0].q() def test_cloze(): d = getEmptyCol() d.models.setCurrent(d.models.byName("Cloze")) - f = d.newNote() - assert f.model()["name"] == "Cloze" + note = d.newNote() + assert note.model()["name"] == "Cloze" # a cloze model with no clozes is not empty - f["Text"] = "nothing" - assert d.addNote(f) + note["Text"] = "nothing" + assert d.addNote(note) # try with one cloze - f = d.newNote() - f["Text"] = "hello {{c1::world}}" - assert d.addNote(f) == 1 - assert "hello [...]" in f.cards()[0].q() - assert "hello world" in f.cards()[0].a() + note = d.newNote() + note["Text"] = "hello {{c1::world}}" + assert d.addNote(note) == 1 + assert "hello [...]" in note.cards()[0].q() + assert "hello world" in note.cards()[0].a() # and with a comment - f = d.newNote() - f["Text"] = "hello {{c1::world::typical}}" - assert d.addNote(f) == 1 - assert "[typical]" in f.cards()[0].q() - assert "world" in f.cards()[0].a() + note = d.newNote() + note["Text"] = "hello {{c1::world::typical}}" + assert d.addNote(note) == 1 + assert "[typical]" in note.cards()[0].q() + assert "world" in note.cards()[0].a() # and with 2 clozes - f = d.newNote() - f["Text"] = "hello {{c1::world}} {{c2::bar}}" - assert d.addNote(f) == 2 - (c1, c2) = f.cards() + note = d.newNote() + note["Text"] = "hello {{c1::world}} {{c2::bar}}" + assert d.addNote(note) == 2 + (c1, c2) = note.cards() assert "[...] bar" in c1.q() assert "world bar" in c1.a() assert "world [...]" in c2.q() assert "world bar" in c2.a() # if there are multiple answers for a single cloze, they are given in a # list - f = d.newNote() - f["Text"] = "a {{c1::b}} {{c1::c}}" - assert d.addNote(f) == 1 - assert "b c" in (f.cards()[0].a()) + note = d.newNote() + note["Text"] = "a {{c1::b}} {{c1::c}}" + assert d.addNote(note) == 1 + assert "b c" in ( + note.cards()[0].a() + ) # if we add another cloze, a card should be generated cnt = d.cardCount() - f["Text"] = "{{c2::hello}} {{c1::foo}}" - f.flush() + note["Text"] = "{{c2::hello}} {{c1::foo}}" + note.flush() assert d.cardCount() == cnt + 1 # 0 or negative indices are not supported - f["Text"] += "{{c0::zero}} {{c-1:foo}}" - f.flush() - assert len(f.cards()) == 2 + note["Text"] += "{{c0::zero}} {{c-1:foo}}" + note.flush() + assert len(note.cards()) == 2 def test_cloze_mathjax(): d = getEmptyCol() d.models.setCurrent(d.models.byName("Cloze")) - f = d.newNote() - f[ + note = d.newNote() + note[ "Text" ] = r"{{c1::ok}} \(2^2\) {{c2::not ok}} \(2^{{c3::2}}\) \(x^3\) {{c4::blah}} {{c5::text with \(x^2\) jax}}" - assert d.addNote(f) - assert len(f.cards()) == 5 - assert "class=cloze" in f.cards()[0].q() - assert "class=cloze" in f.cards()[1].q() - assert "class=cloze" not in f.cards()[2].q() - assert "class=cloze" in f.cards()[3].q() - assert "class=cloze" in f.cards()[4].q() + assert d.addNote(note) + assert len(note.cards()) == 5 + assert "class=cloze" in note.cards()[0].q() + assert "class=cloze" in note.cards()[1].q() + assert "class=cloze" not in note.cards()[2].q() + assert "class=cloze" in note.cards()[3].q() + assert "class=cloze" in note.cards()[4].q() - f = d.newNote() - f["Text"] = r"\(a\) {{c1::b}} \[ {{c1::c}} \]" - assert d.addNote(f) - assert len(f.cards()) == 1 + note = d.newNote() + note["Text"] = r"\(a\) {{c1::b}} \[ {{c1::c}} \]" + assert d.addNote(note) + assert len(note.cards()) == 1 assert ( - f.cards()[0].q().endswith(r"\(a\) [...] \[ [...] \]") + note.cards()[0] + .q() + .endswith(r"\(a\) [...] \[ [...] \]") ) @@ -231,10 +235,10 @@ def test_typecloze(): d.models.setCurrent(m) m["tmpls"][0]["qfmt"] = "{{cloze:Text}}{{type:cloze:Text}}" d.models.save(m) - f = d.newNote() - f["Text"] = "hello {{c1::world}}" - d.addNote(f) - assert "[[type:cloze:Text]]" in f.cards()[0].q() + note = d.newNote() + note["Text"] = "hello {{c1::world}}" + d.addNote(note) + assert "[[type:cloze:Text]]" in note.cards()[0].q() def test_chained_mods(): @@ -251,25 +255,25 @@ def test_chained_mods(): mm.save(m) d.models.remTemplate(m, m["tmpls"][0]) - f = d.newNote() + note = d.newNote() q1 = 'phrase' a1 = "sentence" q2 = 'en chaine' a2 = "chained" - f["Text"] = "This {{c1::%s::%s}} demonstrates {{c1::%s::%s}} clozes." % ( + note["Text"] = "This {{c1::%s::%s}} demonstrates {{c1::%s::%s}} clozes." % ( q1, a1, q2, a2, ) - assert d.addNote(f) == 1 + assert d.addNote(note) == 1 assert ( "This [sentence] demonstrates [chained] clozes." - in f.cards()[0].q() + in note.cards()[0].q() ) assert ( "This phrase demonstrates en chaine clozes." - in f.cards()[0].a() + in note.cards()[0].a() ) @@ -285,40 +289,40 @@ def test_modelChange(): mm.addTemplate(m, t) mm.save(m) basic = m - f = deck.newNote() - f["Front"] = "f" - f["Back"] = "b123" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "note" + note["Back"] = "b123" + deck.addNote(note) # switch fields map = {0: 1, 1: 0} - deck.models.change(basic, [f.id], basic, map, None) - f.load() - assert f["Front"] == "b123" - assert f["Back"] == "f" + deck.models.change(basic, [note.id], basic, map, None) + note.load() + assert note["Front"] == "b123" + assert note["Back"] == "note" # switch cards - c0 = f.cards()[0] - c1 = f.cards()[1] + c0 = note.cards()[0] + c1 = note.cards()[1] assert "b123" in c0.q() - assert "f" in c1.q() + assert "note" in c1.q() assert c0.ord == 0 assert c1.ord == 1 - deck.models.change(basic, [f.id], basic, None, map) - f.load() + deck.models.change(basic, [note.id], basic, None, map) + note.load() c0.load() c1.load() - assert "f" in c0.q() + assert "note" in c0.q() assert "b123" in c1.q() assert c0.ord == 1 assert c1.ord == 0 # .cards() returns cards in order - assert f.cards()[0].id == c1.id + assert note.cards()[0].id == c1.id # delete first card map = {0: None, 1: 1} if isWin: # The low precision timer on Windows reveals a race condition time.sleep(0.05) - deck.models.change(basic, [f.id], basic, None, map) - f.load() + deck.models.change(basic, [note.id], basic, None, map) + note.load() c0.load() # the card was deleted try: @@ -327,33 +331,33 @@ def test_modelChange(): except NotFoundError: pass # but we have two cards, as a new one was generated - assert len(f.cards()) == 2 + assert len(note.cards()) == 2 # an unmapped field becomes blank - assert f["Front"] == "b123" - assert f["Back"] == "f" - deck.models.change(basic, [f.id], basic, map, None) - f.load() - assert f["Front"] == "" - assert f["Back"] == "f" + assert note["Front"] == "b123" + assert note["Back"] == "note" + deck.models.change(basic, [note.id], basic, map, None) + note.load() + assert note["Front"] == "" + assert note["Back"] == "note" # another note to try model conversion - f = deck.newNote() - f["Front"] = "f2" - f["Back"] = "b2" - deck.addNote(f) + note = deck.newNote() + note["Front"] = "f2" + note["Back"] = "b2" + deck.addNote(note) counts = deck.models.all_use_counts() assert next(c.use_count for c in counts if c.name == "Basic") == 2 assert next(c.use_count for c in counts if c.name == "Cloze") == 0 map = {0: 0, 1: 1} - deck.models.change(basic, [f.id], cloze, map, map) - f.load() - assert f["Text"] == "f2" - assert len(f.cards()) == 2 + deck.models.change(basic, [note.id], cloze, map, map) + note.load() + assert note["Text"] == "f2" + assert len(note.cards()) == 2 # back the other way, with deletion of second ord deck.models.remTemplate(basic, basic["tmpls"][1]) - assert deck.db.scalar("select count() from cards where nid = ?", f.id) == 2 + assert deck.db.scalar("select count() from cards where nid = ?", note.id) == 2 map = {0: 0} - deck.models.change(cloze, [f.id], basic, map, map) - assert deck.db.scalar("select count() from cards where nid = ?", f.id) == 1 + deck.models.change(cloze, [note.id], basic, map, map) + assert deck.db.scalar("select count() from cards where nid = ?", note.id) == 1 def test_req(): diff --git a/pylib/tests/test_schedv1.py b/pylib/tests/test_schedv1.py index 819e8671d..5e530fe34 100644 --- a/pylib/tests/test_schedv1.py +++ b/pylib/tests/test_schedv1.py @@ -37,10 +37,10 @@ def test_new(): d.reset() assert d.sched.newCount == 0 # add a note - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) d.reset() assert d.sched.newCount == 1 # fetch it @@ -64,12 +64,12 @@ def test_new(): # t['afmt'] = "{{Front}}" # mm.addTemplate(m, t) # mm.save(m) - # f = d.newNote() - # f['Front'] = u"2"; f['Back'] = u"2" - # d.addNote(f) - # f = d.newNote() - # f['Front'] = u"3"; f['Back'] = u"3" - # d.addNote(f) + # note = d.newNote() + # note['Front'] = u"2"; note['Back'] = u"2" + # d.addNote(note) + # note = d.newNote() + # note['Front'] = u"3"; note['Back'] = u"3" + # d.addNote(note) # d.reset() # qs = ("2", "3", "2", "3") # for n in range(4): @@ -83,11 +83,11 @@ def test_newLimits(): # add some notes g2 = d.decks.id("Default::foo") for i in range(30): - f = d.newNote() - f["Front"] = str(i) + note = d.newNote() + note["Front"] = str(i) if i > 4: - f.model()["did"] = g2 - d.addNote(f) + note.model()["did"] = g2 + d.addNote(note) # give the child deck a different configuration c2 = d.decks.add_config_returning_id("new conf") d.decks.setConf(d.decks.get(g2), c2) @@ -113,9 +113,9 @@ def test_newLimits(): def test_newBoxes(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) d.reset() c = d.sched.getCard() conf = d.sched._cardConf(c) @@ -131,10 +131,10 @@ def test_newBoxes(): def test_learn(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - f = d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + note = d.addNote(note) # set as a learn card and rebuild queues d.db.execute("update cards set queue=0, type=0") d.reset() @@ -209,12 +209,12 @@ def test_learn(): def test_learn_collapsed(): d = getEmptyCol() # add 2 notes - f = d.newNote() - f["Front"] = "1" - f = d.addNote(f) - f = d.newNote() - f["Front"] = "2" - f = d.addNote(f) + note = d.newNote() + note["Front"] = "1" + note = d.addNote(note) + note = d.newNote() + note["Front"] = "2" + note = d.addNote(note) # set as a learn card and rebuild queues d.db.execute("update cards set queue=0, type=0") d.reset() @@ -236,9 +236,9 @@ def test_learn_collapsed(): def test_learn_day(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - f = d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note = d.addNote(note) d.sched.reset() c = d.sched.getCard() conf = d.sched._cardConf(c) @@ -299,12 +299,12 @@ def test_learn_day(): def test_reviews(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) # set the card up as a review card, due 8 days ago - c = f.cards()[0] + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = d.sched.today - 8 @@ -379,11 +379,11 @@ def test_reviews(): def test_button_spacing(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # 1 day ivl review card due now - c = f.cards()[0] + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = d.sched.today @@ -404,11 +404,11 @@ def test_overdue_lapse(): return d = getEmptyCol() # pylint: disable=unreachable # add a note - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # simulate a review that was lapsed and is now due for its normal review - c = f.cards()[0] + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = 1 c.due = -1 @@ -440,15 +440,15 @@ def test_finished(): # nothing due assert "Congratulations" in d.sched.finishedMsg() assert "limit" not in d.sched.finishedMsg() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) # have a new card assert "new cards available" in d.sched.finishedMsg() # turn it into a review d.reset() - c = f.cards()[0] + c = note.cards()[0] c.startTimer() d.sched.answerCard(c, 3) # nothing should be due tomorrow, as it's due in a week @@ -458,10 +458,10 @@ def test_finished(): def test_nextIvl(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) d.reset() conf = d.decks.confForDid(1) conf["new"]["delays"] = [0.5, 3, 10] @@ -518,10 +518,10 @@ def test_nextIvl(): def test_misc(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] # burying d.sched.buryNote(c.nid) d.reset() @@ -533,10 +533,10 @@ def test_misc(): def test_suspend(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] # suspending d.reset() assert d.sched.getCard() @@ -581,10 +581,10 @@ def test_suspend(): def test_cram(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] c.ivl = 100 c.queue = CARD_TYPE_REV c.type = QUEUE_TYPE_REV @@ -693,10 +693,10 @@ def test_cram(): def test_cram_rem(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - oldDue = f.cards()[0].due + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + oldDue = note.cards()[0].due did = d.decks.newDyn("Cram") d.sched.rebuildDyn(did) d.reset() @@ -715,9 +715,9 @@ def test_cram_rem(): def test_cram_resched(): # add card d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # cram deck did = d.decks.newDyn("Cram") cram = d.decks.get(did) @@ -835,10 +835,10 @@ def test_ordcycle(): mm.addTemplate(m, t) mm.save(m) # create a new note; it should have 3 cards - f = d.newNote() - f["Front"] = "1" - f["Back"] = "1" - d.addNote(f) + note = d.newNote() + note["Front"] = "1" + note["Back"] = "1" + d.addNote(note) assert d.cardCount() == 3 d.reset() # ordinals should arrive in order @@ -849,10 +849,10 @@ def test_ordcycle(): def test_counts_idx(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) d.reset() assert d.sched.counts() == (1, 0, 0) c = d.sched.getCard() @@ -873,9 +873,9 @@ def test_counts_idx(): def test_repCounts(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) d.reset() # lrnReps should be accurate on pass/fail assert d.sched.counts() == (1, 0, 0) @@ -891,9 +891,9 @@ def test_repCounts(): assert d.sched.counts() == (0, 1, 0) d.sched.answerCard(d.sched.getCard(), 2) assert d.sched.counts() == (0, 0, 0) - f = d.newNote() - f["Front"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + d.addNote(note) d.reset() # initial pass should be correct too d.sched.answerCard(d.sched.getCard(), 2) @@ -903,17 +903,17 @@ def test_repCounts(): d.sched.answerCard(d.sched.getCard(), 3) assert d.sched.counts() == (0, 0, 0) # immediate graduate should work - f = d.newNote() - f["Front"] = "three" - d.addNote(f) + note = d.newNote() + note["Front"] = "three" + d.addNote(note) d.reset() d.sched.answerCard(d.sched.getCard(), 3) assert d.sched.counts() == (0, 0, 0) # and failing a review should too - f = d.newNote() - f["Front"] = "three" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "three" + d.addNote(note) + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = d.sched.today @@ -928,10 +928,10 @@ def test_timing(): d = getEmptyCol() # add a few review cards, due today for i in range(5): - f = d.newNote() - f["Front"] = "num" + str(i) - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "num" + str(i) + d.addNote(note) + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = 0 @@ -962,9 +962,9 @@ def test_timing(): def test_collapse(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) d.reset() # test collapsing c = d.sched.getCard() @@ -977,29 +977,29 @@ def test_collapse(): def test_deckDue(): d = getEmptyCol() # add a note with default deck - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # and one that's a child - f = d.newNote() - f["Front"] = "two" - default1 = f.model()["did"] = d.decks.id("Default::1") - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + default1 = note.model()["did"] = d.decks.id("Default::1") + d.addNote(note) # make it a review card - c = f.cards()[0] + c = note.cards()[0] c.queue = QUEUE_TYPE_REV c.due = 0 c.flush() # add one more with a new deck - f = d.newNote() - f["Front"] = "two" - foobar = f.model()["did"] = d.decks.id("foo::bar") - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + foobar = note.model()["did"] = d.decks.id("foo::bar") + d.addNote(note) # and one that's a sibling - f = d.newNote() - f["Front"] = "three" - foobaz = f.model()["did"] = d.decks.id("foo::baz") - d.addNote(f) + note = d.newNote() + note["Front"] = "three" + foobaz = note.model()["did"] = d.decks.id("foo::baz") + d.addNote(note) d.reset() assert len(d.decks.all_names_and_ids()) == 5 tree = d.sched.deck_due_tree().children @@ -1023,19 +1023,19 @@ def test_deckDue(): def test_deckFlow(): d = getEmptyCol() # add a note with default deck - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # and one that's a child - f = d.newNote() - f["Front"] = "two" - default1 = f.model()["did"] = d.decks.id("Default::2") - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + default1 = note.model()["did"] = d.decks.id("Default::2") + d.addNote(note) # and another that's higher up - f = d.newNote() - f["Front"] = "three" - default1 = f.model()["did"] = d.decks.id("Default::1") - d.addNote(f) + note = d.newNote() + note["Front"] = "three" + default1 = note.model()["did"] = d.decks.id("Default::1") + d.addNote(note) # should get top level one first, then ::1, then ::2 d.reset() assert d.sched.counts() == (3, 0, 0) @@ -1048,9 +1048,9 @@ def test_deckFlow(): def test_reorder(): d = getEmptyCol() # add a note with default deck - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) f2 = d.newNote() f2["Front"] = "two" d.addNote(f2) @@ -1059,12 +1059,12 @@ def test_reorder(): # 50/50 chance of being reordered for i in range(20): d.sched.randomizeCards(1) - if f.cards()[0].due != f.id: + if note.cards()[0].due != note.id: found = True break assert found d.sched.orderCards(1) - assert f.cards()[0].due == 1 + assert note.cards()[0].due == 1 # shifting f3 = d.newNote() f3["Front"] = "three" @@ -1072,12 +1072,12 @@ def test_reorder(): f4 = d.newNote() f4["Front"] = "four" d.addNote(f4) - assert f.cards()[0].due == 1 + assert note.cards()[0].due == 1 assert f2.cards()[0].due == 2 assert f3.cards()[0].due == 3 assert f4.cards()[0].due == 4 d.sched.sortCards([f3.cards()[0].id, f4.cards()[0].id], start=1, shift=True) - assert f.cards()[0].due == 3 + assert note.cards()[0].due == 3 assert f2.cards()[0].due == 4 assert f3.cards()[0].due == 1 assert f4.cards()[0].due == 2 @@ -1085,10 +1085,10 @@ def test_reorder(): def test_forget(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] c.queue = QUEUE_TYPE_REV c.type = CARD_TYPE_REV c.ivl = 100 @@ -1103,10 +1103,10 @@ def test_forget(): def test_resched(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] d.sched.reschedCards([c.id], 0, 0) c.load() assert c.due == d.sched.today @@ -1121,10 +1121,10 @@ def test_resched(): def test_norelearn(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = 0 @@ -1142,11 +1142,11 @@ def test_norelearn(): def test_failmult(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.ivl = 100 diff --git a/pylib/tests/test_schedv2.py b/pylib/tests/test_schedv2.py index 6aeca29a5..b5017acfe 100644 --- a/pylib/tests/test_schedv2.py +++ b/pylib/tests/test_schedv2.py @@ -38,10 +38,10 @@ def test_new(): d.reset() assert d.sched.newCount == 0 # add a note - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) d.reset() assert d.sched.newCount == 1 # fetch it @@ -65,12 +65,12 @@ def test_new(): # t['afmt'] = "{{Front}}" # mm.addTemplate(m, t) # mm.save(m) - # f = d.newNote() - # f['Front'] = u"2"; f['Back'] = u"2" - # d.addNote(f) - # f = d.newNote() - # f['Front'] = u"3"; f['Back'] = u"3" - # d.addNote(f) + # note = d.newNote() + # note['Front'] = u"2"; note['Back'] = u"2" + # d.addNote(note) + # note = d.newNote() + # note['Front'] = u"3"; note['Back'] = u"3" + # d.addNote(note) # d.reset() # qs = ("2", "3", "2", "3") # for n in range(4): @@ -84,11 +84,11 @@ def test_newLimits(): # add some notes g2 = d.decks.id("Default::foo") for i in range(30): - f = d.newNote() - f["Front"] = str(i) + note = d.newNote() + note["Front"] = str(i) if i > 4: - f.model()["did"] = g2 - d.addNote(f) + note.model()["did"] = g2 + d.addNote(note) # give the child deck a different configuration c2 = d.decks.add_config_returning_id("new conf") d.decks.setConf(d.decks.get(g2), c2) @@ -114,9 +114,9 @@ def test_newLimits(): def test_newBoxes(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) d.reset() c = d.sched.getCard() conf = d.sched._cardConf(c) @@ -132,10 +132,10 @@ def test_newBoxes(): def test_learn(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - f = d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + note = d.addNote(note) # set as a learn card and rebuild queues d.db.execute("update cards set queue=0, type=0") d.reset() @@ -194,10 +194,10 @@ def test_learn(): def test_relearn(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] c.ivl = 100 c.due = d.sched.today c.queue = CARD_TYPE_REV @@ -221,10 +221,10 @@ def test_relearn(): def test_relearn_no_steps(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] c.ivl = 100 c.due = d.sched.today c.queue = CARD_TYPE_REV @@ -245,12 +245,12 @@ def test_relearn_no_steps(): def test_learn_collapsed(): d = getEmptyCol() # add 2 notes - f = d.newNote() - f["Front"] = "1" - f = d.addNote(f) - f = d.newNote() - f["Front"] = "2" - f = d.addNote(f) + note = d.newNote() + note["Front"] = "1" + note = d.addNote(note) + note = d.newNote() + note["Front"] = "2" + note = d.addNote(note) # set as a learn card and rebuild queues d.db.execute("update cards set queue=0, type=0") d.reset() @@ -272,9 +272,9 @@ def test_learn_collapsed(): def test_learn_day(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - f = d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note = d.addNote(note) d.sched.reset() c = d.sched.getCard() conf = d.sched._cardConf(c) @@ -335,12 +335,12 @@ def test_learn_day(): def test_reviews(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) # set the card up as a review card, due 8 days ago - c = f.cards()[0] + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = d.sched.today - 8 @@ -431,13 +431,13 @@ def test_review_limits(): # add some cards for i in range(20): - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) # make them reviews - c = f.cards()[0] + c = note.cards()[0] c.queue = CARD_TYPE_REV c.type = QUEUE_TYPE_REV c.due = 0 @@ -465,11 +465,11 @@ def test_review_limits(): def test_button_spacing(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # 1 day ivl review card due now - c = f.cards()[0] + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = d.sched.today @@ -496,11 +496,11 @@ def test_overdue_lapse(): return d = getEmptyCol() # pylint: disable=unreachable # add a note - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # simulate a review that was lapsed and is now due for its normal review - c = f.cards()[0] + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = 1 c.due = -1 @@ -532,15 +532,15 @@ def test_finished(): # nothing due assert "Congratulations" in d.sched.finishedMsg() assert "limit" not in d.sched.finishedMsg() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) # have a new card assert "new cards available" in d.sched.finishedMsg() # turn it into a review d.reset() - c = f.cards()[0] + c = note.cards()[0] c.startTimer() d.sched.answerCard(c, 3) # nothing should be due tomorrow, as it's due in a week @@ -550,10 +550,10 @@ def test_finished(): def test_nextIvl(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) d.reset() conf = d.decks.confForDid(1) conf["new"]["delays"] = [0.5, 3, 10] @@ -613,14 +613,14 @@ def test_nextIvl(): def test_bury(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] - f = d.newNote() - f["Front"] = "two" - d.addNote(f) - c2 = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] + note = d.newNote() + note["Front"] = "two" + d.addNote(note) + c2 = note.cards()[0] # burying d.sched.buryCards([c.id], manual=True) # pylint: disable=unexpected-keyword-arg c.load() @@ -654,10 +654,10 @@ def test_bury(): def test_suspend(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] # suspending d.reset() assert d.sched.getCard() @@ -704,10 +704,10 @@ def test_suspend(): def test_filt_reviewing_early_normal(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] c.ivl = 100 c.queue = CARD_TYPE_REV c.type = QUEUE_TYPE_REV @@ -761,9 +761,9 @@ def test_filt_reviewing_early_normal(): def test_filt_keep_lrn_state(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # fail the card outside filtered deck c = d.sched.getCard() @@ -805,10 +805,10 @@ def test_filt_keep_lrn_state(): def test_preview(): # add cards d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] orig = copy.copy(c) f2 = d.newNote() f2["Front"] = "two" @@ -867,10 +867,10 @@ def test_ordcycle(): mm.addTemplate(m, t) mm.save(m) # create a new note; it should have 3 cards - f = d.newNote() - f["Front"] = "1" - f["Back"] = "1" - d.addNote(f) + note = d.newNote() + note["Front"] = "1" + note["Back"] = "1" + d.addNote(note) assert d.cardCount() == 3 d.reset() # ordinals should arrive in order @@ -881,10 +881,10 @@ def test_ordcycle(): def test_counts_idx(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) d.reset() assert d.sched.counts() == (1, 0, 0) c = d.sched.getCard() @@ -905,9 +905,9 @@ def test_counts_idx(): def test_repCounts(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) d.reset() # lrnReps should be accurate on pass/fail assert d.sched.counts() == (1, 0, 0) @@ -923,9 +923,9 @@ def test_repCounts(): assert d.sched.counts() == (0, 1, 0) d.sched.answerCard(d.sched.getCard(), 3) assert d.sched.counts() == (0, 0, 0) - f = d.newNote() - f["Front"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + d.addNote(note) d.reset() # initial pass should be correct too d.sched.answerCard(d.sched.getCard(), 3) @@ -935,17 +935,17 @@ def test_repCounts(): d.sched.answerCard(d.sched.getCard(), 4) assert d.sched.counts() == (0, 0, 0) # immediate graduate should work - f = d.newNote() - f["Front"] = "three" - d.addNote(f) + note = d.newNote() + note["Front"] = "three" + d.addNote(note) d.reset() d.sched.answerCard(d.sched.getCard(), 4) assert d.sched.counts() == (0, 0, 0) # and failing a review should too - f = d.newNote() - f["Front"] = "three" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "three" + d.addNote(note) + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = d.sched.today @@ -960,10 +960,10 @@ def test_timing(): d = getEmptyCol() # add a few review cards, due today for i in range(5): - f = d.newNote() - f["Front"] = "num" + str(i) - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "num" + str(i) + d.addNote(note) + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = 0 @@ -986,9 +986,9 @@ def test_timing(): def test_collapse(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) d.reset() # test collapsing c = d.sched.getCard() @@ -1001,29 +1001,29 @@ def test_collapse(): def test_deckDue(): d = getEmptyCol() # add a note with default deck - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # and one that's a child - f = d.newNote() - f["Front"] = "two" - default1 = f.model()["did"] = d.decks.id("Default::1") - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + default1 = note.model()["did"] = d.decks.id("Default::1") + d.addNote(note) # make it a review card - c = f.cards()[0] + c = note.cards()[0] c.queue = QUEUE_TYPE_REV c.due = 0 c.flush() # add one more with a new deck - f = d.newNote() - f["Front"] = "two" - foobar = f.model()["did"] = d.decks.id("foo::bar") - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + foobar = note.model()["did"] = d.decks.id("foo::bar") + d.addNote(note) # and one that's a sibling - f = d.newNote() - f["Front"] = "three" - foobaz = f.model()["did"] = d.decks.id("foo::baz") - d.addNote(f) + note = d.newNote() + note["Front"] = "three" + foobaz = note.model()["did"] = d.decks.id("foo::baz") + d.addNote(note) d.reset() assert len(d.decks.all_names_and_ids()) == 5 tree = d.sched.deck_due_tree().children @@ -1057,19 +1057,19 @@ def test_deckTree(): def test_deckFlow(): d = getEmptyCol() # add a note with default deck - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) # and one that's a child - f = d.newNote() - f["Front"] = "two" - default1 = f.model()["did"] = d.decks.id("Default::2") - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + default1 = note.model()["did"] = d.decks.id("Default::2") + d.addNote(note) # and another that's higher up - f = d.newNote() - f["Front"] = "three" - default1 = f.model()["did"] = d.decks.id("Default::1") - d.addNote(f) + note = d.newNote() + note["Front"] = "three" + default1 = note.model()["did"] = d.decks.id("Default::1") + d.addNote(note) # should get top level one first, then ::1, then ::2 d.reset() assert d.sched.counts() == (3, 0, 0) @@ -1082,9 +1082,9 @@ def test_deckFlow(): def test_reorder(): d = getEmptyCol() # add a note with default deck - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) f2 = d.newNote() f2["Front"] = "two" d.addNote(f2) @@ -1093,12 +1093,12 @@ def test_reorder(): # 50/50 chance of being reordered for i in range(20): d.sched.randomizeCards(1) - if f.cards()[0].due != f.id: + if note.cards()[0].due != note.id: found = True break assert found d.sched.orderCards(1) - assert f.cards()[0].due == 1 + assert note.cards()[0].due == 1 # shifting f3 = d.newNote() f3["Front"] = "three" @@ -1106,12 +1106,12 @@ def test_reorder(): f4 = d.newNote() f4["Front"] = "four" d.addNote(f4) - assert f.cards()[0].due == 1 + assert note.cards()[0].due == 1 assert f2.cards()[0].due == 2 assert f3.cards()[0].due == 3 assert f4.cards()[0].due == 4 d.sched.sortCards([f3.cards()[0].id, f4.cards()[0].id], start=1, shift=True) - assert f.cards()[0].due == 3 + assert note.cards()[0].due == 3 assert f2.cards()[0].due == 4 assert f3.cards()[0].due == 1 assert f4.cards()[0].due == 2 @@ -1119,10 +1119,10 @@ def test_reorder(): def test_forget(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] c.queue = QUEUE_TYPE_REV c.type = CARD_TYPE_REV c.ivl = 100 @@ -1137,10 +1137,10 @@ def test_forget(): def test_resched(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] d.sched.reschedCards([c.id], 0, 0) c.load() assert c.due == d.sched.today @@ -1155,10 +1155,10 @@ def test_resched(): def test_norelearn(): d = getEmptyCol() # add a note - f = d.newNote() - f["Front"] = "one" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + d.addNote(note) + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = 0 @@ -1176,11 +1176,11 @@ def test_norelearn(): def test_failmult(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) + c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.ivl = 100 @@ -1264,11 +1264,11 @@ def test_negativeDueFilter(): d = getEmptyCol() # card due prior to collection date - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) + c = note.cards()[0] c.due = -5 c.queue = QUEUE_TYPE_REV c.ivl = 5 @@ -1288,10 +1288,10 @@ def test_negativeDueFilter(): # and it should be logged properly def test_initial_repeat(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "one" - f["Back"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + note["Back"] = "two" + d.addNote(note) d.reset() c = d.sched.getCard() diff --git a/pylib/tests/test_stats.py b/pylib/tests/test_stats.py index 91e59e263..56d1b27c6 100644 --- a/pylib/tests/test_stats.py +++ b/pylib/tests/test_stats.py @@ -9,10 +9,10 @@ from tests.shared import getEmptyCol def test_stats(): d = getEmptyCol() - f = d.newNote() - f["Front"] = "foo" - d.addNote(f) - c = f.cards()[0] + note = d.newNote() + note["Front"] = "foo" + d.addNote(note) + c = note.cards()[0] # card stats assert d.cardStats(c) d.reset() @@ -32,6 +32,6 @@ def test_graphs(): d = getEmptyCol() g = d.stats() rep = g.report() - with open(os.path.join(dir, "test.html"), "w", encoding="UTF-8") as f: - f.write(rep) + with open(os.path.join(dir, "test.html"), "w", encoding="UTF-8") as note: + note.write(rep) return diff --git a/pylib/tests/test_template.py b/pylib/tests/test_template.py index fc40af99d..6a7487ab6 100644 --- a/pylib/tests/test_template.py +++ b/pylib/tests/test_template.py @@ -7,9 +7,9 @@ def test_deferred_frontside(): m["tmpls"][0]["qfmt"] = "{{custom:Front}}" d.models.save(m) - f = d.newNote() - f["Front"] = "xxtest" - f["Back"] = "" - d.addNote(f) + note = d.newNote() + note["Front"] = "xxtest" + note["Back"] = "" + d.addNote(note) - assert "xxtest" in f.cards()[0].a() + assert "xxtest" in note.cards()[0].a() diff --git a/pylib/tests/test_undo.py b/pylib/tests/test_undo.py index 89e0fac0e..a21bdbf14 100644 --- a/pylib/tests/test_undo.py +++ b/pylib/tests/test_undo.py @@ -34,9 +34,9 @@ def test_op(): assert not d.undoName() # and a review will, too d.save("add") - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) d.reset() assert d.undoName() == "add" c = d.sched.getCard() @@ -47,9 +47,9 @@ def test_op(): def test_review(): d = getEmptyCol() d.conf["counts"] = COUNT_REMAINING - f = d.newNote() - f["Front"] = "one" - d.addNote(f) + note = d.newNote() + note["Front"] = "one" + d.addNote(note) d.reset() assert not d.undoName() # answer @@ -70,9 +70,9 @@ def test_review(): assert c.left != 1001 assert not d.undoName() # we should be able to undo multiple answers too - f = d.newNote() - f["Front"] = "two" - d.addNote(f) + note = d.newNote() + note["Front"] = "two" + d.addNote(note) d.reset() assert d.sched.counts() == (2, 0, 0) c = d.sched.getCard() From 425b82e6e7788015174c9c7ad1952bfbb5042e16 Mon Sep 17 00:00:00 2001 From: Arthur Milchior Date: Fri, 17 Jul 2020 05:18:35 +0200 Subject: [PATCH 3/6] f2->note2 in test Obtained by ``` sed -i "s/\bf2\b/note2/g" pylib/tests/*py qt/tests/*py ``` --- pylib/tests/test_collection.py | 22 +++++++++++----------- pylib/tests/test_find.py | 26 +++++++++++++------------- pylib/tests/test_schedv1.py | 12 ++++++------ pylib/tests/test_schedv2.py | 18 +++++++++--------- 4 files changed, 39 insertions(+), 39 deletions(-) diff --git a/pylib/tests/test_collection.py b/pylib/tests/test_collection.py index 59a09ce43..141bdb5ee 100644 --- a/pylib/tests/test_collection.py +++ b/pylib/tests/test_collection.py @@ -74,13 +74,13 @@ def test_noteAddDelete(): # it should not be a duplicate assert not note.dupeOrEmpty() # now let's make a duplicate - f2 = deck.newNote() - f2["Front"] = "one" - f2["Back"] = "" - assert f2.dupeOrEmpty() + note2 = deck.newNote() + note2["Front"] = "one" + note2["Back"] = "" + assert note2.dupeOrEmpty() # empty first field should not be permitted either - f2["Front"] = " " - assert f2.dupeOrEmpty() + note2["Front"] = " " + assert note2.dupeOrEmpty() def test_fieldChecksum(): @@ -101,15 +101,15 @@ def test_addDelTags(): note = deck.newNote() note["Front"] = "1" deck.addNote(note) - f2 = deck.newNote() - f2["Front"] = "2" - deck.addNote(f2) + note2 = deck.newNote() + note2["Front"] = "2" + deck.addNote(note2) # adding for a given id deck.tags.bulkAdd([note.id], "foo") note.load() - f2.load() + note2.load() assert "foo" in note.tags - assert "foo" not in f2.tags + assert "foo" not in note2.tags # should be canonified deck.tags.bulkAdd([note.id], "foo aaa") note.load() diff --git a/pylib/tests/test_find.py b/pylib/tests/test_find.py index dbb387282..b75ce24cd 100644 --- a/pylib/tests/test_find.py +++ b/pylib/tests/test_find.py @@ -235,25 +235,25 @@ def test_findReplace(): note["Front"] = "foo" note["Back"] = "bar" deck.addNote(note) - f2 = deck.newNote() - f2["Front"] = "baz" - f2["Back"] = "foo" - deck.addNote(f2) - nids = [note.id, f2.id] + note2 = deck.newNote() + note2["Front"] = "baz" + note2["Back"] = "foo" + deck.addNote(note2) + nids = [note.id, note2.id] # should do nothing assert deck.findReplace(nids, "abc", "123") == 0 # global replace assert deck.findReplace(nids, "foo", "qux") == 2 note.load() assert note["Front"] == "qux" - f2.load() - assert f2["Back"] == "qux" + note2.load() + assert note2["Back"] == "qux" # single field replace assert deck.findReplace(nids, "qux", "foo", field="Front") == 1 note.load() assert note["Front"] == "foo" - f2.load() - assert f2["Back"] == "qux" + note2.load() + assert note2["Back"] == "qux" # regex replace assert deck.findReplace(nids, "B.r", "reg") == 0 note.load() @@ -269,10 +269,10 @@ def test_findDupes(): note["Front"] = "foo" note["Back"] = "bar" deck.addNote(note) - f2 = deck.newNote() - f2["Front"] = "baz" - f2["Back"] = "bar" - deck.addNote(f2) + note2 = deck.newNote() + note2["Front"] = "baz" + note2["Back"] = "bar" + deck.addNote(note2) f3 = deck.newNote() f3["Front"] = "quux" f3["Back"] = "bar" diff --git a/pylib/tests/test_schedv1.py b/pylib/tests/test_schedv1.py index 5e530fe34..ed5821baf 100644 --- a/pylib/tests/test_schedv1.py +++ b/pylib/tests/test_schedv1.py @@ -1051,10 +1051,10 @@ def test_reorder(): note = d.newNote() note["Front"] = "one" d.addNote(note) - f2 = d.newNote() - f2["Front"] = "two" - d.addNote(f2) - assert f2.cards()[0].due == 2 + note2 = d.newNote() + note2["Front"] = "two" + d.addNote(note2) + assert note2.cards()[0].due == 2 found = False # 50/50 chance of being reordered for i in range(20): @@ -1073,12 +1073,12 @@ def test_reorder(): f4["Front"] = "four" d.addNote(f4) assert note.cards()[0].due == 1 - assert f2.cards()[0].due == 2 + assert note2.cards()[0].due == 2 assert f3.cards()[0].due == 3 assert f4.cards()[0].due == 4 d.sched.sortCards([f3.cards()[0].id, f4.cards()[0].id], start=1, shift=True) assert note.cards()[0].due == 3 - assert f2.cards()[0].due == 4 + assert note2.cards()[0].due == 4 assert f3.cards()[0].due == 1 assert f4.cards()[0].due == 2 diff --git a/pylib/tests/test_schedv2.py b/pylib/tests/test_schedv2.py index b5017acfe..5124166d9 100644 --- a/pylib/tests/test_schedv2.py +++ b/pylib/tests/test_schedv2.py @@ -810,9 +810,9 @@ def test_preview(): d.addNote(note) c = note.cards()[0] orig = copy.copy(c) - f2 = d.newNote() - f2["Front"] = "two" - d.addNote(f2) + note2 = d.newNote() + note2["Front"] = "two" + d.addNote(note2) # cram deck did = d.decks.newDyn("Cram") cram = d.decks.get(did) @@ -1085,10 +1085,10 @@ def test_reorder(): note = d.newNote() note["Front"] = "one" d.addNote(note) - f2 = d.newNote() - f2["Front"] = "two" - d.addNote(f2) - assert f2.cards()[0].due == 2 + note2 = d.newNote() + note2["Front"] = "two" + d.addNote(note2) + assert note2.cards()[0].due == 2 found = False # 50/50 chance of being reordered for i in range(20): @@ -1107,12 +1107,12 @@ def test_reorder(): f4["Front"] = "four" d.addNote(f4) assert note.cards()[0].due == 1 - assert f2.cards()[0].due == 2 + assert note2.cards()[0].due == 2 assert f3.cards()[0].due == 3 assert f4.cards()[0].due == 4 d.sched.sortCards([f3.cards()[0].id, f4.cards()[0].id], start=1, shift=True) assert note.cards()[0].due == 3 - assert f2.cards()[0].due == 4 + assert note2.cards()[0].due == 4 assert f3.cards()[0].due == 1 assert f4.cards()[0].due == 2 From c376714a9bd558474a91f68ce0dc9cfaa9334d71 Mon Sep 17 00:00:00 2001 From: Arthur Milchior Date: Fri, 17 Jul 2020 05:21:01 +0200 Subject: [PATCH 4/6] deck->col in tests Obtained by ``` sed -i "s/\bdeck\b/col/g" pylib/tests/*py qt/tests/*py ``` --- pylib/tests/test_cards.py | 28 +-- pylib/tests/test_collection.py | 76 ++++---- pylib/tests/test_decks.py | 88 ++++----- pylib/tests/test_exporting.py | 72 +++---- pylib/tests/test_find.py | 334 ++++++++++++++++----------------- pylib/tests/test_importing.py | 82 ++++---- pylib/tests/test_models.py | 56 +++--- 7 files changed, 368 insertions(+), 368 deletions(-) diff --git a/pylib/tests/test_cards.py b/pylib/tests/test_cards.py index 74123c164..7c94aa0eb 100644 --- a/pylib/tests/test_cards.py +++ b/pylib/tests/test_cards.py @@ -4,20 +4,20 @@ from tests.shared import getEmptyCol def test_delete(): - deck = getEmptyCol() - note = deck.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "1" note["Back"] = "2" - deck.addNote(note) + col.addNote(note) cid = note.cards()[0].id - deck.reset() - deck.sched.answerCard(deck.sched.getCard(), 2) - deck.remove_cards_and_orphaned_notes([cid]) - assert deck.cardCount() == 0 - assert deck.noteCount() == 0 - assert deck.db.scalar("select count() from notes") == 0 - assert deck.db.scalar("select count() from cards") == 0 - assert deck.db.scalar("select count() from graves") == 2 + col.reset() + col.sched.answerCard(col.sched.getCard(), 2) + col.remove_cards_and_orphaned_notes([cid]) + assert col.cardCount() == 0 + assert col.noteCount() == 0 + assert col.db.scalar("select count() from notes") == 0 + assert col.db.scalar("select count() from cards") == 0 + assert col.db.scalar("select count() from graves") == 2 def test_misc(): @@ -71,11 +71,11 @@ def test_gendeck(): d.addNote(note) assert d.cardCount() == 1 assert note.cards()[0].did == 1 - # set the model to a new default deck + # set the model to a new default col newId = d.decks.id("new") cloze["did"] = newId d.models.save(cloze, updateReqs=False) - # a newly generated card should share the first card's deck + # a newly generated card should share the first card's col note["Text"] += "{{c2::two}}" note.flush() assert note.cards()[1].did == 1 @@ -83,7 +83,7 @@ def test_gendeck(): note["Text"] += "{{c3::three}}" note.flush() assert note.cards()[2].did == 1 - # if one of the cards is in a different deck, it should revert to the + # if one of the cards is in a different col, it should revert to the # model default c = note.cards()[1] c.did = newId diff --git a/pylib/tests/test_collection.py b/pylib/tests/test_collection.py index 141bdb5ee..00f199788 100644 --- a/pylib/tests/test_collection.py +++ b/pylib/tests/test_collection.py @@ -19,17 +19,17 @@ def test_create_open(): os.unlink(path) except OSError: pass - deck = aopen(path) + col = aopen(path) # for open() - newPath = deck.path - newMod = deck.mod - deck.close() - del deck + newPath = col.path + newMod = col.mod + col.close() + del col # reopen - deck = aopen(newPath) - assert deck.mod == newMod - deck.close() + col = aopen(newPath) + assert col.mod == newMod + col.close() # non-writeable dir if isWin: @@ -45,36 +45,36 @@ def test_create_open(): def test_noteAddDelete(): - deck = getEmptyCol() + col = getEmptyCol() # add a note - note = deck.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - n = deck.addNote(note) + n = col.addNote(note) assert n == 1 # test multiple cards - add another template - m = deck.models.current() - mm = deck.models + m = col.models.current() + mm = col.models t = mm.newTemplate("Reverse") t["qfmt"] = "{{Back}}" t["afmt"] = "{{Front}}" mm.addTemplate(m, t) mm.save(m) - assert deck.cardCount() == 2 + assert col.cardCount() == 2 # creating new notes should use both cards - note = deck.newNote() + note = col.newNote() note["Front"] = "three" note["Back"] = "four" - n = deck.addNote(note) + n = col.addNote(note) assert n == 2 - assert deck.cardCount() == 4 + assert col.cardCount() == 4 # check q/a generation c0 = note.cards()[0] assert "three" in c0.q() # it should not be a duplicate assert not note.dupeOrEmpty() # now let's make a duplicate - note2 = deck.newNote() + note2 = col.newNote() note2["Front"] = "one" note2["Back"] = "" assert note2.dupeOrEmpty() @@ -84,57 +84,57 @@ def test_noteAddDelete(): def test_fieldChecksum(): - deck = getEmptyCol() - note = deck.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "new" note["Back"] = "new2" - deck.addNote(note) - assert deck.db.scalar("select csum from notes") == int("c2a6b03f", 16) + col.addNote(note) + assert col.db.scalar("select csum from notes") == int("c2a6b03f", 16) # changing the val should change the checksum note["Front"] = "newx" note.flush() - assert deck.db.scalar("select csum from notes") == int("302811ae", 16) + assert col.db.scalar("select csum from notes") == int("302811ae", 16) def test_addDelTags(): - deck = getEmptyCol() - note = deck.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "1" - deck.addNote(note) - note2 = deck.newNote() + col.addNote(note) + note2 = col.newNote() note2["Front"] = "2" - deck.addNote(note2) + col.addNote(note2) # adding for a given id - deck.tags.bulkAdd([note.id], "foo") + col.tags.bulkAdd([note.id], "foo") note.load() note2.load() assert "foo" in note.tags assert "foo" not in note2.tags # should be canonified - deck.tags.bulkAdd([note.id], "foo aaa") + col.tags.bulkAdd([note.id], "foo aaa") note.load() assert note.tags[0] == "aaa" assert len(note.tags) == 2 def test_timestamps(): - deck = getEmptyCol() - assert len(deck.models.all_names_and_ids()) == len(get_stock_notetypes(deck)) + col = getEmptyCol() + assert len(col.models.all_names_and_ids()) == len(get_stock_notetypes(col)) for i in range(100): - addBasicModel(deck) - assert len(deck.models.all_names_and_ids()) == 100 + len(get_stock_notetypes(deck)) + addBasicModel(col) + assert len(col.models.all_names_and_ids()) == 100 + len(get_stock_notetypes(col)) def test_furigana(): - deck = getEmptyCol() - mm = deck.models + col = getEmptyCol() + mm = col.models m = mm.current() # filter should work m["tmpls"][0]["qfmt"] = "{{kana:Front}}" mm.save(m) - n = deck.newNote() + n = col.newNote() n["Front"] = "foo[abc]" - deck.addNote(n) + col.addNote(n) c = n.cards()[0] assert c.q().endswith("abc") # and should avoid sound diff --git a/pylib/tests/test_decks.py b/pylib/tests/test_decks.py index a441b9d57..ab2d0b677 100644 --- a/pylib/tests/test_decks.py +++ b/pylib/tests/test_decks.py @@ -5,59 +5,59 @@ from tests.shared import assertException, getEmptyCol def test_basic(): - deck = getEmptyCol() - # we start with a standard deck - assert len(deck.decks.all_names_and_ids()) == 1 + col = getEmptyCol() + # we start with a standard col + assert len(col.decks.all_names_and_ids()) == 1 # it should have an id of 1 - assert deck.decks.name(1) - # create a new deck - parentId = deck.decks.id("new deck") + assert col.decks.name(1) + # create a new col + parentId = col.decks.id("new deck") assert parentId - assert len(deck.decks.all_names_and_ids()) == 2 + assert len(col.decks.all_names_and_ids()) == 2 # should get the same id - assert deck.decks.id("new deck") == parentId - # we start with the default deck selected - assert deck.decks.selected() == 1 - assert deck.decks.active() == [1] - # we can select a different deck - deck.decks.select(parentId) - assert deck.decks.selected() == parentId - assert deck.decks.active() == [parentId] + assert col.decks.id("new deck") == parentId + # we start with the default col selected + assert col.decks.selected() == 1 + assert col.decks.active() == [1] + # we can select a different col + col.decks.select(parentId) + assert col.decks.selected() == parentId + assert col.decks.active() == [parentId] # let's create a child - childId = deck.decks.id("new deck::child") - deck.sched.reset() + childId = col.decks.id("new deck::child") + col.sched.reset() # it should have been added to the active list - assert deck.decks.selected() == parentId - assert deck.decks.active() == [parentId, childId] + assert col.decks.selected() == parentId + assert col.decks.active() == [parentId, childId] # we can select the child individually too - deck.decks.select(childId) - assert deck.decks.selected() == childId - assert deck.decks.active() == [childId] + col.decks.select(childId) + assert col.decks.selected() == childId + assert col.decks.active() == [childId] # parents with a different case should be handled correctly - deck.decks.id("ONE") - m = deck.models.current() - m["did"] = deck.decks.id("one::two") - deck.models.save(m, updateReqs=False) - n = deck.newNote() + col.decks.id("ONE") + m = col.models.current() + m["did"] = col.decks.id("one::two") + col.models.save(m, updateReqs=False) + n = col.newNote() n["Front"] = "abc" - deck.addNote(n) + col.addNote(n) def test_remove(): - deck = getEmptyCol() - # create a new deck, and add a note/card to it - g1 = deck.decks.id("g1") - note = deck.newNote() + col = getEmptyCol() + # create a new col, and add a note/card to it + g1 = col.decks.id("g1") + note = col.newNote() note["Front"] = "1" note.model()["did"] = g1 - deck.addNote(note) + col.addNote(note) c = note.cards()[0] assert c.did == g1 - assert deck.cardCount() == 1 - deck.decks.rem(g1) - assert deck.cardCount() == 0 + assert col.cardCount() == 1 + col.decks.rem(g1) + assert col.cardCount() == 0 # if we try to get it, we get the default - assert deck.decks.name(c.did) == "[no deck]" + assert col.decks.name(c.did) == "[no deck]" def test_rename(): @@ -70,7 +70,7 @@ def test_rename(): assert "foo" in names assert "foo::bar" in names assert "hello::world" not in names - # create another deck + # create another col id = d.decks.id("tmp") # automatically adjusted if a duplicate name d.decks.rename(d.decks.get(id), "FOO") @@ -106,15 +106,15 @@ def test_renameForDragAndDrop(): d.decks.renameForDragAndDrop(chinese_did, languages_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] - # Dragging a deck onto itself is a no-op + # Dragging a col onto itself is a no-op d.decks.renameForDragAndDrop(languages_did, languages_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] - # Dragging a deck onto its parent is a no-op + # Dragging a col onto its parent is a no-op d.decks.renameForDragAndDrop(hsk_did, chinese_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] - # Dragging a deck onto a descendant is a no-op + # Dragging a col onto a descendant is a no-op d.decks.renameForDragAndDrop(languages_did, hsk_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] @@ -122,15 +122,15 @@ def test_renameForDragAndDrop(): d.decks.renameForDragAndDrop(hsk_did, languages_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::HSK"] - # Can drag a deck onto its sibling + # Can drag a col onto its sibling d.decks.renameForDragAndDrop(hsk_did, chinese_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] - # Can drag a deck back to the top level + # Can drag a col back to the top level d.decks.renameForDragAndDrop(chinese_did, None) assert deckNames() == ["Chinese", "Chinese::HSK", "Languages"] - # Dragging a top level deck to the top level is a no-op + # Dragging a top level col to the top level is a no-op d.decks.renameForDragAndDrop(chinese_did, None) assert deckNames() == ["Chinese", "Chinese::HSK", "Languages"] diff --git a/pylib/tests/test_exporting.py b/pylib/tests/test_exporting.py index a74d5af74..67e98852e 100644 --- a/pylib/tests/test_exporting.py +++ b/pylib/tests/test_exporting.py @@ -16,25 +16,25 @@ def getEmptyCol(): return col -deck = None +col = None ds = None testDir = os.path.dirname(__file__) def setup1(): - global deck - deck = getEmptyCol() - note = deck.newNote() + global col + col = getEmptyCol() + note = col.newNote() note["Front"] = "foo" note["Back"] = "bar
" note.tags = ["tag", "tag2"] - deck.addNote(note) - # with a different deck - note = deck.newNote() + col.addNote(note) + # with a different col + note = col.newNote() note["Front"] = "baz" note["Back"] = "qux" - note.model()["did"] = deck.decks.id("new deck") - deck.addNote(note) + note.model()["did"] = col.decks.id("new col") + col.addNote(note) ########################################################################## @@ -42,23 +42,23 @@ def setup1(): def test_export_anki(): setup1() - # create a new deck with its own conf to test conf copying - did = deck.decks.id("test") - dobj = deck.decks.get(did) - confId = deck.decks.add_config_returning_id("newconf") - conf = deck.decks.get_config(confId) + # create a new col with its own conf to test conf copying + did = col.decks.id("test") + dobj = col.decks.get(did) + confId = col.decks.add_config_returning_id("newconf") + conf = col.decks.get_config(confId) conf["new"]["perDay"] = 5 - deck.decks.save(conf) - deck.decks.setConf(dobj, confId) + col.decks.save(conf) + col.decks.setConf(dobj, confId) # export - e = AnkiExporter(deck) + e = AnkiExporter(col) fd, newname = tempfile.mkstemp(prefix="ankitest", suffix=".anki2") newname = str(newname) os.close(fd) os.unlink(newname) e.exportInto(newname) # exporting should not have changed conf for original deck - conf = deck.decks.confForDid(did) + conf = col.decks.confForDid(did) assert conf["id"] != 1 # connect to new deck d2 = aopen(newname) @@ -85,12 +85,12 @@ def test_export_anki(): def test_export_ankipkg(): setup1() # add a test file to the media folder - with open(os.path.join(deck.media.dir(), "今日.mp3"), "w") as note: + with open(os.path.join(col.media.dir(), "今日.mp3"), "w") as note: note.write("test") - n = deck.newNote() + n = col.newNote() n["Front"] = "[sound:今日.mp3]" - deck.addNote(n) - e = AnkiPackageExporter(deck) + col.addNote(n) + e = AnkiPackageExporter(col) fd, newname = tempfile.mkstemp(prefix="ankitest", suffix=".apkg") newname = str(newname) os.close(fd) @@ -101,23 +101,23 @@ def test_export_ankipkg(): @errorsAfterMidnight def test_export_anki_due(): setup1() - deck = getEmptyCol() - note = deck.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "foo" - deck.addNote(note) - deck.crt -= 86400 * 10 - deck.flush() - deck.sched.reset() - c = deck.sched.getCard() - deck.sched.answerCard(c, 3) - deck.sched.answerCard(c, 3) + col.addNote(note) + col.crt -= 86400 * 10 + col.flush() + col.sched.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # should have ivl of 1, due on day 11 assert c.ivl == 1 assert c.due == 11 - assert deck.sched.today == 10 - assert c.due - deck.sched.today == 1 + assert col.sched.today == 10 + assert c.due - col.sched.today == 1 # export - e = AnkiExporter(deck) + e = AnkiExporter(col) e.includeSched = True fd, newname = tempfile.mkstemp(prefix="ankitest", suffix=".anki2") newname = str(newname) @@ -135,7 +135,7 @@ def test_export_anki_due(): # def test_export_textcard(): # setup1() -# e = TextCardExporter(deck) +# e = TextCardExporter(col) # note = unicode(tempfile.mkstemp(prefix="ankitest")[1]) # os.unlink(note) # e.exportInto(note) @@ -145,7 +145,7 @@ def test_export_anki_due(): def test_export_textnote(): setup1() - e = TextNoteExporter(deck) + e = TextNoteExporter(col) fd, note = tempfile.mkstemp(prefix="ankitest") note = str(note) os.close(fd) diff --git a/pylib/tests/test_find.py b/pylib/tests/test_find.py index b75ce24cd..573f94726 100644 --- a/pylib/tests/test_find.py +++ b/pylib/tests/test_find.py @@ -12,284 +12,284 @@ class DummyCollection: def test_findCards(): - deck = getEmptyCol() - note = deck.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "dog" note["Back"] = "cat" note.tags.append("monkey animal_1 * %") - deck.addNote(note) + col.addNote(note) f1id = note.id firstCardId = note.cards()[0].id - note = deck.newNote() + note = col.newNote() note["Front"] = "goats are fun" note["Back"] = "sheep" note.tags.append("sheep goat horse animal11") - deck.addNote(note) + col.addNote(note) f2id = note.id - note = deck.newNote() + note = col.newNote() note["Front"] = "cat" note["Back"] = "sheep" - deck.addNote(note) + col.addNote(note) catCard = note.cards()[0] - m = deck.models.current() - m = deck.models.copy(m) - mm = deck.models + m = col.models.current() + m = col.models.copy(m) + mm = col.models t = mm.newTemplate("Reverse") t["qfmt"] = "{{Back}}" t["afmt"] = "{{Front}}" mm.addTemplate(m, t) mm.save(m) - note = deck.newNote() + note = col.newNote() note["Front"] = "test" note["Back"] = "foo bar" - deck.addNote(note) - deck.save() + col.addNote(note) + col.save() latestCardIds = [c.id for c in note.cards()] # tag searches - assert len(deck.findCards("tag:*")) == 5 - assert len(deck.findCards("tag:\\*")) == 1 - assert len(deck.findCards("tag:%")) == 5 - assert len(deck.findCards("tag:\\%")) == 1 - assert len(deck.findCards("tag:animal_1")) == 2 - assert len(deck.findCards("tag:animal\\_1")) == 1 - assert not deck.findCards("tag:donkey") - assert len(deck.findCards("tag:sheep")) == 1 - assert len(deck.findCards("tag:sheep tag:goat")) == 1 - assert len(deck.findCards("tag:sheep tag:monkey")) == 0 - assert len(deck.findCards("tag:monkey")) == 1 - assert len(deck.findCards("tag:sheep -tag:monkey")) == 1 - assert len(deck.findCards("-tag:sheep")) == 4 - deck.tags.bulkAdd(deck.db.list("select id from notes"), "foo bar") - assert len(deck.findCards("tag:foo")) == len(deck.findCards("tag:bar")) == 5 - deck.tags.bulkRem(deck.db.list("select id from notes"), "foo") - assert len(deck.findCards("tag:foo")) == 0 - assert len(deck.findCards("tag:bar")) == 5 + assert len(col.findCards("tag:*")) == 5 + assert len(col.findCards("tag:\\*")) == 1 + assert len(col.findCards("tag:%")) == 5 + assert len(col.findCards("tag:\\%")) == 1 + assert len(col.findCards("tag:animal_1")) == 2 + assert len(col.findCards("tag:animal\\_1")) == 1 + assert not col.findCards("tag:donkey") + assert len(col.findCards("tag:sheep")) == 1 + assert len(col.findCards("tag:sheep tag:goat")) == 1 + assert len(col.findCards("tag:sheep tag:monkey")) == 0 + assert len(col.findCards("tag:monkey")) == 1 + assert len(col.findCards("tag:sheep -tag:monkey")) == 1 + assert len(col.findCards("-tag:sheep")) == 4 + col.tags.bulkAdd(col.db.list("select id from notes"), "foo bar") + assert len(col.findCards("tag:foo")) == len(col.findCards("tag:bar")) == 5 + col.tags.bulkRem(col.db.list("select id from notes"), "foo") + assert len(col.findCards("tag:foo")) == 0 + assert len(col.findCards("tag:bar")) == 5 # text searches - assert len(deck.findCards("cat")) == 2 - assert len(deck.findCards("cat -dog")) == 1 - assert len(deck.findCards("cat -dog")) == 1 - assert len(deck.findCards("are goats")) == 1 - assert len(deck.findCards('"are goats"')) == 0 - assert len(deck.findCards('"goats are"')) == 1 + assert len(col.findCards("cat")) == 2 + assert len(col.findCards("cat -dog")) == 1 + assert len(col.findCards("cat -dog")) == 1 + assert len(col.findCards("are goats")) == 1 + assert len(col.findCards('"are goats"')) == 0 + assert len(col.findCards('"goats are"')) == 1 # card states c = note.cards()[0] c.queue = c.type = CARD_TYPE_REV - assert deck.findCards("is:review") == [] + assert col.findCards("is:review") == [] c.flush() - assert deck.findCards("is:review") == [c.id] - assert deck.findCards("is:due") == [] + assert col.findCards("is:review") == [c.id] + assert col.findCards("is:due") == [] c.due = 0 c.queue = QUEUE_TYPE_REV c.flush() - assert deck.findCards("is:due") == [c.id] - assert len(deck.findCards("-is:due")) == 4 + assert col.findCards("is:due") == [c.id] + assert len(col.findCards("-is:due")) == 4 c.queue = -1 # ensure this card gets a later mod time c.flush() - deck.db.execute("update cards set mod = mod + 1 where id = ?", c.id) - assert deck.findCards("is:suspended") == [c.id] + col.db.execute("update cards set mod = mod + 1 where id = ?", c.id) + assert col.findCards("is:suspended") == [c.id] # nids - assert deck.findCards("nid:54321") == [] - assert len(deck.findCards("nid:%d" % note.id)) == 2 - assert len(deck.findCards("nid:%d,%d" % (f1id, f2id))) == 2 + assert col.findCards("nid:54321") == [] + assert len(col.findCards("nid:%d" % note.id)) == 2 + assert len(col.findCards("nid:%d,%d" % (f1id, f2id))) == 2 # templates - assert len(deck.findCards("card:foo")) == 0 - assert len(deck.findCards('"card:card 1"')) == 4 - assert len(deck.findCards("card:reverse")) == 1 - assert len(deck.findCards("card:1")) == 4 - assert len(deck.findCards("card:2")) == 1 + assert len(col.findCards("card:foo")) == 0 + assert len(col.findCards('"card:card 1"')) == 4 + assert len(col.findCards("card:reverse")) == 1 + assert len(col.findCards("card:1")) == 4 + assert len(col.findCards("card:2")) == 1 # fields - assert len(deck.findCards("front:dog")) == 1 - assert len(deck.findCards("-front:dog")) == 4 - assert len(deck.findCards("front:sheep")) == 0 - assert len(deck.findCards("back:sheep")) == 2 - assert len(deck.findCards("-back:sheep")) == 3 - assert len(deck.findCards("front:do")) == 0 - assert len(deck.findCards("front:*")) == 5 + assert len(col.findCards("front:dog")) == 1 + assert len(col.findCards("-front:dog")) == 4 + assert len(col.findCards("front:sheep")) == 0 + assert len(col.findCards("back:sheep")) == 2 + assert len(col.findCards("-back:sheep")) == 3 + assert len(col.findCards("front:do")) == 0 + assert len(col.findCards("front:*")) == 5 # ordering - deck.conf["sortType"] = "noteCrt" - deck.flush() - assert deck.findCards("front:*", order=True)[-1] in latestCardIds - assert deck.findCards("", order=True)[-1] in latestCardIds - deck.conf["sortType"] = "noteFld" - deck.flush() - assert deck.findCards("", order=True)[0] == catCard.id - assert deck.findCards("", order=True)[-1] in latestCardIds - deck.conf["sortType"] = "cardMod" - deck.flush() - assert deck.findCards("", order=True)[-1] in latestCardIds - assert deck.findCards("", order=True)[0] == firstCardId - deck.conf["sortBackwards"] = True - deck.flush() - assert deck.findCards("", order=True)[0] in latestCardIds + col.conf["sortType"] = "noteCrt" + col.flush() + assert col.findCards("front:*", order=True)[-1] in latestCardIds + assert col.findCards("", order=True)[-1] in latestCardIds + col.conf["sortType"] = "noteFld" + col.flush() + assert col.findCards("", order=True)[0] == catCard.id + assert col.findCards("", order=True)[-1] in latestCardIds + col.conf["sortType"] = "cardMod" + col.flush() + assert col.findCards("", order=True)[-1] in latestCardIds + assert col.findCards("", order=True)[0] == firstCardId + col.conf["sortBackwards"] = True + col.flush() + assert col.findCards("", order=True)[0] in latestCardIds assert ( - deck.find_cards("", order=BuiltinSortKind.CARD_DUE, reverse=False)[0] + col.find_cards("", order=BuiltinSortKind.CARD_DUE, reverse=False)[0] == firstCardId ) assert ( - deck.find_cards("", order=BuiltinSortKind.CARD_DUE, reverse=True)[0] + col.find_cards("", order=BuiltinSortKind.CARD_DUE, reverse=True)[0] != firstCardId ) # model - assert len(deck.findCards("note:basic")) == 3 - assert len(deck.findCards("-note:basic")) == 2 - assert len(deck.findCards("-note:foo")) == 5 - # deck - assert len(deck.findCards("deck:default")) == 5 - assert len(deck.findCards("-deck:default")) == 0 - assert len(deck.findCards("-deck:foo")) == 5 - assert len(deck.findCards("deck:def*")) == 5 - assert len(deck.findCards("deck:*EFAULT")) == 5 - assert len(deck.findCards("deck:*cefault")) == 0 + assert len(col.findCards("note:basic")) == 3 + assert len(col.findCards("-note:basic")) == 2 + assert len(col.findCards("-note:foo")) == 5 + # col + assert len(col.findCards("deck:default")) == 5 + assert len(col.findCards("-deck:default")) == 0 + assert len(col.findCards("-deck:foo")) == 5 + assert len(col.findCards("deck:def*")) == 5 + assert len(col.findCards("deck:*EFAULT")) == 5 + assert len(col.findCards("deck:*cefault")) == 0 # full search - note = deck.newNote() + note = col.newNote() note["Front"] = "helloworld" note["Back"] = "abc" - deck.addNote(note) + col.addNote(note) # as it's the sort field, it matches - assert len(deck.findCards("helloworld")) == 2 - # assert len(deck.findCards("helloworld", full=True)) == 2 + assert len(col.findCards("helloworld")) == 2 + # assert len(col.findCards("helloworld", full=True)) == 2 # if we put it on the back, it won't (note["Front"], note["Back"]) = (note["Back"], note["Front"]) note.flush() - assert len(deck.findCards("helloworld")) == 0 - # assert len(deck.findCards("helloworld", full=True)) == 2 - # assert len(deck.findCards("back:helloworld", full=True)) == 2 + assert len(col.findCards("helloworld")) == 0 + # assert len(col.findCards("helloworld", full=True)) == 2 + # assert len(col.findCards("back:helloworld", full=True)) == 2 # searching for an invalid special tag should not error with pytest.raises(Exception): - len(deck.findCards("is:invalid")) - # should be able to limit to parent deck, no children - id = deck.db.scalar("select id from cards limit 1") - deck.db.execute( - "update cards set did = ? where id = ?", deck.decks.id("Default::Child"), id + len(col.findCards("is:invalid")) + # should be able to limit to parent col, no children + id = col.db.scalar("select id from cards limit 1") + col.db.execute( + "update cards set did = ? where id = ?", col.decks.id("Default::Child"), id ) - deck.save() - assert len(deck.findCards("deck:default")) == 7 - assert len(deck.findCards("deck:default::child")) == 1 - assert len(deck.findCards("deck:default -deck:default::*")) == 6 + col.save() + assert len(col.findCards("deck:default")) == 7 + assert len(col.findCards("deck:default::child")) == 1 + assert len(col.findCards("deck:default -deck:default::*")) == 6 # properties - id = deck.db.scalar("select id from cards limit 1") - deck.db.execute( + id = col.db.scalar("select id from cards limit 1") + col.db.execute( "update cards set queue=2, ivl=10, reps=20, due=30, factor=2200 " "where id = ?", id, ) - assert len(deck.findCards("prop:ivl>5")) == 1 - assert len(deck.findCards("prop:ivl<5")) > 1 - assert len(deck.findCards("prop:ivl>=5")) == 1 - assert len(deck.findCards("prop:ivl=9")) == 0 - assert len(deck.findCards("prop:ivl=10")) == 1 - assert len(deck.findCards("prop:ivl!=10")) > 1 - assert len(deck.findCards("prop:due>0")) == 1 + assert len(col.findCards("prop:ivl>5")) == 1 + assert len(col.findCards("prop:ivl<5")) > 1 + assert len(col.findCards("prop:ivl>=5")) == 1 + assert len(col.findCards("prop:ivl=9")) == 0 + assert len(col.findCards("prop:ivl=10")) == 1 + assert len(col.findCards("prop:ivl!=10")) > 1 + assert len(col.findCards("prop:due>0")) == 1 # due dates should work - assert len(deck.findCards("prop:due=29")) == 0 - assert len(deck.findCards("prop:due=30")) == 1 + assert len(col.findCards("prop:due=29")) == 0 + assert len(col.findCards("prop:due=30")) == 1 # ease factors - assert len(deck.findCards("prop:ease=2.3")) == 0 - assert len(deck.findCards("prop:ease=2.2")) == 1 - assert len(deck.findCards("prop:ease>2")) == 1 - assert len(deck.findCards("-prop:ease>2")) > 1 + assert len(col.findCards("prop:ease=2.3")) == 0 + assert len(col.findCards("prop:ease=2.2")) == 1 + assert len(col.findCards("prop:ease>2")) == 1 + assert len(col.findCards("-prop:ease>2")) > 1 # recently failed if not isNearCutoff(): - assert len(deck.findCards("rated:1:1")) == 0 - assert len(deck.findCards("rated:1:2")) == 0 - c = deck.sched.getCard() - deck.sched.answerCard(c, 2) - assert len(deck.findCards("rated:1:1")) == 0 - assert len(deck.findCards("rated:1:2")) == 1 - c = deck.sched.getCard() - deck.sched.answerCard(c, 1) - assert len(deck.findCards("rated:1:1")) == 1 - assert len(deck.findCards("rated:1:2")) == 1 - assert len(deck.findCards("rated:1")) == 2 - assert len(deck.findCards("rated:0:2")) == 0 - assert len(deck.findCards("rated:2:2")) == 1 + assert len(col.findCards("rated:1:1")) == 0 + assert len(col.findCards("rated:1:2")) == 0 + c = col.sched.getCard() + col.sched.answerCard(c, 2) + assert len(col.findCards("rated:1:1")) == 0 + assert len(col.findCards("rated:1:2")) == 1 + c = col.sched.getCard() + col.sched.answerCard(c, 1) + assert len(col.findCards("rated:1:1")) == 1 + assert len(col.findCards("rated:1:2")) == 1 + assert len(col.findCards("rated:1")) == 2 + assert len(col.findCards("rated:0:2")) == 0 + assert len(col.findCards("rated:2:2")) == 1 # added - assert len(deck.findCards("added:0")) == 0 - deck.db.execute("update cards set id = id - 86400*1000 where id = ?", id) - assert len(deck.findCards("added:1")) == deck.cardCount() - 1 - assert len(deck.findCards("added:2")) == deck.cardCount() + assert len(col.findCards("added:0")) == 0 + col.db.execute("update cards set id = id - 86400*1000 where id = ?", id) + assert len(col.findCards("added:1")) == col.cardCount() - 1 + assert len(col.findCards("added:2")) == col.cardCount() else: print("some find tests disabled near cutoff") # empty field - assert len(deck.findCards("front:")) == 0 - note = deck.newNote() + assert len(col.findCards("front:")) == 0 + note = col.newNote() note["Front"] = "" note["Back"] = "abc2" - assert deck.addNote(note) == 1 - assert len(deck.findCards("front:")) == 1 + assert col.addNote(note) == 1 + assert len(col.findCards("front:")) == 1 # OR searches and nesting - assert len(deck.findCards("tag:monkey or tag:sheep")) == 2 - assert len(deck.findCards("(tag:monkey OR tag:sheep)")) == 2 - assert len(deck.findCards("-(tag:monkey OR tag:sheep)")) == 6 - assert len(deck.findCards("tag:monkey or (tag:sheep sheep)")) == 2 - assert len(deck.findCards("tag:monkey or (tag:sheep octopus)")) == 1 + assert len(col.findCards("tag:monkey or tag:sheep")) == 2 + assert len(col.findCards("(tag:monkey OR tag:sheep)")) == 2 + assert len(col.findCards("-(tag:monkey OR tag:sheep)")) == 6 + assert len(col.findCards("tag:monkey or (tag:sheep sheep)")) == 2 + assert len(col.findCards("tag:monkey or (tag:sheep octopus)")) == 1 # flag with pytest.raises(Exception): - deck.findCards("flag:12") + col.findCards("flag:12") def test_findReplace(): - deck = getEmptyCol() - note = deck.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "foo" note["Back"] = "bar" - deck.addNote(note) - note2 = deck.newNote() + col.addNote(note) + note2 = col.newNote() note2["Front"] = "baz" note2["Back"] = "foo" - deck.addNote(note2) + col.addNote(note2) nids = [note.id, note2.id] # should do nothing - assert deck.findReplace(nids, "abc", "123") == 0 + assert col.findReplace(nids, "abc", "123") == 0 # global replace - assert deck.findReplace(nids, "foo", "qux") == 2 + assert col.findReplace(nids, "foo", "qux") == 2 note.load() assert note["Front"] == "qux" note2.load() assert note2["Back"] == "qux" # single field replace - assert deck.findReplace(nids, "qux", "foo", field="Front") == 1 + assert col.findReplace(nids, "qux", "foo", field="Front") == 1 note.load() assert note["Front"] == "foo" note2.load() assert note2["Back"] == "qux" # regex replace - assert deck.findReplace(nids, "B.r", "reg") == 0 + assert col.findReplace(nids, "B.r", "reg") == 0 note.load() assert note["Back"] != "reg" - assert deck.findReplace(nids, "B.r", "reg", regex=True) == 1 + assert col.findReplace(nids, "B.r", "reg", regex=True) == 1 note.load() assert note["Back"] == "reg" def test_findDupes(): - deck = getEmptyCol() - note = deck.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "foo" note["Back"] = "bar" - deck.addNote(note) - note2 = deck.newNote() + col.addNote(note) + note2 = col.newNote() note2["Front"] = "baz" note2["Back"] = "bar" - deck.addNote(note2) - f3 = deck.newNote() + col.addNote(note2) + f3 = col.newNote() f3["Front"] = "quux" f3["Back"] = "bar" - deck.addNote(f3) - f4 = deck.newNote() + col.addNote(f3) + f4 = col.newNote() f4["Front"] = "quuux" f4["Back"] = "nope" - deck.addNote(f4) - r = deck.findDupes("Back") + col.addNote(f4) + r = col.findDupes("Back") assert r[0][0] == "bar" assert len(r[0][1]) == 3 # valid search - r = deck.findDupes("Back", "bar") + r = col.findDupes("Back", "bar") assert r[0][0] == "bar" assert len(r[0][1]) == 3 # excludes everything - r = deck.findDupes("Back", "invalid") + r = col.findDupes("Back", "invalid") assert not r # front isn't dupe - assert deck.findDupes("Front") == [] + assert col.findDupes("Front") == [] diff --git a/pylib/tests/test_importing.py b/pylib/tests/test_importing.py index 43c9f5a20..6748ac6c7 100644 --- a/pylib/tests/test_importing.py +++ b/pylib/tests/test_importing.py @@ -147,9 +147,9 @@ def test_anki2_updates(): def test_csv(): - deck = getEmptyCol() + col = getEmptyCol() file = str(os.path.join(testDir, "support/text-2fields.txt")) - i = TextImporter(deck, file) + i = TextImporter(col, file) i.initMapping() i.run() # four problems - too many & too few fields, a missing front, and a @@ -161,7 +161,7 @@ def test_csv(): assert len(i.log) == 10 assert i.total == 5 # but importing should not clobber tags if they're unmapped - n = deck.getNote(deck.db.scalar("select id from notes")) + n = col.getNote(col.db.scalar("select id from notes")) n.addTag("test") n.flush() i.run() @@ -172,58 +172,58 @@ def test_csv(): i.run() assert i.total == 0 # and if dupes mode, will reimport everything - assert deck.cardCount() == 5 + assert col.cardCount() == 5 i.importMode = 2 i.run() # includes repeated field assert i.total == 6 - assert deck.cardCount() == 11 - deck.close() + assert col.cardCount() == 11 + col.close() def test_csv2(): - deck = getEmptyCol() - mm = deck.models + col = getEmptyCol() + mm = col.models m = mm.current() note = mm.newField("Three") mm.addField(m, note) mm.save(m) - n = deck.newNote() + n = col.newNote() n["Front"] = "1" n["Back"] = "2" n["Three"] = "3" - deck.addNote(n) + col.addNote(n) # an update with unmapped fields should not clobber those fields file = str(os.path.join(testDir, "support/text-update.txt")) - i = TextImporter(deck, file) + i = TextImporter(col, file) i.initMapping() i.run() n.load() assert n["Front"] == "1" assert n["Back"] == "x" assert n["Three"] == "3" - deck.close() + col.close() def test_tsv_tag_modified(): - deck = getEmptyCol() - mm = deck.models + col = getEmptyCol() + mm = col.models m = mm.current() note = mm.newField("Top") mm.addField(m, note) mm.save(m) - n = deck.newNote() + n = col.newNote() n["Front"] = "1" n["Back"] = "2" n["Top"] = "3" n.addTag("four") - deck.addNote(n) + col.addNote(n) # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file with NamedTemporaryFile(mode="w", delete=False) as tf: tf.write("1\tb\tc\n") tf.flush() - i = TextImporter(deck, tf.name) + i = TextImporter(col, tf.name) i.initMapping() i.tagModified = "boom" i.run() @@ -238,29 +238,29 @@ def test_tsv_tag_modified(): assert len(n.tags) == 2 assert i.updateCount == 1 - deck.close() + col.close() def test_tsv_tag_multiple_tags(): - deck = getEmptyCol() - mm = deck.models + col = getEmptyCol() + mm = col.models m = mm.current() note = mm.newField("Top") mm.addField(m, note) mm.save(m) - n = deck.newNote() + n = col.newNote() n["Front"] = "1" n["Back"] = "2" n["Top"] = "3" n.addTag("four") n.addTag("five") - deck.addNote(n) + col.addNote(n) # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file with NamedTemporaryFile(mode="w", delete=False) as tf: tf.write("1\tb\tc\n") tf.flush() - i = TextImporter(deck, tf.name) + i = TextImporter(col, tf.name) i.initMapping() i.tagModified = "five six" i.run() @@ -272,27 +272,27 @@ def test_tsv_tag_multiple_tags(): assert n["Top"] == "c" assert list(sorted(n.tags)) == list(sorted(["four", "five", "six"])) - deck.close() + col.close() def test_csv_tag_only_if_modified(): - deck = getEmptyCol() - mm = deck.models + col = getEmptyCol() + mm = col.models m = mm.current() note = mm.newField("Left") mm.addField(m, note) mm.save(m) - n = deck.newNote() + n = col.newNote() n["Front"] = "1" n["Back"] = "2" n["Left"] = "3" - deck.addNote(n) + col.addNote(n) # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file with NamedTemporaryFile(mode="w", delete=False) as tf: tf.write("1,2,3\n") tf.flush() - i = TextImporter(deck, tf.name) + i = TextImporter(col, tf.name) i.initMapping() i.tagModified = "right" i.run() @@ -302,31 +302,31 @@ def test_csv_tag_only_if_modified(): assert n.tags == [] assert i.updateCount == 0 - deck.close() + col.close() @pytest.mark.filterwarnings("ignore:Using or importing the ABCs") def test_supermemo_xml_01_unicode(): - deck = getEmptyCol() + col = getEmptyCol() file = str(os.path.join(testDir, "support/supermemo1.xml")) - i = SupermemoXmlImporter(deck, file) + i = SupermemoXmlImporter(col, file) # i.META.logToStdOutput = True i.run() assert i.total == 1 - cid = deck.db.scalar("select id from cards") - c = deck.getCard(cid) + cid = col.db.scalar("select id from cards") + c = col.getCard(cid) # Applies A Factor-to-E Factor conversion assert c.factor == 2879 assert c.reps == 7 - deck.close() + col.close() def test_mnemo(): - deck = getEmptyCol() + col = getEmptyCol() file = str(os.path.join(testDir, "support/mnemo.db")) - i = MnemosyneImporter(deck, file) + i = MnemosyneImporter(col, file) i.run() - assert deck.cardCount() == 7 - assert "a_longer_tag" in deck.tags.all() - assert deck.db.scalar("select count() from cards where type = 0") == 1 - deck.close() + assert col.cardCount() == 7 + assert "a_longer_tag" in col.tags.all() + assert col.db.scalar("select count() from cards where type = 0") == 1 + col.close() diff --git a/pylib/tests/test_models.py b/pylib/tests/test_models.py index 9d14f580c..7afaf4ca9 100644 --- a/pylib/tests/test_models.py +++ b/pylib/tests/test_models.py @@ -8,20 +8,20 @@ from tests.shared import getEmptyCol def test_modelDelete(): - deck = getEmptyCol() - note = deck.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "1" note["Back"] = "2" - deck.addNote(note) - assert deck.cardCount() == 1 - deck.models.rem(deck.models.current()) - assert deck.cardCount() == 0 + col.addNote(note) + assert col.cardCount() == 1 + col.models.rem(col.models.current()) + assert col.cardCount() == 0 def test_modelCopy(): - deck = getEmptyCol() - m = deck.models.current() - m2 = deck.models.copy(m) + col = getEmptyCol() + m = col.models.current() + m2 = col.models.copy(m) assert m2["name"] == "Basic copy" assert m2["id"] != m["id"] assert len(m2["flds"]) == 2 @@ -29,7 +29,7 @@ def test_modelCopy(): assert len(m2["flds"]) == len(m["flds"]) assert len(m["tmpls"]) == 1 assert len(m2["tmpls"]) == 1 - assert deck.models.scmhash(m) == deck.models.scmhash(m2) + assert col.models.scmhash(m) == col.models.scmhash(m2) def test_fields(): @@ -278,24 +278,24 @@ def test_chained_mods(): def test_modelChange(): - deck = getEmptyCol() - cloze = deck.models.byName("Cloze") + col = getEmptyCol() + cloze = col.models.byName("Cloze") # enable second template and add a note - m = deck.models.current() - mm = deck.models + m = col.models.current() + mm = col.models t = mm.newTemplate("Reverse") t["qfmt"] = "{{Back}}" t["afmt"] = "{{Front}}" mm.addTemplate(m, t) mm.save(m) basic = m - note = deck.newNote() + note = col.newNote() note["Front"] = "note" note["Back"] = "b123" - deck.addNote(note) + col.addNote(note) # switch fields map = {0: 1, 1: 0} - deck.models.change(basic, [note.id], basic, map, None) + col.models.change(basic, [note.id], basic, map, None) note.load() assert note["Front"] == "b123" assert note["Back"] == "note" @@ -306,7 +306,7 @@ def test_modelChange(): assert "note" in c1.q() assert c0.ord == 0 assert c1.ord == 1 - deck.models.change(basic, [note.id], basic, None, map) + col.models.change(basic, [note.id], basic, None, map) note.load() c0.load() c1.load() @@ -321,7 +321,7 @@ def test_modelChange(): if isWin: # The low precision timer on Windows reveals a race condition time.sleep(0.05) - deck.models.change(basic, [note.id], basic, None, map) + col.models.change(basic, [note.id], basic, None, map) note.load() c0.load() # the card was deleted @@ -335,29 +335,29 @@ def test_modelChange(): # an unmapped field becomes blank assert note["Front"] == "b123" assert note["Back"] == "note" - deck.models.change(basic, [note.id], basic, map, None) + col.models.change(basic, [note.id], basic, map, None) note.load() assert note["Front"] == "" assert note["Back"] == "note" # another note to try model conversion - note = deck.newNote() + note = col.newNote() note["Front"] = "f2" note["Back"] = "b2" - deck.addNote(note) - counts = deck.models.all_use_counts() + col.addNote(note) + counts = col.models.all_use_counts() assert next(c.use_count for c in counts if c.name == "Basic") == 2 assert next(c.use_count for c in counts if c.name == "Cloze") == 0 map = {0: 0, 1: 1} - deck.models.change(basic, [note.id], cloze, map, map) + col.models.change(basic, [note.id], cloze, map, map) note.load() assert note["Text"] == "f2" assert len(note.cards()) == 2 # back the other way, with deletion of second ord - deck.models.remTemplate(basic, basic["tmpls"][1]) - assert deck.db.scalar("select count() from cards where nid = ?", note.id) == 2 + col.models.remTemplate(basic, basic["tmpls"][1]) + assert col.db.scalar("select count() from cards where nid = ?", note.id) == 2 map = {0: 0} - deck.models.change(cloze, [note.id], basic, map, map) - assert deck.db.scalar("select count() from cards where nid = ?", note.id) == 1 + col.models.change(cloze, [note.id], basic, map, map) + assert col.db.scalar("select count() from cards where nid = ?", note.id) == 1 def test_req(): From 2c73dcb2e547c44d9e02c20a00f3c52419dc277b Mon Sep 17 00:00:00 2001 From: Arthur Milchior Date: Fri, 17 Jul 2020 05:21:12 +0200 Subject: [PATCH 5/6] d->col in tests obtained by ``` sed -i "s/\bd\b/col/g" pylib/tests/*py qt/tests/*py ``` --- pylib/tests/test_cards.py | 39 +- pylib/tests/test_collection.py | 8 +- pylib/tests/test_decks.py | 68 +-- pylib/tests/test_find.py | 4 +- pylib/tests/test_latex.py | 36 +- pylib/tests/test_media.py | 36 +- pylib/tests/test_models.py | 176 +++--- pylib/tests/test_schedv1.py | 944 ++++++++++++++++---------------- pylib/tests/test_schedv2.py | 956 +++++++++++++++++---------------- pylib/tests/test_stats.py | 26 +- pylib/tests/test_template.py | 10 +- pylib/tests/test_undo.py | 116 ++-- 12 files changed, 1212 insertions(+), 1207 deletions(-) diff --git a/pylib/tests/test_cards.py b/pylib/tests/test_cards.py index 7c94aa0eb..8ed06fa17 100644 --- a/pylib/tests/test_cards.py +++ b/pylib/tests/test_cards.py @@ -21,25 +21,25 @@ def test_delete(): def test_misc(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "1" note["Back"] = "2" - d.addNote(note) + col.addNote(note) c = note.cards()[0] - id = d.models.current()["id"] + id = col.models.current()["id"] assert c.template()["ord"] == 0 def test_genrem(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "1" note["Back"] = "" - d.addNote(note) + col.addNote(note) assert len(note.cards()) == 1 - m = d.models.current() - mm = d.models + m = col.models.current() + mm = col.models # adding a new template should automatically create cards t = mm.newTemplate("rev") t["qfmt"] = "{{Front}}" @@ -51,9 +51,10 @@ def test_genrem(): t = m["tmpls"][1] t["qfmt"] = "{{Back}}" mm.save(m, templates=True) - rep = d.backend.get_empty_cards() + rep = col.backend.get_empty_cards() + rep = col.backend.get_empty_cards() for n in rep.notes: - d.remove_cards_and_orphaned_notes(n.card_ids) + col.remove_cards_and_orphaned_notes(n.card_ids) assert len(note.cards()) == 1 # if we add to the note, a card should be automatically generated note.load() @@ -63,18 +64,18 @@ def test_genrem(): def test_gendeck(): - d = getEmptyCol() - cloze = d.models.byName("Cloze") - d.models.setCurrent(cloze) - note = d.newNote() + col = getEmptyCol() + cloze = col.models.byName("Cloze") + col.models.setCurrent(cloze) + note = col.newNote() note["Text"] = "{{c1::one}}" - d.addNote(note) - assert d.cardCount() == 1 + col.addNote(note) + assert col.cardCount() == 1 assert note.cards()[0].did == 1 # set the model to a new default col - newId = d.decks.id("new") + newId = col.decks.id("new") cloze["did"] = newId - d.models.save(cloze, updateReqs=False) + col.models.save(cloze, updateReqs=False) # a newly generated card should share the first card's col note["Text"] += "{{c2::two}}" note.flush() diff --git a/pylib/tests/test_collection.py b/pylib/tests/test_collection.py index 00f199788..601ca9dc2 100644 --- a/pylib/tests/test_collection.py +++ b/pylib/tests/test_collection.py @@ -148,15 +148,15 @@ def test_furigana(): def test_translate(): - d = getEmptyCol() + col = getEmptyCol() no_uni = without_unicode_isolation assert ( - d.tr(TR.CARD_TEMPLATE_RENDERING_FRONT_SIDE_PROBLEM) + col.tr(TR.CARD_TEMPLATE_RENDERING_FRONT_SIDE_PROBLEM) == "Front template has a problem:" ) - assert no_uni(d.tr(TR.STATISTICS_REVIEWS, reviews=1)) == "1 review" - assert no_uni(d.tr(TR.STATISTICS_REVIEWS, reviews=2)) == "2 reviews" + assert no_uni(col.tr(TR.STATISTICS_REVIEWS, reviews=1)) == "1 review" + assert no_uni(col.tr(TR.STATISTICS_REVIEWS, reviews=2)) == "2 reviews" def test_db_named_args(capsys): diff --git a/pylib/tests/test_decks.py b/pylib/tests/test_decks.py index ab2d0b677..005d46aa3 100644 --- a/pylib/tests/test_decks.py +++ b/pylib/tests/test_decks.py @@ -61,85 +61,85 @@ def test_remove(): def test_rename(): - d = getEmptyCol() - id = d.decks.id("hello::world") + col = getEmptyCol() + id = col.decks.id("hello::world") # should be able to rename into a completely different branch, creating # parents as necessary - d.decks.rename(d.decks.get(id), "foo::bar") - names = [n.name for n in d.decks.all_names_and_ids()] + col.decks.rename(col.decks.get(id), "foo::bar") + names = [n.name for n in col.decks.all_names_and_ids()] assert "foo" in names assert "foo::bar" in names assert "hello::world" not in names # create another col - id = d.decks.id("tmp") + id = col.decks.id("tmp") # automatically adjusted if a duplicate name - d.decks.rename(d.decks.get(id), "FOO") - names = [n.name for n in d.decks.all_names_and_ids()] + col.decks.rename(col.decks.get(id), "FOO") + names = [n.name for n in col.decks.all_names_and_ids()] assert "FOO+" in names # when renaming, the children should be renamed too - d.decks.id("one::two::three") - id = d.decks.id("one") - d.decks.rename(d.decks.get(id), "yo") - names = [n.name for n in d.decks.all_names_and_ids()] + col.decks.id("one::two::three") + id = col.decks.id("one") + col.decks.rename(col.decks.get(id), "yo") + names = [n.name for n in col.decks.all_names_and_ids()] for n in "yo", "yo::two", "yo::two::three": assert n in names # over filtered - filteredId = d.decks.newDyn("filtered") - filtered = d.decks.get(filteredId) - childId = d.decks.id("child") - child = d.decks.get(childId) - assertException(DeckRenameError, lambda: d.decks.rename(child, "filtered::child")) - assertException(DeckRenameError, lambda: d.decks.rename(child, "FILTERED::child")) + filteredId = col.decks.newDyn("filtered") + filtered = col.decks.get(filteredId) + childId = col.decks.id("child") + child = col.decks.get(childId) + assertException(DeckRenameError, lambda: col.decks.rename(child, "filtered::child")) + assertException(DeckRenameError, lambda: col.decks.rename(child, "FILTERED::child")) def test_renameForDragAndDrop(): - d = getEmptyCol() + col = getEmptyCol() def deckNames(): - return [n.name for n in d.decks.all_names_and_ids(skip_empty_default=True)] + return [n.name for n in col.decks.all_names_and_ids(skip_empty_default=True)] - languages_did = d.decks.id("Languages") - chinese_did = d.decks.id("Chinese") - hsk_did = d.decks.id("Chinese::HSK") + languages_did = col.decks.id("Languages") + chinese_did = col.decks.id("Chinese") + hsk_did = col.decks.id("Chinese::HSK") # Renaming also renames children - d.decks.renameForDragAndDrop(chinese_did, languages_did) + col.decks.renameForDragAndDrop(chinese_did, languages_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] # Dragging a col onto itself is a no-op - d.decks.renameForDragAndDrop(languages_did, languages_did) + col.decks.renameForDragAndDrop(languages_did, languages_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] # Dragging a col onto its parent is a no-op - d.decks.renameForDragAndDrop(hsk_did, chinese_did) + col.decks.renameForDragAndDrop(hsk_did, chinese_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] # Dragging a col onto a descendant is a no-op - d.decks.renameForDragAndDrop(languages_did, hsk_did) + col.decks.renameForDragAndDrop(languages_did, hsk_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] # Can drag a grandchild onto its grandparent. It becomes a child - d.decks.renameForDragAndDrop(hsk_did, languages_did) + col.decks.renameForDragAndDrop(hsk_did, languages_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::HSK"] # Can drag a col onto its sibling - d.decks.renameForDragAndDrop(hsk_did, chinese_did) + col.decks.renameForDragAndDrop(hsk_did, chinese_did) assert deckNames() == ["Languages", "Languages::Chinese", "Languages::Chinese::HSK"] # Can drag a col back to the top level - d.decks.renameForDragAndDrop(chinese_did, None) + col.decks.renameForDragAndDrop(chinese_did, None) assert deckNames() == ["Chinese", "Chinese::HSK", "Languages"] # Dragging a top level col to the top level is a no-op - d.decks.renameForDragAndDrop(chinese_did, None) + col.decks.renameForDragAndDrop(chinese_did, None) assert deckNames() == ["Chinese", "Chinese::HSK", "Languages"] # decks are renamed if necessary - new_hsk_did = d.decks.id("hsk") - d.decks.renameForDragAndDrop(new_hsk_did, chinese_did) + new_hsk_did = col.decks.id("hsk") + col.decks.renameForDragAndDrop(new_hsk_did, chinese_did) assert deckNames() == ["Chinese", "Chinese::HSK", "Chinese::hsk+", "Languages"] - d.decks.rem(new_hsk_did) + col.decks.rem(new_hsk_did) # '' is a convenient alias for the top level DID - d.decks.renameForDragAndDrop(hsk_did, "") + col.decks.renameForDragAndDrop(hsk_did, "") assert deckNames() == ["Chinese", "HSK", "Languages"] diff --git a/pylib/tests/test_find.py b/pylib/tests/test_find.py index 573f94726..1372a9885 100644 --- a/pylib/tests/test_find.py +++ b/pylib/tests/test_find.py @@ -90,8 +90,8 @@ def test_findCards(): assert col.findCards("is:suspended") == [c.id] # nids assert col.findCards("nid:54321") == [] - assert len(col.findCards("nid:%d" % note.id)) == 2 - assert len(col.findCards("nid:%d,%d" % (f1id, f2id))) == 2 + assert len(col.findCards(f"nid:{note.id}")) == 2 + assert len(col.findCards(f"nid:{f1id},{f2id}")) == 2 # templates assert len(col.findCards("card:foo")) == 0 assert len(col.findCards('"card:card 1"')) == 4 diff --git a/pylib/tests/test_latex.py b/pylib/tests/test_latex.py index e21022f55..befd063ea 100644 --- a/pylib/tests/test_latex.py +++ b/pylib/tests/test_latex.py @@ -7,17 +7,17 @@ from tests.shared import getEmptyCol def test_latex(): - d = getEmptyCol() + col = getEmptyCol() # change latex cmd to simulate broken build import anki.latex anki.latex.pngCommands[0][0] = "nolatex" # add a note with latex - note = d.newNote() + note = col.newNote() note["Front"] = "[latex]hello[/latex]" - d.addNote(note) + col.addNote(note) # but since latex couldn't run, there's nothing there - assert len(os.listdir(d.media.dir())) == 0 + assert len(os.listdir(col.media.dir())) == 0 # check the error message msg = note.cards()[0].q() assert "executing nolatex" in msg @@ -29,29 +29,29 @@ def test_latex(): # fix path anki.latex.pngCommands[0][0] = "latex" # check media db should cause latex to be generated - d.media.render_all_latex() - assert len(os.listdir(d.media.dir())) == 1 + col.media.render_all_latex() + assert len(os.listdir(col.media.dir())) == 1 assert ".png" in note.cards()[0].q() # adding new notes should cause generation on question display - note = d.newNote() + note = col.newNote() note["Front"] = "[latex]world[/latex]" - d.addNote(note) + col.addNote(note) note.cards()[0].q() - assert len(os.listdir(d.media.dir())) == 2 + assert len(os.listdir(col.media.dir())) == 2 # another note with the same media should reuse - note = d.newNote() + note = col.newNote() note["Front"] = " [latex]world[/latex]" - d.addNote(note) - assert len(os.listdir(d.media.dir())) == 2 + col.addNote(note) + assert len(os.listdir(col.media.dir())) == 2 oldcard = note.cards()[0] assert ".png" in oldcard.q() # if we turn off building, then previous cards should work, but cards with # missing media will show a broken image anki.latex.build = False - note = d.newNote() + note = col.newNote() note["Front"] = "[latex]foo[/latex]" - d.addNote(note) - assert len(os.listdir(d.media.dir())) == 2 + col.addNote(note) + assert len(os.listdir(col.media.dir())) == 2 assert ".png" in oldcard.q() # turn it on again so other test don't suffer anki.latex.build = True @@ -87,9 +87,9 @@ def test_latex(): def _test_includes_bad_command(bad): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "[latex]%s[/latex]" % bad - d.addNote(note) + col.addNote(note) q = note.cards()[0].q() return ("'%s' is not allowed on cards" % bad in q, "Card content: %s" % q) diff --git a/pylib/tests/test_media.py b/pylib/tests/test_media.py index d7fc6b332..5f17af373 100644 --- a/pylib/tests/test_media.py +++ b/pylib/tests/test_media.py @@ -8,25 +8,25 @@ from .shared import getEmptyCol, testDir # copying files to media folder def test_add(): - d = getEmptyCol() + col = getEmptyCol() dir = tempfile.mkdtemp(prefix="anki") path = os.path.join(dir, "foo.jpg") with open(path, "w") as note: note.write("hello") # new file, should preserve name - assert d.media.addFile(path) == "foo.jpg" + assert col.media.addFile(path) == "foo.jpg" # adding the same file again should not create a duplicate - assert d.media.addFile(path) == "foo.jpg" + assert col.media.addFile(path) == "foo.jpg" # but if it has a different sha1, it should with open(path, "w") as note: note.write("world") - assert d.media.addFile(path) == "foo-7c211433f02071597741e6ff5a8ea34789abbf43.jpg" + assert col.media.addFile(path) == "foo-7c211433f02071597741e6ff5a8ea34789abbf43.jpg" def test_strings(): - d = getEmptyCol() - mf = d.media.filesInStr - mid = d.models.current()["id"] + col = getEmptyCol() + mf = col.media.filesInStr + mid = col.models.current()["id"] assert mf(mid, "aoeu") == [] assert mf(mid, "aoeuao") == ["foo.jpg"] assert mf(mid, "aoeuao") == ["foo.jpg"] @@ -42,37 +42,37 @@ def test_strings(): "fo", ] assert mf(mid, "aou[sound:foo.mp3]aou") == ["foo.mp3"] - sp = d.media.strip + sp = col.media.strip assert sp("aoeu") == "aoeu" assert sp("aoeu[sound:foo.mp3]aoeu") == "aoeuaoeu" assert sp("aoeu") == "aoeu" - es = d.media.escapeImages + es = col.media.escapeImages assert es("aoeu") == "aoeu" assert es("") == "" assert es('') == '' def test_deckIntegration(): - d = getEmptyCol() + col = getEmptyCol() # create a media dir - d.media.dir() + col.media.dir() # put a file into it file = str(os.path.join(testDir, "support/fake.png")) - d.media.addFile(file) + col.media.addFile(file) # add a note which references it - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "" - d.addNote(note) + col.addNote(note) # and one which references a non-existent file - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "" - d.addNote(note) + col.addNote(note) # and add another file which isn't used - with open(os.path.join(d.media.dir(), "foo.jpg"), "w") as note: + with open(os.path.join(col.media.dir(), "foo.jpg"), "w") as note: note.write("test") # check media - ret = d.media.check() + ret = col.media.check() assert ret.missing == ["fake2.png"] assert ret.unused == ["foo.jpg"] diff --git a/pylib/tests/test_models.py b/pylib/tests/test_models.py index 7afaf4ca9..5f2827cc6 100644 --- a/pylib/tests/test_models.py +++ b/pylib/tests/test_models.py @@ -33,79 +33,79 @@ def test_modelCopy(): def test_fields(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "1" note["Back"] = "2" - d.addNote(note) - m = d.models.current() + col.addNote(note) + m = col.models.current() # make sure renaming a field updates the templates - d.models.renameField(m, m["flds"][0], "NewFront") + col.models.renameField(m, m["flds"][0], "NewFront") assert "{{NewFront}}" in m["tmpls"][0]["qfmt"] - h = d.models.scmhash(m) + h = col.models.scmhash(m) # add a field - note = d.models.newField("foo") - d.models.addField(m, note) - assert d.getNote(d.models.nids(m)[0]).fields == ["1", "2", ""] - assert d.models.scmhash(m) != h + note = col.models.newField("foo") + col.models.addField(m, note) + assert col.getNote(col.models.nids(m)[0]).fields == ["1", "2", ""] + assert col.models.scmhash(m) != h # rename it note = m["flds"][2] - d.models.renameField(m, note, "bar") - assert d.getNote(d.models.nids(m)[0])["bar"] == "" + col.models.renameField(m, note, "bar") + assert col.getNote(col.models.nids(m)[0])["bar"] == "" # delete back - d.models.remField(m, m["flds"][1]) - assert d.getNote(d.models.nids(m)[0]).fields == ["1", ""] + col.models.remField(m, m["flds"][1]) + assert col.getNote(col.models.nids(m)[0]).fields == ["1", ""] # move 0 -> 1 - d.models.moveField(m, m["flds"][0], 1) - assert d.getNote(d.models.nids(m)[0]).fields == ["", "1"] + col.models.moveField(m, m["flds"][0], 1) + assert col.getNote(col.models.nids(m)[0]).fields == ["", "1"] # move 1 -> 0 - d.models.moveField(m, m["flds"][1], 0) - assert d.getNote(d.models.nids(m)[0]).fields == ["1", ""] + col.models.moveField(m, m["flds"][1], 0) + assert col.getNote(col.models.nids(m)[0]).fields == ["1", ""] # add another and put in middle - note = d.models.newField("baz") - d.models.addField(m, note) - note = d.getNote(d.models.nids(m)[0]) + note = col.models.newField("baz") + col.models.addField(m, note) + note = col.getNote(col.models.nids(m)[0]) note["baz"] = "2" note.flush() - assert d.getNote(d.models.nids(m)[0]).fields == ["1", "", "2"] + assert col.getNote(col.models.nids(m)[0]).fields == ["1", "", "2"] # move 2 -> 1 - d.models.moveField(m, m["flds"][2], 1) - assert d.getNote(d.models.nids(m)[0]).fields == ["1", "2", ""] + col.models.moveField(m, m["flds"][2], 1) + assert col.getNote(col.models.nids(m)[0]).fields == ["1", "2", ""] # move 0 -> 2 - d.models.moveField(m, m["flds"][0], 2) - assert d.getNote(d.models.nids(m)[0]).fields == ["2", "", "1"] + col.models.moveField(m, m["flds"][0], 2) + assert col.getNote(col.models.nids(m)[0]).fields == ["2", "", "1"] # move 0 -> 1 - d.models.moveField(m, m["flds"][0], 1) - assert d.getNote(d.models.nids(m)[0]).fields == ["", "2", "1"] + col.models.moveField(m, m["flds"][0], 1) + assert col.getNote(col.models.nids(m)[0]).fields == ["", "2", "1"] def test_templates(): - d = getEmptyCol() - m = d.models.current() - mm = d.models + col = getEmptyCol() + m = col.models.current() + mm = col.models t = mm.newTemplate("Reverse") t["qfmt"] = "{{Back}}" t["afmt"] = "{{Front}}" mm.addTemplate(m, t) mm.save(m) - note = d.newNote() + note = col.newNote() note["Front"] = "1" note["Back"] = "2" - d.addNote(note) - assert d.cardCount() == 2 + col.addNote(note) + assert col.cardCount() == 2 (c, c2) = note.cards() # first card should have first ord assert c.ord == 0 assert c2.ord == 1 # switch templates - d.models.moveTemplate(m, c.template(), 1) + col.models.moveTemplate(m, c.template(), 1) c.load() c2.load() assert c.ord == 1 assert c2.ord == 0 # removing a template should delete its cards - d.models.remTemplate(m, m["tmpls"][0]) - assert d.cardCount() == 1 + col.models.remTemplate(m, m["tmpls"][0]) + assert col.cardCount() == 1 # and should have updated the other cards' ordinals c = note.cards()[0] assert c.ord == 0 @@ -113,18 +113,20 @@ def test_templates(): # it shouldn't be possible to orphan notes by removing templates t = mm.newTemplate("template name") mm.addTemplate(m, t) - d.models.remTemplate(m, m["tmpls"][0]) + col.models.remTemplate(m, m["tmpls"][0]) assert ( - d.db.scalar("select count() from cards where nid not in (select id from notes)") + col.db.scalar( + "select count() from cards where nid not in (select id from notes)" + ) == 0 ) def test_cloze_ordinals(): - d = getEmptyCol() - d.models.setCurrent(d.models.byName("Cloze")) - m = d.models.current() - mm = d.models + col = getEmptyCol() + col.models.setCurrent(col.models.byName("Cloze")) + m = col.models.current() + mm = col.models # We replace the default Cloze template t = mm.newTemplate("ChainedCloze") @@ -132,12 +134,12 @@ def test_cloze_ordinals(): t["afmt"] = "{{text:cloze:Text}}" mm.addTemplate(m, t) mm.save(m) - d.models.remTemplate(m, m["tmpls"][0]) + col.models.remTemplate(m, m["tmpls"][0]) - note = d.newNote() + note = col.newNote() note["Text"] = "{{c1::firstQ::firstA}}{{c2::secondQ::secondA}}" - d.addNote(note) - assert d.cardCount() == 2 + col.addNote(note) + assert col.cardCount() == 2 (c, c2) = note.cards() # first card should have first ord assert c.ord == 0 @@ -145,40 +147,40 @@ def test_cloze_ordinals(): def test_text(): - d = getEmptyCol() - m = d.models.current() + col = getEmptyCol() + m = col.models.current() m["tmpls"][0]["qfmt"] = "{{text:Front}}" - d.models.save(m) - note = d.newNote() + col.models.save(m) + note = col.newNote() note["Front"] = "helloworld" - d.addNote(note) + col.addNote(note) assert "helloworld" in note.cards()[0].q() def test_cloze(): - d = getEmptyCol() - d.models.setCurrent(d.models.byName("Cloze")) - note = d.newNote() + col = getEmptyCol() + col.models.setCurrent(col.models.byName("Cloze")) + note = col.newNote() assert note.model()["name"] == "Cloze" # a cloze model with no clozes is not empty note["Text"] = "nothing" - assert d.addNote(note) + assert col.addNote(note) # try with one cloze - note = d.newNote() + note = col.newNote() note["Text"] = "hello {{c1::world}}" - assert d.addNote(note) == 1 + assert col.addNote(note) == 1 assert "hello [...]" in note.cards()[0].q() assert "hello world" in note.cards()[0].a() # and with a comment - note = d.newNote() + note = col.newNote() note["Text"] = "hello {{c1::world::typical}}" - assert d.addNote(note) == 1 + assert col.addNote(note) == 1 assert "[typical]" in note.cards()[0].q() assert "world" in note.cards()[0].a() # and with 2 clozes - note = d.newNote() + note = col.newNote() note["Text"] = "hello {{c1::world}} {{c2::bar}}" - assert d.addNote(note) == 2 + assert col.addNote(note) == 2 (c1, c2) = note.cards() assert "[...] bar" in c1.q() assert "world bar" in c1.a() @@ -186,17 +188,17 @@ def test_cloze(): assert "world bar" in c2.a() # if there are multiple answers for a single cloze, they are given in a # list - note = d.newNote() + note = col.newNote() note["Text"] = "a {{c1::b}} {{c1::c}}" - assert d.addNote(note) == 1 + assert col.addNote(note) == 1 assert "b c" in ( note.cards()[0].a() ) # if we add another cloze, a card should be generated - cnt = d.cardCount() + cnt = col.cardCount() note["Text"] = "{{c2::hello}} {{c1::foo}}" note.flush() - assert d.cardCount() == cnt + 1 + assert col.cardCount() == cnt + 1 # 0 or negative indices are not supported note["Text"] += "{{c0::zero}} {{c-1:foo}}" note.flush() @@ -204,13 +206,13 @@ def test_cloze(): def test_cloze_mathjax(): - d = getEmptyCol() - d.models.setCurrent(d.models.byName("Cloze")) - note = d.newNote() + col = getEmptyCol() + col.models.setCurrent(col.models.byName("Cloze")) + note = col.newNote() note[ "Text" ] = r"{{c1::ok}} \(2^2\) {{c2::not ok}} \(2^{{c3::2}}\) \(x^3\) {{c4::blah}} {{c5::text with \(x^2\) jax}}" - assert d.addNote(note) + assert col.addNote(note) assert len(note.cards()) == 5 assert "class=cloze" in note.cards()[0].q() assert "class=cloze" in note.cards()[1].q() @@ -218,9 +220,9 @@ def test_cloze_mathjax(): assert "class=cloze" in note.cards()[3].q() assert "class=cloze" in note.cards()[4].q() - note = d.newNote() + note = col.newNote() note["Text"] = r"\(a\) {{c1::b}} \[ {{c1::c}} \]" - assert d.addNote(note) + assert col.addNote(note) assert len(note.cards()) == 1 assert ( note.cards()[0] @@ -230,22 +232,22 @@ def test_cloze_mathjax(): def test_typecloze(): - d = getEmptyCol() - m = d.models.byName("Cloze") - d.models.setCurrent(m) + col = getEmptyCol() + m = col.models.byName("Cloze") + col.models.setCurrent(m) m["tmpls"][0]["qfmt"] = "{{cloze:Text}}{{type:cloze:Text}}" - d.models.save(m) - note = d.newNote() + col.models.save(m) + note = col.newNote() note["Text"] = "hello {{c1::world}}" - d.addNote(note) + col.addNote(note) assert "[[type:cloze:Text]]" in note.cards()[0].q() def test_chained_mods(): - d = getEmptyCol() - d.models.setCurrent(d.models.byName("Cloze")) - m = d.models.current() - mm = d.models + col = getEmptyCol() + col.models.setCurrent(col.models.byName("Cloze")) + m = col.models.current() + mm = col.models # We replace the default Cloze template t = mm.newTemplate("ChainedCloze") @@ -253,9 +255,9 @@ def test_chained_mods(): t["afmt"] = "{{cloze:text:Text}}" mm.addTemplate(m, t) mm.save(m) - d.models.remTemplate(m, m["tmpls"][0]) + col.models.remTemplate(m, m["tmpls"][0]) - note = d.newNote() + note = col.newNote() q1 = 'phrase' a1 = "sentence" q2 = 'en chaine' @@ -266,7 +268,7 @@ def test_chained_mods(): q2, a2, ) - assert d.addNote(note) == 1 + assert col.addNote(note) == 1 assert ( "This [sentence] demonstrates [chained] clozes." in note.cards()[0].q() @@ -366,8 +368,8 @@ def test_req(): return assert len(model["tmpls"]) == len(model["req"]) - d = getEmptyCol() - mm = d.models + col = getEmptyCol() + mm = col.models basic = mm.byName("Basic") assert "req" in basic reqSize(basic) diff --git a/pylib/tests/test_schedv1.py b/pylib/tests/test_schedv1.py index ed5821baf..8d8b7a32f 100644 --- a/pylib/tests/test_schedv1.py +++ b/pylib/tests/test_schedv1.py @@ -16,41 +16,41 @@ def getEmptyCol(): def test_clock(): - d = getEmptyCol() - if (d.sched.dayCutoff - intTime()) < 10 * 60: + col = getEmptyCol() + if (col.sched.dayCutoff - intTime()) < 10 * 60: raise Exception("Unit tests will fail around the day rollover.") -def checkRevIvl(d, c, targetIvl): - min, max = d.sched._fuzzIvlRange(targetIvl) +def checkRevIvl(col, c, targetIvl): + min, max = col.sched._fuzzIvlRange(targetIvl) return min <= c.ivl <= max def test_basics(): - d = getEmptyCol() - d.reset() - assert not d.sched.getCard() + col = getEmptyCol() + col.reset() + assert not col.sched.getCard() def test_new(): - d = getEmptyCol() - d.reset() - assert d.sched.newCount == 0 + col = getEmptyCol() + col.reset() + assert col.sched.newCount == 0 # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) - d.reset() - assert d.sched.newCount == 1 + col.addNote(note) + col.reset() + assert col.sched.newCount == 1 # fetch it - c = d.sched.getCard() + c = col.sched.getCard() assert c assert c.queue == QUEUE_TYPE_NEW assert c.type == CARD_TYPE_NEW # if we answer it, it should become a learn card t = intTime() - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert c.queue == QUEUE_TYPE_LRN assert c.type == CARD_TYPE_LRN assert c.due >= t @@ -58,94 +58,94 @@ def test_new(): # disabled for now, as the learn fudging makes this randomly fail # # the default order should ensure siblings are not seen together, and # # should show all cards - # m = d.models.current(); mm = d.models + # m = col.models.current(); mm = col.models # t = mm.newTemplate("Reverse") # t['qfmt'] = "{{Back}}" # t['afmt'] = "{{Front}}" # mm.addTemplate(m, t) # mm.save(m) - # note = d.newNote() + # note = col.newNote() # note['Front'] = u"2"; note['Back'] = u"2" - # d.addNote(note) - # note = d.newNote() + # col.addNote(note) + # note = col.newNote() # note['Front'] = u"3"; note['Back'] = u"3" - # d.addNote(note) - # d.reset() + # col.addNote(note) + # col.reset() # qs = ("2", "3", "2", "3") # for n in range(4): - # c = d.sched.getCard() + # c = col.sched.getCard() # assert qs[n] in c.q() - # d.sched.answerCard(c, 2) + # col.sched.answerCard(c, 2) def test_newLimits(): - d = getEmptyCol() + col = getEmptyCol() # add some notes - g2 = d.decks.id("Default::foo") + g2 = col.decks.id("Default::foo") for i in range(30): - note = d.newNote() + note = col.newNote() note["Front"] = str(i) if i > 4: note.model()["did"] = g2 - d.addNote(note) + col.addNote(note) # give the child deck a different configuration - c2 = d.decks.add_config_returning_id("new conf") - d.decks.setConf(d.decks.get(g2), c2) - d.reset() + c2 = col.decks.add_config_returning_id("new conf") + col.decks.setConf(col.decks.get(g2), c2) + col.reset() # both confs have defaulted to a limit of 20 - assert d.sched.newCount == 20 + assert col.sched.newCount == 20 # first card we get comes from parent - c = d.sched.getCard() + c = col.sched.getCard() assert c.did == 1 # limit the parent to 10 cards, meaning we get 10 in total - conf1 = d.decks.confForDid(1) + conf1 = col.decks.confForDid(1) conf1["new"]["perDay"] = 10 - d.decks.save(conf1) - d.reset() - assert d.sched.newCount == 10 + col.decks.save(conf1) + col.reset() + assert col.sched.newCount == 10 # if we limit child to 4, we should get 9 - conf2 = d.decks.confForDid(g2) + conf2 = col.decks.confForDid(g2) conf2["new"]["perDay"] = 4 - d.decks.save(conf2) - d.reset() - assert d.sched.newCount == 9 + col.decks.save(conf2) + col.reset() + assert col.sched.newCount == 9 def test_newBoxes(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) - d.reset() - c = d.sched.getCard() - conf = d.sched._cardConf(c) + col.addNote(note) + col.reset() + c = col.sched.getCard() + conf = col.sched._cardConf(c) conf["new"]["delays"] = [1, 2, 3, 4, 5] - d.decks.save(conf) - d.sched.answerCard(c, 2) + col.decks.save(conf) + col.sched.answerCard(c, 2) # should handle gracefully conf["new"]["delays"] = [1] - d.decks.save(conf) - d.sched.answerCard(c, 2) + col.decks.save(conf) + col.sched.answerCard(c, 2) def test_learn(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - note = d.addNote(note) + note = col.addNote(note) # set as a learn card and rebuild queues - d.db.execute("update cards set queue=0, type=0") - d.reset() + col.db.execute("update cards set queue=0, type=0") + col.reset() # sched.getCard should return it, since it's due in the past - c = d.sched.getCard() + c = col.sched.getCard() assert c - conf = d.sched._cardConf(c) + conf = col.sched._cardConf(c) conf["new"]["delays"] = [0.5, 3, 10] - d.decks.save(conf) + col.decks.save(conf) # fail it - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) # it should have three reps left to graduation assert c.left % 1000 == 3 assert c.left // 1000 == 3 @@ -153,18 +153,18 @@ def test_learn(): t = round(c.due - time.time()) assert t >= 25 and t <= 40 # pass it once - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) # it should by due in 3 minutes assert round(c.due - time.time()) in (179, 180) assert c.left % 1000 == 2 assert c.left // 1000 == 2 # check log is accurate - log = d.db.first("select * from revlog order by id desc") + log = col.db.first("select * from revlog order by id desc") assert log[3] == 2 assert log[4] == -180 assert log[5] == -30 # pass again - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) # it should by due in 10 minutes assert round(c.due - time.time()) in (599, 600) assert c.left % 1000 == 1 @@ -172,26 +172,26 @@ def test_learn(): # the next pass should graduate the card assert c.queue == QUEUE_TYPE_LRN assert c.type == CARD_TYPE_LRN - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) assert c.queue == QUEUE_TYPE_REV assert c.type == CARD_TYPE_REV # should be due tomorrow, with an interval of 1 - assert c.due == d.sched.today + 1 + assert c.due == col.sched.today + 1 assert c.ivl == 1 # or normal removal c.type = 0 c.queue = 1 - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) assert c.type == CARD_TYPE_REV assert c.queue == QUEUE_TYPE_REV - assert checkRevIvl(d, c, 4) + assert checkRevIvl(col, c, 4) # revlog should have been updated each time - assert d.db.scalar("select count() from revlog where type = 0") == 5 + assert col.db.scalar("select count() from revlog where type = 0") == 5 # now failed card handling c.type = CARD_TYPE_REV c.queue = 1 c.odue = 123 - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) assert c.due == 123 assert c.type == CARD_TYPE_REV assert c.queue == QUEUE_TYPE_REV @@ -200,114 +200,114 @@ def test_learn(): c.queue = 1 c.odue = 321 c.flush() - d.sched.removeLrn() + col.sched.removeLrn() c.load() assert c.queue == QUEUE_TYPE_REV assert c.due == 321 def test_learn_collapsed(): - d = getEmptyCol() + col = getEmptyCol() # add 2 notes - note = d.newNote() + note = col.newNote() note["Front"] = "1" - note = d.addNote(note) - note = d.newNote() + note = col.addNote(note) + note = col.newNote() note["Front"] = "2" - note = d.addNote(note) + note = col.addNote(note) # set as a learn card and rebuild queues - d.db.execute("update cards set queue=0, type=0") - d.reset() + col.db.execute("update cards set queue=0, type=0") + col.reset() # should get '1' first - c = d.sched.getCard() + c = col.sched.getCard() assert c.q().endswith("1") # pass it so it's due in 10 minutes - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) # get the other card - c = d.sched.getCard() + c = col.sched.getCard() assert c.q().endswith("2") # fail it so it's due in 1 minute - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) # we shouldn't get the same card again - c = d.sched.getCard() + c = col.sched.getCard() assert not c.q().endswith("2") def test_learn_day(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" - note = d.addNote(note) - d.sched.reset() - c = d.sched.getCard() - conf = d.sched._cardConf(c) + note = col.addNote(note) + col.sched.reset() + c = col.sched.getCard() + conf = col.sched._cardConf(c) conf["new"]["delays"] = [1, 10, 1440, 2880] - d.decks.save(conf) + col.decks.save(conf) # pass it - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) # two reps to graduate, 1 more today assert c.left % 1000 == 3 assert c.left // 1000 == 1 - assert d.sched.counts() == (0, 1, 0) - c = d.sched.getCard() - ni = d.sched.nextIvl + assert col.sched.counts() == (0, 1, 0) + c = col.sched.getCard() + ni = col.sched.nextIvl assert ni(c, 2) == 86400 # answering it will place it in queue 3 - d.sched.answerCard(c, 2) - assert c.due == d.sched.today + 1 + col.sched.answerCard(c, 2) + assert c.due == col.sched.today + 1 assert c.queue == CARD_TYPE_RELEARNING - assert not d.sched.getCard() + assert not col.sched.getCard() # for testing, move it back a day c.due -= 1 c.flush() - d.reset() - assert d.sched.counts() == (0, 1, 0) - c = d.sched.getCard() + col.reset() + assert col.sched.counts() == (0, 1, 0) + c = col.sched.getCard() # nextIvl should work assert ni(c, 2) == 86400 * 2 # if we fail it, it should be back in the correct queue - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert c.queue == QUEUE_TYPE_LRN - d.undo() - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 2) + col.undo() + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 2) # simulate the passing of another two days c.due -= 2 c.flush() - d.reset() + col.reset() # the last pass should graduate it into a review card assert ni(c, 2) == 86400 - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) assert c.queue == CARD_TYPE_REV and c.type == QUEUE_TYPE_REV # if the lapse step is tomorrow, failing it should handle the counts # correctly c.due = 0 c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 1) - conf = d.sched._cardConf(c) + col.reset() + assert col.sched.counts() == (0, 0, 1) + conf = col.sched._cardConf(c) conf["lapse"]["delays"] = [1440] - d.decks.save(conf) - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.decks.save(conf) + c = col.sched.getCard() + col.sched.answerCard(c, 1) assert c.queue == CARD_TYPE_RELEARNING - assert d.sched.counts() == (0, 0, 0) + assert col.sched.counts() == (0, 0, 0) def test_reviews(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) # set the card up as a review card, due 8 days ago c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV - c.due = d.sched.today - 8 + c.due = col.sched.today - 8 c.factor = STARTING_FACTOR c.reps = 3 c.lapses = 1 @@ -319,14 +319,14 @@ def test_reviews(): # failing it should put it in the learn queue with the default options ################################################## # different delay to new - d.reset() - conf = d.sched._cardConf(c) + col.reset() + conf = col.sched._cardConf(c) conf["lapse"]["delays"] = [2, 20] - d.decks.save(conf) - d.sched.answerCard(c, 1) + col.decks.save(conf) + col.sched.answerCard(c, 1) assert c.queue == QUEUE_TYPE_LRN # it should be due tomorrow, with an interval of 1 - assert c.odue == d.sched.today + 1 + assert c.odue == col.sched.today + 1 assert c.ivl == 1 # but because it's in the learn queue, its current due time should be in # the future @@ -338,18 +338,18 @@ def test_reviews(): assert c.lapses == 2 assert c.reps == 4 # check ests. - ni = d.sched.nextIvl + ni = col.sched.nextIvl assert ni(c, 1) == 120 assert ni(c, 2) == 20 * 60 # try again with an ease of 2 instead ################################################## c = copy.copy(cardcopy) c.flush() - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) assert c.queue == QUEUE_TYPE_REV # the new interval should be (100 + 8/4) * 1.2 = 122 - assert checkRevIvl(d, c, 122) - assert c.due == d.sched.today + c.ivl + assert checkRevIvl(col, c, 122) + assert c.due == col.sched.today + c.ivl # factor should have been decremented assert c.factor == 2350 # check counters @@ -359,40 +359,40 @@ def test_reviews(): ################################################## c = copy.copy(cardcopy) c.flush() - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # the new interval should be (100 + 8/2) * 2.5 = 260 - assert checkRevIvl(d, c, 260) - assert c.due == d.sched.today + c.ivl + assert checkRevIvl(col, c, 260) + assert c.due == col.sched.today + c.ivl # factor should have been left alone assert c.factor == STARTING_FACTOR # ease 4 ################################################## c = copy.copy(cardcopy) c.flush() - d.sched.answerCard(c, 4) + col.sched.answerCard(c, 4) # the new interval should be (100 + 8) * 2.5 * 1.3 = 351 - assert checkRevIvl(d, c, 351) - assert c.due == d.sched.today + c.ivl + assert checkRevIvl(col, c, 351) + assert c.due == col.sched.today + c.ivl # factor should have been increased assert c.factor == 2650 def test_button_spacing(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # 1 day ivl review card due now c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV - c.due = d.sched.today + c.due = col.sched.today c.reps = 1 c.ivl = 1 c.startTimer() c.flush() - d.reset() - ni = d.sched.nextIvlStr + col.reset() + ni = col.sched.nextIvlStr wo = without_unicode_isolation assert wo(ni(c, 2)) == "2d" assert wo(ni(c, 3)) == "3d" @@ -402,11 +402,11 @@ def test_button_spacing(): def test_overdue_lapse(): # disabled in commit 3069729776990980f34c25be66410e947e9d51a2 return - d = getEmptyCol() # pylint: disable=unreachable + col = getEmptyCol() # pylint: disable=unreachable # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # simulate a review that was lapsed and is now due for its normal review c = note.cards()[0] c.type = CARD_TYPE_REV @@ -417,74 +417,74 @@ def test_overdue_lapse(): c.left = 2002 c.ivl = 0 c.flush() - d.sched._clearOverdue = False + col.sched._clearOverdue = False # checkpoint - d.save() - d.sched.reset() - assert d.sched.counts() == (0, 2, 0) - c = d.sched.getCard() - d.sched.answerCard(c, 3) + col.save() + col.sched.reset() + assert col.sched.counts() == (0, 2, 0) + c = col.sched.getCard() + col.sched.answerCard(c, 3) # it should be due tomorrow - assert c.due == d.sched.today + 1 + assert c.due == col.sched.today + 1 # revert to before - d.rollback() - d.sched._clearOverdue = True + col.rollback() + col.sched._clearOverdue = True # with the default settings, the overdue card should be removed from the # learning queue - d.sched.reset() - assert d.sched.counts() == (0, 0, 1) + col.sched.reset() + assert col.sched.counts() == (0, 0, 1) def test_finished(): - d = getEmptyCol() + col = getEmptyCol() # nothing due - assert "Congratulations" in d.sched.finishedMsg() - assert "limit" not in d.sched.finishedMsg() - note = d.newNote() + assert "Congratulations" in col.sched.finishedMsg() + assert "limit" not in col.sched.finishedMsg() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) # have a new card - assert "new cards available" in d.sched.finishedMsg() + assert "new cards available" in col.sched.finishedMsg() # turn it into a review - d.reset() + col.reset() c = note.cards()[0] c.startTimer() - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # nothing should be due tomorrow, as it's due in a week - assert "Congratulations" in d.sched.finishedMsg() - assert "limit" not in d.sched.finishedMsg() + assert "Congratulations" in col.sched.finishedMsg() + assert "limit" not in col.sched.finishedMsg() def test_nextIvl(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) - d.reset() - conf = d.decks.confForDid(1) + col.addNote(note) + col.reset() + conf = col.decks.confForDid(1) conf["new"]["delays"] = [0.5, 3, 10] conf["lapse"]["delays"] = [1, 5, 9] - d.decks.save(conf) - c = d.sched.getCard() + col.decks.save(conf) + c = col.sched.getCard() # new cards ################################################## - ni = d.sched.nextIvl + ni = col.sched.nextIvl assert ni(c, 1) == 30 assert ni(c, 2) == 180 assert ni(c, 3) == 4 * 86400 - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) # cards in learning ################################################## assert ni(c, 1) == 30 assert ni(c, 2) == 180 assert ni(c, 3) == 4 * 86400 - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) assert ni(c, 1) == 30 assert ni(c, 2) == 600 assert ni(c, 3) == 4 * 86400 - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) # normal graduation is tomorrow assert ni(c, 2) == 1 * 86400 assert ni(c, 3) == 4 * 86400 @@ -505,7 +505,7 @@ def test_nextIvl(): assert ni(c, 1) == 60 # or 1 day if relearn is false conf["lapse"]["delays"] = [] - d.decks.save(conf) + col.decks.save(conf) assert ni(c, 1) == 1 * 86400 # (* 100 1.2 86400)10368000.0 assert ni(c, 2) == 10368000 @@ -513,54 +513,54 @@ def test_nextIvl(): assert ni(c, 3) == 21600000 # (* 100 2.5 1.3 86400)28080000.0 assert ni(c, 4) == 28080000 - assert without_unicode_isolation(d.sched.nextIvlStr(c, 4)) == "10.8mo" + assert without_unicode_isolation(col.sched.nextIvlStr(c, 4)) == "10.8mo" def test_misc(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] # burying - d.sched.buryNote(c.nid) - d.reset() - assert not d.sched.getCard() - d.sched.unburyCards() - d.reset() - assert d.sched.getCard() + col.sched.buryNote(c.nid) + col.reset() + assert not col.sched.getCard() + col.sched.unburyCards() + col.reset() + assert col.sched.getCard() def test_suspend(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] # suspending - d.reset() - assert d.sched.getCard() - d.sched.suspendCards([c.id]) - d.reset() - assert not d.sched.getCard() + col.reset() + assert col.sched.getCard() + col.sched.suspendCards([c.id]) + col.reset() + assert not col.sched.getCard() # unsuspending - d.sched.unsuspendCards([c.id]) - d.reset() - assert d.sched.getCard() + col.sched.unsuspendCards([c.id]) + col.reset() + assert col.sched.getCard() # should cope with rev cards being relearnt c.due = 0 c.ivl = 100 c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.flush() - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) assert c.due >= time.time() assert c.queue == QUEUE_TYPE_LRN assert c.type == CARD_TYPE_REV - d.sched.suspendCards([c.id]) - d.sched.unsuspendCards([c.id]) + col.sched.suspendCards([c.id]) + col.sched.unsuspendCards([c.id]) c.load() assert c.queue == QUEUE_TYPE_REV assert c.type == CARD_TYPE_REV @@ -568,56 +568,56 @@ def test_suspend(): # should cope with cards in cram decks c.due = 1 c.flush() - cram = d.decks.newDyn("tmp") - d.sched.rebuildDyn() + cram = col.decks.newDyn("tmp") + col.sched.rebuildDyn() c.load() assert c.due != 1 assert c.did != 1 - d.sched.suspendCards([c.id]) + col.sched.suspendCards([c.id]) c.load() assert c.due == 1 assert c.did == 1 def test_cram(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.ivl = 100 c.queue = CARD_TYPE_REV c.type = QUEUE_TYPE_REV # due in 25 days, so it's been waiting 75 days - c.due = d.sched.today + 25 + c.due = col.sched.today + 25 c.mod = 1 c.factor = STARTING_FACTOR c.startTimer() c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 0) + col.reset() + assert col.sched.counts() == (0, 0, 0) cardcopy = copy.copy(c) # create a dynamic deck and refresh it - did = d.decks.newDyn("Cram") - d.sched.rebuildDyn(did) - d.reset() + did = col.decks.newDyn("Cram") + col.sched.rebuildDyn(did) + col.reset() # should appear as new in the deck list - assert sorted(d.sched.deck_due_tree().children)[0].new_count == 1 + assert sorted(col.sched.deck_due_tree().children)[0].new_count == 1 # and should appear in the counts - assert d.sched.counts() == (1, 0, 0) + assert col.sched.counts() == (1, 0, 0) # grab it and check estimates - c = d.sched.getCard() - assert d.sched.answerButtons(c) == 2 - assert d.sched.nextIvl(c, 1) == 600 - assert d.sched.nextIvl(c, 2) == 138 * 60 * 60 * 24 - cram = d.decks.get(did) + c = col.sched.getCard() + assert col.sched.answerButtons(c) == 2 + assert col.sched.nextIvl(c, 1) == 600 + assert col.sched.nextIvl(c, 2) == 138 * 60 * 60 * 24 + cram = col.decks.get(did) cram["delays"] = [1, 10] - d.decks.save(cram) - assert d.sched.answerButtons(c) == 3 - assert d.sched.nextIvl(c, 1) == 60 - assert d.sched.nextIvl(c, 2) == 600 - assert d.sched.nextIvl(c, 3) == 138 * 60 * 60 * 24 - d.sched.answerCard(c, 2) + col.decks.save(cram) + assert col.sched.answerButtons(c) == 3 + assert col.sched.nextIvl(c, 1) == 60 + assert col.sched.nextIvl(c, 2) == 600 + assert col.sched.nextIvl(c, 3) == 138 * 60 * 60 * 24 + col.sched.answerCard(c, 2) # elapsed time was 75 days # factor = 2.5+1.2/2 = 1.85 # int(75*1.85) = 138 @@ -625,88 +625,88 @@ def test_cram(): assert c.odue == 138 assert c.queue == QUEUE_TYPE_LRN # should be logged as a cram rep - assert d.db.scalar("select type from revlog order by id desc limit 1") == 3 + assert col.db.scalar("select type from revlog order by id desc limit 1") == 3 # check ivls again - assert d.sched.nextIvl(c, 1) == 60 - assert d.sched.nextIvl(c, 2) == 138 * 60 * 60 * 24 - assert d.sched.nextIvl(c, 3) == 138 * 60 * 60 * 24 + assert col.sched.nextIvl(c, 1) == 60 + assert col.sched.nextIvl(c, 2) == 138 * 60 * 60 * 24 + assert col.sched.nextIvl(c, 3) == 138 * 60 * 60 * 24 # when it graduates, due is updated - c = d.sched.getCard() - d.sched.answerCard(c, 2) + c = col.sched.getCard() + col.sched.answerCard(c, 2) assert c.ivl == 138 assert c.due == 138 assert c.queue == QUEUE_TYPE_REV # and it will have moved back to the previous deck assert c.did == 1 # cram the deck again - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() # check ivls again - passing should be idempotent - assert d.sched.nextIvl(c, 1) == 60 - assert d.sched.nextIvl(c, 2) == 600 - assert d.sched.nextIvl(c, 3) == 138 * 60 * 60 * 24 - d.sched.answerCard(c, 2) + assert col.sched.nextIvl(c, 1) == 60 + assert col.sched.nextIvl(c, 2) == 600 + assert col.sched.nextIvl(c, 3) == 138 * 60 * 60 * 24 + col.sched.answerCard(c, 2) assert c.ivl == 138 assert c.odue == 138 # fail - d.sched.answerCard(c, 1) - assert d.sched.nextIvl(c, 1) == 60 - assert d.sched.nextIvl(c, 2) == 600 - assert d.sched.nextIvl(c, 3) == 86400 + col.sched.answerCard(c, 1) + assert col.sched.nextIvl(c, 1) == 60 + assert col.sched.nextIvl(c, 2) == 600 + assert col.sched.nextIvl(c, 3) == 86400 # delete the deck, returning the card mid-study - d.decks.rem(d.decks.selected()) - assert len(d.sched.deck_due_tree().children) == 1 + col.decks.rem(col.decks.selected()) + assert len(col.sched.deck_due_tree().children) == 1 c.load() assert c.ivl == 1 - assert c.due == d.sched.today + 1 + assert c.due == col.sched.today + 1 # make it due - d.reset() - assert d.sched.counts() == (0, 0, 0) + col.reset() + assert col.sched.counts() == (0, 0, 0) c.due = -5 c.ivl = 100 c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 1) + col.reset() + assert col.sched.counts() == (0, 0, 1) # cram again - did = d.decks.newDyn("Cram") - d.sched.rebuildDyn(did) - d.reset() - assert d.sched.counts() == (0, 0, 1) + did = col.decks.newDyn("Cram") + col.sched.rebuildDyn(did) + col.reset() + assert col.sched.counts() == (0, 0, 1) c.load() - assert d.sched.answerButtons(c) == 4 + assert col.sched.answerButtons(c) == 4 # add a sibling so we can test minSpace, etc c.col = None c2 = copy.deepcopy(c) - c2.col = c.col = d + c2.col = c.col = col c2.id = 0 c2.ord = 1 c2.due = 325 c2.col = c.col c2.flush() # should be able to answer it - c = d.sched.getCard() - d.sched.answerCard(c, 4) + c = col.sched.getCard() + col.sched.answerCard(c, 4) # it should have been moved back to the original deck assert c.did == 1 def test_cram_rem(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) oldDue = note.cards()[0].due - did = d.decks.newDyn("Cram") - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 2) + did = col.decks.newDyn("Cram") + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 2) # answering the card will put it in the learning queue assert c.type == CARD_TYPE_LRN and c.queue == QUEUE_TYPE_LRN assert c.due != oldDue # if we terminate cramming prematurely it should be set back to new - d.sched.emptyDyn(did) + col.sched.emptyDyn(did) c.load() assert c.type == CARD_TYPE_NEW and c.queue == QUEUE_TYPE_NEW assert c.due == oldDue @@ -714,75 +714,75 @@ def test_cram_rem(): def test_cram_resched(): # add card - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # cram deck - did = d.decks.newDyn("Cram") - cram = d.decks.get(did) + did = col.decks.newDyn("Cram") + cram = col.decks.get(did) cram["resched"] = False - d.decks.save(cram) - d.sched.rebuildDyn(did) - d.reset() + col.decks.save(cram) + col.sched.rebuildDyn(did) + col.reset() # graduate should return it to new - c = d.sched.getCard() - ni = d.sched.nextIvl + c = col.sched.getCard() + ni = col.sched.nextIvl assert ni(c, 1) == 60 assert ni(c, 2) == 600 assert ni(c, 3) == 0 - assert d.sched.nextIvlStr(c, 3) == "(end)" - d.sched.answerCard(c, 3) + assert col.sched.nextIvlStr(c, 3) == "(end)" + col.sched.answerCard(c, 3) assert c.type == CARD_TYPE_NEW and c.queue == QUEUE_TYPE_NEW # undue reviews should also be unaffected c.ivl = 100 c.queue = CARD_TYPE_REV c.type = QUEUE_TYPE_REV - c.due = d.sched.today + 25 + c.due = col.sched.today + 25 c.factor = STARTING_FACTOR c.flush() cardcopy = copy.copy(c) - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() assert ni(c, 1) == 600 assert ni(c, 2) == 0 assert ni(c, 3) == 0 - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) assert c.ivl == 100 - assert c.due == d.sched.today + 25 + assert c.due == col.sched.today + 25 # check failure too c = cardcopy c.flush() - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) - d.sched.emptyDyn(did) + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) + col.sched.emptyDyn(did) c.load() assert c.ivl == 100 - assert c.due == d.sched.today + 25 + assert c.due == col.sched.today + 25 # fail+grad early c = cardcopy c.flush() - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) - d.sched.answerCard(c, 3) - d.sched.emptyDyn(did) + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) + col.sched.answerCard(c, 3) + col.sched.emptyDyn(did) c.load() assert c.ivl == 100 - assert c.due == d.sched.today + 25 + assert c.due == col.sched.today + 25 # due cards - pass c = cardcopy c.due = -25 c.flush() - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 3) - d.sched.emptyDyn(did) + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 3) + col.sched.emptyDyn(did) c.load() assert c.ivl == 100 assert c.due == -25 @@ -790,11 +790,11 @@ def test_cram_resched(): c = cardcopy c.due = -25 c.flush() - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) - d.sched.emptyDyn(did) + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) + col.sched.emptyDyn(did) c.load() assert c.ivl == 100 assert c.due == -25 @@ -802,29 +802,29 @@ def test_cram_resched(): c = cardcopy c.due = -25 c.flush() - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) - d.sched.answerCard(c, 3) + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) + col.sched.answerCard(c, 3) c.load() assert c.ivl == 100 assert c.due == -25 # lapsed card pulled into cram - # d.sched._cardConf(c)['lapse']['mult']=0.5 - # d.sched.answerCard(c, 1) - # d.sched.rebuildDyn(did) - # d.reset() - # c = d.sched.getCard() - # d.sched.answerCard(c, 2) + # col.sched._cardConf(c)['lapse']['mult']=0.5 + # col.sched.answerCard(c, 1) + # col.sched.rebuildDyn(did) + # col.reset() + # c = col.sched.getCard() + # col.sched.answerCard(c, 2) # print c.__dict__ def test_ordcycle(): - d = getEmptyCol() + col = getEmptyCol() # add two more templates and set second active - m = d.models.current() - mm = d.models + m = col.models.current() + mm = col.models t = mm.newTemplate("Reverse") t["qfmt"] = "{{Back}}" t["afmt"] = "{{Front}}" @@ -835,117 +835,117 @@ def test_ordcycle(): mm.addTemplate(m, t) mm.save(m) # create a new note; it should have 3 cards - note = d.newNote() + note = col.newNote() note["Front"] = "1" note["Back"] = "1" - d.addNote(note) - assert d.cardCount() == 3 - d.reset() + col.addNote(note) + assert col.cardCount() == 3 + col.reset() # ordinals should arrive in order - assert d.sched.getCard().ord == 0 - assert d.sched.getCard().ord == 1 - assert d.sched.getCard().ord == 2 + assert col.sched.getCard().ord == 0 + assert col.sched.getCard().ord == 1 + assert col.sched.getCard().ord == 2 def test_counts_idx(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) - d.reset() - assert d.sched.counts() == (1, 0, 0) - c = d.sched.getCard() + col.addNote(note) + col.reset() + assert col.sched.counts() == (1, 0, 0) + c = col.sched.getCard() # counter's been decremented but idx indicates 1 - assert d.sched.counts() == (0, 0, 0) - assert d.sched.countIdx(c) == 0 + assert col.sched.counts() == (0, 0, 0) + assert col.sched.countIdx(c) == 0 # answer to move to learn queue - d.sched.answerCard(c, 1) - assert d.sched.counts() == (0, 2, 0) + col.sched.answerCard(c, 1) + assert col.sched.counts() == (0, 2, 0) # fetching again will decrement the count - c = d.sched.getCard() - assert d.sched.counts() == (0, 0, 0) - assert d.sched.countIdx(c) == 1 + c = col.sched.getCard() + assert col.sched.counts() == (0, 0, 0) + assert col.sched.countIdx(c) == 1 # answering should add it back again - d.sched.answerCard(c, 1) - assert d.sched.counts() == (0, 2, 0) + col.sched.answerCard(c, 1) + assert col.sched.counts() == (0, 2, 0) def test_repCounts(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) - d.reset() + col.addNote(note) + col.reset() # lrnReps should be accurate on pass/fail - assert d.sched.counts() == (1, 0, 0) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 2, 0) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 2, 0) - d.sched.answerCard(d.sched.getCard(), 2) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 2, 0) - d.sched.answerCard(d.sched.getCard(), 2) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 2) - assert d.sched.counts() == (0, 0, 0) - note = d.newNote() + assert col.sched.counts() == (1, 0, 0) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 2, 0) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 2, 0) + col.sched.answerCard(col.sched.getCard(), 2) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 2, 0) + col.sched.answerCard(col.sched.getCard(), 2) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 2) + assert col.sched.counts() == (0, 0, 0) + note = col.newNote() note["Front"] = "two" - d.addNote(note) - d.reset() + col.addNote(note) + col.reset() # initial pass should be correct too - d.sched.answerCard(d.sched.getCard(), 2) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 2, 0) - d.sched.answerCard(d.sched.getCard(), 3) - assert d.sched.counts() == (0, 0, 0) + col.sched.answerCard(col.sched.getCard(), 2) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 2, 0) + col.sched.answerCard(col.sched.getCard(), 3) + assert col.sched.counts() == (0, 0, 0) # immediate graduate should work - note = d.newNote() + note = col.newNote() note["Front"] = "three" - d.addNote(note) - d.reset() - d.sched.answerCard(d.sched.getCard(), 3) - assert d.sched.counts() == (0, 0, 0) + col.addNote(note) + col.reset() + col.sched.answerCard(col.sched.getCard(), 3) + assert col.sched.counts() == (0, 0, 0) # and failing a review should too - note = d.newNote() + note = col.newNote() note["Front"] = "three" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV - c.due = d.sched.today + c.due = col.sched.today c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 1) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 1, 0) + col.reset() + assert col.sched.counts() == (0, 0, 1) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 1, 0) def test_timing(): - d = getEmptyCol() + col = getEmptyCol() # add a few review cards, due today for i in range(5): - note = d.newNote() + note = col.newNote() note["Front"] = "num" + str(i) - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = 0 c.flush() # fail the first one - d.reset() - c = d.sched.getCard() + col.reset() + c = col.sched.getCard() # set a a fail delay of 4 seconds - conf = d.sched._cardConf(c) + conf = col.sched._cardConf(c) conf["lapse"]["delays"][0] = 1 / 15.0 - d.decks.save(conf) - d.sched.answerCard(c, 1) + col.decks.save(conf) + col.sched.answerCard(c, 1) # the next card should be another review - c = d.sched.getCard() + c = col.sched.getCard() assert c.queue == QUEUE_TYPE_REV # but if we wait for a few seconds, the failed card should come back orig_time = time.time @@ -954,55 +954,55 @@ def test_timing(): return orig_time() + 5 time.time = adjusted_time - c = d.sched.getCard() + c = col.sched.getCard() assert c.queue == QUEUE_TYPE_LRN time.time = orig_time def test_collapse(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) - d.reset() + col.addNote(note) + col.reset() # test collapsing - c = d.sched.getCard() - d.sched.answerCard(c, 1) - c = d.sched.getCard() - d.sched.answerCard(c, 3) - assert not d.sched.getCard() + c = col.sched.getCard() + col.sched.answerCard(c, 1) + c = col.sched.getCard() + col.sched.answerCard(c, 3) + assert not col.sched.getCard() def test_deckDue(): - d = getEmptyCol() + col = getEmptyCol() # add a note with default deck - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # and one that's a child - note = d.newNote() + note = col.newNote() note["Front"] = "two" - default1 = note.model()["did"] = d.decks.id("Default::1") - d.addNote(note) + default1 = note.model()["did"] = col.decks.id("Default::1") + col.addNote(note) # make it a review card c = note.cards()[0] c.queue = QUEUE_TYPE_REV c.due = 0 c.flush() # add one more with a new deck - note = d.newNote() + note = col.newNote() note["Front"] = "two" - foobar = note.model()["did"] = d.decks.id("foo::bar") - d.addNote(note) + foobar = note.model()["did"] = col.decks.id("foo::bar") + col.addNote(note) # and one that's a sibling - note = d.newNote() + note = col.newNote() note["Front"] = "three" - foobaz = note.model()["did"] = d.decks.id("foo::baz") - d.addNote(note) - d.reset() - assert len(d.decks.all_names_and_ids()) == 5 - tree = d.sched.deck_due_tree().children + foobaz = note.model()["did"] = col.decks.id("foo::baz") + col.addNote(note) + col.reset() + assert len(col.decks.all_names_and_ids()) == 5 + tree = col.sched.deck_due_tree().children assert tree[0].name == "Default" # sum of child and parent assert tree[0].deck_id == 1 @@ -1017,66 +1017,66 @@ def test_deckDue(): # code should not fail if a card has an invalid deck c.did = 12345 c.flush() - d.sched.deck_due_tree() + col.sched.deck_due_tree() def test_deckFlow(): - d = getEmptyCol() + col = getEmptyCol() # add a note with default deck - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # and one that's a child - note = d.newNote() + note = col.newNote() note["Front"] = "two" - default1 = note.model()["did"] = d.decks.id("Default::2") - d.addNote(note) + default1 = note.model()["did"] = col.decks.id("Default::2") + col.addNote(note) # and another that's higher up - note = d.newNote() + note = col.newNote() note["Front"] = "three" - default1 = note.model()["did"] = d.decks.id("Default::1") - d.addNote(note) + default1 = note.model()["did"] = col.decks.id("Default::1") + col.addNote(note) # should get top level one first, then ::1, then ::2 - d.reset() - assert d.sched.counts() == (3, 0, 0) + col.reset() + assert col.sched.counts() == (3, 0, 0) for i in "one", "three", "two": - c = d.sched.getCard() + c = col.sched.getCard() assert c.note()["Front"] == i - d.sched.answerCard(c, 2) + col.sched.answerCard(c, 2) def test_reorder(): - d = getEmptyCol() + col = getEmptyCol() # add a note with default deck - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) - note2 = d.newNote() + col.addNote(note) + note2 = col.newNote() note2["Front"] = "two" - d.addNote(note2) + col.addNote(note2) assert note2.cards()[0].due == 2 found = False # 50/50 chance of being reordered for i in range(20): - d.sched.randomizeCards(1) + col.sched.randomizeCards(1) if note.cards()[0].due != note.id: found = True break assert found - d.sched.orderCards(1) + col.sched.orderCards(1) assert note.cards()[0].due == 1 # shifting - f3 = d.newNote() + f3 = col.newNote() f3["Front"] = "three" - d.addNote(f3) - f4 = d.newNote() + col.addNote(f3) + f4 = col.newNote() f4["Front"] = "four" - d.addNote(f4) + col.addNote(f4) assert note.cards()[0].due == 1 assert note2.cards()[0].due == 2 assert f3.cards()[0].due == 3 assert f4.cards()[0].due == 4 - d.sched.sortCards([f3.cards()[0].id, f4.cards()[0].id], start=1, shift=True) + col.sched.sortCards([f3.cards()[0].id, f4.cards()[0].id], start=1, shift=True) assert note.cards()[0].due == 3 assert note2.cards()[0].due == 4 assert f3.cards()[0].due == 1 @@ -1084,46 +1084,46 @@ def test_reorder(): def test_forget(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.queue = QUEUE_TYPE_REV c.type = CARD_TYPE_REV c.ivl = 100 c.due = 0 c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 1) - d.sched.forgetCards([c.id]) - d.reset() - assert d.sched.counts() == (1, 0, 0) + col.reset() + assert col.sched.counts() == (0, 0, 1) + col.sched.forgetCards([c.id]) + col.reset() + assert col.sched.counts() == (1, 0, 0) def test_resched(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] - d.sched.reschedCards([c.id], 0, 0) + col.sched.reschedCards([c.id], 0, 0) c.load() - assert c.due == d.sched.today + assert c.due == col.sched.today assert c.ivl == 1 assert c.queue == CARD_TYPE_REV and c.type == QUEUE_TYPE_REV - d.sched.reschedCards([c.id], 1, 1) + col.sched.reschedCards([c.id], 1, 1) c.load() - assert c.due == d.sched.today + 1 + assert c.due == col.sched.today + 1 assert c.ivl == +1 def test_norelearn(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV @@ -1134,33 +1134,33 @@ def test_norelearn(): c.ivl = 100 c.startTimer() c.flush() - d.reset() - d.sched.answerCard(c, 1) - d.sched._cardConf(c)["lapse"]["delays"] = [] - d.sched.answerCard(c, 1) + col.reset() + col.sched.answerCard(c, 1) + col.sched._cardConf(c)["lapse"]["delays"] = [] + col.sched.answerCard(c, 1) def test_failmult(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.ivl = 100 - c.due = d.sched.today - c.ivl + c.due = col.sched.today - c.ivl c.factor = STARTING_FACTOR c.reps = 3 c.lapses = 1 c.startTimer() c.flush() - conf = d.sched._cardConf(c) + conf = col.sched._cardConf(c) conf["lapse"]["mult"] = 0.5 - d.decks.save(conf) - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.decks.save(conf) + c = col.sched.getCard() + col.sched.answerCard(c, 1) assert c.ivl == 50 - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert c.ivl == 25 diff --git a/pylib/tests/test_schedv2.py b/pylib/tests/test_schedv2.py index 5124166d9..30c654d17 100644 --- a/pylib/tests/test_schedv2.py +++ b/pylib/tests/test_schedv2.py @@ -17,41 +17,41 @@ def getEmptyCol(): def test_clock(): - d = getEmptyCol() - if (d.sched.dayCutoff - intTime()) < 10 * 60: + col = getEmptyCol() + if (col.sched.dayCutoff - intTime()) < 10 * 60: raise Exception("Unit tests will fail around the day rollover.") -def checkRevIvl(d, c, targetIvl): - min, max = d.sched._fuzzIvlRange(targetIvl) +def checkRevIvl(col, c, targetIvl): + min, max = col.sched._fuzzIvlRange(targetIvl) return min <= c.ivl <= max def test_basics(): - d = getEmptyCol() - d.reset() - assert not d.sched.getCard() + col = getEmptyCol() + col.reset() + assert not col.sched.getCard() def test_new(): - d = getEmptyCol() - d.reset() - assert d.sched.newCount == 0 + col = getEmptyCol() + col.reset() + assert col.sched.newCount == 0 # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) - d.reset() - assert d.sched.newCount == 1 + col.addNote(note) + col.reset() + assert col.sched.newCount == 1 # fetch it - c = d.sched.getCard() + c = col.sched.getCard() assert c assert c.queue == QUEUE_TYPE_NEW assert c.type == CARD_TYPE_NEW # if we answer it, it should become a learn card t = intTime() - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert c.queue == QUEUE_TYPE_LRN assert c.type == CARD_TYPE_LRN assert c.due >= t @@ -59,94 +59,94 @@ def test_new(): # disabled for now, as the learn fudging makes this randomly fail # # the default order should ensure siblings are not seen together, and # # should show all cards - # m = d.models.current(); mm = d.models + # m = col.models.current(); mm = col.models # t = mm.newTemplate("Reverse") # t['qfmt'] = "{{Back}}" # t['afmt'] = "{{Front}}" # mm.addTemplate(m, t) # mm.save(m) - # note = d.newNote() + # note = col.newNote() # note['Front'] = u"2"; note['Back'] = u"2" - # d.addNote(note) - # note = d.newNote() + # col.addNote(note) + # note = col.newNote() # note['Front'] = u"3"; note['Back'] = u"3" - # d.addNote(note) - # d.reset() + # col.addNote(note) + # col.reset() # qs = ("2", "3", "2", "3") # for n in range(4): - # c = d.sched.getCard() + # c = col.sched.getCard() # assert qs[n] in c.q() - # d.sched.answerCard(c, 2) + # col.sched.answerCard(c, 2) def test_newLimits(): - d = getEmptyCol() + col = getEmptyCol() # add some notes - g2 = d.decks.id("Default::foo") + g2 = col.decks.id("Default::foo") for i in range(30): - note = d.newNote() + note = col.newNote() note["Front"] = str(i) if i > 4: note.model()["did"] = g2 - d.addNote(note) + col.addNote(note) # give the child deck a different configuration - c2 = d.decks.add_config_returning_id("new conf") - d.decks.setConf(d.decks.get(g2), c2) - d.reset() + c2 = col.decks.add_config_returning_id("new conf") + col.decks.setConf(col.decks.get(g2), c2) + col.reset() # both confs have defaulted to a limit of 20 - assert d.sched.newCount == 20 + assert col.sched.newCount == 20 # first card we get comes from parent - c = d.sched.getCard() + c = col.sched.getCard() assert c.did == 1 # limit the parent to 10 cards, meaning we get 10 in total - conf1 = d.decks.confForDid(1) + conf1 = col.decks.confForDid(1) conf1["new"]["perDay"] = 10 - d.decks.save(conf1) - d.reset() - assert d.sched.newCount == 10 + col.decks.save(conf1) + col.reset() + assert col.sched.newCount == 10 # if we limit child to 4, we should get 9 - conf2 = d.decks.confForDid(g2) + conf2 = col.decks.confForDid(g2) conf2["new"]["perDay"] = 4 - d.decks.save(conf2) - d.reset() - assert d.sched.newCount == 9 + col.decks.save(conf2) + col.reset() + assert col.sched.newCount == 9 def test_newBoxes(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) - d.reset() - c = d.sched.getCard() - conf = d.sched._cardConf(c) + col.addNote(note) + col.reset() + c = col.sched.getCard() + conf = col.sched._cardConf(c) conf["new"]["delays"] = [1, 2, 3, 4, 5] - d.decks.save(conf) - d.sched.answerCard(c, 2) + col.decks.save(conf) + col.sched.answerCard(c, 2) # should handle gracefully conf["new"]["delays"] = [1] - d.decks.save(conf) - d.sched.answerCard(c, 2) + col.decks.save(conf) + col.sched.answerCard(c, 2) def test_learn(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - note = d.addNote(note) + note = col.addNote(note) # set as a learn card and rebuild queues - d.db.execute("update cards set queue=0, type=0") - d.reset() + col.db.execute("update cards set queue=0, type=0") + col.reset() # sched.getCard should return it, since it's due in the past - c = d.sched.getCard() + c = col.sched.getCard() assert c - conf = d.sched._cardConf(c) + conf = col.sched._cardConf(c) conf["new"]["delays"] = [0.5, 3, 10] - d.decks.save(conf) + col.decks.save(conf) # fail it - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) # it should have three reps left to graduation assert c.left % 1000 == 3 assert c.left // 1000 == 3 @@ -154,19 +154,19 @@ def test_learn(): t = round(c.due - time.time()) assert t >= 25 and t <= 40 # pass it once - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # it should by due in 3 minutes dueIn = c.due - time.time() assert 178 <= dueIn <= 180 * 1.25 assert c.left % 1000 == 2 assert c.left // 1000 == 2 # check log is accurate - log = d.db.first("select * from revlog order by id desc") + log = col.db.first("select * from revlog order by id desc") assert log[3] == 3 assert log[4] == -180 assert log[5] == -30 # pass again - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # it should by due in 10 minutes dueIn = c.due - time.time() assert 599 <= dueIn <= 600 * 1.25 @@ -175,175 +175,175 @@ def test_learn(): # the next pass should graduate the card assert c.queue == QUEUE_TYPE_LRN assert c.type == CARD_TYPE_LRN - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) assert c.queue == QUEUE_TYPE_REV assert c.type == CARD_TYPE_REV # should be due tomorrow, with an interval of 1 - assert c.due == d.sched.today + 1 + assert c.due == col.sched.today + 1 assert c.ivl == 1 # or normal removal c.type = 0 c.queue = 1 - d.sched.answerCard(c, 4) + col.sched.answerCard(c, 4) assert c.type == CARD_TYPE_REV assert c.queue == QUEUE_TYPE_REV - assert checkRevIvl(d, c, 4) + assert checkRevIvl(col, c, 4) # revlog should have been updated each time - assert d.db.scalar("select count() from revlog where type = 0") == 5 + assert col.db.scalar("select count() from revlog where type = 0") == 5 def test_relearn(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.ivl = 100 - c.due = d.sched.today + c.due = col.sched.today c.queue = CARD_TYPE_REV c.type = QUEUE_TYPE_REV c.flush() # fail the card - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) assert c.queue == QUEUE_TYPE_LRN assert c.type == CARD_TYPE_RELEARNING assert c.ivl == 1 # immediately graduate it - d.sched.answerCard(c, 4) + col.sched.answerCard(c, 4) assert c.queue == CARD_TYPE_REV and c.type == QUEUE_TYPE_REV assert c.ivl == 2 - assert c.due == d.sched.today + c.ivl + assert c.due == col.sched.today + c.ivl def test_relearn_no_steps(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.ivl = 100 - c.due = d.sched.today + c.due = col.sched.today c.queue = CARD_TYPE_REV c.type = QUEUE_TYPE_REV c.flush() - conf = d.decks.confForDid(1) + conf = col.decks.confForDid(1) conf["lapse"]["delays"] = [] - d.decks.save(conf) + col.decks.save(conf) # fail the card - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) assert c.queue == CARD_TYPE_REV and c.type == QUEUE_TYPE_REV def test_learn_collapsed(): - d = getEmptyCol() + col = getEmptyCol() # add 2 notes - note = d.newNote() + note = col.newNote() note["Front"] = "1" - note = d.addNote(note) - note = d.newNote() + note = col.addNote(note) + note = col.newNote() note["Front"] = "2" - note = d.addNote(note) + note = col.addNote(note) # set as a learn card and rebuild queues - d.db.execute("update cards set queue=0, type=0") - d.reset() + col.db.execute("update cards set queue=0, type=0") + col.reset() # should get '1' first - c = d.sched.getCard() + c = col.sched.getCard() assert c.q().endswith("1") # pass it so it's due in 10 minutes - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # get the other card - c = d.sched.getCard() + c = col.sched.getCard() assert c.q().endswith("2") # fail it so it's due in 1 minute - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) # we shouldn't get the same card again - c = d.sched.getCard() + c = col.sched.getCard() assert not c.q().endswith("2") def test_learn_day(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" - note = d.addNote(note) - d.sched.reset() - c = d.sched.getCard() - conf = d.sched._cardConf(c) + note = col.addNote(note) + col.sched.reset() + c = col.sched.getCard() + conf = col.sched._cardConf(c) conf["new"]["delays"] = [1, 10, 1440, 2880] - d.decks.save(conf) + col.decks.save(conf) # pass it - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # two reps to graduate, 1 more today assert c.left % 1000 == 3 assert c.left // 1000 == 1 - assert d.sched.counts() == (0, 1, 0) - c = d.sched.getCard() - ni = d.sched.nextIvl + assert col.sched.counts() == (0, 1, 0) + c = col.sched.getCard() + ni = col.sched.nextIvl assert ni(c, 3) == 86400 # answering it will place it in queue 3 - d.sched.answerCard(c, 3) - assert c.due == d.sched.today + 1 + col.sched.answerCard(c, 3) + assert c.due == col.sched.today + 1 assert c.queue == QUEUE_TYPE_DAY_LEARN_RELEARN - assert not d.sched.getCard() + assert not col.sched.getCard() # for testing, move it back a day c.due -= 1 c.flush() - d.reset() - assert d.sched.counts() == (0, 1, 0) - c = d.sched.getCard() + col.reset() + assert col.sched.counts() == (0, 1, 0) + c = col.sched.getCard() # nextIvl should work assert ni(c, 3) == 86400 * 2 # if we fail it, it should be back in the correct queue - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert c.queue == QUEUE_TYPE_LRN - d.undo() - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 3) + col.undo() + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 3) # simulate the passing of another two days c.due -= 2 c.flush() - d.reset() + col.reset() # the last pass should graduate it into a review card assert ni(c, 3) == 86400 - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) assert c.queue == CARD_TYPE_REV and c.type == QUEUE_TYPE_REV # if the lapse step is tomorrow, failing it should handle the counts # correctly c.due = 0 c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 1) - conf = d.sched._cardConf(c) + col.reset() + assert col.sched.counts() == (0, 0, 1) + conf = col.sched._cardConf(c) conf["lapse"]["delays"] = [1440] - d.decks.save(conf) - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.decks.save(conf) + c = col.sched.getCard() + col.sched.answerCard(c, 1) assert c.queue == QUEUE_TYPE_DAY_LEARN_RELEARN - assert d.sched.counts() == (0, 0, 0) + assert col.sched.counts() == (0, 0, 0) def test_reviews(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) # set the card up as a review card, due 8 days ago c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV - c.due = d.sched.today - 8 + c.due = col.sched.today - 8 c.factor = STARTING_FACTOR c.reps = 3 c.lapses = 1 @@ -356,12 +356,12 @@ def test_reviews(): ################################################## c = copy.copy(cardcopy) c.flush() - d.reset() - d.sched.answerCard(c, 2) + col.reset() + col.sched.answerCard(c, 2) assert c.queue == QUEUE_TYPE_REV # the new interval should be (100) * 1.2 = 120 - assert checkRevIvl(d, c, 120) - assert c.due == d.sched.today + c.ivl + assert checkRevIvl(col, c, 120) + assert c.due == col.sched.today + c.ivl # factor should have been decremented assert c.factor == 2350 # check counters @@ -371,27 +371,27 @@ def test_reviews(): ################################################## c = copy.copy(cardcopy) c.flush() - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # the new interval should be (100 + 8/2) * 2.5 = 260 - assert checkRevIvl(d, c, 260) - assert c.due == d.sched.today + c.ivl + assert checkRevIvl(col, c, 260) + assert c.due == col.sched.today + c.ivl # factor should have been left alone assert c.factor == STARTING_FACTOR # ease 4 ################################################## c = copy.copy(cardcopy) c.flush() - d.sched.answerCard(c, 4) + col.sched.answerCard(c, 4) # the new interval should be (100 + 8) * 2.5 * 1.3 = 351 - assert checkRevIvl(d, c, 351) - assert c.due == d.sched.today + c.ivl + assert checkRevIvl(col, c, 351) + assert c.due == col.sched.today + c.ivl # factor should have been increased assert c.factor == 2650 # leech handling ################################################## - conf = d.decks.getConf(1) + conf = col.decks.getConf(1) conf["lapse"]["leechAction"] = LEECH_SUSPEND - d.decks.save(conf) + col.decks.save(conf) c = copy.copy(cardcopy) c.lapses = 7 c.flush() @@ -402,7 +402,7 @@ def test_reviews(): hooked.append(1) hooks.card_did_leech.append(onLeech) - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert hooked assert c.queue == QUEUE_TYPE_SUSPENDED c.load() @@ -410,31 +410,31 @@ def test_reviews(): def test_review_limits(): - d = getEmptyCol() + col = getEmptyCol() - parent = d.decks.get(d.decks.id("parent")) - child = d.decks.get(d.decks.id("parent::child")) + parent = col.decks.get(col.decks.id("parent")) + child = col.decks.get(col.decks.id("parent::child")) - pconf = d.decks.get_config(d.decks.add_config_returning_id("parentConf")) - cconf = d.decks.get_config(d.decks.add_config_returning_id("childConf")) + pconf = col.decks.get_config(col.decks.add_config_returning_id("parentConf")) + cconf = col.decks.get_config(col.decks.add_config_returning_id("childConf")) pconf["rev"]["perDay"] = 5 - d.decks.update_config(pconf) - d.decks.setConf(parent, pconf["id"]) + col.decks.update_config(pconf) + col.decks.setConf(parent, pconf["id"]) cconf["rev"]["perDay"] = 10 - d.decks.update_config(cconf) - d.decks.setConf(child, cconf["id"]) + col.decks.update_config(cconf) + col.decks.setConf(child, cconf["id"]) - m = d.models.current() + m = col.models.current() m["did"] = child["id"] - d.models.save(m, updateReqs=False) + col.models.save(m, updateReqs=False) # add some cards for i in range(20): - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) # make them reviews c = note.cards()[0] @@ -443,62 +443,62 @@ def test_review_limits(): c.due = 0 c.flush() - tree = d.sched.deck_due_tree().children + tree = col.sched.deck_due_tree().children # (('parent', 1514457677462, 5, 0, 0, (('child', 1514457677463, 5, 0, 0, ()),))) assert tree[0].review_count == 5 # parent assert tree[0].children[0].review_count == 5 # child # .counts() should match - d.decks.select(child["id"]) - d.sched.reset() - assert d.sched.counts() == (0, 0, 5) + col.decks.select(child["id"]) + col.sched.reset() + assert col.sched.counts() == (0, 0, 5) # answering a card in the child should decrement parent count - c = d.sched.getCard() - d.sched.answerCard(c, 3) - assert d.sched.counts() == (0, 0, 4) + c = col.sched.getCard() + col.sched.answerCard(c, 3) + assert col.sched.counts() == (0, 0, 4) - tree = d.sched.deck_due_tree().children + tree = col.sched.deck_due_tree().children assert tree[0].review_count == 4 # parent assert tree[0].children[0].review_count == 4 # child def test_button_spacing(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # 1 day ivl review card due now c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV - c.due = d.sched.today + c.due = col.sched.today c.reps = 1 c.ivl = 1 c.startTimer() c.flush() - d.reset() - ni = d.sched.nextIvlStr + col.reset() + ni = col.sched.nextIvlStr wo = without_unicode_isolation assert wo(ni(c, 2)) == "2d" assert wo(ni(c, 3)) == "3d" assert wo(ni(c, 4)) == "4d" # if hard factor is <= 1, then hard may not increase - conf = d.decks.confForDid(1) + conf = col.decks.confForDid(1) conf["rev"]["hardFactor"] = 1 - d.decks.save(conf) + col.decks.save(conf) assert wo(ni(c, 2)) == "1d" def test_overdue_lapse(): # disabled in commit 3069729776990980f34c25be66410e947e9d51a2 return - d = getEmptyCol() # pylint: disable=unreachable + col = getEmptyCol() # pylint: disable=unreachable # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # simulate a review that was lapsed and is now due for its normal review c = note.cards()[0] c.type = CARD_TYPE_REV @@ -509,77 +509,77 @@ def test_overdue_lapse(): c.left = 2002 c.ivl = 0 c.flush() - d.sched._clearOverdue = False + col.sched._clearOverdue = False # checkpoint - d.save() - d.sched.reset() - assert d.sched.counts() == (0, 2, 0) - c = d.sched.getCard() - d.sched.answerCard(c, 3) + col.save() + col.sched.reset() + assert col.sched.counts() == (0, 2, 0) + c = col.sched.getCard() + col.sched.answerCard(c, 3) # it should be due tomorrow - assert c.due == d.sched.today + 1 + assert c.due == col.sched.today + 1 # revert to before - d.rollback() - d.sched._clearOverdue = True + col.rollback() + col.sched._clearOverdue = True # with the default settings, the overdue card should be removed from the # learning queue - d.sched.reset() - assert d.sched.counts() == (0, 0, 1) + col.sched.reset() + assert col.sched.counts() == (0, 0, 1) def test_finished(): - d = getEmptyCol() + col = getEmptyCol() # nothing due - assert "Congratulations" in d.sched.finishedMsg() - assert "limit" not in d.sched.finishedMsg() - note = d.newNote() + assert "Congratulations" in col.sched.finishedMsg() + assert "limit" not in col.sched.finishedMsg() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) # have a new card - assert "new cards available" in d.sched.finishedMsg() + assert "new cards available" in col.sched.finishedMsg() # turn it into a review - d.reset() + col.reset() c = note.cards()[0] c.startTimer() - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # nothing should be due tomorrow, as it's due in a week - assert "Congratulations" in d.sched.finishedMsg() - assert "limit" not in d.sched.finishedMsg() + assert "Congratulations" in col.sched.finishedMsg() + assert "limit" not in col.sched.finishedMsg() def test_nextIvl(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) - d.reset() - conf = d.decks.confForDid(1) + col.addNote(note) + col.reset() + conf = col.decks.confForDid(1) conf["new"]["delays"] = [0.5, 3, 10] conf["lapse"]["delays"] = [1, 5, 9] - d.decks.save(conf) - c = d.sched.getCard() + col.decks.save(conf) + c = col.sched.getCard() # new cards ################################################## - ni = d.sched.nextIvl + ni = col.sched.nextIvl assert ni(c, 1) == 30 assert ni(c, 2) == (30 + 180) // 2 assert ni(c, 3) == 180 assert ni(c, 4) == 4 * 86400 - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) # cards in learning ################################################## assert ni(c, 1) == 30 assert ni(c, 2) == (30 + 180) // 2 assert ni(c, 3) == 180 assert ni(c, 4) == 4 * 86400 - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) assert ni(c, 1) == 30 assert ni(c, 2) == (180 + 600) // 2 assert ni(c, 3) == 600 assert ni(c, 4) == 4 * 86400 - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # normal graduation is tomorrow assert ni(c, 3) == 1 * 86400 assert ni(c, 4) == 4 * 86400 @@ -600,7 +600,7 @@ def test_nextIvl(): assert ni(c, 1) == 60 # or 1 day if relearn is false conf["lapse"]["delays"] = [] - d.decks.save(conf) + col.decks.save(conf) assert ni(c, 1) == 1 * 86400 # (* 100 1.2 86400)10368000.0 assert ni(c, 2) == 10368000 @@ -608,81 +608,83 @@ def test_nextIvl(): assert ni(c, 3) == 21600000 # (* 100 2.5 1.3 86400)28080000.0 assert ni(c, 4) == 28080000 - assert without_unicode_isolation(d.sched.nextIvlStr(c, 4)) == "10.8mo" + assert without_unicode_isolation(col.sched.nextIvlStr(c, 4)) == "10.8mo" def test_bury(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] - note = d.newNote() + note = col.newNote() note["Front"] = "two" - d.addNote(note) + col.addNote(note) c2 = note.cards()[0] # burying - d.sched.buryCards([c.id], manual=True) # pylint: disable=unexpected-keyword-arg + col.sched.buryCards([c.id], manual=True) # pylint: disable=unexpected-keyword-arg c.load() assert c.queue == QUEUE_TYPE_MANUALLY_BURIED - d.sched.buryCards([c2.id], manual=False) # pylint: disable=unexpected-keyword-arg + col.sched.buryCards([c2.id], manual=False) # pylint: disable=unexpected-keyword-arg c2.load() assert c2.queue == QUEUE_TYPE_SIBLING_BURIED - d.reset() - assert not d.sched.getCard() + col.reset() + assert not col.sched.getCard() - d.sched.unburyCardsForDeck(type="manual") # pylint: disable=unexpected-keyword-arg + col.sched.unburyCardsForDeck( # pylint: disable=unexpected-keyword-arg + type="manual" + ) c.load() assert c.queue == QUEUE_TYPE_NEW c2.load() assert c2.queue == QUEUE_TYPE_SIBLING_BURIED - d.sched.unburyCardsForDeck( # pylint: disable=unexpected-keyword-arg + col.sched.unburyCardsForDeck( # pylint: disable=unexpected-keyword-arg type="siblings" ) c2.load() assert c2.queue == QUEUE_TYPE_NEW - d.sched.buryCards([c.id, c2.id]) - d.sched.unburyCardsForDeck(type="all") # pylint: disable=unexpected-keyword-arg + col.sched.buryCards([c.id, c2.id]) + col.sched.unburyCardsForDeck(type="all") # pylint: disable=unexpected-keyword-arg - d.reset() + col.reset() - assert d.sched.counts() == (2, 0, 0) + assert col.sched.counts() == (2, 0, 0) def test_suspend(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] # suspending - d.reset() - assert d.sched.getCard() - d.sched.suspendCards([c.id]) - d.reset() - assert not d.sched.getCard() + col.reset() + assert col.sched.getCard() + col.sched.suspendCards([c.id]) + col.reset() + assert not col.sched.getCard() # unsuspending - d.sched.unsuspendCards([c.id]) - d.reset() - assert d.sched.getCard() + col.sched.unsuspendCards([c.id]) + col.reset() + assert col.sched.getCard() # should cope with rev cards being relearnt c.due = 0 c.ivl = 100 c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.flush() - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) assert c.due >= time.time() due = c.due assert c.queue == QUEUE_TYPE_LRN assert c.type == CARD_TYPE_RELEARNING - d.sched.suspendCards([c.id]) - d.sched.unsuspendCards([c.id]) + col.sched.suspendCards([c.id]) + col.sched.unsuspendCards([c.id]) c.load() assert c.queue == QUEUE_TYPE_LRN assert c.type == CARD_TYPE_RELEARNING @@ -690,12 +692,12 @@ def test_suspend(): # should cope with cards in cram decks c.due = 1 c.flush() - cram = d.decks.newDyn("tmp") - d.sched.rebuildDyn() + cram = col.decks.newDyn("tmp") + col.sched.rebuildDyn() c.load() assert c.due != 1 assert c.did != 1 - d.sched.suspendCards([c.id]) + col.sched.suspendCards([c.id]) c.load() assert c.due != 1 assert c.did != 1 @@ -703,86 +705,86 @@ def test_suspend(): def test_filt_reviewing_early_normal(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.ivl = 100 c.queue = CARD_TYPE_REV c.type = QUEUE_TYPE_REV # due in 25 days, so it's been waiting 75 days - c.due = d.sched.today + 25 + c.due = col.sched.today + 25 c.mod = 1 c.factor = STARTING_FACTOR c.startTimer() c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 0) + col.reset() + assert col.sched.counts() == (0, 0, 0) # create a dynamic deck and refresh it - did = d.decks.newDyn("Cram") - d.sched.rebuildDyn(did) - d.reset() + did = col.decks.newDyn("Cram") + col.sched.rebuildDyn(did) + col.reset() # should appear as normal in the deck list - assert sorted(d.sched.deck_due_tree().children)[0].review_count == 1 + assert sorted(col.sched.deck_due_tree().children)[0].review_count == 1 # and should appear in the counts - assert d.sched.counts() == (0, 0, 1) + assert col.sched.counts() == (0, 0, 1) # grab it and check estimates - c = d.sched.getCard() - assert d.sched.answerButtons(c) == 4 - assert d.sched.nextIvl(c, 1) == 600 - assert d.sched.nextIvl(c, 2) == int(75 * 1.2) * 86400 - assert d.sched.nextIvl(c, 3) == int(75 * 2.5) * 86400 - assert d.sched.nextIvl(c, 4) == int(75 * 2.5 * 1.15) * 86400 + c = col.sched.getCard() + assert col.sched.answerButtons(c) == 4 + assert col.sched.nextIvl(c, 1) == 600 + assert col.sched.nextIvl(c, 2) == int(75 * 1.2) * 86400 + assert col.sched.nextIvl(c, 3) == int(75 * 2.5) * 86400 + assert col.sched.nextIvl(c, 4) == int(75 * 2.5 * 1.15) * 86400 # answer 'good' - d.sched.answerCard(c, 3) - checkRevIvl(d, c, 90) - assert c.due == d.sched.today + c.ivl + col.sched.answerCard(c, 3) + checkRevIvl(col, c, 90) + assert c.due == col.sched.today + c.ivl assert not c.odue # should not be in learning assert c.queue == QUEUE_TYPE_REV # should be logged as a cram rep - assert d.db.scalar("select type from revlog order by id desc limit 1") == 3 + assert col.db.scalar("select type from revlog order by id desc limit 1") == 3 # due in 75 days, so it's been waiting 25 days c.ivl = 100 - c.due = d.sched.today + 75 + c.due = col.sched.today + 75 c.flush() - d.sched.rebuildDyn(did) - d.reset() - c = d.sched.getCard() + col.sched.rebuildDyn(did) + col.reset() + c = col.sched.getCard() - assert d.sched.nextIvl(c, 2) == 60 * 86400 - assert d.sched.nextIvl(c, 3) == 100 * 86400 - assert d.sched.nextIvl(c, 4) == 114 * 86400 + assert col.sched.nextIvl(c, 2) == 60 * 86400 + assert col.sched.nextIvl(c, 3) == 100 * 86400 + assert col.sched.nextIvl(c, 4) == 114 * 86400 def test_filt_keep_lrn_state(): - d = getEmptyCol() + col = getEmptyCol() - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # fail the card outside filtered deck - c = d.sched.getCard() - conf = d.sched._cardConf(c) + c = col.sched.getCard() + conf = col.sched._cardConf(c) conf["new"]["delays"] = [1, 10, 61] - d.decks.save(conf) + col.decks.save(conf) - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert c.type == CARD_TYPE_LRN and c.queue == QUEUE_TYPE_LRN assert c.left == 3003 - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) assert c.type == CARD_TYPE_LRN and c.queue == QUEUE_TYPE_LRN # create a dynamic deck and refresh it - did = d.decks.newDyn("Cram") - d.sched.rebuildDyn(did) - d.reset() + did = col.decks.newDyn("Cram") + col.sched.rebuildDyn(did) + col.reset() # card should still be in learning state c.load() @@ -790,12 +792,12 @@ def test_filt_keep_lrn_state(): assert c.left == 2002 # should be able to advance learning steps - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) # should be due at least an hour in the future assert c.due - intTime() > 60 * 60 # emptying the deck preserves learning state - d.sched.emptyDyn(did) + col.sched.emptyDyn(did) c.load() assert c.type == CARD_TYPE_LRN and c.queue == QUEUE_TYPE_LRN assert c.left == 1001 @@ -804,48 +806,48 @@ def test_filt_keep_lrn_state(): def test_preview(): # add cards - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] orig = copy.copy(c) - note2 = d.newNote() + note2 = col.newNote() note2["Front"] = "two" - d.addNote(note2) + col.addNote(note2) # cram deck - did = d.decks.newDyn("Cram") - cram = d.decks.get(did) + did = col.decks.newDyn("Cram") + cram = col.decks.get(did) cram["resched"] = False - d.decks.save(cram) - d.sched.rebuildDyn(did) - d.reset() + col.decks.save(cram) + col.sched.rebuildDyn(did) + col.reset() # grab the first card - c = d.sched.getCard() - assert d.sched.answerButtons(c) == 2 - assert d.sched.nextIvl(c, 1) == 600 - assert d.sched.nextIvl(c, 2) == 0 + c = col.sched.getCard() + assert col.sched.answerButtons(c) == 2 + assert col.sched.nextIvl(c, 1) == 600 + assert col.sched.nextIvl(c, 2) == 0 # failing it will push its due time back due = c.due - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert c.due != due # the other card should come next - c2 = d.sched.getCard() + c2 = col.sched.getCard() assert c2.id != c.id # passing it will remove it - d.sched.answerCard(c2, 2) + col.sched.answerCard(c2, 2) assert c2.queue == QUEUE_TYPE_NEW assert c2.reps == 0 assert c2.type == CARD_TYPE_NEW # the other card should appear again - c = d.sched.getCard() + c = col.sched.getCard() assert c.id == orig.id # emptying the filtered deck should restore card - d.sched.emptyDyn(did) + col.sched.emptyDyn(did) c.load() assert c.queue == QUEUE_TYPE_NEW assert c.reps == 0 @@ -853,10 +855,10 @@ def test_preview(): def test_ordcycle(): - d = getEmptyCol() + col = getEmptyCol() # add two more templates and set second active - m = d.models.current() - mm = d.models + m = col.models.current() + mm = col.models t = mm.newTemplate("Reverse") t["qfmt"] = "{{Back}}" t["afmt"] = "{{Front}}" @@ -867,166 +869,166 @@ def test_ordcycle(): mm.addTemplate(m, t) mm.save(m) # create a new note; it should have 3 cards - note = d.newNote() + note = col.newNote() note["Front"] = "1" note["Back"] = "1" - d.addNote(note) - assert d.cardCount() == 3 - d.reset() + col.addNote(note) + assert col.cardCount() == 3 + col.reset() # ordinals should arrive in order - assert d.sched.getCard().ord == 0 - assert d.sched.getCard().ord == 1 - assert d.sched.getCard().ord == 2 + assert col.sched.getCard().ord == 0 + assert col.sched.getCard().ord == 1 + assert col.sched.getCard().ord == 2 def test_counts_idx(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) - d.reset() - assert d.sched.counts() == (1, 0, 0) - c = d.sched.getCard() + col.addNote(note) + col.reset() + assert col.sched.counts() == (1, 0, 0) + c = col.sched.getCard() # counter's been decremented but idx indicates 1 - assert d.sched.counts() == (0, 0, 0) - assert d.sched.countIdx(c) == 0 + assert col.sched.counts() == (0, 0, 0) + assert col.sched.countIdx(c) == 0 # answer to move to learn queue - d.sched.answerCard(c, 1) - assert d.sched.counts() == (0, 1, 0) + col.sched.answerCard(c, 1) + assert col.sched.counts() == (0, 1, 0) # fetching again will decrement the count - c = d.sched.getCard() - assert d.sched.counts() == (0, 0, 0) - assert d.sched.countIdx(c) == 1 + c = col.sched.getCard() + assert col.sched.counts() == (0, 0, 0) + assert col.sched.countIdx(c) == 1 # answering should add it back again - d.sched.answerCard(c, 1) - assert d.sched.counts() == (0, 1, 0) + col.sched.answerCard(c, 1) + assert col.sched.counts() == (0, 1, 0) def test_repCounts(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) - d.reset() + col.addNote(note) + col.reset() # lrnReps should be accurate on pass/fail - assert d.sched.counts() == (1, 0, 0) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 3) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 3) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 3) - assert d.sched.counts() == (0, 0, 0) - note = d.newNote() + assert col.sched.counts() == (1, 0, 0) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 3) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 3) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 3) + assert col.sched.counts() == (0, 0, 0) + note = col.newNote() note["Front"] = "two" - d.addNote(note) - d.reset() + col.addNote(note) + col.reset() # initial pass should be correct too - d.sched.answerCard(d.sched.getCard(), 3) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 1, 0) - d.sched.answerCard(d.sched.getCard(), 4) - assert d.sched.counts() == (0, 0, 0) + col.sched.answerCard(col.sched.getCard(), 3) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 1, 0) + col.sched.answerCard(col.sched.getCard(), 4) + assert col.sched.counts() == (0, 0, 0) # immediate graduate should work - note = d.newNote() + note = col.newNote() note["Front"] = "three" - d.addNote(note) - d.reset() - d.sched.answerCard(d.sched.getCard(), 4) - assert d.sched.counts() == (0, 0, 0) + col.addNote(note) + col.reset() + col.sched.answerCard(col.sched.getCard(), 4) + assert col.sched.counts() == (0, 0, 0) # and failing a review should too - note = d.newNote() + note = col.newNote() note["Front"] = "three" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV - c.due = d.sched.today + c.due = col.sched.today c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 1) - d.sched.answerCard(d.sched.getCard(), 1) - assert d.sched.counts() == (0, 1, 0) + col.reset() + assert col.sched.counts() == (0, 0, 1) + col.sched.answerCard(col.sched.getCard(), 1) + assert col.sched.counts() == (0, 1, 0) def test_timing(): - d = getEmptyCol() + col = getEmptyCol() # add a few review cards, due today for i in range(5): - note = d.newNote() + note = col.newNote() note["Front"] = "num" + str(i) - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.due = 0 c.flush() # fail the first one - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 1) # the next card should be another review - c2 = d.sched.getCard() + c2 = col.sched.getCard() assert c2.queue == QUEUE_TYPE_REV # if the failed card becomes due, it should show first c.due = intTime() - 1 c.flush() - d.reset() - c = d.sched.getCard() + col.reset() + c = col.sched.getCard() assert c.queue == QUEUE_TYPE_LRN def test_collapse(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) - d.reset() + col.addNote(note) + col.reset() # test collapsing - c = d.sched.getCard() - d.sched.answerCard(c, 1) - c = d.sched.getCard() - d.sched.answerCard(c, 4) - assert not d.sched.getCard() + c = col.sched.getCard() + col.sched.answerCard(c, 1) + c = col.sched.getCard() + col.sched.answerCard(c, 4) + assert not col.sched.getCard() def test_deckDue(): - d = getEmptyCol() + col = getEmptyCol() # add a note with default deck - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # and one that's a child - note = d.newNote() + note = col.newNote() note["Front"] = "two" - default1 = note.model()["did"] = d.decks.id("Default::1") - d.addNote(note) + default1 = note.model()["did"] = col.decks.id("Default::1") + col.addNote(note) # make it a review card c = note.cards()[0] c.queue = QUEUE_TYPE_REV c.due = 0 c.flush() # add one more with a new deck - note = d.newNote() + note = col.newNote() note["Front"] = "two" - foobar = note.model()["did"] = d.decks.id("foo::bar") - d.addNote(note) + foobar = note.model()["did"] = col.decks.id("foo::bar") + col.addNote(note) # and one that's a sibling - note = d.newNote() + note = col.newNote() note["Front"] = "three" - foobaz = note.model()["did"] = d.decks.id("foo::baz") - d.addNote(note) - d.reset() - assert len(d.decks.all_names_and_ids()) == 5 - tree = d.sched.deck_due_tree().children + foobaz = note.model()["did"] = col.decks.id("foo::baz") + col.addNote(note) + col.reset() + assert len(col.decks.all_names_and_ids()) == 5 + tree = col.sched.deck_due_tree().children assert tree[0].name == "Default" # sum of child and parent assert tree[0].deck_id == 1 @@ -1041,76 +1043,76 @@ def test_deckDue(): # code should not fail if a card has an invalid deck c.did = 12345 c.flush() - d.sched.deck_due_tree() + col.sched.deck_due_tree() def test_deckTree(): - d = getEmptyCol() - d.decks.id("new::b::c") - d.decks.id("new2") + col = getEmptyCol() + col.decks.id("new::b::c") + col.decks.id("new2") # new should not appear twice in tree - names = [x.name for x in d.sched.deck_due_tree().children] + names = [x.name for x in col.sched.deck_due_tree().children] names.remove("new") assert "new" not in names def test_deckFlow(): - d = getEmptyCol() + col = getEmptyCol() # add a note with default deck - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) # and one that's a child - note = d.newNote() + note = col.newNote() note["Front"] = "two" - default1 = note.model()["did"] = d.decks.id("Default::2") - d.addNote(note) + default1 = note.model()["did"] = col.decks.id("Default::2") + col.addNote(note) # and another that's higher up - note = d.newNote() + note = col.newNote() note["Front"] = "three" - default1 = note.model()["did"] = d.decks.id("Default::1") - d.addNote(note) + default1 = note.model()["did"] = col.decks.id("Default::1") + col.addNote(note) # should get top level one first, then ::1, then ::2 - d.reset() - assert d.sched.counts() == (3, 0, 0) + col.reset() + assert col.sched.counts() == (3, 0, 0) for i in "one", "three", "two": - c = d.sched.getCard() + c = col.sched.getCard() assert c.note()["Front"] == i - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) def test_reorder(): - d = getEmptyCol() + col = getEmptyCol() # add a note with default deck - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) - note2 = d.newNote() + col.addNote(note) + note2 = col.newNote() note2["Front"] = "two" - d.addNote(note2) + col.addNote(note2) assert note2.cards()[0].due == 2 found = False # 50/50 chance of being reordered for i in range(20): - d.sched.randomizeCards(1) + col.sched.randomizeCards(1) if note.cards()[0].due != note.id: found = True break assert found - d.sched.orderCards(1) + col.sched.orderCards(1) assert note.cards()[0].due == 1 # shifting - f3 = d.newNote() + f3 = col.newNote() f3["Front"] = "three" - d.addNote(f3) - f4 = d.newNote() + col.addNote(f3) + f4 = col.newNote() f4["Front"] = "four" - d.addNote(f4) + col.addNote(f4) assert note.cards()[0].due == 1 assert note2.cards()[0].due == 2 assert f3.cards()[0].due == 3 assert f4.cards()[0].due == 4 - d.sched.sortCards([f3.cards()[0].id, f4.cards()[0].id], start=1, shift=True) + col.sched.sortCards([f3.cards()[0].id, f4.cards()[0].id], start=1, shift=True) assert note.cards()[0].due == 3 assert note2.cards()[0].due == 4 assert f3.cards()[0].due == 1 @@ -1118,46 +1120,46 @@ def test_reorder(): def test_forget(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.queue = QUEUE_TYPE_REV c.type = CARD_TYPE_REV c.ivl = 100 c.due = 0 c.flush() - d.reset() - assert d.sched.counts() == (0, 0, 1) - d.sched.forgetCards([c.id]) - d.reset() - assert d.sched.counts() == (1, 0, 0) + col.reset() + assert col.sched.counts() == (0, 0, 1) + col.sched.forgetCards([c.id]) + col.reset() + assert col.sched.counts() == (1, 0, 0) def test_resched(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] - d.sched.reschedCards([c.id], 0, 0) + col.sched.reschedCards([c.id], 0, 0) c.load() - assert c.due == d.sched.today + assert c.due == col.sched.today assert c.ivl == 1 assert c.queue == QUEUE_TYPE_REV and c.type == CARD_TYPE_REV - d.sched.reschedCards([c.id], 1, 1) + col.sched.reschedCards([c.id], 1, 1) c.load() - assert c.due == d.sched.today + 1 + assert c.due == col.sched.today + 1 assert c.ivl == +1 def test_norelearn(): - d = getEmptyCol() + col = getEmptyCol() # add a note - note = d.newNote() + note = col.newNote() note["Front"] = "one" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV @@ -1168,35 +1170,35 @@ def test_norelearn(): c.ivl = 100 c.startTimer() c.flush() - d.reset() - d.sched.answerCard(c, 1) - d.sched._cardConf(c)["lapse"]["delays"] = [] - d.sched.answerCard(c, 1) + col.reset() + col.sched.answerCard(c, 1) + col.sched._cardConf(c)["lapse"]["delays"] = [] + col.sched.answerCard(c, 1) def test_failmult(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.type = CARD_TYPE_REV c.queue = QUEUE_TYPE_REV c.ivl = 100 - c.due = d.sched.today - c.ivl + c.due = col.sched.today - c.ivl c.factor = STARTING_FACTOR c.reps = 3 c.lapses = 1 c.startTimer() c.flush() - conf = d.sched._cardConf(c) + conf = col.sched._cardConf(c) conf["lapse"]["mult"] = 0.5 - d.decks.save(conf) - c = d.sched.getCard() - d.sched.answerCard(c, 1) + col.decks.save(conf) + c = col.sched.getCard() + col.sched.answerCard(c, 1) assert c.ivl == 50 - d.sched.answerCard(c, 1) + col.sched.answerCard(c, 1) assert c.ivl == 25 @@ -1261,13 +1263,13 @@ def test_moveVersions(): # cards with a due date earlier than the collection should retain # their due date when removed def test_negativeDueFilter(): - d = getEmptyCol() + col = getEmptyCol() # card due prior to collection date - note = d.newNote() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) c = note.cards()[0] c.due = -5 c.queue = QUEUE_TYPE_REV @@ -1275,10 +1277,10 @@ def test_negativeDueFilter(): c.flush() # into and out of filtered deck - did = d.decks.newDyn("Cram") - d.sched.rebuildDyn(did) - d.sched.emptyDyn(did) - d.reset() + did = col.decks.newDyn("Cram") + col.sched.rebuildDyn(did) + col.sched.emptyDyn(did) + col.reset() c.load() assert c.due == -5 @@ -1287,18 +1289,18 @@ def test_negativeDueFilter(): # hard on the first step should be the average of again and good, # and it should be logged properly def test_initial_repeat(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "one" note["Back"] = "two" - d.addNote(note) + col.addNote(note) - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 2) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 2) # should be due in ~ 5.5 mins expected = time.time() + 5.5 * 60 assert expected - 10 < c.due < expected * 1.25 - ivl = d.db.scalar("select ivl from revlog") + ivl = col.db.scalar("select ivl from revlog") assert ivl == -5.5 * 60 diff --git a/pylib/tests/test_stats.py b/pylib/tests/test_stats.py index 56d1b27c6..101bd50ed 100644 --- a/pylib/tests/test_stats.py +++ b/pylib/tests/test_stats.py @@ -8,29 +8,29 @@ from tests.shared import getEmptyCol def test_stats(): - d = getEmptyCol() - note = d.newNote() + col = getEmptyCol() + note = col.newNote() note["Front"] = "foo" - d.addNote(note) + col.addNote(note) c = note.cards()[0] # card stats - assert d.cardStats(c) - d.reset() - c = d.sched.getCard() - d.sched.answerCard(c, 3) - d.sched.answerCard(c, 2) - assert d.cardStats(c) + assert col.cardStats(c) + col.reset() + c = col.sched.getCard() + col.sched.answerCard(c, 3) + col.sched.answerCard(c, 2) + assert col.cardStats(c) def test_graphs_empty(): - d = getEmptyCol() - assert d.stats().report() + col = getEmptyCol() + assert col.stats().report() def test_graphs(): dir = tempfile.gettempdir() - d = getEmptyCol() - g = d.stats() + col = getEmptyCol() + g = col.stats() rep = g.report() with open(os.path.join(dir, "test.html"), "w", encoding="UTF-8") as note: note.write(rep) diff --git a/pylib/tests/test_template.py b/pylib/tests/test_template.py index 6a7487ab6..bd3234d6f 100644 --- a/pylib/tests/test_template.py +++ b/pylib/tests/test_template.py @@ -2,14 +2,14 @@ from tests.shared import getEmptyCol def test_deferred_frontside(): - d = getEmptyCol() - m = d.models.current() + col = getEmptyCol() + m = col.models.current() m["tmpls"][0]["qfmt"] = "{{custom:Front}}" - d.models.save(m) + col.models.save(m) - note = d.newNote() + note = col.newNote() note["Front"] = "xxtest" note["Back"] = "" - d.addNote(note) + col.addNote(note) assert "xxtest" in note.cards()[0].a() diff --git a/pylib/tests/test_undo.py b/pylib/tests/test_undo.py index a21bdbf14..70b08ce0a 100644 --- a/pylib/tests/test_undo.py +++ b/pylib/tests/test_undo.py @@ -13,84 +13,84 @@ def getEmptyCol(): def test_op(): - d = getEmptyCol() + col = getEmptyCol() # should have no undo by default - assert not d.undoName() + assert not col.undoName() # let's adjust a study option - d.save("studyopts") - d.conf["abc"] = 5 + col.save("studyopts") + col.conf["abc"] = 5 # it should be listed as undoable - assert d.undoName() == "studyopts" + assert col.undoName() == "studyopts" # with about 5 minutes until it's clobbered - assert time.time() - d._lastSave < 1 + assert time.time() - col._lastSave < 1 # undoing should restore the old value - d.undo() - assert not d.undoName() - assert "abc" not in d.conf + col.undo() + assert not col.undoName() + assert "abc" not in col.conf # an (auto)save will clear the undo - d.save("foo") - assert d.undoName() == "foo" - d.save() - assert not d.undoName() + col.save("foo") + assert col.undoName() == "foo" + col.save() + assert not col.undoName() # and a review will, too - d.save("add") - note = d.newNote() + col.save("add") + note = col.newNote() note["Front"] = "one" - d.addNote(note) - d.reset() - assert d.undoName() == "add" - c = d.sched.getCard() - d.sched.answerCard(c, 2) - assert d.undoName() == "Review" + col.addNote(note) + col.reset() + assert col.undoName() == "add" + c = col.sched.getCard() + col.sched.answerCard(c, 2) + assert col.undoName() == "Review" def test_review(): - d = getEmptyCol() - d.conf["counts"] = COUNT_REMAINING - note = d.newNote() + col = getEmptyCol() + col.conf["counts"] = COUNT_REMAINING + note = col.newNote() note["Front"] = "one" - d.addNote(note) - d.reset() - assert not d.undoName() + col.addNote(note) + col.reset() + assert not col.undoName() # answer - assert d.sched.counts() == (1, 0, 0) - c = d.sched.getCard() + assert col.sched.counts() == (1, 0, 0) + c = col.sched.getCard() assert c.queue == QUEUE_TYPE_NEW - d.sched.answerCard(c, 3) + col.sched.answerCard(c, 3) assert c.left == 1001 - assert d.sched.counts() == (0, 1, 0) + assert col.sched.counts() == (0, 1, 0) assert c.queue == QUEUE_TYPE_LRN # undo - assert d.undoName() - d.undo() - d.reset() - assert d.sched.counts() == (1, 0, 0) + assert col.undoName() + col.undo() + col.reset() + assert col.sched.counts() == (1, 0, 0) c.load() assert c.queue == QUEUE_TYPE_NEW assert c.left != 1001 - assert not d.undoName() + assert not col.undoName() # we should be able to undo multiple answers too - note = d.newNote() + note = col.newNote() note["Front"] = "two" - d.addNote(note) - d.reset() - assert d.sched.counts() == (2, 0, 0) - c = d.sched.getCard() - d.sched.answerCard(c, 3) - c = d.sched.getCard() - d.sched.answerCard(c, 3) - assert d.sched.counts() == (0, 2, 0) - d.undo() - d.reset() - assert d.sched.counts() == (1, 1, 0) - d.undo() - d.reset() - assert d.sched.counts() == (2, 0, 0) + col.addNote(note) + col.reset() + assert col.sched.counts() == (2, 0, 0) + c = col.sched.getCard() + col.sched.answerCard(c, 3) + c = col.sched.getCard() + col.sched.answerCard(c, 3) + assert col.sched.counts() == (0, 2, 0) + col.undo() + col.reset() + assert col.sched.counts() == (1, 1, 0) + col.undo() + col.reset() + assert col.sched.counts() == (2, 0, 0) # performing a normal op will clear the review queue - c = d.sched.getCard() - d.sched.answerCard(c, 3) - assert d.undoName() == "Review" - d.save("foo") - assert d.undoName() == "foo" - d.undo() - assert not d.undoName() + c = col.sched.getCard() + col.sched.answerCard(c, 3) + assert col.undoName() == "Review" + col.save("foo") + assert col.undoName() == "foo" + col.undo() + assert not col.undoName() From 1af59545bde221d5b95f91ff41a9d324c998bc83 Mon Sep 17 00:00:00 2001 From: Arthur Milchior Date: Fri, 17 Jul 2020 05:23:33 +0200 Subject: [PATCH 6/6] gn->deckn in test Obtained by ``` sed -i "s/\bg1\b/deck1/g" pylib/tests/*py qt/tests/*py sed -i "s/\bg2\b/deck2/g" pylib/tests/*py qt/tests/*py ``` --- pylib/tests/test_decks.py | 8 ++++---- pylib/tests/test_schedv1.py | 8 ++++---- pylib/tests/test_schedv2.py | 8 ++++---- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/pylib/tests/test_decks.py b/pylib/tests/test_decks.py index 005d46aa3..4dbe61551 100644 --- a/pylib/tests/test_decks.py +++ b/pylib/tests/test_decks.py @@ -46,15 +46,15 @@ def test_basic(): def test_remove(): col = getEmptyCol() # create a new col, and add a note/card to it - g1 = col.decks.id("g1") + deck1 = col.decks.id("deck1") note = col.newNote() note["Front"] = "1" - note.model()["did"] = g1 + note.model()["did"] = deck1 col.addNote(note) c = note.cards()[0] - assert c.did == g1 + assert c.did == deck1 assert col.cardCount() == 1 - col.decks.rem(g1) + col.decks.rem(deck1) assert col.cardCount() == 0 # if we try to get it, we get the default assert col.decks.name(c.did) == "[no deck]" diff --git a/pylib/tests/test_schedv1.py b/pylib/tests/test_schedv1.py index 8d8b7a32f..6586564b9 100644 --- a/pylib/tests/test_schedv1.py +++ b/pylib/tests/test_schedv1.py @@ -81,16 +81,16 @@ def test_new(): def test_newLimits(): col = getEmptyCol() # add some notes - g2 = col.decks.id("Default::foo") + deck2 = col.decks.id("Default::foo") for i in range(30): note = col.newNote() note["Front"] = str(i) if i > 4: - note.model()["did"] = g2 + note.model()["did"] = deck2 col.addNote(note) # give the child deck a different configuration c2 = col.decks.add_config_returning_id("new conf") - col.decks.setConf(col.decks.get(g2), c2) + col.decks.setConf(col.decks.get(deck2), c2) col.reset() # both confs have defaulted to a limit of 20 assert col.sched.newCount == 20 @@ -104,7 +104,7 @@ def test_newLimits(): col.reset() assert col.sched.newCount == 10 # if we limit child to 4, we should get 9 - conf2 = col.decks.confForDid(g2) + conf2 = col.decks.confForDid(deck2) conf2["new"]["perDay"] = 4 col.decks.save(conf2) col.reset() diff --git a/pylib/tests/test_schedv2.py b/pylib/tests/test_schedv2.py index 30c654d17..f41041860 100644 --- a/pylib/tests/test_schedv2.py +++ b/pylib/tests/test_schedv2.py @@ -82,16 +82,16 @@ def test_new(): def test_newLimits(): col = getEmptyCol() # add some notes - g2 = col.decks.id("Default::foo") + deck2 = col.decks.id("Default::foo") for i in range(30): note = col.newNote() note["Front"] = str(i) if i > 4: - note.model()["did"] = g2 + note.model()["did"] = deck2 col.addNote(note) # give the child deck a different configuration c2 = col.decks.add_config_returning_id("new conf") - col.decks.setConf(col.decks.get(g2), c2) + col.decks.setConf(col.decks.get(deck2), c2) col.reset() # both confs have defaulted to a limit of 20 assert col.sched.newCount == 20 @@ -105,7 +105,7 @@ def test_newLimits(): col.reset() assert col.sched.newCount == 10 # if we limit child to 4, we should get 9 - conf2 = col.decks.confForDid(g2) + conf2 = col.decks.confForDid(deck2) conf2["new"]["perDay"] = 4 col.decks.save(conf2) col.reset()