def test_notebook_move_deja_vu(self):
"""Move a unicode titled node."""
book = notebook.NoteBook()
book.load(_notebook_file)
deja = notebook.new_page(book, u'Déjà vu again')
nodex = book.get_node_by_id(self._pagex_nodeid)
deja.move(nodex)
# clean up.
deja.delete()
book.close()
def test_bad_index(self):
# initialize two notebooks
make_clean_dir(_tmpdir)
book = notebook.NoteBook()
book.create(_tmpdir + "/n1")
book.close()
# corrupt index
out = open(_tmpdir + "/n1/__NOTEBOOK__/index.sqlite", "w")
out.write("jsakhdfjhdsfh")
out.close()
# try to load again
book = notebook.NoteBook()
book.load(_tmpdir + "/n1")
self.assertFalse(book._conn._index.is_corrupt())
self.assertTrue(book.index_needed())
book.close()
def test_notebook_search_titles(self):
"""Search notebook titles."""
book = notebook.NoteBook()
book.load(_notebook_file)
results = book.search_node_titles("Page X")
self.assertTrue(self._pagex_nodeid in (nodeid
for nodeid, title in results))
results = book.search_node_titles("Page")
self.assertTrue(len(results) >= 7)
book.close()
def test_high(self):
old_version = 'HIGH'
new_version = notebook.NOTEBOOK_FORMAT_VERSION
notebook_filename = setup_old_notebook(old_version, new_version)
book = notebook.NoteBook()
try:
book.load(notebook_filename)
except notebook.NoteBookVersionError:
print "Correctly detects version error"
else:
print "Error not detected"
self.assert_(False)
def test_rename(self):
struct = [["a", ["a1"], ["a2"], ["a3"]],
["b", ["b1"], ["b2", ["c1"], ["c2"]]]]
# initialize a notebook
make_clean_dir(_datapath)
print "creating notebook"
book = notebook.NoteBook()
book.create(_datapath + "/n1")
make_notebook(book, struct)
c1 = book.get_children()[1].get_children()[1].get_children()[0]
c1.rename("new c1")
book.close()
print "load"
book = notebook.NoteBook()
book.load(_datapath + "/n1")
display_notebook(book)
book.close()
def test_notebook_schema(self):
"""
Full HTTP Notebook should enfore schema with nodeid usage.
"""
# Make pure memory notebook.
self.conn = mem.NoteBookConnectionMem()
self.notebook = notebooklib.NoteBook()
self.notebook.create('', self.conn)
# Start server in another thread
host = "localhost"
self.port = 8124
url = "http://%s:%d/notebook/" % (host, self.port)
server = NoteBookHttpServer(self.conn, port=self.port)
thread.start_new_thread(server.serve_forever, ())
# Connect to server.
self.conn2 = NoteBookConnectionHttp()
self.conn2.connect(url)
self.wait_for_server(self.conn2)
# Test new node without specifying nodeid.
attr = {
"key1": 123,
"key2": 456,
}
data = urllib.urlopen(url + 'nodes/', json.dumps(attr)).read()
nodeid = json.loads(data)['nodeid']
data = urllib.urlopen(url + 'nodes/%s' % nodeid).read()
attr2 = json.loads(data)
attr['nodeid'] = nodeid
self.assertEqual(attr, attr2)
# Test new node without specifying nodeid and with auto set.
attr = {
"key1": 123,
"key2": 456,
}
data = urllib.urlopen(url + 'nodes/?auto', json.dumps(attr)).read()
nodeid = json.loads(data)['nodeid']
data = urllib.urlopen(url + 'nodes/%s' % nodeid).read()
attr2 = json.loads(data)
attr["nodeid"] = nodeid
self.assertEqual(attr, attr2)
# Close server.
server.shutdown()
def test_notebook_lookup_node(self):
export_filename = "test/tmp/notebook_export"
app = keepnote.KeepNote()
app.init()
ext = app.get_extension("export_html")
print("loading notebook...")
book = notebooklib.NoteBook()
book.load("test/data/notebook-v3")
print("clearing output...")
if os.path.exists(export_filename):
shutil.rmtree(export_filename)
print("exporting...")
ext.export_notebook(book, export_filename)
def test_install_icon(self):
"""
Test whether icon installing works correctly.
"""
book = notebook.NoteBook()
book.load(self.filename)
files_before = sorted(
os.listdir(self.filename + "/__NOTEBOOK__/icons"))
self.assertEqual(files_before, ['zip-2.png', 'zip.png'])
# Install the same icon twice.
book.install_icon("share/icons/gnome/16x16/mimetypes/zip.png")
book.install_icon("share/icons/gnome/16x16/mimetypes/zip.png")
book.install_icons(
"keepnote/images/node_icons/folder-orange.png",
"keepnote/images/node_icons/folder-orange-open.png")
book.install_icons(
"keepnote/images/node_icons/folder-orange.png",
"keepnote/images/node_icons/folder-orange-open.png")
book.save()
# Check that unique names were given.
files_after = sorted(os.listdir(self.filename + "/__NOTEBOOK__/icons"))
self.assertEqual(
files_after,
['folder-orange-2-open.png',
'folder-orange-2.png',
'folder-orange-open.png',
'folder-orange.png',
'zip-2.png',
'zip-3.png',
'zip-4.png',
'zip.png'])
# Check that uninstalling works.
for icon in files_after:
book.uninstall_icon(icon)
clean_icons = sorted(os.listdir(self.filename + "/__NOTEBOOK__/icons"))
self.assertEqual(clean_icons, [])
book.close()
def test_v5_to_latest(self):
# Setup paths.
old_version = 5
new_version = notebook.NOTEBOOK_FORMAT_VERSION
notebook_filename = setup_old_notebook(old_version, new_version)
# Update notebook (in place).
update.update_notebook(notebook_filename, new_version, verify=True)
# Load new notebook.
book = notebook.NoteBook()
book.load(notebook_filename)
# Test for common error.
old_title = 'Test Example Notebook'
self.assertEqual(book.get_title(), old_title)
book.close()
def test_notebook_read_icons(self):
"""
Test whether icon preferences are stored correctly.
"""
# Set quick icons.
book = notebook.NoteBook()
book.load(self.filename)
book.pref.set_quick_pick_icons(["x.png"])
book.set_preferences_dirty()
book.save()
# Assert that we can read them.
self.assertEqual(book.pref.get_quick_pick_icons(), ["x.png"])
book.close()
book.load(self.filename)
self.assertEqual(book.pref.get_quick_pick_icons(), ["x.png"])
book.close()
def test_bad_notebook_pref(self):
# initialize two notebooks
make_clean_dir(_tmpdir)
book = notebook.NoteBook()
book.create(_tmpdir + "/n1")
book.close()
# corrupt preference data
out = open(_tmpdir + "/n1/notebook.nbk", "w")
out.write("***bad preference***")
out.close()
# try to load again
def func():
book = notebook.NoteBook()
book.load(_tmpdir + "/n1")
self.assertRaises(notebook.NoteBookError, func)
def test_bad_node(self):
# initialize two notebooks
make_clean_dir(_tmpdir)
book = notebook.NoteBook()
book.create(_tmpdir + "/n1")
book.close()
# corrupt node
out = open(_tmpdir + "/n1/node.xml", "w")
out.write("***bad node***")
out.close()
# try to load again, should raise error.
def func():
book = notebook.NoteBook()
book.load(_tmpdir + "/n1")
self.assertRaises(ConnectionError, func)
def test_notebook_threads(self):
"""Access a notebook in another thread"""
test = self
book = notebook.NoteBook()
book.load(_notebook_file)
class Task(threading.Thread):
def run(self):
try:
results = list(book.search_node_contents('world'))
test.assertTrue(len(results) == 2)
except Exception as e:
traceback.print_exception(*sys.exc_info())
raise e
task = Task()
task.start()
task.join()
book.close()
def test_new_node(self):
clean_dir("test/tmp/notebook_new_node")
shutil.copytree("test/data/notebook-v6", "test/tmp/notebook_new_node")
book = notebook.NoteBook()
book.load("test/tmp/notebook_new_node")
for n in book.index_all():
pass
start = time.time()
n = book.get_node_by_id("76363514-ac2c-4090-a348-58aa1721db68")
print(n)
for i in range(100):
print(i)
notebook.new_page(n, str(i))
t = time.time() - start
print("seconds: ", t)
book.close()
def setUpClass(cls):
# Create a simple notebook to test against.
clean_dir(_notebook_file)
cls._notebook = book = notebook.NoteBook()
book.create(_notebook_file)
# create simple nodes
page1 = notebook.new_page(book, 'Page 1')
pagea = notebook.new_page(page1, 'Page A')
write_content(pagea, 'hello world')
pageb = notebook.new_page(page1, 'Page B')
write_content(pageb, 'why hello, what is new?')
pagec = notebook.new_page(page1, 'Page C')
write_content(pagec, 'brand new world')
pagex = notebook.new_page(pageb, 'Page X')
cls._pagex_nodeid = pagex.get_attr('nodeid')
notebook.new_page(book, 'Page 2')
notebook.new_page(book, 'Page 3')
book.close()
def test_v4_to_latest(self):
# Setup paths.
old_version = 4
new_version = notebook.NOTEBOOK_FORMAT_VERSION
notebook_filename = setup_old_notebook(old_version, new_version)
# Load old notebook.
book = notebook_v4.NoteBook()
book.load(notebook_filename)
old_attrs = dict(book._attr)
book.close()
# Update notebook (in place).
update.update_notebook(notebook_filename, new_version, verify=True)
# Load new notebook.
book = notebook.NoteBook()
book.load(notebook_filename)
# Test for common error.
self.assertEqual(book.get_title(), old_attrs['title'])
book.close()
def test_notebook1_to_2(self):
self.setUp_buffer()
if os.path.exists("test/tmp/notebook-v1-2"):
shutil.rmtree("test/tmp/notebook-v1-2")
shutil.copytree("test/data/notebook-v1", "test/tmp/notebook-v1-2")
book = notebook.NoteBook()
book.load("test/tmp/notebook-v1-2")
book.save(force=True)
def walk(node):
if node.get_attr("content_type") == "text/xhtml+xml":
print "rewrite", node.get_data_file()
filename = node.get_data_file()
self.buffer.clear()
infile = open(filename)
self.read(self.buffer, infile)
infile.close()
outfile = open(filename, "w")
self.write(self.buffer, outfile)
outfile.close()
for child in node.get_children():
walk(child)
walk(book)
# should be no differences
print "differences"
os.system(
"diff -r test/data/notebook-v1 test/tmp/notebook-v1-2 > test/tmp/notebook-v1-2.tmp"
)
def test_notebook_threads2(self):
""""""
test = self
error = [False]
print
book = notebook.NoteBook()
book.load(_notebook_file)
def process(book, name):
for i in range(100):
print i, name
results = list(book.search_node_contents('world'))
test.assertTrue(len(results) == 2)
time.sleep(.001)
class Task(threading.Thread):
def run(self):
try:
process(book, 'B')
except Exception, e:
error[0] = True
traceback.print_exception(type(e), e, sys.exc_info()[2])
raise e
def update_old(task):
notebook = notebooklib.NoteBook()
notebook.load(filename)
task.set_result(notebook)
def update_notebook(filename, desired_version, warn=lambda w: False,
verify=True):
"""Updates a notebook to the desired version (downgrading not implemented)"""
# try to open notebook (may raise exceptions)
version = notebooklib.get_notebook_version(filename)
if version >= desired_version:
return
while version < desired_version:
# upgrade 1 --> 2
if version == 1:
notebook_update_v1_2.update_notebook(filename, 2, warn=warn,
verify=verify)
version = 2
# upgrade 2 --> 3
elif version == 2:
from keepnote.compat import notebook_v2 as old_notebooklib
# try to load old notebook (may raise exceptions)
notebook = old_notebooklib.NoteBook()
notebook.load(filename)
# write new notebook preference file
notebook.pref.version = 3
notebook.write_preferences()
# recursively upgrade notes
def walk(node):
try:
node._version = 3
node.write_meta_data()
except Exception, e:
if not warn(e):
raise notebooklib.NoteBookError("Could not update notebook", e)
# recurse
for child in node.get_children():
walk(child)
walk(notebook)
version = notebook.pref.version
# verify notebook updated successfully
if verify:
notebook = notebooklib.NoteBook()
notebook.load(filename)
def walk(node):
for child in node.get_children():
walk(child)
walk(notebook)
notebook.close()
# upgrade 3 --> 4
elif version == 3:
from keepnote.compat import notebook_v3 as old_notebooklib
# try to load old notebook (may raise exceptions)
notebook = old_notebooklib.NoteBook()
notebook.load(filename)
notebook.pref.version = 4
old_notebooklib.write_new_preferences(notebook.pref,
notebook.get_pref_file())
notebook.close()
version = 4
class KeepNote(keepnote.KeepNote):
"""GUI version of the KeepNote application instance"""
def __init__(self, basedir=None):
keepnote.KeepNote.__init__(self, basedir)
# window management
self._current_window = None
self._windows = []
# shared gui resources
self._tag_table = keepnote.gui.richtext.richtext_tags.RichTextTagTable(
)
self.app_options_dialog = keepnote.gui.dialog_app_options.ApplicationOptionsDialog(
self)
self.node_icon_dialog = keepnote.gui.dialog_node_icon.NodeIconDialog(
self)
# auto save
self._auto_saving = False # True if autosave is on
self._auto_save_registered = False # True if autosave is registered
self._auto_save_pause = 0 # >0 if autosave is paused
def init(self):
"""Initialize application from disk"""
keepnote.KeepNote.init(self)
def set_lang(self):
"""Set language for application"""
keepnote.KeepNote.set_lang(self)
# setup glade with gettext
import gtk.glade
gtk.glade.bindtextdomain(keepnote.GETTEXT_DOMAIN,
keepnote.get_locale_dir())
gtk.glade.textdomain(keepnote.GETTEXT_DOMAIN)
def load_preferences(self):
keepnote.KeepNote.load_preferences(self)
# set defaults for auto save
p = self.pref
use_autosave = p.get("autosave", default=True)
p.get("autosave_time", default=keepnote.DEFAULT_AUTOSAVE_TIME)
self.begin_auto_save()
#=================================
# GUI
def get_richtext_tag_table(self):
"""Returns the application-wide richtext tag table"""
return self._tag_table
def new_window(self):
"""Create a new main window"""
import keepnote.gui.main_window
window = keepnote.gui.main_window.KeepNoteWindow(self)
window.connect("delete-event", self._on_window_close)
window.connect("focus-in-event", self._on_window_focus)
self._windows.append(window)
self.init_extensions_windows([window])
window.show_all()
return window
def get_current_window(self):
"""Returns the currenly active window"""
return self._current_window
def get_windows(self):
"""Returns a list of open windows"""
return self._windows
def open_notebook(self, filename, window=None, task=None):
"""Open notebook"""
from keepnote.gui import dialog_update_notebook
try:
version = notebooklib.get_notebook_version(filename)
except Exception, e:
self.error(
_("Could not load notebook '%s'.") % filename, e,
sys.exc_info()[2])
return None
if version < notebooklib.NOTEBOOK_FORMAT_VERSION:
dialog = dialog_update_notebook.UpdateNoteBookDialog(self, window)
if not dialog.show(filename, version=version, task=task):
self.error(_("Cannot open notebook (version too old)"))
return None
# try to open notebook
try:
notebook = notebooklib.NoteBook()
notebook.load(filename)
except notebooklib.NoteBookVersionError, e:
self.error(
_("This version of %s cannot read this notebook.\n"
"The notebook has version %d. %s can only read %d.") %
(keepnote.PROGRAM_NAME, e.notebook_version,
keepnote.PROGRAM_NAME, e.readable_version), e,
sys.exc_info()[2])
return None
def test_create_unicode_node(self):
"""Create a node with a unicode title."""
book = notebook.NoteBook()
book.load(_notebook_file)
notebook.new_page(book, u'Déjà vu')
book.close()
def func():
book = notebook.NoteBook()
book.load(_tmpdir + "/n1")
def update_notebook(filename,
desired_version=notebooklib.NOTEBOOK_FORMAT_VERSION,
warn=lambda w: False,
verify=True):
"""Updates a notebook to the desired version (downgrading not implemented)"""
# try to open notebook (may raise exceptions)
version = notebooklib.get_notebook_version(filename)
if version >= desired_version:
return
while version < desired_version:
# upgrade 1 --> 2
if version == 1:
notebook_update_v1_2.update_notebook(filename,
2,
warn=warn,
verify=verify)
version = 2
# upgrade 2 --> 3
elif version == 2:
from keepnote.compat import notebook_v2 as old_notebooklib
# try to load old notebook (may raise exceptions)
notebook = old_notebooklib.NoteBook()
notebook.load(filename)
# write new notebook preference file
notebook.pref.version = 3
notebook.write_preferences()
# recursively upgrade notes
def walk(node):
try:
node._version = 3
node.write_meta_data()
except Exception as e:
if not warn(e):
raise notebooklib.NoteBookError(
"Could not update notebook", e)
# recurse
for child in node.get_children():
walk(child)
walk(notebook)
version = notebook.pref.version
# verify notebook updated successfully
if verify:
notebook = notebooklib.NoteBook()
notebook.load(filename)
def walk(node):
for child in node.get_children():
walk(child)
walk(notebook)
notebook.close()
# upgrade 3 --> 4
elif version == 3:
from keepnote.compat import notebook_v3 as old_notebooklib
# try to load old notebook (may raise exceptions)
notebook = old_notebooklib.NoteBook()
notebook.load(filename)
notebook.pref.version = 4
index_file = os.path.join(notebook.get_pref_dir(), "index.sqlite")
if os.path.exists(index_file):
os.remove(index_file)
old_notebooklib.write_new_preferences(notebook.pref,
notebook.get_pref_file())
notebook.close()
version = 4
# upgrade 4 --> 5
elif version == 4:
from keepnote.compat import notebook_v4 as old_notebooklib
# try to load old notebook (may raise exceptions)
notebook = old_notebooklib.NoteBook()
notebook.load(filename)
notebook.pref.set("version", 5)
notebook.save(force=True)
#if notebook.index_needed():
# notebook.clear_index()
notebook.close()
version = 5
elif version == 5:
notebook_update_v5_6.update(filename)
version = 6
def _test_notebook(self, conn, filename):
# initialize a notebook
book1 = notebook.NoteBook()
book1.create(filename, conn)
book1.set_attr("title", "root")
# populate book
for i in range(5):
node = notebook.new_page(book1, "a%d" % i)
for j in range(2):
notebook.new_page(node, "b%d-%d" % (i, j))
expected = """\
root
a0
b0-0
b0-1
a1
b1-0
b1-1
a2
b2-0
b2-1
a3
b3-0
b3-1
a4
b4-0
b4-1
Trash
"""
# assert structure is correct.
out = StringIO()
display_notebook(book1, out=out)
self.assertEqual(out.getvalue(), expected)
# edit book
nodeid = book1.search_node_titles("a1")[0][0]
node1 = book1.get_node_by_id(nodeid)
nodeid = book1.search_node_titles("b3-0")[0][0]
node2 = book1.get_node_by_id(nodeid)
node1.move(node2)
expected = """\
root
a0
b0-0
b0-1
a2
b2-0
b2-1
a3
b3-0
a1
b1-0
b1-1
b3-1
a4
b4-0
b4-1
Trash
"""
# Assert new structure.
out = StringIO()
display_notebook(book1, out=out)
self.assertEqual(out.getvalue(), expected)
# Assert that file contents are provided.
self.assertEqual(
node1.open_file("page.html").read(), notebook.BLANK_NOTE)
