def testCoreProject_AccessItems(nwMinimal, mockGUI):
"""Test helper functions for the project folder.
"""
theProject = NWProject(mockGUI)
theProject.openProject(nwMinimal)
# Move Novel ROOT to after its files
oldOrder = [
"a508bb932959c", # ROOT: Novel
"a35baf2e93843", # FILE: Title Page
"a6d311a93600a", # FOLDER: New Chapter
"f5ab3e30151e1", # FILE: New Chapter
"8c659a11cd429", # FILE: New Scene
"7695ce551d265", # ROOT: Plot
"afb3043c7b2b3", # ROOT: Characters
"9d5247ab588e0", # ROOT: World
]
newOrder = [
"a35baf2e93843", # FILE: Title Page
"f5ab3e30151e1", # FILE: New Chapter
"8c659a11cd429", # FILE: New Scene
"a6d311a93600a", # FOLDER: New Chapter
"a508bb932959c", # ROOT: Novel
"7695ce551d265", # ROOT: Plot
"afb3043c7b2b3", # ROOT: Characters
"9d5247ab588e0", # ROOT: World
]
assert theProject.projTree.handles() == oldOrder
assert theProject.setTreeOrder(newOrder)
assert theProject.projTree.handles() == newOrder
# Add a non-existing item
theProject.projTree._treeOrder.append("01234567789abc")
# Add an item with a non-existent parent
nHandle = theProject.newFile("Test File", nwItemClass.NOVEL,
"a6d311a93600a")
theProject.projTree[nHandle].setParent("cba9876543210")
assert theProject.projTree[nHandle].itemParent == "cba9876543210"
retOrder = []
for tItem in theProject.getProjectItems():
retOrder.append(tItem.itemHandle)
assert retOrder == [
"a508bb932959c", # ROOT: Novel
"7695ce551d265", # ROOT: Plot
"afb3043c7b2b3", # ROOT: Characters
"9d5247ab588e0", # ROOT: World
nHandle, # FILE: Test File
"a35baf2e93843", # FILE: Title Page
"a6d311a93600a", # FOLDER: New Chapter
"f5ab3e30151e1", # FILE: New Chapter
"8c659a11cd429", # FILE: New Scene
]
assert theProject.projTree[nHandle].itemParent is None
def testCoreProject_NewSampleB(monkeypatch, fncDir, tmpConf, mockGUI, tmpDir):
"""Check that we can create a new project can be created from the
provided sample project folder.
"""
projData = {
"projName": "Test Sample",
"projTitle": "Test Novel",
"projAuthors": "Jane Doe\nJohn Doh\n",
"projPath": fncDir,
"popSample": True,
"popMinimal": False,
"popCustom": False,
}
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
# Make sure we do not pick up the novelwriter/assets/sample.zip file
tmpConf.assetPath = tmpDir
# Set a fake project file name
monkeypatch.setattr(nwFiles, "PROJ_FILE", "nothing.nwx")
assert not theProject.newProject(projData)
monkeypatch.setattr(nwFiles, "PROJ_FILE", "nwProject.nwx")
assert theProject.newProject(projData) is True
assert theProject.openProject(fncDir) is True
assert theProject.projName == "Sample Project"
assert theProject.saveProject() is True
assert theProject.closeProject() is True
# Misdirect the appRoot path so neither is possible
tmpConf.appRoot = tmpDir
assert not theProject.newProject(projData)
def testCoreProject_NewFile(fncDir, outDir, refDir, mockGUI):
"""Check that new files can be added to the project.
"""
projFile = os.path.join(fncDir, "nwProject.nwx")
testFile = os.path.join(outDir, "coreProject_NewFile_nwProject.nwx")
compFile = os.path.join(refDir, "coreProject_NewFile_nwProject.nwx")
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
assert theProject.newProject({"projPath": fncDir}) is True
assert theProject.setProjectPath(fncDir) is True
assert theProject.saveProject() is True
assert theProject.closeProject() is True
assert theProject.openProject(projFile) is True
assert isinstance(
theProject.newFile("Hello", nwItemClass.NOVEL, "31489056e0916"), str)
assert isinstance(
theProject.newFile("Jane", nwItemClass.CHARACTER, "71ee45a3c0db9"),
str)
assert theProject.projChanged
assert theProject.saveProject() is True
assert theProject.closeProject() is True
copyfile(projFile, testFile)
assert cmpFiles(testFile, compFile, [2, 6, 7, 8])
assert theProject.projChanged is False
def testCoreProject_NewMinimal(fncDir, outDir, refDir, mockGUI):
"""Create a new project from a project wizard dictionary. With
default setting, creating a Minimal project.
"""
projFile = os.path.join(fncDir, "nwProject.nwx")
testFile = os.path.join(outDir, "coreProject_NewMinimal_nwProject.nwx")
compFile = os.path.join(refDir, "coreProject_NewMinimal_nwProject.nwx")
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
# Setting no data should fail
assert theProject.newProject({}) is False
# Wrong type should also fail
assert theProject.newProject("stuff") is False
# Try again with a proper path
assert theProject.newProject({"projPath": fncDir}) is True
assert theProject.saveProject() is True
assert theProject.closeProject() is True
# Creating the project once more should fail
assert theProject.newProject({"projPath": fncDir}) is False
# Open again
assert theProject.openProject(projFile) is True
# Save and close
assert theProject.saveProject() is True
assert theProject.closeProject() is True
copyfile(projFile, testFile)
assert cmpFiles(testFile, compFile, [2, 6, 7, 8])
assert theProject.projChanged is False
# Open a second time
assert theProject.openProject(projFile) is True
assert theProject.openProject(projFile) is False
assert theProject.openProject(projFile, overrideLock=True) is True
assert theProject.saveProject() is True
assert theProject.closeProject() is True
copyfile(projFile, testFile)
assert cmpFiles(testFile, compFile, [2, 6, 7, 8])
def testCoreProject_Save(monkeypatch, nwMinimal, mockGUI, refDir):
"""Test saving a project.
"""
theProject = NWProject(mockGUI)
testFile = os.path.join(nwMinimal, "nwProject.nwx")
backFile = os.path.join(nwMinimal, "nwProject.bak")
compFile = os.path.join(refDir, os.path.pardir, "minimal", "nwProject.nwx")
# Nothing to save
assert theProject.saveProject() is False
# Open test project
assert theProject.openProject(nwMinimal)
# Fail on folder structure check
with monkeypatch.context() as mp:
mp.setattr("os.path.isdir", lambda *a: False)
assert theProject.saveProject() is False
# Fail on open file
with monkeypatch.context() as mp:
mp.setattr("builtins.open", causeOSError)
assert theProject.saveProject() is False
# Fail on creating .bak file
with monkeypatch.context() as mp:
mp.setattr("os.replace", causeOSError)
assert theProject.saveProject() is False
assert os.path.isfile(backFile) is False
# Successful save
saveCount = theProject.saveCount
autoCount = theProject.autoCount
assert theProject.saveProject() is True
assert theProject.saveCount == saveCount + 1
assert theProject.autoCount == autoCount
assert cmpFiles(testFile, compFile, [2, 6, 7, 8, 9])
# Check that a second save creates a .bak file
assert os.path.isfile(backFile) is True
# Successful autosave
saveCount = theProject.saveCount
autoCount = theProject.autoCount
assert theProject.saveProject(autoSave=True) is True
assert theProject.saveCount == saveCount
assert theProject.autoCount == autoCount + 1
assert cmpFiles(testFile, compFile, [2, 6, 7, 8, 9])
# Close test project
assert theProject.closeProject()
def testCoreIndex_ScanThis(nwMinimal, mockGUI):
"""Test the tag scanner function scanThis.
"""
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
assert theProject.openProject(nwMinimal) is True
theIndex = NWIndex(theProject)
isValid, theBits, thePos = theIndex.scanThis("tag: this, and this")
assert isValid is False
isValid, theBits, thePos = theIndex.scanThis("@")
assert isValid is False
isValid, theBits, thePos = theIndex.scanThis("@:")
assert isValid is False
isValid, theBits, thePos = theIndex.scanThis(" @a: b")
assert isValid is False
isValid, theBits, thePos = theIndex.scanThis("@a:")
assert isValid is True
assert theBits == ["@a"]
assert thePos == [0]
isValid, theBits, thePos = theIndex.scanThis("@a:b")
assert isValid is True
assert theBits == ["@a", "b"]
assert thePos == [0, 3]
isValid, theBits, thePos = theIndex.scanThis("@a:b,c,d")
assert isValid is True
assert theBits == ["@a", "b", "c", "d"]
assert thePos == [0, 3, 5, 7]
isValid, theBits, thePos = theIndex.scanThis("@a : b , c , d")
assert isValid is True
assert theBits == ["@a", "b", "c", "d"]
assert thePos == [0, 5, 9, 13]
isValid, theBits, thePos = theIndex.scanThis("@tag: this, and this")
assert isValid is True
assert theBits == ["@tag", "this", "and this"]
assert thePos == [0, 6, 12]
assert theProject.closeProject() is True
def testCoreProject_NewSampleA(fncDir, tmpConf, mockGUI, tmpDir):
"""Check that we can create a new project can be created from the
provided sample project via a zip file.
"""
projData = {
"projName": "Test Sample",
"projTitle": "Test Novel",
"projAuthors": "Jane Doe\nJohn Doh\n",
"projPath": fncDir,
"popSample": True,
"popMinimal": False,
"popCustom": False,
}
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
# Sample set, but no path
assert not theProject.newProject({"popSample": True})
# Force the lookup path for assets to our temp folder
srcSample = os.path.abspath(os.path.join(tmpConf.appRoot, "sample"))
dstSample = os.path.join(tmpDir, "sample.zip")
tmpConf.assetPath = tmpDir
# Create and open a defective zip file
with open(dstSample, mode="w+") as outFile:
outFile.write("foo")
assert not theProject.newProject(projData)
os.unlink(dstSample)
# Create a real zip file, and unpack it
with ZipFile(dstSample, "w") as zipObj:
zipObj.write(os.path.join(srcSample, "nwProject.nwx"), "nwProject.nwx")
for docFile in os.listdir(os.path.join(srcSample, "content")):
srcDoc = os.path.join(srcSample, "content", docFile)
zipObj.write(srcDoc, "content/" + docFile)
assert theProject.newProject(projData) is True
assert theProject.openProject(fncDir) is True
assert theProject.projName == "Sample Project"
assert theProject.saveProject() is True
assert theProject.closeProject() is True
os.unlink(dstSample)
def testCoreProject_NewRoot(fncDir, outDir, refDir, mockGUI):
"""Check that new root folders can be added to the project.
"""
projFile = os.path.join(fncDir, "nwProject.nwx")
testFile = os.path.join(outDir, "coreProject_NewRoot_nwProject.nwx")
compFile = os.path.join(refDir, "coreProject_NewRoot_nwProject.nwx")
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
assert theProject.newProject({"projPath": fncDir}) is True
assert theProject.setProjectPath(fncDir) is True
assert theProject.saveProject() is True
assert theProject.closeProject() is True
assert theProject.openProject(projFile) is True
assert isinstance(theProject.newRoot("Novel", nwItemClass.NOVEL),
type(None))
assert isinstance(theProject.newRoot("Plot", nwItemClass.PLOT), type(None))
assert isinstance(theProject.newRoot("Character", nwItemClass.CHARACTER),
type(None))
assert isinstance(theProject.newRoot("World", nwItemClass.WORLD),
type(None))
assert isinstance(theProject.newRoot("Timeline", nwItemClass.TIMELINE),
str)
assert isinstance(theProject.newRoot("Object", nwItemClass.OBJECT), str)
assert isinstance(theProject.newRoot("Custom1", nwItemClass.CUSTOM), str)
assert isinstance(theProject.newRoot("Custom2", nwItemClass.CUSTOM), str)
assert theProject.projChanged is True
assert theProject.saveProject() is True
assert theProject.closeProject() is True
copyfile(projFile, testFile)
assert cmpFiles(testFile, compFile, [2, 6, 7, 8])
assert theProject.projChanged is False
def testCoreIndex_ScanText(nwMinimal, mockGUI):
"""Check the index text scanner.
"""
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
assert theProject.openProject(nwMinimal) is True
theIndex = NWIndex(theProject)
# Some items for fail to scan tests
dHandle = theProject.newFolder("Folder", nwItemClass.NOVEL,
"a508bb932959c")
xHandle = theProject.newFile("No Layout", nwItemClass.NOVEL,
"a508bb932959c")
xItem = theProject.projTree[xHandle]
xItem.setLayout(nwItemLayout.NO_LAYOUT)
# Check invalid data
assert theIndex.scanText(None, "Hello World!") is False
assert theIndex.scanText(dHandle, "Hello World!") is False
assert theIndex.scanText(xHandle, "Hello World!") is False
xItem.setLayout(nwItemLayout.DOCUMENT)
xItem.setParent(None)
assert theIndex.scanText(xHandle, "Hello World!") is False
# Create the trash folder
tHandle = theProject.trashFolder()
assert theProject.projTree[tHandle] is not None
xItem.setParent(tHandle)
assert theIndex.scanText(xHandle, "Hello World!") is False
# Create the archive root
aHandle = theProject.newRoot("Archive", nwItemClass.ARCHIVE)
assert theProject.projTree[aHandle] is not None
xItem.setParent(aHandle)
assert theIndex.scanText(xHandle, "Hello World!") is False
# Make some usable items
tHandle = theProject.newFile("Title", nwItemClass.NOVEL, "a508bb932959c")
pHandle = theProject.newFile("Page", nwItemClass.NOVEL, "a508bb932959c")
nHandle = theProject.newFile("Hello", nwItemClass.NOVEL, "a508bb932959c")
cHandle = theProject.newFile("Jane", nwItemClass.CHARACTER,
"afb3043c7b2b3")
sHandle = theProject.newFile("Scene", nwItemClass.NOVEL, "a508bb932959c")
# Text Indexing
# =============
# Index correct text
assert theIndex.scanText(cHandle, ("# Jane Smith\n" "@tag: Jane\n"))
assert theIndex.scanText(nHandle, ("# Hello World!\n"
"@pov: Jane\n"
"@char: Jane\n\n"
"% this is a comment\n\n"
"This is a story about Jane Smith.\n\n"
"Well, not really.\n"))
assert theIndex._tagIndex == {"Jane": [2, cHandle, "CHARACTER", "T000001"]}
assert theIndex.getNovelData(nHandle, "T000001")["title"] == "Hello World!"
# Title Indexing
# ==============
# Document File
assert theIndex.scanText(
nHandle,
(
"# Title One\n\n"
"% synopsis: Synopsis One.\n\n"
"Paragraph One.\n\n"
"## Title Two\n\n"
"% synopsis: Synopsis Two.\n\n"
"Paragraph Two.\n\n"
"### Title Three\n\n"
"% synopsis: Synopsis Three.\n\n"
"Paragraph Three.\n\n"
"#### Title Four\n\n"
"% synopsis: Synopsis Four.\n\n"
"Paragraph Four.\n\n"
"##### Title Five\n\n" # Not interpreted as a title, the hashes are counted as a word
"Paragraph Five.\n\n"))
assert nHandle not in theIndex._refIndex
assert theIndex._fileIndex[nHandle]["T000001"]["level"] == "H1"
assert theIndex._fileIndex[nHandle]["T000007"]["level"] == "H2"
assert theIndex._fileIndex[nHandle]["T000013"]["level"] == "H3"
assert theIndex._fileIndex[nHandle]["T000019"]["level"] == "H4"
assert theIndex._fileIndex[nHandle]["T000001"]["title"] == "Title One"
assert theIndex._fileIndex[nHandle]["T000007"]["title"] == "Title Two"
assert theIndex._fileIndex[nHandle]["T000013"]["title"] == "Title Three"
assert theIndex._fileIndex[nHandle]["T000019"]["title"] == "Title Four"
assert theIndex._fileIndex[nHandle]["T000001"]["layout"] == "DOCUMENT"
assert theIndex._fileIndex[nHandle]["T000007"]["layout"] == "DOCUMENT"
assert theIndex._fileIndex[nHandle]["T000013"]["layout"] == "DOCUMENT"
assert theIndex._fileIndex[nHandle]["T000019"]["layout"] == "DOCUMENT"
assert theIndex._fileIndex[nHandle]["T000001"]["cCount"] == 23
assert theIndex._fileIndex[nHandle]["T000007"]["cCount"] == 23
assert theIndex._fileIndex[nHandle]["T000013"]["cCount"] == 27
assert theIndex._fileIndex[nHandle]["T000019"]["cCount"] == 56
assert theIndex._fileIndex[nHandle]["T000001"]["wCount"] == 4
assert theIndex._fileIndex[nHandle]["T000007"]["wCount"] == 4
assert theIndex._fileIndex[nHandle]["T000013"]["wCount"] == 4
assert theIndex._fileIndex[nHandle]["T000019"]["wCount"] == 9
assert theIndex._fileIndex[nHandle]["T000001"]["pCount"] == 1
assert theIndex._fileIndex[nHandle]["T000007"]["pCount"] == 1
assert theIndex._fileIndex[nHandle]["T000013"]["pCount"] == 1
assert theIndex._fileIndex[nHandle]["T000019"]["pCount"] == 3
assert theIndex._fileIndex[nHandle]["T000001"][
"synopsis"] == "Synopsis One."
assert theIndex._fileIndex[nHandle]["T000007"][
"synopsis"] == "Synopsis Two."
assert theIndex._fileIndex[nHandle]["T000013"][
"synopsis"] == "Synopsis Three."
assert theIndex._fileIndex[nHandle]["T000019"][
"synopsis"] == "Synopsis Four."
# Note File
assert theIndex.scanText(cHandle, ("# Title One\n\n"
"@tag: One\n\n"
"% synopsis: Synopsis One.\n\n"
"Paragraph One.\n\n"))
assert cHandle not in theIndex._refIndex
assert theIndex._fileIndex[cHandle]["T000001"]["level"] == "H1"
assert theIndex._fileIndex[cHandle]["T000001"]["title"] == "Title One"
assert theIndex._fileIndex[cHandle]["T000001"]["layout"] == "NOTE"
assert theIndex._fileIndex[cHandle]["T000001"]["cCount"] == 23
assert theIndex._fileIndex[cHandle]["T000001"]["wCount"] == 4
assert theIndex._fileIndex[cHandle]["T000001"]["pCount"] == 1
assert theIndex._fileIndex[cHandle]["T000001"][
"synopsis"] == "Synopsis One."
# Valid and Invalid References
assert theIndex.scanText(
sHandle,
(
"# Title One\n\n"
"@pov: One\n\n" # Valid
"@char: Two\n\n" # Invalid tag
"@:\n\n" # Invalid line
"% synopsis: Synopsis One.\n\n"
"Paragraph One.\n\n"))
assert theIndex._refIndex[sHandle]["T000001"] == ([[3, "@pov", "One"],
[5, "@char", "Two"]])
# Special Titles
# ==============
assert theIndex.scanText(tHandle, ("#! My Project\n\n"
">> By Jane Doe <<\n\n"))
assert tHandle not in theIndex._refIndex
assert theIndex._fileIndex[tHandle]["T000001"]["level"] == "H1"
assert theIndex._fileIndex[tHandle]["T000001"]["title"] == "My Project"
assert theIndex._fileIndex[tHandle]["T000001"]["layout"] == "DOCUMENT"
assert theIndex._fileIndex[tHandle]["T000001"]["cCount"] == 21
assert theIndex._fileIndex[tHandle]["T000001"]["wCount"] == 5
assert theIndex._fileIndex[tHandle]["T000001"]["pCount"] == 1
assert theIndex._fileIndex[tHandle]["T000001"]["synopsis"] == ""
assert theIndex.scanText(tHandle,
("##! Prologue\n\n"
"In the beginning there was time ...\n\n"))
assert tHandle not in theIndex._refIndex
assert theIndex._fileIndex[tHandle]["T000001"]["level"] == "H2"
assert theIndex._fileIndex[tHandle]["T000001"]["title"] == "Prologue"
assert theIndex._fileIndex[tHandle]["T000001"]["layout"] == "DOCUMENT"
assert theIndex._fileIndex[tHandle]["T000001"]["cCount"] == 43
assert theIndex._fileIndex[tHandle]["T000001"]["wCount"] == 8
assert theIndex._fileIndex[tHandle]["T000001"]["pCount"] == 1
assert theIndex._fileIndex[tHandle]["T000001"]["synopsis"] == ""
# Page wo/Title
# =============
theProject.projTree[pHandle]._layout = nwItemLayout.DOCUMENT
assert theIndex.scanText(pHandle,
("This is a page with some text on it.\n\n"))
assert pHandle in theIndex._fileIndex
assert theIndex._fileIndex[pHandle]["T000000"]["level"] == "H0"
assert theIndex._fileIndex[pHandle]["T000000"]["title"] == ""
assert theIndex._fileIndex[pHandle]["T000000"]["layout"] == "DOCUMENT"
assert theIndex._fileIndex[pHandle]["T000000"]["cCount"] == 36
assert theIndex._fileIndex[pHandle]["T000000"]["wCount"] == 9
assert theIndex._fileIndex[pHandle]["T000000"]["pCount"] == 1
assert theIndex._fileIndex[pHandle]["T000000"]["synopsis"] == ""
theProject.projTree[pHandle]._layout = nwItemLayout.NOTE
assert theIndex.scanText(pHandle,
("This is a page with some text on it.\n\n"))
assert pHandle in theIndex._fileIndex
assert theIndex._fileIndex[pHandle]["T000000"]["level"] == "H0"
assert theIndex._fileIndex[pHandle]["T000000"]["title"] == ""
assert theIndex._fileIndex[pHandle]["T000000"]["layout"] == "NOTE"
assert theIndex._fileIndex[pHandle]["T000000"]["cCount"] == 36
assert theIndex._fileIndex[pHandle]["T000000"]["wCount"] == 9
assert theIndex._fileIndex[pHandle]["T000000"]["pCount"] == 1
assert theIndex._fileIndex[pHandle]["T000000"]["synopsis"] == ""
assert theProject.closeProject() is True
def testCoreIndex_CheckThese(nwMinimal, mockGUI):
"""Test the tag checker function checkThese.
"""
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
assert theProject.openProject(nwMinimal) is True
theIndex = NWIndex(theProject)
nHandle = theProject.newFile("Hello", nwItemClass.NOVEL, "a508bb932959c")
cHandle = theProject.newFile("Jane", nwItemClass.CHARACTER,
"afb3043c7b2b3")
nItem = theProject.projTree[nHandle]
cItem = theProject.projTree[cHandle]
assert theIndex.novelChangedSince(0) is False
assert theIndex.notesChangedSince(0) is False
assert theIndex.indexChangedSince(0) is False
assert theIndex.scanText(cHandle, ("# Jane Smith\n"
"@tag: Jane\n"
"@tag:\n"
"@:\n"))
assert theIndex.scanText(
nHandle,
(
"# Hello World!\n"
"@pov: Jane\n"
"@invalid: John\n" # Checks for issue #688
))
assert theIndex._tagIndex == {"Jane": [2, cHandle, "CHARACTER", "T000001"]}
assert theIndex.getNovelData(nHandle, "T000001")["title"] == "Hello World!"
assert theIndex.getReferences(nHandle, "T000001") == {
"@char": [],
"@custom": [],
"@entity": [],
"@focus": [],
"@location": [],
"@object": [],
"@plot": [],
"@pov": ["Jane"],
"@time": []
}
assert theIndex.novelChangedSince(0) is True
assert theIndex.notesChangedSince(0) is True
assert theIndex.indexChangedSince(0) is True
assert theIndex.getHandleHeaderLevel(cHandle) == "H1"
assert theIndex.getHandleHeaderLevel(nHandle) == "H1"
# Zero Items
assert theIndex.checkThese([], cItem) == []
# One Item
assert theIndex.checkThese(["@tag"], cItem) == [True]
assert theIndex.checkThese(["@who"], cItem) == [False]
# Two Items
assert theIndex.checkThese(["@tag", "Jane"], cItem) == [True, True]
assert theIndex.checkThese(["@tag", "John"], cItem) == [True, True]
assert theIndex.checkThese(["@tag", "Jane"], nItem) == [True, False]
assert theIndex.checkThese(["@tag", "John"], nItem) == [True, True]
assert theIndex.checkThese(["@pov", "John"], nItem) == [True, False]
assert theIndex.checkThese(["@pov", "Jane"], nItem) == [True, True]
assert theIndex.checkThese(["@ pov", "Jane"], nItem) == [False, False]
assert theIndex.checkThese(["@what", "Jane"], nItem) == [False, False]
# Three Items
assert theIndex.checkThese(["@tag", "Jane", "John"],
cItem) == [True, True, False]
assert theIndex.checkThese(["@who", "Jane", "John"],
cItem) == [False, False, False]
assert theIndex.checkThese(["@pov", "Jane", "John"],
nItem) == [True, True, False]
assert theProject.closeProject() is True
def testCoreProject_OrphanedFiles(mockGUI, nwLipsum):
"""Check that files in the content folder that are not tracked in
the project XML file are handled correctly by the orphaned files
function. It should also restore as much meta data as possible from
the meta line at the top of the document file.
"""
theProject = NWProject(mockGUI)
assert theProject.openProject(nwLipsum)
assert theProject.projTree["636b6aa9b697b"] is None
assert theProject.closeProject()
# First Item with Meta Data
orphPath = os.path.join(nwLipsum, "content", "636b6aa9b697b.nwd")
writeFile(orphPath, ("%%~name:[Recovered] Mars\n"
"%%~path:5eaea4e8cdee8/636b6aa9b697b\n"
"%%~kind:WORLD/NOTE\n"
"%%~invalid\n"
"\n"))
# Second Item without Meta Data
orphPath = os.path.join(nwLipsum, "content", "736b6aa9b697b.nwd")
writeFile(orphPath, "\n")
# Invalid File Name
tstPath = os.path.join(nwLipsum, "content", "636b6aa9b697b.txt")
writeFile(tstPath, "\n")
# Invalid File Name
tstPath = os.path.join(nwLipsum, "content", "636b6aa9b697bb.nwd")
writeFile(tstPath, "\n")
# Invalid File Name
tstPath = os.path.join(nwLipsum, "content", "abcdefghijklm.nwd")
writeFile(tstPath, "\n")
assert theProject.openProject(nwLipsum)
assert theProject.projPath is not None
assert theProject.projTree["636b6aa9b697bb"] is None
assert theProject.projTree["abcdefghijklm"] is None
# First Item with Meta Data
oItem = theProject.projTree["636b6aa9b697b"]
assert oItem is not None
assert oItem.itemName == "[Recovered] Mars"
assert oItem.itemHandle == "636b6aa9b697b"
assert oItem.itemParent == "60bdf227455cc"
assert oItem.itemClass == nwItemClass.WORLD
assert oItem.itemType == nwItemType.FILE
assert oItem.itemLayout == nwItemLayout.NOTE
# Second Item without Meta Data
oItem = theProject.projTree["736b6aa9b697b"]
assert oItem is not None
assert oItem.itemName == "Recovered File 1"
assert oItem.itemHandle == "736b6aa9b697b"
assert oItem.itemParent == "b3643d0f92e32"
assert oItem.itemClass == nwItemClass.NOVEL
assert oItem.itemType == nwItemType.FILE
assert oItem.itemLayout == nwItemLayout.NOTE
assert theProject.saveProject(nwLipsum)
assert theProject.closeProject()
# Finally, check that the orphaned files function returns
# if no project is open and no path is set
assert not theProject._scanProjectFolder()
def testCoreProject_Methods(monkeypatch, nwMinimal, mockGUI, tmpDir):
"""Test other project class methods and functions.
"""
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
assert theProject.openProject(nwMinimal)
assert theProject.projPath == nwMinimal
# Setting project path
assert theProject.setProjectPath(None)
assert theProject.projPath is None
assert theProject.setProjectPath("")
assert theProject.projPath is None
assert theProject.setProjectPath("~")
assert theProject.projPath == os.path.expanduser("~")
# Create a new folder and populate it
projPath = os.path.join(nwMinimal, "mock1")
assert theProject.setProjectPath(projPath, newProject=True)
# Make os.mkdir fail
monkeypatch.setattr("os.mkdir", causeOSError)
projPath = os.path.join(nwMinimal, "mock2")
assert not theProject.setProjectPath(projPath, newProject=True)
# Set back
assert theProject.setProjectPath(nwMinimal)
# Project Name
assert theProject.setProjectName(" A Name ")
assert theProject.projName == "A Name"
# Project Title
assert theProject.setBookTitle(" A Title ")
assert theProject.bookTitle == "A Title"
# Project Authors
# Check that the list is cleaned up and that it can be extracted as
# a properly formatted string, depending on number of names
assert not theProject.setBookAuthors([])
assert theProject.setBookAuthors(" Jane Doe \n John Doh \n ")
assert theProject.bookAuthors == ["Jane Doe", "John Doh"]
assert theProject.setBookAuthors("")
assert theProject.getAuthors() == ""
assert theProject.setBookAuthors("Jane Doe")
assert theProject.getAuthors() == "Jane Doe"
assert theProject.setBookAuthors("Jane Doe\nJohn Doh")
assert theProject.getAuthors() == "Jane Doe and John Doh"
assert theProject.setBookAuthors("Jane Doe\nJohn Doh\nBod Owens")
assert theProject.getAuthors() == "Jane Doe, John Doh and Bod Owens"
# Edit Time
theProject.editTime = 1234
theProject.projOpened = 1600000000
with monkeypatch.context() as mp:
mp.setattr("novelwriter.core.project.time", lambda: 1600005600)
assert theProject.getCurrentEditTime() == 6834
# Trash folder
# Should create on first call, and just returned on later calls
assert theProject.projTree["73475cb40a568"] is None
assert theProject.trashFolder() == "73475cb40a568"
assert theProject.trashFolder() == "73475cb40a568"
# Project backup
assert theProject.doBackup is True
assert theProject.setProjBackup(False)
assert theProject.doBackup is False
assert not theProject.setProjBackup(True)
theProject.mainConf.backupPath = tmpDir
assert theProject.setProjBackup(True)
assert theProject.setProjectName("")
assert not theProject.setProjBackup(True)
assert theProject.setProjectName("A Name")
assert theProject.setProjBackup(True)
# Spell check
theProject.projChanged = False
assert theProject.setSpellCheck(True)
assert not theProject.setSpellCheck(False)
assert theProject.projChanged
# Spell language
theProject.projChanged = False
assert theProject.setSpellLang(None)
assert theProject.projSpell is None
assert theProject.setSpellLang("None")
assert theProject.projSpell is None
assert theProject.setSpellLang("en_GB")
assert theProject.projSpell == "en_GB"
assert theProject.projChanged
# Project Language
theProject.projChanged = False
theProject.projLang = "en"
assert theProject.setProjectLang(None) is True
assert theProject.projLang is None
assert theProject.setProjectLang("en_GB") is True
assert theProject.projLang == "en_GB"
# Automatic outline update
theProject.projChanged = False
assert theProject.setAutoOutline(True)
assert not theProject.setAutoOutline(False)
assert theProject.projChanged
# Last edited
theProject.projChanged = False
assert theProject.setLastEdited("0123456789abc")
assert theProject.lastEdited == "0123456789abc"
assert theProject.projChanged
# Last viewed
theProject.projChanged = False
assert theProject.setLastViewed("0123456789abc")
assert theProject.lastViewed == "0123456789abc"
assert theProject.projChanged
# Autoreplace
theProject.projChanged = False
assert theProject.setAutoReplace({"A": "B", "C": "D"})
assert theProject.autoReplace == {"A": "B", "C": "D"}
assert theProject.projChanged
# Change project tree order
oldOrder = [
"a508bb932959c",
"a35baf2e93843",
"a6d311a93600a",
"f5ab3e30151e1",
"8c659a11cd429",
"7695ce551d265",
"afb3043c7b2b3",
"9d5247ab588e0",
"73475cb40a568",
]
newOrder = [
"f5ab3e30151e1",
"8c659a11cd429",
"7695ce551d265",
"a508bb932959c",
"a35baf2e93843",
"a6d311a93600a",
"afb3043c7b2b3",
"9d5247ab588e0",
]
assert theProject.projTree.handles() == oldOrder
assert theProject.setTreeOrder(newOrder)
assert theProject.projTree.handles() == newOrder
assert theProject.setTreeOrder(oldOrder)
assert theProject.projTree.handles() == oldOrder
# Change status
theProject.projTree["a35baf2e93843"].setStatus("Finished")
theProject.projTree["a6d311a93600a"].setStatus("Draft")
theProject.projTree["f5ab3e30151e1"].setStatus("Note")
theProject.projTree["8c659a11cd429"].setStatus("Finished")
newList = [
("New", 1, 1, 1, "New"),
("Draft", 2, 2, 2, "Note"), # These are swapped
("Note", 3, 3, 3, "Draft"), # These are swapped
("Edited", 4, 4, 4, "Finished"), # Renamed
("Finished", 5, 5, 5, None), # New, with reused name
]
assert theProject.setStatusColours(newList)
assert theProject.statusItems._theLabels == [
"New", "Draft", "Note", "Edited", "Finished"
]
assert theProject.statusItems._theColours == [(1, 1, 1), (2, 2, 2),
(3, 3, 3), (4, 4, 4),
(5, 5, 5)]
assert theProject.projTree[
"a35baf2e93843"].itemStatus == "Edited" # Renamed
assert theProject.projTree["a6d311a93600a"].itemStatus == "Note" # Swapped
assert theProject.projTree["f5ab3e30151e1"].itemStatus == "Draft" # Swapped
assert theProject.projTree[
"8c659a11cd429"].itemStatus == "Edited" # Renamed
# Change importance
fHandle = theProject.newFile("Jane Doe", nwItemClass.CHARACTER,
"afb3043c7b2b3")
theProject.projTree[fHandle].setImport("Main")
newList = [
("New", 1, 1, 1, "New"),
("Minor", 2, 2, 2, "Minor"),
("Major", 3, 3, 3, "Major"),
("Min", 4, 4, 4, "Main"),
("Max", 5, 5, 5, None),
]
assert theProject.setImportColours(newList)
assert theProject.importItems._theLabels == [
"New", "Minor", "Major", "Min", "Max"
]
assert theProject.importItems._theColours == [(1, 1, 1), (2, 2, 2),
(3, 3, 3), (4, 4, 4),
(5, 5, 5)]
assert theProject.projTree[fHandle].itemImport == "Min"
# Check status counts
assert theProject.statusItems._theCounts == [0, 0, 0, 0, 0]
assert theProject.importItems._theCounts == [0, 0, 0, 0, 0]
theProject.countStatus()
assert theProject.statusItems._theCounts == [1, 1, 1, 2, 0]
assert theProject.importItems._theCounts == [3, 0, 0, 1, 0]
# Session stats
theProject.currWCount = 200
theProject.lastWCount = 100
with monkeypatch.context() as mp:
mp.setattr("os.path.isdir", lambda *a, **k: False)
assert not theProject._appendSessionStats(idleTime=0)
# Block open
with monkeypatch.context() as mp:
mp.setattr("builtins.open", causeOSError)
assert not theProject._appendSessionStats(idleTime=0)
# Write entry
assert theProject.projMeta == os.path.join(nwMinimal, "meta")
statsFile = os.path.join(theProject.projMeta, nwFiles.SESS_STATS)
theProject.projOpened = 1600002000
theProject.currNovelWC = 200
theProject.currNotesWC = 100
with monkeypatch.context() as mp:
mp.setattr("novelwriter.core.project.time", lambda: 1600005600)
assert theProject._appendSessionStats(idleTime=99)
assert readFile(statsFile) == (
"# Offset 100\n"
"# Start Time End Time Novel Notes Idle\n"
"%s %s 200 100 99\n") % (
formatTimeStamp(1600002000), formatTimeStamp(1600005600))
# Pack XML Value
xElem = etree.Element("element")
theProject._packProjectValue(xElem, "A", "B", allowNone=False)
assert etree.tostring(xElem, pretty_print=False,
encoding="utf-8") == (b"<element><A>B</A></element>")
xElem = etree.Element("element")
theProject._packProjectValue(xElem, "A", "", allowNone=False)
assert etree.tostring(xElem, pretty_print=False,
encoding="utf-8") == (b"<element/>")
# Pack XML Key/Value
xElem = etree.Element("element")
theProject._packProjectKeyValue(xElem, "item", {"A": "B", "C": "D"})
assert etree.tostring(xElem, pretty_print=False,
encoding="utf-8") == (b"<element>"
b"<item>"
b"<entry key=\"A\">B</entry>"
b"<entry key=\"C\">D</entry>"
b"</item>"
b"</element>")
def testCoreProject_OldFormat(mockGUI, nwOldProj):
"""Test that a project folder structure of version 1.0 can be
converted to the latest folder structure. Version 1.0 split the
documents into 'data_0' ... 'data_f' folders, which are now all
contained in a single 'content' folder.
"""
theProject = NWProject(mockGUI)
# Create mock files for known legacy files
deleteFiles = [
os.path.join(nwOldProj, "cache", "nwProject.nwx.0"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.1"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.2"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.3"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.4"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.5"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.6"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.7"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.8"),
os.path.join(nwOldProj, "cache", "nwProject.nwx.9"),
os.path.join(nwOldProj, "meta", "mainOptions.json"),
os.path.join(nwOldProj, "meta", "exportOptions.json"),
os.path.join(nwOldProj, "meta", "outlineOptions.json"),
os.path.join(nwOldProj, "meta", "timelineOptions.json"),
os.path.join(nwOldProj, "meta", "docMergeOptions.json"),
os.path.join(nwOldProj, "meta", "sessionLogOptions.json"),
]
# Add some files that shouldn't be there
deleteFiles.append(os.path.join(nwOldProj, "data_f", "whatnow.nwd"))
deleteFiles.append(os.path.join(nwOldProj, "data_f", "whatnow.txt"))
# Add some folders that shouldn't be there
os.mkdir(os.path.join(nwOldProj, "stuff"))
os.mkdir(os.path.join(nwOldProj, "data_1", "stuff"))
# Create mock files
os.mkdir(os.path.join(nwOldProj, "cache"))
for aFile in deleteFiles:
writeFile(aFile, "Hi")
for aFile in deleteFiles:
assert os.path.isfile(aFile)
# Open project and check that files that are not supposed to be
# there have been removed
assert theProject.openProject(nwOldProj)
for aFile in deleteFiles:
assert not os.path.isfile(aFile)
assert not os.path.isdir(os.path.join(nwOldProj, "data_1", "stuff"))
assert not os.path.isdir(os.path.join(nwOldProj, "data_1"))
assert not os.path.isdir(os.path.join(nwOldProj, "data_7"))
assert not os.path.isdir(os.path.join(nwOldProj, "data_8"))
assert not os.path.isdir(os.path.join(nwOldProj, "data_9"))
assert not os.path.isdir(os.path.join(nwOldProj, "data_a"))
assert not os.path.isdir(os.path.join(nwOldProj, "data_f"))
# Check stuff that has been moved
assert os.path.isdir(os.path.join(nwOldProj, "junk"))
assert os.path.isdir(os.path.join(nwOldProj, "junk", "stuff"))
assert os.path.isfile(os.path.join(nwOldProj, "junk", "whatnow.nwd"))
assert os.path.isfile(os.path.join(nwOldProj, "junk", "whatnow.txt"))
# Check that files we want to keep are in the right place
assert os.path.isdir(os.path.join(nwOldProj, "cache"))
assert os.path.isdir(os.path.join(nwOldProj, "content"))
assert os.path.isdir(os.path.join(nwOldProj, "meta"))
assert os.path.isfile(
os.path.join(nwOldProj, "content", "f528d831f5b24.nwd"))
assert os.path.isfile(
os.path.join(nwOldProj, "content", "88124a4292d8b.nwd"))
assert os.path.isfile(
os.path.join(nwOldProj, "content", "91239bf2f8b69.nwd"))
assert os.path.isfile(
os.path.join(nwOldProj, "content", "19752e7f9d8af.nwd"))
assert os.path.isfile(
os.path.join(nwOldProj, "content", "a764d5acf5a21.nwd"))
assert os.path.isfile(
os.path.join(nwOldProj, "content", "9058ae29f0dfd.nwd"))
assert os.path.isfile(
os.path.join(nwOldProj, "content", "7ff63b8afc4cd.nwd"))
assert os.path.isfile(os.path.join(nwOldProj, "meta", "tagsIndex.json"))
assert os.path.isfile(os.path.join(nwOldProj, "meta", "sessionInfo.log"))
# Close the project
theProject.closeProject()
# Check that new files have been created
assert os.path.isfile(os.path.join(nwOldProj, "meta", "guiOptions.json"))
assert os.path.isfile(os.path.join(nwOldProj, "ToC.txt"))
def testCoreProject_Open(monkeypatch, nwMinimal, mockGUI):
"""Test opening a project.
"""
theProject = NWProject(mockGUI)
# Rename the project file to check handling
rName = os.path.join(nwMinimal, nwFiles.PROJ_FILE)
wName = os.path.join(nwMinimal, nwFiles.PROJ_FILE + "_sdfghj")
os.rename(rName, wName)
assert theProject.openProject(nwMinimal) is False
os.rename(wName, rName)
# Fail on folder structure check
with monkeypatch.context() as mp:
mp.setattr("os.mkdir", causeOSError)
assert theProject.openProject(nwMinimal) is False
# Fail on lock file
theProject.setProjectPath(nwMinimal)
assert theProject._writeLockFile()
assert theProject.openProject(nwMinimal) is False
# Fail to read lockfile (which still opens the project)
with monkeypatch.context() as mp:
mp.setattr("builtins.open", causeOSError)
assert theProject.openProject(nwMinimal) is True
assert theProject.closeProject()
# Force open with lockfile
theProject.setProjectPath(nwMinimal)
assert theProject._writeLockFile()
assert theProject.openProject(nwMinimal, overrideLock=True) is True
assert theProject.closeProject()
# Make a junk XML file
oName = os.path.join(nwMinimal, nwFiles.PROJ_FILE[:-3] + "orig")
bName = os.path.join(nwMinimal, nwFiles.PROJ_FILE[:-3] + "bak")
os.rename(rName, oName)
writeFile(rName, "stuff")
assert theProject.openProject(nwMinimal) is False
# Also write a jun XML backup file
writeFile(bName, "stuff")
assert theProject.openProject(nwMinimal) is False
# Wrong root item
writeFile(rName, "<not_novelWriterXML></not_novelWriterXML>\n")
assert theProject.openProject(nwMinimal) is False
# Wrong file version
writeFile(rName, ("<?xml version='0.0' encoding='utf-8'?>\n"
"<novelWriterXML "
"appVersion=\"1.0\" "
"hexVersion=\"0x01000000\" "
"fileVersion=\"1.0\" "
"timeStamp=\"2020-01-01 00:00:00\">\n"
"</novelWriterXML>\n"))
mockGUI.askResponse = False
assert theProject.openProject(nwMinimal) is False
mockGUI.undo()
# Future file version
writeFile(rName, ("<?xml version='1.0' encoding='utf-8'?>\n"
"<novelWriterXML "
"appVersion=\"1.0\" "
"hexVersion=\"0x01000000\" "
"fileVersion=\"99.99\" "
"timeStamp=\"2020-01-01 00:00:00\">\n"
"</novelWriterXML>\n"))
assert theProject.openProject(nwMinimal) is False
# Update file version
writeFile(rName, ("<?xml version='1.0' encoding='utf-8'?>\n"
"<novelWriterXML "
"appVersion=\"1.0\" "
"hexVersion=\"0xffffffff\" "
"fileVersion=\"1.2\" "
"timeStamp=\"2020-01-01 00:00:00\">\n"
"</novelWriterXML>\n"))
mockGUI.askResponse = False
assert theProject.openProject(nwMinimal) is False
assert mockGUI.lastQuestion[0] == "File Version"
mockGUI.undo()
# Larger hex version
writeFile(rName, ("<?xml version='1.0' encoding='utf-8'?>\n"
"<novelWriterXML "
"appVersion=\"1.0\" "
"hexVersion=\"0xffffffff\" "
"fileVersion=\"%s\" "
"timeStamp=\"2020-01-01 00:00:00\">\n"
"</novelWriterXML>\n") % theProject.FILE_VERSION)
mockGUI.askResponse = False
assert theProject.openProject(nwMinimal) is False
assert mockGUI.lastQuestion[0] == "Version Conflict"
mockGUI.undo()
# Test skipping XML entries
writeFile(rName, ("<?xml version='1.0' encoding='utf-8'?>\n"
"<novelWriterXML "
"appVersion=\"1.0\" "
"hexVersion=\"0x01000000\" "
"fileVersion=\"1.2\" "
"timeStamp=\"2020-01-01 00:00:00\">\n"
"<project><stuff/></project>\n"
"<settings><stuff/></settings>\n"
"</novelWriterXML>\n"))
assert theProject.openProject(nwMinimal) is True
assert theProject.closeProject()
# Clean up XML files
os.unlink(rName)
os.unlink(bName)
os.rename(oName, rName)
# Add some legacy stuff that cannot be removed
writeFile(os.path.join(nwMinimal, "junk"), "stuff")
os.mkdir(os.path.join(nwMinimal, "data_0"))
writeFile(os.path.join(nwMinimal, "data_0", "junk"), "stuff")
mockGUI.clear()
assert theProject.openProject(nwMinimal) is True
assert "data_0" in mockGUI.lastAlert
assert theProject.closeProject()
def testCoreProject_Backup(monkeypatch, mockGUI, nwMinimal, tmpDir):
"""Test the automated backup feature of the project class. The test
creates a backup of the Minimal test project, and then unzips the
backupd file and checks that the project XML file is identical to
the original file.
"""
theProject = NWProject(mockGUI)
assert theProject.openProject(nwMinimal)
# Test faulty settings
# No project
mockGUI.hasProject = False
assert theProject.zipIt(doNotify=False) is False
mockGUI.hasProject = True
# Invalid path
theProject.mainConf.backupPath = None
assert theProject.zipIt(doNotify=False) is False
# Missing project name
theProject.mainConf.backupPath = tmpDir
theProject.projName = ""
assert theProject.zipIt(doNotify=False) is False
# Non-existent folder
theProject.mainConf.backupPath = os.path.join(tmpDir, "nonexistent")
theProject.projName = "Test Minimal"
assert theProject.zipIt(doNotify=False) is False
# Same folder as project (causes infinite loop in zipping)
theProject.mainConf.backupPath = nwMinimal
assert theProject.zipIt(doNotify=False) is False
# Subfolder of project (causes infinite loop in zipping)
theProject.mainConf.backupPath = os.path.join(nwMinimal, "subdir")
assert theProject.zipIt(doNotify=False) is False
# Set a valid folder
theProject.mainConf.backupPath = tmpDir
# Can't make folder
with monkeypatch.context() as mp:
mp.setattr("os.mkdir", causeOSError)
assert theProject.zipIt(doNotify=False) is False
# Can't write archive
with monkeypatch.context() as mp:
mp.setattr("shutil.make_archive", causeOSError)
assert theProject.zipIt(doNotify=False) is False
# Test correct settings
assert theProject.zipIt(doNotify=True) is True
theFiles = os.listdir(os.path.join(tmpDir, "Test Minimal"))
assert len(theFiles) == 1
theZip = theFiles[0]
assert theZip[:12] == "Backup from "
assert theZip[-4:] == ".zip"
# Extract the archive
with ZipFile(os.path.join(tmpDir, "Test Minimal", theZip), "r") as inZip:
inZip.extractall(os.path.join(tmpDir, "extract"))
# Check that the main project file was restored
assert cmpFiles(os.path.join(nwMinimal, "nwProject.nwx"),
os.path.join(tmpDir, "extract", "nwProject.nwx"))
def testCoreIndex_LoadSave(monkeypatch, nwLipsum, mockGUI, outDir, refDir):
"""Test core functionality of scaning, saving, loading and checking
the index cache file.
"""
projFile = os.path.join(nwLipsum, "meta", "tagsIndex.json")
testFile = os.path.join(outDir, "coreIndex_LoadSave_tagsIndex.json")
compFile = os.path.join(refDir, "coreIndex_LoadSave_tagsIndex.json")
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
assert theProject.openProject(nwLipsum)
theIndex = NWIndex(theProject)
notIndexable = {
"b3643d0f92e32": False, # Novel ROOT
"45e6b01ca35c1": False, # Chapter One FOLDER
"6bd935d2490cd": False, # Chapter Two FOLDER
"67a8707f2f249": False, # Character ROOT
"6c6afb1247750": False, # Plot ROOT
"60bdf227455cc": False, # World ROOT
}
for tItem in theProject.projTree:
assert theIndex.reIndexHandle(tItem.itemHandle) is notIndexable.get(
tItem.itemHandle, True)
assert theIndex.reIndexHandle(None) is False
# Make the save fail
with monkeypatch.context() as mp:
mp.setattr("builtins.open", causeException)
assert theIndex.saveIndex() is False
# Make the save pass
assert theIndex.saveIndex() is True
# Take a copy of the index
tagIndex = str(theIndex._tagIndex)
refIndex = str(theIndex._refIndex)
fileIndex = str(theIndex._fileIndex)
textCounts = str(theIndex._fileMeta)
# Delete a handle
assert theIndex._tagIndex.get("Bod", None) is not None
assert theIndex._refIndex.get("4c4f28287af27", None) is not None
assert theIndex._fileIndex.get("4c4f28287af27", None) is not None
assert theIndex._fileMeta.get("4c4f28287af27", None) is not None
theIndex.deleteHandle("4c4f28287af27")
assert theIndex._tagIndex.get("Bod", None) is None
assert theIndex._refIndex.get("4c4f28287af27", None) is None
assert theIndex._fileIndex.get("4c4f28287af27", None) is None
assert theIndex._fileMeta.get("4c4f28287af27", None) is None
# Clear the index
theIndex.clearIndex()
assert theIndex._tagIndex == {}
assert theIndex._refIndex == {}
assert theIndex._fileIndex == {}
assert theIndex._fileMeta == {}
# Make the load fail
with monkeypatch.context() as mp:
mp.setattr(json, "load", causeException)
assert theIndex.loadIndex() is False
# Make the load pass
assert theIndex.loadIndex() is True
assert str(theIndex._tagIndex) == tagIndex
assert str(theIndex._refIndex) == refIndex
assert str(theIndex._fileIndex) == fileIndex
assert str(theIndex._fileMeta) == textCounts
# Break the index and check that we notice
assert theIndex.indexBroken is False
theIndex._tagIndex["Bod"].append("Stuff")
theIndex._checkIndex()
assert theIndex.indexBroken is True
# Finalise
assert theProject.closeProject() is True
copyfile(projFile, testFile)
assert cmpFiles(testFile, compFile)
def testCoreIndex_ExtractData(nwMinimal, mockGUI):
"""Check the index data extraction functions.
"""
theProject = NWProject(mockGUI)
theProject.projTree.setSeed(42)
assert theProject.openProject(nwMinimal) is True
theIndex = NWIndex(theProject)
nHandle = theProject.newFile("Hello", nwItemClass.NOVEL, "a508bb932959c")
cHandle = theProject.newFile("Jane", nwItemClass.CHARACTER,
"afb3043c7b2b3")
assert theIndex.getNovelData("", "") is None
assert theIndex.getNovelData("a508bb932959c", "") is None
assert theIndex.scanText(cHandle, ("# Jane Smith\n" "@tag: Jane\n"))
assert theIndex.scanText(nHandle, ("# Hello World!\n"
"@pov: Jane\n"
"@char: Jane\n\n"
"% this is a comment\n\n"
"This is a story about Jane Smith.\n\n"
"Well, not really.\n"))
# The novel structure should contain the pointer to the novel file header
theKeys = []
for aKey, _, _, _ in theIndex.novelStructure():
theKeys.append(aKey)
assert theKeys == ["%s:T000001" % nHandle]
# Check that excluded files can be skipped
theProject.projTree[nHandle].setExported(False)
theKeys = []
for aKey, _, _, _ in theIndex.novelStructure(skipExcluded=False):
theKeys.append(aKey)
assert theKeys == ["%s:T000001" % nHandle]
theKeys = []
for aKey, _, _, _ in theIndex.novelStructure(skipExcluded=True):
theKeys.append(aKey)
assert theKeys == []
theKeys = []
for aKey, _, _, _ in theIndex.novelStructure():
theKeys.append(aKey)
assert theKeys == []
# The novel file should have the correct counts
cC, wC, pC = theIndex.getCounts(nHandle)
assert cC == 62 # Characters in text and title only
assert wC == 12 # Words in text and title only
assert pC == 2 # Paragraphs in text only
# getReferences
# =============
# Look up an ivalid handle
theRefs = theIndex.getReferences("Not a handle")
assert theRefs["@pov"] == []
assert theRefs["@char"] == []
# The novel file should now refer to Jane as @pov and @char
theRefs = theIndex.getReferences(nHandle)
assert theRefs["@pov"] == ["Jane"]
assert theRefs["@char"] == ["Jane"]
# getBackReferenceList
# ====================
# None handle should return an empty dict
assert theIndex.getBackReferenceList(None) == {}
# The character file should have a record of the reference from the novel file
theRefs = theIndex.getBackReferenceList(cHandle)
assert theRefs == {nHandle: "T000001"}
# getTagSource
# ============
assert theIndex.getTagSource("Jane") == (cHandle, 2, "T000001")
assert theIndex.getTagSource("John") == (None, 0, "T000000")
# getCounts
# =========
# For whole text and sections
# Get section counts for a novel file
assert theIndex.scanText(
nHandle, ("# Hello World!\n"
"@pov: Jane\n"
"@char: Jane\n\n"
"% this is a comment\n\n"
"This is a story about Jane Smith.\n\n"
"Well, not really.\n\n"
"# Hello World!\n"
"@pov: Jane\n"
"@char: Jane\n\n"
"% this is a comment\n\n"
"This is a story about Jane Smith.\n\n"
"Well, not really. She's still awesome though.\n"))
# Whole document
cC, wC, pC = theIndex.getCounts(nHandle)
assert cC == 152
assert wC == 28
assert pC == 4
# First part
cC, wC, pC = theIndex.getCounts(nHandle, "T000001")
assert cC == 62
assert wC == 12
assert pC == 2
# Second part
cC, wC, pC = theIndex.getCounts(nHandle, "T000011")
assert cC == 90
assert wC == 16
assert pC == 2
# Get section counts for a note file
assert theIndex.scanText(
cHandle, ("# Hello World!\n"
"@pov: Jane\n"
"@char: Jane\n\n"
"% this is a comment\n\n"
"This is a story about Jane Smith.\n\n"
"Well, not really.\n\n"
"# Hello World!\n"
"@pov: Jane\n"
"@char: Jane\n\n"
"% this is a comment\n\n"
"This is a story about Jane Smith.\n\n"
"Well, not really. She's still awesome though.\n"))
# Whole document
cC, wC, pC = theIndex.getCounts(cHandle)
assert cC == 152
assert wC == 28
assert pC == 4
# First part
cC, wC, pC = theIndex.getCounts(cHandle, "T000001")
assert cC == 62
assert wC == 12
assert pC == 2
# Second part
cC, wC, pC = theIndex.getCounts(cHandle, "T000011")
assert cC == 90
assert wC == 16
assert pC == 2
# Novel Stats
# ===========
hHandle = theProject.newFile("Chapter", nwItemClass.NOVEL, "a508bb932959c")
sHandle = theProject.newFile("Scene One", nwItemClass.NOVEL,
"a508bb932959c")
tHandle = theProject.newFile("Scene Two", nwItemClass.NOVEL,
"a508bb932959c")
theProject.projTree[hHandle].itemLayout == nwItemLayout.DOCUMENT
theProject.projTree[sHandle].itemLayout == nwItemLayout.DOCUMENT
theProject.projTree[tHandle].itemLayout == nwItemLayout.DOCUMENT
assert theIndex.scanText(hHandle, "## Chapter One\n\n")
assert theIndex.scanText(sHandle, "### Scene One\n\n")
assert theIndex.scanText(tHandle, "### Scene Two\n\n")
assert theIndex._listNovelHandles(False) == [
nHandle, hHandle, sHandle, tHandle
]
assert theIndex._listNovelHandles(True) == [hHandle, sHandle, tHandle]
# Add a fake handle to the tree and check that it's ignored
theProject.projTree._treeOrder.append("0000000000000")
assert theIndex._listNovelHandles(False) == [
nHandle, hHandle, sHandle, tHandle
]
theProject.projTree._treeOrder.remove("0000000000000")
# Extract stats
assert theIndex.getNovelWordCount(False) == 34
assert theIndex.getNovelWordCount(True) == 6
assert theIndex.getNovelTitleCounts(False) == [0, 2, 1, 2, 0]
assert theIndex.getNovelTitleCounts(True) == [0, 0, 1, 2, 0]
# Table of Contents
assert theIndex.getTableOfContents(0, True) == []
assert theIndex.getTableOfContents(1, True) == []
assert theIndex.getTableOfContents(2, True) == [
("%s:T000001" % hHandle, 2, "Chapter One", 6),
]
assert theIndex.getTableOfContents(3, True) == [
("%s:T000001" % hHandle, 2, "Chapter One", 2),
("%s:T000001" % sHandle, 3, "Scene One", 2),
("%s:T000001" % tHandle, 3, "Scene Two", 2),
]
assert theIndex.getTableOfContents(0, False) == []
assert theIndex.getTableOfContents(1, False) == [
("%s:T000001" % nHandle, 1, "Hello World!", 12),
("%s:T000011" % nHandle, 1, "Hello World!", 22),
]
# Header Word Counts
bHandle = "0000000000000"
assert theIndex.getHandleWordCounts(bHandle) == []
assert theIndex.getHandleWordCounts(hHandle) == [("%s:T000001" % hHandle,
2)]
assert theIndex.getHandleWordCounts(sHandle) == [("%s:T000001" % sHandle,
2)]
assert theIndex.getHandleWordCounts(tHandle) == [("%s:T000001" % tHandle,
2)]
assert theIndex.getHandleWordCounts(nHandle) == [
("%s:T000001" % nHandle, 12), ("%s:T000011" % nHandle, 16)
]
assert theProject.closeProject()
# Header Record
bHandle = "0000000000000"
assert theIndex.getHandleHeaders(bHandle) == []
assert theIndex.getHandleHeaders(hHandle) == [("T000001", "H2",
"Chapter One")]
assert theIndex.getHandleHeaders(sHandle) == [("T000001", "H3",
"Scene One")]
assert theIndex.getHandleHeaders(tHandle) == [("T000001", "H3",
"Scene Two")]
assert theIndex.getHandleHeaders(nHandle) == [
("T000001", "H1", "Hello World!"), ("T000011", "H1", "Hello World!")
]
def testCoreIndex_LoadSave(monkeypatch, nwLipsum, mockGUI, outDir, refDir):
"""Test core functionality of scaning, saving, loading and checking
the index cache file.
"""
projFile = os.path.join(nwLipsum, "meta", "tagsIndex.json")
testFile = os.path.join(outDir, "coreIndex_LoadSave_tagsIndex.json")
compFile = os.path.join(refDir, "coreIndex_LoadSave_tagsIndex.json")
theProject = NWProject(mockGUI)
assert theProject.openProject(nwLipsum)
theIndex = NWIndex(theProject)
assert repr(theIndex) == "<NWIndex project='Lorem Ipsum'>"
notIndexable = {
"b3643d0f92e32": False, # Novel ROOT
"45e6b01ca35c1": False, # Chapter One FOLDER
"6bd935d2490cd": False, # Chapter Two FOLDER
"67a8707f2f249": False, # Character ROOT
"6c6afb1247750": False, # Plot ROOT
"60bdf227455cc": False, # World ROOT
}
for tItem in theProject.tree:
assert theIndex.reIndexHandle(tItem.itemHandle) is notIndexable.get(
tItem.itemHandle, True)
assert theIndex.reIndexHandle(None) is False
# Make the save fail
with monkeypatch.context() as mp:
mp.setattr("builtins.open", causeException)
assert theIndex.saveIndex() is False
# Make the save pass
assert theIndex.saveIndex() is True
# Take a copy of the index
tagIndex = str(theIndex._tagsIndex.packData())
itemsIndex = str(theIndex._itemIndex.packData())
# Delete a handle
assert theIndex._tagsIndex["Bod"] is not None
assert theIndex._itemIndex["4c4f28287af27"] is not None
theIndex.deleteHandle("4c4f28287af27")
assert theIndex._tagsIndex["Bod"] is None
assert theIndex._itemIndex["4c4f28287af27"] is None
# Clear the index
theIndex.clearIndex()
assert theIndex._tagsIndex._tags == {}
assert theIndex._itemIndex._items == {}
# Make the load fail
with monkeypatch.context() as mp:
mp.setattr(json, "load", causeException)
assert theIndex.loadIndex() is False
assert theIndex.indexBroken is True
# Make the load pass
assert theIndex.loadIndex() is True
assert theIndex.indexBroken is False
assert str(theIndex._tagsIndex.packData()) == tagIndex
assert str(theIndex._itemIndex.packData()) == itemsIndex
# Check File
copyfile(projFile, testFile)
assert cmpFiles(testFile, compFile)
# Write an emtpy index file and load it
writeFile(projFile, "{}")
assert theIndex.loadIndex() is False
assert theIndex.indexBroken is True
# Write an index file that passes loading, but is still empty
writeFile(projFile, '{"tagsIndex": {}, "itemIndex": {}}')
assert theIndex.loadIndex() is True
assert theIndex.indexBroken is False
# Check that the index is re-populated
assert "04468803b92e1" in theIndex._itemIndex
assert "2426c6f0ca922" in theIndex._itemIndex
assert "441420a886d82" in theIndex._itemIndex
assert "47666c91c7ccf" in theIndex._itemIndex
assert "4c4f28287af27" in theIndex._itemIndex
assert "846352075de7d" in theIndex._itemIndex
assert "88243afbe5ed8" in theIndex._itemIndex
assert "88d59a277361b" in theIndex._itemIndex
assert "8c58a65414c23" in theIndex._itemIndex
assert "db7e733775d4d" in theIndex._itemIndex
assert "eb103bc70c90c" in theIndex._itemIndex
assert "f8c0562e50f1b" in theIndex._itemIndex
assert "f96ec11c6a3da" in theIndex._itemIndex
assert "fb609cd8319dc" in theIndex._itemIndex
assert "7a992350f3eb6" in theIndex._itemIndex
# Finalise
assert theProject.closeProject() is True
