deck->col in tests

Obtained by
```
sed -i "s/\bdeck\b/col/g" pylib/tests/*py qt/tests/*py
```

pylib/tests/test_cards.py

@@ -4,20 +4,20 @@ from tests.shared import getEmptyCol
 
 
 def test_delete():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "1"
     note["Back"] = "2"
-    deck.addNote(note)
+    col.addNote(note)
     cid = note.cards()[0].id
-    deck.reset()
+    col.reset()
-    deck.sched.answerCard(deck.sched.getCard(), 2)
+    col.sched.answerCard(col.sched.getCard(), 2)
-    deck.remove_cards_and_orphaned_notes([cid])
+    col.remove_cards_and_orphaned_notes([cid])
-    assert deck.cardCount() == 0
+    assert col.cardCount() == 0
-    assert deck.noteCount() == 0
+    assert col.noteCount() == 0
-    assert deck.db.scalar("select count() from notes") == 0
+    assert col.db.scalar("select count() from notes") == 0
-    assert deck.db.scalar("select count() from cards") == 0
+    assert col.db.scalar("select count() from cards") == 0
-    assert deck.db.scalar("select count() from graves") == 2
+    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

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
+    newPath = col.path
-    newMod = deck.mod
+    newMod = col.mod
-    deck.close()
+    col.close()
-    del deck
+    del col
 
     # reopen
-    deck = aopen(newPath)
+    col = aopen(newPath)
-    assert deck.mod == newMod
+    assert col.mod == newMod
-    deck.close()
+    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()
+    m = col.models.current()
-    mm = deck.models
+    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()
+    col = getEmptyCol()
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "new"
     note["Back"] = "new2"
-    deck.addNote(note)
+    col.addNote(note)
-    assert deck.db.scalar("select csum from notes") == int("c2a6b03f", 16)
+    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()
+    col = getEmptyCol()
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "1"
-    deck.addNote(note)
+    col.addNote(note)
-    note2 = deck.newNote()
+    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()
+    col = getEmptyCol()
-    assert len(deck.models.all_names_and_ids()) == len(get_stock_notetypes(deck))
+    assert len(col.models.all_names_and_ids()) == len(get_stock_notetypes(col))
     for i in range(100):
-        addBasicModel(deck)
+        addBasicModel(col)
-    assert len(deck.models.all_names_and_ids()) == 100 + len(get_stock_notetypes(deck))
+    assert len(col.models.all_names_and_ids()) == 100 + len(get_stock_notetypes(col))
 
 
 def test_furigana():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    mm = deck.models
+    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

pylib/tests/test_decks.py

@@ -5,59 +5,59 @@ from tests.shared import assertException, getEmptyCol
 
 
 def test_basic():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    # we start with a standard deck
+    # we start with a standard col
-    assert len(deck.decks.all_names_and_ids()) == 1
+    assert len(col.decks.all_names_and_ids()) == 1
     # it should have an id of 1
-    assert deck.decks.name(1)
+    assert col.decks.name(1)
-    # create a new deck
+    # create a new col
-    parentId = deck.decks.id("new deck")
+    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
+    assert col.decks.id("new deck") == parentId
-    # we start with the default deck selected
+    # we start with the default col selected
-    assert deck.decks.selected() == 1
+    assert col.decks.selected() == 1
-    assert deck.decks.active() == [1]
+    assert col.decks.active() == [1]
-    # we can select a different deck
+    # we can select a different col
-    deck.decks.select(parentId)
+    col.decks.select(parentId)
-    assert deck.decks.selected() == parentId
+    assert col.decks.selected() == parentId
-    assert deck.decks.active() == [parentId]
+    assert col.decks.active() == [parentId]
     # let's create a child
-    childId = deck.decks.id("new deck::child")
+    childId = col.decks.id("new deck::child")
-    deck.sched.reset()
+    col.sched.reset()
     # it should have been added to the active list
-    assert deck.decks.selected() == parentId
+    assert col.decks.selected() == parentId
-    assert deck.decks.active() == [parentId, childId]
+    assert col.decks.active() == [parentId, childId]
     # we can select the child individually too
-    deck.decks.select(childId)
+    col.decks.select(childId)
-    assert deck.decks.selected() == childId
+    assert col.decks.selected() == childId
-    assert deck.decks.active() == [childId]
+    assert col.decks.active() == [childId]
     # parents with a different case should be handled correctly
-    deck.decks.id("ONE")
+    col.decks.id("ONE")
-    m = deck.models.current()
+    m = col.models.current()
-    m["did"] = deck.decks.id("one::two")
+    m["did"] = col.decks.id("one::two")
-    deck.models.save(m, updateReqs=False)
+    col.models.save(m, updateReqs=False)
-    n = deck.newNote()
+    n = col.newNote()
     n["Front"] = "abc"
-    deck.addNote(n)
+    col.addNote(n)
 
 
 def test_remove():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    # create a new deck, and add a note/card to it
+    # create a new col, and add a note/card to it
-    g1 = deck.decks.id("g1")
+    g1 = col.decks.id("g1")
-    note = deck.newNote()
+    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
+    assert col.cardCount() == 1
-    deck.decks.rem(g1)
+    col.decks.rem(g1)
-    assert deck.cardCount() == 0
+    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"]
 

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
+    global col
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "foo"
     note["Back"] = "bar<br>"
     note.tags = ["tag", "tag2"]
-    deck.addNote(note)
+    col.addNote(note)
-    # with a different deck
+    # with a different col
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "baz"
     note["Back"] = "qux"
-    note.model()["did"] = deck.decks.id("new deck")
+    note.model()["did"] = col.decks.id("new col")
-    deck.addNote(note)
+    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
+    # create a new col with its own conf to test conf copying
-    did = deck.decks.id("test")
+    did = col.decks.id("test")
-    dobj = deck.decks.get(did)
+    dobj = col.decks.get(did)
-    confId = deck.decks.add_config_returning_id("newconf")
+    confId = col.decks.add_config_returning_id("newconf")
-    conf = deck.decks.get_config(confId)
+    conf = col.decks.get_config(confId)
     conf["new"]["perDay"] = 5
-    deck.decks.save(conf)
+    col.decks.save(conf)
-    deck.decks.setConf(dobj, confId)
+    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)
+    col.addNote(n)
-    e = AnkiPackageExporter(deck)
+    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()
+    col = getEmptyCol()
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "foo"
-    deck.addNote(note)
+    col.addNote(note)
-    deck.crt -= 86400 * 10
+    col.crt -= 86400 * 10
-    deck.flush()
+    col.flush()
-    deck.sched.reset()
+    col.sched.reset()
-    c = deck.sched.getCard()
+    c = col.sched.getCard()
-    deck.sched.answerCard(c, 3)
+    col.sched.answerCard(c, 3)
-    deck.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 col.sched.today == 10
-    assert c.due - deck.sched.today == 1
+    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)

pylib/tests/test_find.py

@@ -12,284 +12,284 @@ class DummyCollection:
 
 
 def test_findCards():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    note = deck.newNote()
+    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 = col.models.current()
-    m = deck.models.copy(m)
+    m = col.models.copy(m)
-    mm = deck.models
+    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)
+    col.addNote(note)
-    deck.save()
+    col.save()
     latestCardIds = [c.id for c in note.cards()]
     # tag searches
-    assert len(deck.findCards("tag:*")) == 5
+    assert len(col.findCards("tag:*")) == 5
-    assert len(deck.findCards("tag:\\*")) == 1
+    assert len(col.findCards("tag:\\*")) == 1
-    assert len(deck.findCards("tag:%")) == 5
+    assert len(col.findCards("tag:%")) == 5
-    assert len(deck.findCards("tag:\\%")) == 1
+    assert len(col.findCards("tag:\\%")) == 1
-    assert len(deck.findCards("tag:animal_1")) == 2
+    assert len(col.findCards("tag:animal_1")) == 2
-    assert len(deck.findCards("tag:animal\\_1")) == 1
+    assert len(col.findCards("tag:animal\\_1")) == 1
-    assert not deck.findCards("tag:donkey")
+    assert not col.findCards("tag:donkey")
-    assert len(deck.findCards("tag:sheep")) == 1
+    assert len(col.findCards("tag:sheep")) == 1
-    assert len(deck.findCards("tag:sheep tag:goat")) == 1
+    assert len(col.findCards("tag:sheep tag:goat")) == 1
-    assert len(deck.findCards("tag:sheep tag:monkey")) == 0
+    assert len(col.findCards("tag:sheep tag:monkey")) == 0
-    assert len(deck.findCards("tag:monkey")) == 1
+    assert len(col.findCards("tag:monkey")) == 1
-    assert len(deck.findCards("tag:sheep -tag:monkey")) == 1
+    assert len(col.findCards("tag:sheep -tag:monkey")) == 1
-    assert len(deck.findCards("-tag:sheep")) == 4
+    assert len(col.findCards("-tag:sheep")) == 4
-    deck.tags.bulkAdd(deck.db.list("select id from notes"), "foo bar")
+    col.tags.bulkAdd(col.db.list("select id from notes"), "foo bar")
-    assert len(deck.findCards("tag:foo")) == len(deck.findCards("tag:bar")) == 5
+    assert len(col.findCards("tag:foo")) == len(col.findCards("tag:bar")) == 5
-    deck.tags.bulkRem(deck.db.list("select id from notes"), "foo")
+    col.tags.bulkRem(col.db.list("select id from notes"), "foo")
-    assert len(deck.findCards("tag:foo")) == 0
+    assert len(col.findCards("tag:foo")) == 0
-    assert len(deck.findCards("tag:bar")) == 5
+    assert len(col.findCards("tag:bar")) == 5
     # text searches
-    assert len(deck.findCards("cat")) == 2
+    assert len(col.findCards("cat")) == 2
-    assert len(deck.findCards("cat -dog")) == 1
+    assert len(col.findCards("cat -dog")) == 1
-    assert len(deck.findCards("cat -dog")) == 1
+    assert len(col.findCards("cat -dog")) == 1
-    assert len(deck.findCards("are goats")) == 1
+    assert len(col.findCards("are goats")) == 1
-    assert len(deck.findCards('"are goats"')) == 0
+    assert len(col.findCards('"are goats"')) == 0
-    assert len(deck.findCards('"goats are"')) == 1
+    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 col.findCards("is:review") == [c.id]
-    assert deck.findCards("is:due") == []
+    assert col.findCards("is:due") == []
     c.due = 0
     c.queue = QUEUE_TYPE_REV
     c.flush()
-    assert deck.findCards("is:due") == [c.id]
+    assert col.findCards("is:due") == [c.id]
-    assert len(deck.findCards("-is:due")) == 4
+    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)
+    col.db.execute("update cards set mod = mod + 1 where id = ?", c.id)
-    assert deck.findCards("is:suspended") == [c.id]
+    assert col.findCards("is:suspended") == [c.id]
     # nids
-    assert deck.findCards("nid:54321") == []
+    assert col.findCards("nid:54321") == []
-    assert len(deck.findCards("nid:%d" % note.id)) == 2
+    assert len(col.findCards("nid:%d" % note.id)) == 2
-    assert len(deck.findCards("nid:%d,%d" % (f1id, f2id))) == 2
+    assert len(col.findCards("nid:%d,%d" % (f1id, f2id))) == 2
     # templates
-    assert len(deck.findCards("card:foo")) == 0
+    assert len(col.findCards("card:foo")) == 0
-    assert len(deck.findCards('"card:card 1"')) == 4
+    assert len(col.findCards('"card:card 1"')) == 4
-    assert len(deck.findCards("card:reverse")) == 1
+    assert len(col.findCards("card:reverse")) == 1
-    assert len(deck.findCards("card:1")) == 4
+    assert len(col.findCards("card:1")) == 4
-    assert len(deck.findCards("card:2")) == 1
+    assert len(col.findCards("card:2")) == 1
     # fields
-    assert len(deck.findCards("front:dog")) == 1
+    assert len(col.findCards("front:dog")) == 1
-    assert len(deck.findCards("-front:dog")) == 4
+    assert len(col.findCards("-front:dog")) == 4
-    assert len(deck.findCards("front:sheep")) == 0
+    assert len(col.findCards("front:sheep")) == 0
-    assert len(deck.findCards("back:sheep")) == 2
+    assert len(col.findCards("back:sheep")) == 2
-    assert len(deck.findCards("-back:sheep")) == 3
+    assert len(col.findCards("-back:sheep")) == 3
-    assert len(deck.findCards("front:do")) == 0
+    assert len(col.findCards("front:do")) == 0
-    assert len(deck.findCards("front:*")) == 5
+    assert len(col.findCards("front:*")) == 5
     # ordering
-    deck.conf["sortType"] = "noteCrt"
+    col.conf["sortType"] = "noteCrt"
-    deck.flush()
+    col.flush()
-    assert deck.findCards("front:*", order=True)[-1] in latestCardIds
+    assert col.findCards("front:*", order=True)[-1] in latestCardIds
-    assert deck.findCards("", order=True)[-1] in latestCardIds
+    assert col.findCards("", order=True)[-1] in latestCardIds
-    deck.conf["sortType"] = "noteFld"
+    col.conf["sortType"] = "noteFld"
-    deck.flush()
+    col.flush()
-    assert deck.findCards("", order=True)[0] == catCard.id
+    assert col.findCards("", order=True)[0] == catCard.id
-    assert deck.findCards("", order=True)[-1] in latestCardIds
+    assert col.findCards("", order=True)[-1] in latestCardIds
-    deck.conf["sortType"] = "cardMod"
+    col.conf["sortType"] = "cardMod"
-    deck.flush()
+    col.flush()
-    assert deck.findCards("", order=True)[-1] in latestCardIds
+    assert col.findCards("", order=True)[-1] in latestCardIds
-    assert deck.findCards("", order=True)[0] == firstCardId
+    assert col.findCards("", order=True)[0] == firstCardId
-    deck.conf["sortBackwards"] = True
+    col.conf["sortBackwards"] = True
-    deck.flush()
+    col.flush()
-    assert deck.findCards("", order=True)[0] in latestCardIds
+    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(col.findCards("note:basic")) == 3
-    assert len(deck.findCards("-note:basic")) == 2
+    assert len(col.findCards("-note:basic")) == 2
-    assert len(deck.findCards("-note:foo")) == 5
+    assert len(col.findCards("-note:foo")) == 5
-    # deck
+    # col
-    assert len(deck.findCards("deck:default")) == 5
+    assert len(col.findCards("deck:default")) == 5
-    assert len(deck.findCards("-deck:default")) == 0
+    assert len(col.findCards("-deck:default")) == 0
-    assert len(deck.findCards("-deck:foo")) == 5
+    assert len(col.findCards("-deck:foo")) == 5
-    assert len(deck.findCards("deck:def*")) == 5
+    assert len(col.findCards("deck:def*")) == 5
-    assert len(deck.findCards("deck:*EFAULT")) == 5
+    assert len(col.findCards("deck:*EFAULT")) == 5
-    assert len(deck.findCards("deck:*cefault")) == 0
+    assert len(col.findCards("deck:*cefault")) == 0
     # full search
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "hello<b>world</b>"
     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(col.findCards("helloworld")) == 2
-    # assert len(deck.findCards("helloworld", full=True)) == 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(col.findCards("helloworld")) == 0
-    # assert len(deck.findCards("helloworld", full=True)) == 2
+    # assert len(col.findCards("helloworld", full=True)) == 2
-    # assert len(deck.findCards("back: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"))
+        len(col.findCards("is:invalid"))
-    # should be able to limit to parent deck, no children
+    # should be able to limit to parent col, no children
-    id = deck.db.scalar("select id from cards limit 1")
+    id = col.db.scalar("select id from cards limit 1")
-    deck.db.execute(
+    col.db.execute(
-        "update cards set did = ? where id = ?", deck.decks.id("Default::Child"), id
+        "update cards set did = ? where id = ?", col.decks.id("Default::Child"), id
     )
-    deck.save()
+    col.save()
-    assert len(deck.findCards("deck:default")) == 7
+    assert len(col.findCards("deck:default")) == 7
-    assert len(deck.findCards("deck:default::child")) == 1
+    assert len(col.findCards("deck:default::child")) == 1
-    assert len(deck.findCards("deck:default -deck:default::*")) == 6
+    assert len(col.findCards("deck:default -deck:default::*")) == 6
     # properties
-    id = deck.db.scalar("select id from cards limit 1")
+    id = col.db.scalar("select id from cards limit 1")
-    deck.db.execute(
+    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(col.findCards("prop:ivl>5")) == 1
-    assert len(deck.findCards("prop:ivl<5")) > 1
+    assert len(col.findCards("prop:ivl<5")) > 1
-    assert len(deck.findCards("prop:ivl>=5")) == 1
+    assert len(col.findCards("prop:ivl>=5")) == 1
-    assert len(deck.findCards("prop:ivl=9")) == 0
+    assert len(col.findCards("prop:ivl=9")) == 0
-    assert len(deck.findCards("prop:ivl=10")) == 1
+    assert len(col.findCards("prop:ivl=10")) == 1
-    assert len(deck.findCards("prop:ivl!=10")) > 1
+    assert len(col.findCards("prop:ivl!=10")) > 1
-    assert len(deck.findCards("prop:due>0")) == 1
+    assert len(col.findCards("prop:due>0")) == 1
     # due dates should work
-    assert len(deck.findCards("prop:due=29")) == 0
+    assert len(col.findCards("prop:due=29")) == 0
-    assert len(deck.findCards("prop:due=30")) == 1
+    assert len(col.findCards("prop:due=30")) == 1
     # ease factors
-    assert len(deck.findCards("prop:ease=2.3")) == 0
+    assert len(col.findCards("prop:ease=2.3")) == 0
-    assert len(deck.findCards("prop:ease=2.2")) == 1
+    assert len(col.findCards("prop:ease=2.2")) == 1
-    assert len(deck.findCards("prop:ease>2")) == 1
+    assert len(col.findCards("prop:ease>2")) == 1
-    assert len(deck.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(col.findCards("rated:1:1")) == 0
-        assert len(deck.findCards("rated:1:2")) == 0
+        assert len(col.findCards("rated:1:2")) == 0
-        c = deck.sched.getCard()
+        c = col.sched.getCard()
-        deck.sched.answerCard(c, 2)
+        col.sched.answerCard(c, 2)
-        assert len(deck.findCards("rated:1:1")) == 0
+        assert len(col.findCards("rated:1:1")) == 0
-        assert len(deck.findCards("rated:1:2")) == 1
+        assert len(col.findCards("rated:1:2")) == 1
-        c = deck.sched.getCard()
+        c = col.sched.getCard()
-        deck.sched.answerCard(c, 1)
+        col.sched.answerCard(c, 1)
-        assert len(deck.findCards("rated:1:1")) == 1
+        assert len(col.findCards("rated:1:1")) == 1
-        assert len(deck.findCards("rated:1:2")) == 1
+        assert len(col.findCards("rated:1:2")) == 1
-        assert len(deck.findCards("rated:1")) == 2
+        assert len(col.findCards("rated:1")) == 2
-        assert len(deck.findCards("rated:0:2")) == 0
+        assert len(col.findCards("rated:0:2")) == 0
-        assert len(deck.findCards("rated:2:2")) == 1
+        assert len(col.findCards("rated:2:2")) == 1
         # added
-        assert len(deck.findCards("added:0")) == 0
+        assert len(col.findCards("added:0")) == 0
-        deck.db.execute("update cards set id = id - 86400*1000 where id = ?", id)
+        col.db.execute("update cards set id = id - 86400*1000 where id = ?", id)
-        assert len(deck.findCards("added:1")) == deck.cardCount() - 1
+        assert len(col.findCards("added:1")) == col.cardCount() - 1
-        assert len(deck.findCards("added:2")) == deck.cardCount()
+        assert len(col.findCards("added:2")) == col.cardCount()
     else:
         print("some find tests disabled near cutoff")
     # empty field
-    assert len(deck.findCards("front:")) == 0
+    assert len(col.findCards("front:")) == 0
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = ""
     note["Back"] = "abc2"
-    assert deck.addNote(note) == 1
+    assert col.addNote(note) == 1
-    assert len(deck.findCards("front:")) == 1
+    assert len(col.findCards("front:")) == 1
     # OR searches and nesting
-    assert len(deck.findCards("tag:monkey or tag:sheep")) == 2
+    assert len(col.findCards("tag:monkey or tag:sheep")) == 2
-    assert len(deck.findCards("(tag:monkey OR tag:sheep)")) == 2
+    assert len(col.findCards("(tag:monkey OR tag:sheep)")) == 2
-    assert len(deck.findCards("-(tag:monkey OR tag:sheep)")) == 6
+    assert len(col.findCards("-(tag:monkey OR tag:sheep)")) == 6
-    assert len(deck.findCards("tag:monkey or (tag:sheep sheep)")) == 2
+    assert len(col.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 octopus)")) == 1
     # flag
     with pytest.raises(Exception):
-        deck.findCards("flag:12")
+        col.findCards("flag:12")
 
 
 def test_findReplace():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "foo"
     note["Back"] = "bar"
-    deck.addNote(note)
+    col.addNote(note)
-    note2 = deck.newNote()
+    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()
+    col = getEmptyCol()
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "foo"
     note["Back"] = "bar"
-    deck.addNote(note)
+    col.addNote(note)
-    note2 = deck.newNote()
+    note2 = col.newNote()
     note2["Front"] = "baz"
     note2["Back"] = "bar"
-    deck.addNote(note2)
+    col.addNote(note2)
-    f3 = deck.newNote()
+    f3 = col.newNote()
     f3["Front"] = "quux"
     f3["Back"] = "bar"
-    deck.addNote(f3)
+    col.addNote(f3)
-    f4 = deck.newNote()
+    f4 = col.newNote()
     f4["Front"] = "quuux"
     f4["Back"] = "nope"
-    deck.addNote(f4)
+    col.addNote(f4)
-    r = deck.findDupes("Back")
+    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") == []

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
+    assert col.cardCount() == 11
-    deck.close()
+    col.close()
 
 
 def test_csv2():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    mm = deck.models
+    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()
+    col = getEmptyCol()
-    mm = deck.models
+    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()
+    col = getEmptyCol()
-    mm = deck.models
+    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()
+    col = getEmptyCol()
-    mm = deck.models
+    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")
+    cid = col.db.scalar("select id from cards")
-    c = deck.getCard(cid)
+    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 col.cardCount() == 7
-    assert "a_longer_tag" in deck.tags.all()
+    assert "a_longer_tag" in col.tags.all()
-    assert deck.db.scalar("select count() from cards where type = 0") == 1
+    assert col.db.scalar("select count() from cards where type = 0") == 1
-    deck.close()
+    col.close()

pylib/tests/test_models.py

@@ -8,20 +8,20 @@ from tests.shared import getEmptyCol
 
 
 def test_modelDelete():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    note = deck.newNote()
+    note = col.newNote()
     note["Front"] = "1"
     note["Back"] = "2"
-    deck.addNote(note)
+    col.addNote(note)
-    assert deck.cardCount() == 1
+    assert col.cardCount() == 1
-    deck.models.rem(deck.models.current())
+    col.models.rem(col.models.current())
-    assert deck.cardCount() == 0
+    assert col.cardCount() == 0
 
 
 def test_modelCopy():
-    deck = getEmptyCol()
+    col = getEmptyCol()
-    m = deck.models.current()
+    m = col.models.current()
-    m2 = deck.models.copy(m)
+    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()
+    col = getEmptyCol()
-    cloze = deck.models.byName("Cloze")
+    cloze = col.models.byName("Cloze")
     # enable second template and add a note
-    m = deck.models.current()
+    m = col.models.current()
-    mm = deck.models
+    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)
+    col.addNote(note)
-    counts = deck.models.all_use_counts()
+    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])
+    col.models.remTemplate(basic, basic["tmpls"][1])
-    assert deck.db.scalar("select count() from cards where nid = ?", note.id) == 2
+    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)
+    col.models.change(cloze, [note.id], basic, map, map)
-    assert deck.db.scalar("select count() from cards where nid = ?", note.id) == 1
+    assert col.db.scalar("select count() from cards where nid = ?", note.id) == 1
 
 
 def test_req():