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)