class EditorTestCase(unittest.TestCase): def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session self.app = app app.update(self.service) notebook = Notebook.from_tuple( self.service.create_notebook('test'), ) self.note = Note.from_tuple(self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=[], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct)) def test_content_nochange(self): """Test content nochange""" editor = Editor(self.note) self.assertEqual( editor.note_edit.content, "New note content", ) for content in CONTENTS: editor.note_edit.content = content self.assertEqual( editor.note_edit.content, content, ) def test_content_changing(self): """Test content changing""" editor = Editor(self.note) for prev, current in CHANGING_CONTENTS: editor.note_edit.content = prev self.assertEqual( editor.note_edit.content, current, ) def test_title_nochange(self): """Test title nochange""" editor = Editor(self.note) self.assertEqual( editor.note_edit.title, "New note", ) for title in TITLES: editor.note_edit.title = title self.assertEqual( editor.note_edit.title, title, )
def setUp(self): self.service = ProviderService() self.session = get_db_session() self.service._session = self.session models.Note.session = self.session self.service.qobject = MagicMock() self.service.app = MagicMock() self.service.sync = MagicMock() factories.invoke_session(self.session)
def setUp(self): self.session = get_db_session(':memory:') self.store = get_note_store(token) self.sc = SyncThread() self.sc.session = self.session self.sc.sq = self.session.query self.sc.note_store = self.store self.sc.auth_token = token self.serv = ProviderService() self.serv._session = self.session models.Note.session = self.session # hack for test
def setUp(self): self.service = ProviderService() self.session = get_db_session() self.service._session = self.session self.service.qobject = MagicMock() self.service.app = MagicMock() self.service.sync = MagicMock()
def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session self.app = app self.app.update(self.service) notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.note = Note.from_tuple(self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=[], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct))
def __init__(self, verbose, *args, **kwargs): App.__init__(self, *args, **kwargs) self.settings = QSettings('everpad', 'everpad-provider') self.verbose = verbose session_bus = dbus.SessionBus() self.bus = dbus.service.BusName("com.everpad.Provider", session_bus) self.service = ProviderService(self, session_bus, '/EverpadProvider') self.sync_thread = SyncThread(self) self.sync_thread.sync_state_changed.connect( Slot(int)(self.service.sync_state_changed), ) self.sync_thread.data_changed.connect( Slot()(self.service.data_changed), ) if get_auth_token(): self.sync_thread.start() self.service.qobject.authenticate_signal.connect( self.on_authenticated, ) self.service.qobject.remove_authenticate_signal.connect( self.on_remove_authenticated, )
def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session self.app = app app.update(self.service) notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.note = Note.from_tuple(self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=[], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct))
class FindTestCase(unittest.TestCase): """Find notes method test case""" def setUp(self): self._create_service() self._create_notebooks() self._create_notes() def _create_notes(self): """Create notes""" notes = [ self.service.create_note(btype.Note( title='New note', content="New note content", tags=['ab', 'cd'], notebook=self.notebook.id, created=const.NONE_VAL, updated=const.NONE_VAL, place='first', pinnded=False, ).struct), self.service.create_note(btype.Note( title='Old note', content="Old note content", tags=['ef', 'gh'], notebook=self.notebook2.id, created=const.NONE_VAL, updated=const.NONE_VAL, place='second', pinnded=False, ).struct), self.service.create_note(btype.Note( title='not', content="oke", tags=['ab', 'gh'], notebook=self.notebook.id, created=const.NONE_VAL, updated=const.NONE_VAL, place='second', pinnded=True, ).struct), self.service.create_note(btype.Note( title=u'Заметка', content=u"Заметка", tags=[u'тэг'], notebook=self.notebook.id, created=const.NONE_VAL, updated=const.NONE_VAL, place=u'место', pinnded=False, ).struct), self.service.create_note(btype.Note( title=u'заметка', content=u"заметка", tags=[u'тэг'], notebook=self.notebook.id, created=const.NONE_VAL, updated=const.NONE_VAL, place=u'место', pinnded=False, ).struct), ] self.notes = btype.Note.list << [ self.service.update_note(note) for note in notes ] def _create_notebooks(self): """Create notebooks""" self.notebook =\ btype.Notebook << self.service.create_notebook('test', None) self.notebook2 =\ btype.Notebook << self.service.create_notebook('test2', None) self.notebook3 =\ btype.Notebook << self.service.create_notebook(u'Блокнот', None) def _create_service(self): """Create service""" self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit def _to_ids(self, items): return set(map(lambda item: item.id, items)) def _find(self, *args, **kwargs): return btype.Note.list << self.service.find_notes(*args, **kwargs) def test_by_words(self): """Test notes find by words""" all_notes = self._find( 'not', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertItemsEqual( self._to_ids(all_notes), self._to_ids(self.notes[:-2]), ) two = self._find( 'note', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertItemsEqual( self._to_ids(two), self._to_ids(self.notes[:2]), ) blank = self._find( 'not note', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertEqual(len(blank), 0) def test_by_tags(self): """Test note find by tags""" tags = btype.Tag.list << self.service.list_tags() first_last = self._find( '', dbus.Array([], signature='i'), [tags[0].id], 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertItemsEqual( self._to_ids(first_last), [self.notes[0].id, self.notes[2].id], ) second = self._find( '', dbus.Array([], signature='i'), [tags[2].id], 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertItemsEqual( self._to_ids(second), [self.notes[1].id], ) all_notes = self._find( '', dbus.Array([], signature='i'), map(lambda tag: tag.id, tags), 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertItemsEqual( self._to_ids(all_notes), self._to_ids(self.notes), ) def test_by_notebooks(self): """Test find note by notebooks""" all_notebooks = self._find( '', self._to_ids([self.notebook, self.notebook2]), dbus.Array([], signature='i'), 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertItemsEqual( self._to_ids(all_notebooks), self._to_ids(self.notes), ) second = self._find( '', [self.notebook2.id], dbus.Array([], signature='i'), 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertItemsEqual( self._to_ids(second), [self.notes[1].id], ) def test_combine(self): """Test find by combination""" places = btype.Place.list << self.service.list_places() tags = btype.Tag.list << self.service.list_tags() first = self._find( 'new', [self.notebook.id], [tags[0].id], places[0].id, 100, const.ORDER_UPDATED_DESC, False, ) self.assertItemsEqual( self._to_ids(first), [self.notes[0].id], ) last = self._find( 'oke', [self.notebook.id], [tags[0].id], places[1].id, 100, const.ORDER_UPDATED_DESC, True, ) self.assertItemsEqual( self._to_ids(last), [self.notes[2].id], ) def test_unicode_ignorecase(self): """Test unicode ignorecase""" all_notes = self._find( u'заметка', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, const.ORDER_UPDATED_DESC, -1, ) self.assertItemsEqual( self._to_ids(all_notes), self._to_ids(self.notes[-2:]), )
class MethodsCase(unittest.TestCase): """Case for dbus shortcuts""" def setUp(self): self.service = ProviderService() self.session = get_db_session() self.service._session = self.session self.service.qobject = MagicMock() self.service.app = MagicMock() self.service.sync = MagicMock() def tearDown(self): self.session.flush() def _create_note(self, **kwargs): """Create note""" note = models.Note( title='note', action=const.ACTION_NONE, **kwargs ) self.session.add(note) self.session.commit() return note def test_get_note(self): """Test get note method""" note = self._create_note() remote_note = btype.Note << self.service.get_note(note.id) self.assertEqual(remote_note.title, note.title) def test_get_note_by_guid(self): """Test get note method""" note = self._create_note(guid='guid') self.session.add(note) self.session.commit() remote_note = btype.Note << self.service.get_note_by_guid(note.guid) self.assertEqual(remote_note.title, note.title) def test_get_note_alternatives(self): """Test get note alternatives""" note = self._create_note(guid='guid') alternative = models.Note( title='title', guid='guid', action=const.ACTION_CONFLICT, conflict_parent_id=note.id, ) self.session.add(alternative) self.session.commit() remote_notes = btype.Note.list << self.service.get_note_alternatives( note.id, ) self.assertEqual(remote_notes[0].id, alternative.id) def test_list_notebooks(self): """Test list notebooks method""" notebooks = [] for name in range(10): notebook = models.Notebook( name=str(name), action=const.ACTION_NONE, ) self.session.add(notebook) self.session.commit() notebooks.append(notebook.id) remote_notebooks = btype.Notebook.list << self.service.list_notebooks() ids = [notebook.id for notebook in remote_notebooks] self.assertItemsEqual(notebooks, ids) def test_get_notebook(self): """Test get notebook method""" notebook = models.Notebook( name='notebook', action=const.ACTION_NONE, ) deleted_notebook = models.Notebook( name='deleted notebook', action=const.ACTION_DELETE, ) self.session.add(notebook) self.session.add(deleted_notebook) self.session.commit() remote_notebook = btype.Notebook << self.service.get_notebook( notebook.id, ) self.assertEqual(notebook.name, remote_notebook.name) with self.assertRaises(DBusException): self.service.get_notebook( deleted_notebook.id, ) def test_get_notebook_notes_count(self): """Test get notebook notes count method""" notebook = models.Notebook( name='notebook', action=const.ACTION_NONE, ) self.session.add(notebook) count = 10 for i in range(count): self.session.add(models.Note( title='note', action=const.ACTION_NONE, notebook=notebook, )) self.session.commit() self.assertEqual( self.service.get_notebook_notes_count(notebook.id), 10, ) def test_update_notebook(self): """Test update notebook method""" notebook = models.Notebook( name='notebook', action=const.ACTION_NONE, ) self.session.add(notebook) self.session.commit() new_name = 'name' notebook_btype = btype.Notebook.from_obj(notebook) notebook_btype.name = new_name notebook_btype = btype.Notebook << self.service.update_notebook( notebook_btype.struct, ) self.assertEqual(notebook_btype.name, new_name) self.assertEqual(notebook.name, new_name) def test_delete_notebook(self): """Test delete notebook""" notebook = models.Notebook( name='notebook', action=const.ACTION_NONE, ) self.session.add(notebook) self.session.commit() self.service.delete_notebook(notebook.id) self.assertEqual(notebook.action, const.ACTION_DELETE) def test_list_tags(self): """Test list tags""" tags = [] for name in range(10): tag = models.Tag( name=str(name), action=const.ACTION_NONE, ) self.session.add(tag) self.session.commit() tags.append(tag.id) remote_tags = btype.Tag.list << self.service.list_tags() tags_ids = [tag.id for tag in remote_tags] self.assertEqual(tags_ids, tags) def test_get_tag_notes_count(self): """Test get tag notes count method""" tag = models.Tag( name='tag', action=const.ACTION_NONE, ) self.session.add(tag) count = 10 for i in range(count): self.session.add(models.Note( title='note', action=const.ACTION_NONE, tags=[tag], )) self.session.commit() self.assertEqual( self.service.get_tag_notes_count(tag.id), 10, ) def test_delete_tag(self): """Test delete tag""" tag = models.Tag( name='tag', action=const.ACTION_NONE, ) self.session.add(tag) self.session.commit() self.service.delete_tag(tag.id) self.assertEqual(tag.action, const.ACTION_DELETE) def test_update_tag(self): """Test update tag method""" tag = models.Tag( name='tag', action=const.ACTION_NONE, ) self.session.add(tag) self.session.commit() new_name = 'name' tag_btype = btype.Tag.from_obj(tag) tag_btype.name = new_name tag_btype = btype.Tag << self.service.update_tag( tag_btype.struct, ) self.assertEqual(tag_btype.name, new_name) self.assertEqual(tag.name, new_name) def test_create_note(self): """Test create note""" title = 'note' note_btype = btype.Note( title=title, tags=[], id=const.NONE_ID, ) note_btype = btype.Note << self.service.create_note( btype.Note >> note_btype, ) note = self.session.query(models.Note).filter( models.Note.id == note_btype.id, ).one() self.assertEqual(note_btype.title, title) self.assertEqual(note.title, title) def test_update_note(self): """Test update note""" note = self._create_note() new_title = 'title' note_btype = btype.Note.from_obj(note) note_btype.title = new_title note_btype = btype.Note << self.service.update_note( note_btype.struct, ) note = self.session.query(models.Note).filter( models.Note.id == note_btype.id, ).one() self.assertEqual(note_btype.title, new_title) self.assertEqual(note.title, new_title) def test_get_note_resources(self): """Test get note resources""" note = self._create_note() resource = models.Resource( file_name='name', action=const.ACTION_NONE, note_id=note.id, ) self.session.add(resource) self.session.commit() resources_btype = btype.Resource.list << self.service.get_note_resources( note.id, ) self.assertEqual(resources_btype[0].file_name, resource.file_name) def test_update_note_resources(self): """Test update note resources""" note = self._create_note() resource = btype.Resource( file_name='test', ) self.service.update_note_resources( note.id, btype.Resource.list >> [resource], ) resource = self.session.query(models.Resource).one() self.assertEqual(resource.file_name, 'test') def test_delete_note(self): """Test delete note""" note = self._create_note() self.service.delete_note(note.id) self.assertEqual(note.action, const.ACTION_DELETE) def test_create_notebook(self): """Test create notebook""" notebook_btype =\ btype.Notebook << self.service.create_notebook('test', 'test') notebook = self.session.query(models.Notebook).filter( models.Notebook.id == notebook_btype.id, ).one() self.assertEqual(notebook.name, 'test') def test_authenticate(self): """Test authenticate""" self.service.authenticate('test') self.service.qobject\ .remove_authenticate_signal.emit.assert_called_once_with() self.service.qobject\ .authenticate_signal.emit.assert_called_once_with('test') def test_remove_authentication(self): """Test remove authentication""" self.service.remove_authentication() self.service.qobject\ .remove_authenticate_signal.emit.assert_called_once_with() def test_list_places(self): """Test list places""" place_ids = [] for num in range(10): place = models.Place( name='{}'.format(num), ) self.session.add(place) self.session.commit() place_ids.append(place.id) places_btype = btype.Place.list << self.service.list_places() for place_btype in places_btype: self.assertIn(place_btype.id, place_ids) def test_share_note(self): """Test share note""" note = self._create_note() self.service.share_note(note.id) self.assertEqual(note.share_status, const.SHARE_NEED_SHARE) self.service.sync.assert_called_once_with() def test_stop_sharing_note(self): """Test stop sharing note""" note = self._create_note(share_status=const.SHARE_SHARED) self.service.stop_sharing_note(note.id) self.assertEqual(note.share_status, const.SHARE_NEED_STOP) self.service.sync.assert_called_once_with() def test_is_first_synced(self): """Test is first synced""" self.assertFalse(self.service.is_first_synced())
class TestProvider(unittest.TestCase): def setUp(self): self.session = get_db_session(':memory:') self.store = get_note_store(token) self.sc = SyncThread() self.sc.session = self.session self.sc.sq = self.session.query self.sc.note_store = self.store self.sc.auth_token = token self.serv = ProviderService() self.serv._session = self.session models.Note.session = self.session # hack for test def test_local_sync(self): note = models.Note( title='test', content='test', action=ACTION_CREATE, ) self.session.add(note) self.sc.local_changes() self.assertEqual( 'test', self.sc.note_store.getNote( token, note.guid, True, False, False, False, ).title, 'sync simple note', ) notebook = models.Notebook( name=str(datetime.now()), default=False, action=ACTION_CREATE, ) self.session.add(notebook) note.notebook = notebook note.action = ACTION_CHANGE self.sc.local_changes() self.assertEqual( notebook.guid, self.sc.note_store.getNote( token, note.guid, True, False, False, False, ).notebookGuid, 'sync note with notebook', ) tag = models.Tag( name=str(datetime.now()), action=ACTION_CREATE, ) self.session.add(tag) note.action = ACTION_CHANGE note.tags = [tag] self.sc.local_changes() self.assertEqual( [tag.guid], self.sc.note_store.getNote( token, note.guid, True, False, False, False, ).tagGuids, 'sync note with tags', ) notebook.name = str(datetime.now()) notebook.action = ACTION_CHANGE self.sc.local_changes() self.assertEqual( notebook.name, self.sc.note_store.getNotebook( token, notebook.guid, ).name, 'sync notebook change', ) tag.name = str(datetime.now()) tag.action = ACTION_CHANGE self.sc.local_changes() self.assertEqual( tag.name, self.sc.note_store.getTag( token, tag.guid, ).name, 'sync tag change', ) note.action = ACTION_DELETE self.sc.local_changes() self.assertIsNotNone(self.sc.note_store.getNote( token, note.guid, True, False, False, False, ), 'remove note') def test_remote_sync(self): notebook = self.sc.note_store.createNotebook( self.sc.auth_token, Notebook( name=str(datetime.now()), defaultNotebook=False, ), ) self.sc.remote_changes() self.assertIsNotNone(self.sc.sq(models.Notebook).filter( models.Notebook.guid == notebook.guid, ).one(), 'sync remote notebook') tag = self.sc.note_store.createTag( self.sc.auth_token, Tag(name=str(datetime.now())), ) self.sc.remote_changes() self.assertIsNotNone(self.sc.sq(models.Tag).filter( models.Tag.guid == tag.guid, ).one(), 'sync remote tag') note = self.sc.note_store.createNote( self.sc.auth_token, Note( title='asd', content=""" <!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd"> <en-note>%s</en-note> """, ) ) self.sc.remote_changes() self.assertIsNotNone(self.sc.sq(models.Note).filter( models.Note.guid == note.guid, ).one(), 'sync remote note') notebook.name = str(datetime.now()) self.sc.note_store.updateNotebook( self.sc.auth_token, notebook, ) self.sc.remote_changes() self.assertEqual(self.sc.sq(models.Notebook).filter( models.Notebook.guid == notebook.guid, ).one().name, notebook.name, 'update local notebook') tag.name = str(datetime.now()) self.sc.note_store.updateTag( self.sc.auth_token, tag, ) self.sc.remote_changes() self.assertEqual(self.sc.sq(models.Tag).filter( models.Tag.guid == tag.guid, ).one().name, tag.name, 'update local tag') note.tagGuids = [] self.sc.note_store.updateNote( self.sc.auth_token, note, ) self.sc.remote_changes() self.assertEqual(self.sc.sq(models.Note).filter( models.Note.guid == note.guid, ).one().tags, [], 'update local note') self.sc.note_store.deleteNote( self.sc.auth_token, note.guid, ) self.sc.remote_changes() # with self.assertRaises(NoResultFound): fails via evernote issue =( # sc.sq(models.Note).filter( # models.Note.guid == note.guid, # ).one().guid def test_service_get_note(self): note = models.Note(title='123', content='123', action=ACTION_CREATE) self.session.add(note) self.session.commit() self.assertEqual( self.serv.get_note(note.id), (note.id, '123', '123', None, None, None, []), 'get note from service', ) def test_service_find_notes(self): note = models.Note(title='q ab cd', content='123', action=ACTION_CREATE) tag = models.Tag(name='eee') notebook = models.Notebook(name='123') self.session.add_all([note, tag, notebook]) note.tags = [tag] note.notebook = notebook self.session.commit() self.assertEqual( self.serv.find_notes('ab cd', [notebook.id], [tag.id]), [(note.id, u'q ab cd', u'123', None, None, notebook.id, [u'eee'])], 'find notes via service', ) def test_service_list_notebooks(self): notebook = models.Notebook(name='a123') self.session.add(notebook) self.session.commit() self.assertEqual( self.serv.list_notebooks(), [(notebook.id, u'a123', None)], 'list notebooks', ) def test_service_get_notebook(self): notebook = models.Notebook(name='a123', default=True) self.session.add(notebook) self.session.commit() self.assertEqual( self.serv.get_notebook(notebook.id), (notebook.id, u'a123', True), 'get notebook', ) def test_service_list_tags(self): tag = models.Tag(name='123') self.session.add(tag) self.session.commit() self.assertEqual( self.serv.list_tags(), [(tag.id, u'123')], 'list tags' ) def test_service_create_note(self): notebook = models.Notebook(name='a123', default=True) self.session.add(notebook) self.session.commit() note = (None, u'q ab cd', u'123', None, None, notebook.id, [u'eee']) self.assertEqual( self.serv.create_note(note), (1, u'q ab cd', u'123', None, None, notebook.id, [u'eee']), 'create note via service', ) def test_service_update_note(self): notebook = models.Notebook(name='a123', default=True) note = models.Note( title='123', content='123', notebook=notebook, ) self.session.add_all([notebook, note]) self.session.commit() result = self.serv.update_note( (note.id, u'q ab cd', u'123', None, None, notebook.id, [u'eee']), ) self.assertEqual(result, (note.id, u'q ab cd', u'123', None, None, notebook.id, [u'eee']), 'update note', ) def test_service_delete_note(self): notebook = models.Notebook(name='a123', default=True) note = models.Note( title='123', content='123', notebook=notebook, ) self.session.add_all([notebook, note]) self.session.commit() self.serv.delete_note(note.id) self.assertEqual(note.action, ACTION_DELETE, 'delete note') def test_service_create_notebook(self): notebook = self.serv.create_notebook( (None, u'a123', True), ) self.assertEqual(notebook, (1, u'a123', True), 'create notebook', )
def __init__(self, verbose, *args, **kwargs): # non-kde: # from PySide.QtCore import QCoreApplication # AppClass = QCoreApplication AppClass.__init__(self, *args, **kwargs) # ************************************************************ # Configure logger # ************************************************************ # https://docs.python.org/2/library/logging.html # good ref: # http://victorlin.me/posts/2012/08/26/good-logging-practice-in-python # Yes, quite drawn out with all my if verbose, but readable for me when # I come back to this in a couple weeks or more #logging.basicConfig(level=logging.INFO) # create logger and set to debug self.logger = logging.getLogger('gevernote-provider') self.logger.setLevel(logging.DEBUG) fh = logging.FileHandler( os.path.expanduser('~/.everpad/logs/gevernote-provider.log')) fh.setLevel(logging.DEBUG) fh.setFormatter( logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s')) self.logger.addHandler(fh) if verbose: ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) ch.setFormatter(logging.Formatter('%(asctime)s - %(message)s')) self.logger.addHandler(ch) self.logger.info('Logging started.') # ref: http://qt-project.org/doc/qt-4.8/qsettings.html # # For example, if your product is called Star Runner and your company # is called MySoft, you would construct the QSettings object as follows: # QSettings settings("MySoft", "Star Runner"); # Backwards? self.settings = QSettings('everpad', 'everpad-provider') # going to do more here - gsettings self.logger.debug('Setting parsed.') # Ref: http://excid3.com/blog/an-actually-decent-python-dbus-tutorial/ # SessionBus because service is a session level daemon session_bus = dbus.SessionBus() # for future name change #self.bus = dbus.service.BusName("com.gevernote.Provider", session_bus) #self.service = ProviderService(session_bus, '/GrevernoteProvider') self.bus = dbus.service.BusName("com.everpad.Provider", session_bus) self.service = ProviderService(session_bus, '/EverpadProvider') self.logger.debug("dbus setup complete") # subclass PySide.QtCore.QThread - agent.py # setup Sync thread self.sync_thread = SyncThread() # connect Sync thread sync_state_changed self.sync_thread.sync_state_changed.connect( Slot(int)(self.service.sync_state_changed), ) # connect Sync thread data_changed self.sync_thread.data_changed.connect( Slot()(self.service.data_changed), ) self.logger.debug("SyncThread init complete") # Start Sync Thread if provider is authenticated if get_auth_token(): self.logger.debug('Auth - Starting Sync Thread.') self.sync_thread.start() else: self.logger.debug('No Auth - Sync Thread not started.') # ************************************************************ # Authentication and Termination Signals Setup # ************************************************************ # provider_authenticate @Slot self.service.qobject.authenticate_signal.connect( self.provider_authenticate, ) # on_authenticated @Slot #self.service.qobject.authenticate_signal.connect( # self.on_authenticated, #) # on_remove_authenticated @Slot self.service.qobject.remove_authenticate_signal.connect( self.on_remove_authenticated, ) self.service.qobject.terminate.connect(self.terminate) self.logger.info('Provider started.')
class FindTestCase(unittest.TestCase): def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit self.notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.notebook2 = Notebook.from_tuple( self.service.create_notebook('test2', None), ) self.notebook3 = Notebook.from_tuple( self.service.create_notebook(u'Блокнот', None), ) notes = [ self.service.create_note( Note( id=NONE_ID, title='New note', content="New note content", tags=['ab', 'cd'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place='first', pinnded=False, ).struct), self.service.create_note( Note( id=NONE_ID, title='Old note', content="Old note content", tags=['ef', 'gh'], notebook=self.notebook2.id, created=NONE_VAL, updated=NONE_VAL, place='second', pinnded=False, ).struct), self.service.create_note( Note( id=NONE_ID, title='not', content="oke", tags=['ab', 'gh'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place='second', pinnded=True, ).struct), self.service.create_note( Note( id=NONE_ID, title=u'Заметка', content=u"Заметка", tags=[u'тэг'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place=u'место', pinnded=False, ).struct), self.service.create_note( Note( id=NONE_ID, title=u'заметка', content=u"заметка", tags=[u'тэг'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place=u'место', pinnded=False, ).struct), ] self.notes = map( lambda note: Note.from_tuple(self.service.update_note(note)), notes) def _to_ids(self, items): return set(map(lambda item: item.id, items)) def _find(self, *args, **kwargs): return map(Note.from_tuple, self.service.find_notes(*args, **kwargs)) def test_by_words(self): """Test notes find by words""" all = self._find( 'not', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( set(self._to_ids(all)), set(self._to_ids(self.notes[:-2])), ) two = self._find( 'note', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( set(self._to_ids(two)), set(self._to_ids(self.notes[:2])), ) blank = self._find( 'not note', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual(len(blank), 0) def test_by_tags(self): """Test notef find by tags""" tags = map(Tag.from_tuple, self.service.list_tags()) first_last = self._find( '', dbus.Array([], signature='i'), [tags[0].id], 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( set(self._to_ids(first_last)), set(self._to_ids([self.notes[0], self.notes[2]])), ) second = self._find( '', dbus.Array([], signature='i'), [tags[2].id], 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( self._to_ids(second), set([self.notes[1].id]), ) all = self._find( '', dbus.Array([], signature='i'), map(lambda tag: tag.id, tags), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( self._to_ids(all), self._to_ids(self.notes), ) def test_by_notebooks(self): """Test find note by notebooks""" all = self._find( '', self._to_ids([self.notebook, self.notebook2]), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( self._to_ids(all), self._to_ids(self.notes), ) second = self._find( '', [self.notebook2.id], dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( self._to_ids(second), set([self.notes[1].id]), ) def test_combine(self): """Test find by combination""" places = map(Place.from_tuple, self.service.list_places()) tags = map(Tag.from_tuple, self.service.list_tags()) first = self._find( 'new', [self.notebook.id], [tags[0].id], places[0].id, 100, Note.ORDER_UPDATED_DESC, False, ) self.assertEqual( self._to_ids(first), set([self.notes[0].id]), ) last = self._find( 'oke', [self.notebook.id], [tags[0].id], places[1].id, 100, Note.ORDER_UPDATED_DESC, True, ) self.assertEqual( self._to_ids(last), set([self.notes[2].id]), ) def test_unicode_ignorecase(self): """Test unicode ignorecase""" all = self._find( u'заметка', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( set(self._to_ids(all)), set(self._to_ids(self.notes[-2:])), )
class FindTestCase(unittest.TestCase): def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit self.notebook = Notebook.from_tuple( self.service.create_notebook('test'), ) self.notebook2 = Notebook.from_tuple( self.service.create_notebook('test2'), ) self.notebook3 = Notebook.from_tuple( self.service.create_notebook(u'Блокнот'), ) notes = [ self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=['ab', 'cd'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place='first', pinnded=False, ).struct), self.service.create_note(Note( id=NONE_ID, title='Old note', content="Old note content", tags=['ef', 'gh'], notebook=self.notebook2.id, created=NONE_VAL, updated=NONE_VAL, place='second', pinnded=False, ).struct), self.service.create_note(Note( id=NONE_ID, title='not', content="oke", tags=['ab', 'gh'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place='second', pinnded=True, ).struct), self.service.create_note(Note( id=NONE_ID, title=u'Заметка', content=u"Заметка", tags=[u'тэг'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place=u'место', pinnded=False, ).struct), self.service.create_note(Note( id=NONE_ID, title=u'заметка', content=u"заметка", tags=[u'тэг'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place=u'место', pinnded=False, ).struct), ] self.notes = map(lambda note: Note.from_tuple(self.service.update_note(note)), notes) def _to_ids(self, items): return set(map(lambda item: item.id, items)) def _find(self, *args, **kwargs): return map(Note.from_tuple, self.service.find_notes(*args, **kwargs)) def test_by_words(self): """Test notes find by words""" all = self._find( 'not', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( set(self._to_ids(all)), set(self._to_ids(self.notes[:-2])), ) two = self._find( 'note', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( set(self._to_ids(two)), set(self._to_ids(self.notes[:2])), ) blank = self._find( 'not note', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual(len(blank), 0) def test_by_tags(self): """Test notef find by tags""" tags = map(Tag.from_tuple, self.service.list_tags()) first_last = self._find( '', dbus.Array([], signature='i'), [tags[0].id], 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( set(self._to_ids(first_last)), set(self._to_ids([self.notes[0], self.notes[2]])), ) second = self._find( '', dbus.Array([], signature='i'), [tags[2].id], 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( self._to_ids(second), set([self.notes[1].id]), ) all = self._find( '', dbus.Array([], signature='i'), map(lambda tag: tag.id, tags), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( self._to_ids(all), self._to_ids(self.notes), ) def test_by_notebooks(self): """Test find note by notebooks""" all = self._find( '', self._to_ids([self.notebook, self.notebook2]), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( self._to_ids(all), self._to_ids(self.notes), ) second = self._find( '', [self.notebook2.id], dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( self._to_ids(second), set([self.notes[1].id]), ) def test_combine(self): """Test find by combination""" places = map(Place.from_tuple, self.service.list_places()) tags = map(Tag.from_tuple, self.service.list_tags()) first = self._find( 'new', [self.notebook.id], [tags[0].id], places[0].id, 100, Note.ORDER_UPDATED_DESC, False, ) self.assertEqual( self._to_ids(first), set([self.notes[0].id]), ) last = self._find( 'oke', [self.notebook.id], [tags[0].id], places[1].id, 100, Note.ORDER_UPDATED_DESC, True, ) self.assertEqual( self._to_ids(last), set([self.notes[2].id]), ) def test_unicode_ignorecase(self): """Test unicode ignorecase""" all = self._find( u'заметка', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ) self.assertEqual( set(self._to_ids(all)), set(self._to_ids(self.notes[-2:])), )
class TestProvider(unittest.TestCase): def setUp(self): self.session = get_db_session(':memory:') self.store = get_note_store(token) self.sc = SyncThread() self.sc.session = self.session self.sc.sq = self.session.query self.sc.note_store = self.store self.sc.auth_token = token self.serv = ProviderService() self.serv._session = self.session models.Note.session = self.session # hack for test def test_local_sync(self): note = models.Note( title='test', content='test', action=ACTION_CREATE, ) self.session.add(note) self.sc.local_changes() self.assertEqual( 'test', self.sc.note_store.getNote( token, note.guid, True, False, False, False, ).title, 'sync simple note', ) notebook = models.Notebook( name=str(datetime.now()), default=False, action=ACTION_CREATE, ) self.session.add(notebook) note.notebook = notebook note.action = ACTION_CHANGE self.sc.local_changes() self.assertEqual( notebook.guid, self.sc.note_store.getNote( token, note.guid, True, False, False, False, ).notebookGuid, 'sync note with notebook', ) tag = models.Tag( name=str(datetime.now()), action=ACTION_CREATE, ) self.session.add(tag) note.action = ACTION_CHANGE note.tags = [tag] self.sc.local_changes() self.assertEqual( [tag.guid], self.sc.note_store.getNote( token, note.guid, True, False, False, False, ).tagGuids, 'sync note with tags', ) notebook.name = str(datetime.now()) notebook.action = ACTION_CHANGE self.sc.local_changes() self.assertEqual( notebook.name, self.sc.note_store.getNotebook( token, notebook.guid, ).name, 'sync notebook change', ) tag.name = str(datetime.now()) tag.action = ACTION_CHANGE self.sc.local_changes() self.assertEqual( tag.name, self.sc.note_store.getTag( token, tag.guid, ).name, 'sync tag change', ) note.action = ACTION_DELETE self.sc.local_changes() self.assertIsNotNone( self.sc.note_store.getNote( token, note.guid, True, False, False, False, ), 'remove note') def test_remote_sync(self): notebook = self.sc.note_store.createNotebook( self.sc.auth_token, Notebook( name=str(datetime.now()), defaultNotebook=False, ), ) self.sc.remote_changes() self.assertIsNotNone( self.sc.sq(models.Notebook).filter( models.Notebook.guid == notebook.guid, ).one(), 'sync remote notebook') tag = self.sc.note_store.createTag( self.sc.auth_token, Tag(name=str(datetime.now())), ) self.sc.remote_changes() self.assertIsNotNone( self.sc.sq(models.Tag).filter(models.Tag.guid == tag.guid, ).one(), 'sync remote tag') note = self.sc.note_store.createNote( self.sc.auth_token, Note( title='asd', content=""" <!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd"> <en-note>%s</en-note> """, )) self.sc.remote_changes() self.assertIsNotNone( self.sc.sq(models.Note).filter( models.Note.guid == note.guid, ).one(), 'sync remote note') notebook.name = str(datetime.now()) self.sc.note_store.updateNotebook( self.sc.auth_token, notebook, ) self.sc.remote_changes() self.assertEqual( self.sc.sq(models.Notebook).filter( models.Notebook.guid == notebook.guid, ).one().name, notebook.name, 'update local notebook') tag.name = str(datetime.now()) self.sc.note_store.updateTag( self.sc.auth_token, tag, ) self.sc.remote_changes() self.assertEqual( self.sc.sq(models.Tag).filter( models.Tag.guid == tag.guid, ).one().name, tag.name, 'update local tag') note.tagGuids = [] self.sc.note_store.updateNote( self.sc.auth_token, note, ) self.sc.remote_changes() self.assertEqual( self.sc.sq(models.Note).filter( models.Note.guid == note.guid, ).one().tags, [], 'update local note') self.sc.note_store.deleteNote( self.sc.auth_token, note.guid, ) self.sc.remote_changes() # with self.assertRaises(NoResultFound): fails via evernote issue =( # sc.sq(models.Note).filter( # models.Note.guid == note.guid, # ).one().guid def test_service_get_note(self): note = models.Note(title='123', content='123', action=ACTION_CREATE) self.session.add(note) self.session.commit() self.assertEqual( self.serv.get_note(note.id), (note.id, '123', '123', None, None, None, []), 'get note from service', ) def test_service_find_notes(self): note = models.Note(title='q ab cd', content='123', action=ACTION_CREATE) tag = models.Tag(name='eee') notebook = models.Notebook(name='123') self.session.add_all([note, tag, notebook]) note.tags = [tag] note.notebook = notebook self.session.commit() self.assertEqual( self.serv.find_notes('ab cd', [notebook.id], [tag.id]), [(note.id, u'q ab cd', u'123', None, None, notebook.id, [u'eee'])], 'find notes via service', ) def test_service_list_notebooks(self): notebook = models.Notebook(name='a123') self.session.add(notebook) self.session.commit() self.assertEqual( self.serv.list_notebooks(), [(notebook.id, u'a123', None)], 'list notebooks', ) def test_service_get_notebook(self): notebook = models.Notebook(name='a123', default=True) self.session.add(notebook) self.session.commit() self.assertEqual( self.serv.get_notebook(notebook.id), (notebook.id, u'a123', True), 'get notebook', ) def test_service_list_tags(self): tag = models.Tag(name='123') self.session.add(tag) self.session.commit() self.assertEqual(self.serv.list_tags(), [(tag.id, u'123')], 'list tags') def test_service_create_note(self): notebook = models.Notebook(name='a123', default=True) self.session.add(notebook) self.session.commit() note = (None, u'q ab cd', u'123', None, None, notebook.id, [u'eee']) self.assertEqual( self.serv.create_note(note), (1, u'q ab cd', u'123', None, None, notebook.id, [u'eee']), 'create note via service', ) def test_service_update_note(self): notebook = models.Notebook(name='a123', default=True) note = models.Note( title='123', content='123', notebook=notebook, ) self.session.add_all([notebook, note]) self.session.commit() result = self.serv.update_note( (note.id, u'q ab cd', u'123', None, None, notebook.id, [u'eee']), ) self.assertEqual( result, (note.id, u'q ab cd', u'123', None, None, notebook.id, [u'eee']), 'update note', ) def test_service_delete_note(self): notebook = models.Notebook(name='a123', default=True) note = models.Note( title='123', content='123', notebook=notebook, ) self.session.add_all([notebook, note]) self.session.commit() self.serv.delete_note(note.id) self.assertEqual(note.action, ACTION_DELETE, 'delete note') def test_service_create_notebook(self): notebook = self.serv.create_notebook((None, u'a123', True), ) self.assertEqual( notebook, (1, u'a123', True), 'create notebook', )
class EditorTestCase(unittest.TestCase): def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session self.app = app app.update(self.service) notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.note = Note.from_tuple(self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=[], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct)) def test_content_nochange(self): """Test content nochange""" editor = Editor(self.note) self.assertEqual( editor.note_edit.content, "New note content", ) for content in CONTENTS: editor.note_edit.content = content self.assertEqual( editor.note_edit.content, content, ) def test_content_changing(self): """Test content changing""" editor = Editor(self.note) for prev, current in CHANGING_CONTENTS: editor.note_edit.content = prev self.assertEqual( editor.note_edit.content, current, ) def test_title_nochange(self): """Test title nochange""" editor = Editor(self.note) self.assertEqual( editor.note_edit.title, "New note", ) for title in TITLES: editor.note_edit.title = title self.assertEqual( editor.note_edit.title, title, ) def test_set_links(self): """Test set links""" for orig, result in SET_LINKS: self.assertEqual( set_links(orig), result, ) def test_not_broken_note_links(self): """Test content nochange""" content = '<a href="evernote:///view/123/123/123/">note link</a>' self.note.content = content editor = Editor(self.note) self.assertEqual( editor.note_edit.content, content, ) def test_open_note_links(self): """Test open note links""" guid = 'guid' note = Note( id=123, ) self.app.open = MagicMock() self.service.get_note_by_guid = MagicMock( return_value=note.struct, ) link = "evernote:///view/123/123/{guid}/123/".format( guid=guid, ) editor = Editor(self.note) editor.note_edit.link_clicked(QUrl(link)) self.assertEqual( self.service.get_note_by_guid.call_args[0][0], guid, ) self.assertEqual( self.app.open.call_args[0][0].id, note.id, )
class MethodsCase(unittest.TestCase): """Case for dbus shortcuts""" def setUp(self): self.service = ProviderService() self.session = get_db_session() self.service._session = self.session models.Note.session = self.session self.service.qobject = MagicMock() self.service.app = MagicMock() self.service.sync = MagicMock() factories.invoke_session(self.session) def tearDown(self): self.session.flush() def _create_note(self, **kwargs): """Create note""" note = factories.NoteFactory.create(action=const.ACTION_NONE, **kwargs) self.session.commit() return note def test_get_note(self): """Test get note method""" note = self._create_note() remote_note = btype.Note << self.service.get_note(note.id) self.assertEqual(remote_note.title, note.title) def test_get_note_by_guid(self): """Test get note method""" note = self._create_note(guid='guid') remote_note = btype.Note << self.service.get_note_by_guid(note.guid) self.assertEqual(remote_note.title, note.title) def test_get_note_alternatives(self): """Test get note alternatives""" note = self._create_note(guid='guid') alternative = factories.NoteFactory.create( guid='guid', action=const.ACTION_CONFLICT, conflict_parent_id=note.id, ) self.session.commit() remote_notes = btype.Note.list << self.service.get_note_alternatives( note.id, ) self.assertEqual(remote_notes[0].id, alternative.id) def test_list_notebooks(self): """Test list notebooks method""" notebooks = factories.NotebookFactory.create_batch( 10, action=const.ACTION_NONE, ) self.session.commit() notebooks = [notebook.id for notebook in notebooks] remote_notebooks = btype.Notebook.list << self.service.list_notebooks() ids = [notebook.id for notebook in remote_notebooks] self.assertItemsEqual(notebooks, ids) def test_get_notebook(self): """Test get notebook method""" notebook = factories.NotebookFactory.create(action=const.ACTION_NONE, ) deleted_notebook = factories.NotebookFactory( action=const.ACTION_DELETE, ) self.session.commit() remote_notebook = btype.Notebook << self.service.get_notebook( notebook.id, ) self.assertEqual(notebook.name, remote_notebook.name) with self.assertRaises(DBusException): self.service.get_notebook(deleted_notebook.id, ) def test_get_notebook_notes_count(self): """Test get notebook notes count method""" notebook = factories.NotebookFactory.create(action=const.ACTION_NONE, ) factories.NoteFactory.create_batch( 10, action=const.ACTION_NONE, notebook=notebook, ) self.session.commit() self.assertEqual( self.service.get_notebook_notes_count(notebook.id), 10, ) def test_update_notebook(self): """Test update notebook method""" notebook = factories.NotebookFactory.create(action=const.ACTION_NONE, ) self.session.commit() new_name = 'name' notebook_btype = btype.Notebook.from_obj(notebook) notebook_btype.name = new_name notebook_btype = btype.Notebook << self.service.update_notebook( notebook_btype.struct, ) self.assertEqual(notebook_btype.name, new_name) self.assertEqual(notebook.name, new_name) def test_delete_notebook(self): """Test delete notebook""" notebook = factories.NotebookFactory.create( name='notebook', action=const.ACTION_NONE, ) self.session.commit() self.service.delete_notebook(notebook.id) self.assertEqual(notebook.action, const.ACTION_DELETE) def test_list_tags(self): """Test list tags""" tags = factories.TagFactory.create_batch( 10, action=const.ACTION_NONE, ) self.session.commit() tags = [tag.id for tag in tags] remote_tags = btype.Tag.list << self.service.list_tags() tags_ids = [tag.id for tag in remote_tags] self.assertItemsEqual(tags_ids, tags) def test_get_tag_notes_count(self): """Test get tag notes count method""" tag = factories.TagFactory.create(action=const.ACTION_NONE, ) factories.NoteFactory.create_batch( 10, action=const.ACTION_NONE, tags=[tag], ) self.session.commit() self.assertEqual( self.service.get_tag_notes_count(tag.id), 10, ) def test_delete_tag(self): """Test delete tag""" tag = factories.TagFactory.create(action=const.ACTION_NONE, ) self.session.commit() self.service.delete_tag(tag.id) self.assertEqual(tag.action, const.ACTION_DELETE) def test_update_tag(self): """Test update tag method""" tag = factories.TagFactory.create(action=const.ACTION_NONE, ) self.session.commit() new_name = 'name' tag_btype = btype.Tag.from_obj(tag) tag_btype.name = new_name tag_btype = btype.Tag << self.service.update_tag(tag_btype.struct, ) self.assertEqual(tag_btype.name, new_name) self.assertEqual(tag.name, new_name) def test_create_note(self): """Test create note""" notebook = factories.NotebookFactory.create(default=True) self.session.commit() title = 'note' note_btype = btype.Note( title=title, tags=[], id=const.NONE_ID, notebook=notebook.id, ) note_btype = btype.Note << self.service.create_note( btype.Note >> note_btype, ) note = self.session.query(models.Note).filter( models.Note.id == note_btype.id, ).one() self.assertEqual(note_btype.title, title) self.assertEqual(note.title, title) def test_update_note(self): """Test update note""" notebook = factories.NotebookFactory.create(default=True) self.session.commit() note = self._create_note(notebook_id=notebook.id, ) new_title = 'title' note_btype = btype.Note.from_obj(note) note_btype.title = new_title note_btype = btype.Note << self.service.update_note( note_btype.struct, ) note = self.session.query(models.Note).filter( models.Note.id == note_btype.id, ).one() self.assertEqual(note_btype.title, new_title) self.assertEqual(note.title, new_title) def test_get_note_resources(self): """Test get note resources""" note = self._create_note() resource = factories.ResourceFactory.create( file_name='name', action=const.ACTION_NONE, note_id=note.id, ) self.session.commit() resources_btype = btype.Resource.list << self.service.get_note_resources( note.id, ) self.assertEqual(resources_btype[0].file_name, resource.file_name) def test_update_note_resources(self): """Test update note resources""" note = self._create_note() resource = btype.Resource(file_name='test', ) self.service.update_note_resources( note.id, btype.Resource.list >> [resource], ) resource = self.session.query(models.Resource).one() self.assertEqual(resource.file_name, 'test') def test_delete_note(self): """Test delete note""" note = self._create_note() self.service.delete_note(note.id) self.assertEqual(note.action, const.ACTION_DELETE) def test_create_notebook(self): """Test create notebook""" notebook_btype =\ btype.Notebook << self.service.create_notebook('test', 'test') notebook = self.session.query(models.Notebook).filter( models.Notebook.id == notebook_btype.id, ).one() self.assertEqual(notebook.name, 'test') def test_authenticate(self): """Test authenticate""" self.service.authenticate('test') self.service.qobject\ .remove_authenticate_signal.emit.assert_called_once_with() self.service.qobject\ .authenticate_signal.emit.assert_called_once_with('test') def test_remove_authentication(self): """Test remove authentication""" self.service.remove_authentication() self.service.qobject\ .remove_authenticate_signal.emit.assert_called_once_with() def test_list_places(self): """Test list places""" places = factories.PlaceFactory.create_batch(10) self.session.commit() place_ids = [place.id for place in places] places_btype = btype.Place.list << self.service.list_places() for place_btype in places_btype: self.assertIn(place_btype.id, place_ids) def test_share_note(self): """Test share note""" note = self._create_note() self.service.share_note(note.id) self.assertEqual(note.share_status, const.SHARE_NEED_SHARE) self.service.sync.assert_called_once_with() def test_stop_sharing_note(self): """Test stop sharing note""" note = self._create_note(share_status=const.SHARE_SHARED) self.service.stop_sharing_note(note.id) self.assertEqual(note.share_status, const.SHARE_NEED_STOP) self.service.sync.assert_called_once_with() def test_is_first_synced(self): """Test is first synced""" self.assertFalse(self.service.is_first_synced())
def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit self.notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.notebook2 = Notebook.from_tuple( self.service.create_notebook('test2', None), ) self.notebook3 = Notebook.from_tuple( self.service.create_notebook(u'Блокнот', None), ) notes = [ self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=['ab', 'cd'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place='first', pinnded=False, ).struct), self.service.create_note(Note( id=NONE_ID, title='Old note', content="Old note content", tags=['ef', 'gh'], notebook=self.notebook2.id, created=NONE_VAL, updated=NONE_VAL, place='second', pinnded=False, ).struct), self.service.create_note(Note( id=NONE_ID, title='not', content="oke", tags=['ab', 'gh'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place='second', pinnded=True, ).struct), self.service.create_note(Note( id=NONE_ID, title=u'Заметка', content=u"Заметка", tags=[u'тэг'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place=u'место', pinnded=False, ).struct), self.service.create_note(Note( id=NONE_ID, title=u'заметка', content=u"заметка", tags=[u'тэг'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place=u'место', pinnded=False, ).struct), ] self.notes = map(lambda note: Note.from_tuple(self.service.update_note(note)), notes)
class ServiceTestCase(unittest.TestCase): def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit self.session = self.service._session def _to_ids(self, items): return set(map(lambda item: item.id, items)) def test_notebooks(self): """Test notebooks""" notebooks = [] for i in range(100): notebooks.append(Notebook.from_tuple( self.service.create_notebook(str(i), None), )) self.assertEqual(notebooks[-1].name, str(i)) for num, notebook in enumerate(notebooks): if num % 2: self.service.delete_notebook(notebook.id) with self.assertRaises(DBusException): self.service.get_notebook(notebook.id) notebooks.remove(notebook) self.assertEqual( self._to_ids(notebooks), self._to_ids(map( Notebook.from_tuple, self.service.list_notebooks(), )), ) for num, notebook in enumerate(notebooks): notebook.name += '*' if num % 2: self.service.delete_notebook(notebook.id) with self.assertRaises(DBusException): self.service.update_notebook(notebook.struct) else: updated = Notebook.from_tuple( self.service.update_notebook(notebook.struct), ) self.assertEqual(notebook.name, updated.name) def test_notes_with_notebook_and_places(self): """Test notes with notebook and places""" notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) notes = [] get_place = lambda num: '123' if num < 50 else '456' for i in range(100): notes.append(Note.from_tuple(self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=['123', '345'], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place=get_place(i), ).struct))) filtered = [] for num, note in enumerate(notes): if not num % 2: self.service.update_note(note.struct) # mark note exist filtered.append(note) notes = filtered # notes.remove(note) not work, wtf self.assertEqual( self._to_ids(notes), self._to_ids(map( Note.from_tuple, self.service.find_notes( '', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ), )), ) filtered = [] for num, note in enumerate(notes): note.title += '*' if num % 2: self.service.delete_note(note.id) with self.assertRaises(DBusException): self.service.update_note(note.struct) else: updated = Note.from_tuple( self.service.update_note(note.struct), ) self.assertEqual(note.title, updated.title) filtered.append(updated) self.assertEqual(len(filtered), self.service.get_notebook_notes_count(notebook.id), ) self.assertEqual(set(['123', '456']), set(map( lambda place: Place.from_tuple(place).name, self.service.list_places(), ))) def test_tags(self): """Test tags""" tags = map(str, range(100)) notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=tags, notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct) remote_tags = map(Tag.from_tuple, self.service.list_tags()) self.assertEqual(set(tags), set(map( lambda tag: tag.name, remote_tags, ))) filtered = [] for num, tag in enumerate(remote_tags): if num % 2: filtered.append(tag) else: self.service.delete_tag(tag.id) tags = filtered # tags.remove(tag) not work, wtf self.assertEqual( self._to_ids(tags), self._to_ids(map( Tag.from_tuple, self.service.list_tags(), )), ) filtered = [] for num, tag in enumerate(tags): tag.name += '*' if num % 2: self.service.delete_tag(tag.id) with self.assertRaises(DBusException): self.service.update_tag(tag.struct) else: updated = Tag.from_tuple( self.service.update_tag(tag.struct), ) self.assertEqual(tag.name, updated.name) filtered.append(updated) def _file_names(self, items): return set(map(lambda item: item.file_name, items)) def test_note_resources(self): """Test note resources""" notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) struct = self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=[], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct) note = Note.from_tuple(self.service.update_note(struct)) resources = [] for i in range(100): resources.append(Resource( id=NONE_ID, file_name="name/%d" % i, file_path="path/%d" % i, mime='image/png', hash='', )) self.service.update_note_resources(note.struct, map(lambda resource: resource.struct, resources), ) received = map(Resource.from_tuple, self.service.get_note_resources(note.id)) self.assertEqual( self._file_names(resources), self._file_names(received), ) received = received[:50] self.service.update_note_resources(note.struct, map(lambda resource: resource.struct, received), ) new_received = map(Resource.from_tuple, self.service.get_note_resources(note.id)) self.assertEqual( self._file_names(new_received), self._file_names(received), ) def test_note_conflicts_serialisation(self): """Test notes with conflict serialisztion""" parent = models.Note( title='123', content='456', ) self.session.add(parent) self.session.commit() conflicts = [] for i in range(10): conflict = models.Note( title='123', content='456', conflict_parent_id=parent.id, ) self.session.add(conflict) conflicts.append(conflict) self.session.commit() self.assertEqual( set(parent.conflict_items_dbus), self._to_ids(conflicts), ) for conflict in conflicts: self.assertEqual(parent.id, conflict.conflict_parent_dbus) def test_tag_delete(self): """Test deleting tags""" tag = models.Tag( name='okok', action=models.ACTION_NONE, ) deleting_tag = models.Tag( name='deleted', action=models.ACTION_NONE, ) self.session.add(tag) self.session.add(deleting_tag) note = models.Note( title='123', content='456', tags=[tag, deleting_tag], ) self.session.add(note) self.session.commit() self.service.delete_tag(deleting_tag.id) self.assertItemsEqual(note.tags, [tag])
class ServiceTestCase(unittest.TestCase): def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit self.session = self.service._session def _to_ids(self, items): return set(map(lambda item: item.id, items)) def test_notebooks(self): """Test notebooks""" notebooks = [] for i in range(100): notebooks.append( Notebook.from_tuple(self.service.create_notebook(str(i), None), )) self.assertEqual(notebooks[-1].name, str(i)) for num, notebook in enumerate(notebooks): if num % 2: self.service.delete_notebook(notebook.id) with self.assertRaises(DBusException): self.service.get_notebook(notebook.id) notebooks.remove(notebook) self.assertEqual( self._to_ids(notebooks), self._to_ids( map( Notebook.from_tuple, self.service.list_notebooks(), )), ) for num, notebook in enumerate(notebooks): notebook.name += '*' if num % 2: self.service.delete_notebook(notebook.id) with self.assertRaises(DBusException): self.service.update_notebook(notebook.struct) else: updated = Notebook.from_tuple( self.service.update_notebook(notebook.struct), ) self.assertEqual(notebook.name, updated.name) def test_notes_with_notebook_and_places(self): """Test notes with notebook and places""" notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) notes = [] get_place = lambda num: '123' if num < 50 else '456' for i in range(100): notes.append( Note.from_tuple( self.service.create_note( Note( id=NONE_ID, title='New note', content="New note content", tags=['123', '345'], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place=get_place(i), ).struct))) filtered = [] for num, note in enumerate(notes): if not num % 2: self.service.update_note(note.struct) # mark note exist filtered.append(note) notes = filtered # notes.remove(note) not work, wtf self.assertEqual( self._to_ids(notes), self._to_ids( map( Note.from_tuple, self.service.find_notes( '', dbus.Array([], signature='i'), dbus.Array([], signature='i'), 0, 100, Note.ORDER_UPDATED_DESC, -1, ), )), ) filtered = [] for num, note in enumerate(notes): note.title += '*' if num % 2: self.service.delete_note(note.id) with self.assertRaises(DBusException): self.service.update_note(note.struct) else: updated = Note.from_tuple( self.service.update_note(note.struct), ) self.assertEqual(note.title, updated.title) filtered.append(updated) self.assertEqual( len(filtered), self.service.get_notebook_notes_count(notebook.id), ) self.assertEqual( set(['123', '456']), set( map( lambda place: Place.from_tuple(place).name, self.service.list_places(), ))) def test_tags(self): """Test tags""" tags = map(str, range(100)) notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.service.create_note( Note( id=NONE_ID, title='New note', content="New note content", tags=tags, notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct) remote_tags = map(Tag.from_tuple, self.service.list_tags()) self.assertEqual(set(tags), set(map( lambda tag: tag.name, remote_tags, ))) filtered = [] for num, tag in enumerate(remote_tags): if num % 2: filtered.append(tag) else: self.service.delete_tag(tag.id) tags = filtered # tags.remove(tag) not work, wtf self.assertEqual( self._to_ids(tags), self._to_ids(map( Tag.from_tuple, self.service.list_tags(), )), ) filtered = [] for num, tag in enumerate(tags): tag.name += '*' if num % 2: self.service.delete_tag(tag.id) with self.assertRaises(DBusException): self.service.update_tag(tag.struct) else: updated = Tag.from_tuple(self.service.update_tag(tag.struct), ) self.assertEqual(tag.name, updated.name) filtered.append(updated) def _file_names(self, items): return set(map(lambda item: item.file_name, items)) def test_note_resources(self): """Test note resources""" notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) struct = self.service.create_note( Note( id=NONE_ID, title='New note', content="New note content", tags=[], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct) note = Note.from_tuple(self.service.update_note(struct)) resources = [] for i in range(100): resources.append( Resource( id=NONE_ID, file_name="name/%d" % i, file_path="path/%d" % i, mime='image/png', hash='', )) self.service.update_note_resources( note.struct, map(lambda resource: resource.struct, resources), ) received = map(Resource.from_tuple, self.service.get_note_resources(note.id)) self.assertEqual( self._file_names(resources), self._file_names(received), ) received = received[:50] self.service.update_note_resources( note.struct, map(lambda resource: resource.struct, received), ) new_received = map(Resource.from_tuple, self.service.get_note_resources(note.id)) self.assertEqual( self._file_names(new_received), self._file_names(received), ) def test_note_conflicts_serialisation(self): """Test notes with conflict serialisztion""" parent = models.Note( title='123', content='456', ) self.session.add(parent) self.session.commit() conflicts = [] for i in range(10): conflict = models.Note( title='123', content='456', conflict_parent_id=parent.id, ) self.session.add(conflict) conflicts.append(conflict) self.session.commit() self.assertEqual( set(parent.conflict_items_dbus), self._to_ids(conflicts), ) for conflict in conflicts: self.assertEqual(parent.id, conflict.conflict_parent_dbus) def test_tag_delete(self): """Test deleting tags""" tag = models.Tag( name='okok', action=models.ACTION_NONE, ) deleting_tag = models.Tag( name='deleted', action=models.ACTION_NONE, ) self.session.add(tag) self.session.add(deleting_tag) note = models.Note( title='123', content='456', tags=[tag, deleting_tag], ) self.session.add(note) self.session.commit() self.service.delete_tag(deleting_tag.id) self.assertItemsEqual(note.tags, [tag])
def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit self.notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.notebook2 = Notebook.from_tuple( self.service.create_notebook('test2', None), ) self.notebook3 = Notebook.from_tuple( self.service.create_notebook(u'Блокнот', None), ) notes = [ self.service.create_note( Note( id=NONE_ID, title='New note', content="New note content", tags=['ab', 'cd'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place='first', pinnded=False, ).struct), self.service.create_note( Note( id=NONE_ID, title='Old note', content="Old note content", tags=['ef', 'gh'], notebook=self.notebook2.id, created=NONE_VAL, updated=NONE_VAL, place='second', pinnded=False, ).struct), self.service.create_note( Note( id=NONE_ID, title='not', content="oke", tags=['ab', 'gh'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place='second', pinnded=True, ).struct), self.service.create_note( Note( id=NONE_ID, title=u'Заметка', content=u"Заметка", tags=[u'тэг'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place=u'место', pinnded=False, ).struct), self.service.create_note( Note( id=NONE_ID, title=u'заметка', content=u"заметка", tags=[u'тэг'], notebook=self.notebook.id, created=NONE_VAL, updated=NONE_VAL, place=u'место', pinnded=False, ).struct), ] self.notes = map( lambda note: Note.from_tuple(self.service.update_note(note)), notes)
def _create_service(self): """Create service""" self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit
class EditorTestCase(unittest.TestCase): def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session self.app = app app.update(self.service) notebook = Notebook.from_tuple( self.service.create_notebook('test'), ) self.note = Note.from_tuple(self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=[], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct)) def test_content_nochange(self): """Test content nochange""" editor = Editor(self.note) self.assertEqual( editor.note_edit.content, "New note content", ) for content in CONTENTS: editor.note_edit.content = content self.assertEqual( editor.note_edit.content, content, ) def test_content_changing(self): """Test content changing""" editor = Editor(self.note) for prev, current in CHANGING_CONTENTS: editor.note_edit.content = prev self.assertEqual( editor.note_edit.content, current, ) def test_title_nochange(self): """Test title nochange""" editor = Editor(self.note) self.assertEqual( editor.note_edit.title, "New note", ) for title in TITLES: editor.note_edit.title = title self.assertEqual( editor.note_edit.title, title, ) def test_set_links(self): """Test set links""" for orig, result in SET_LINKS: self.assertEqual( set_links(orig), result, )
class EditorTestCase(unittest.TestCase): def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session self.app = app self.app.update(self.service) notebook = Notebook.from_tuple( self.service.create_notebook('test', None), ) self.note = Note.from_tuple(self.service.create_note(Note( id=NONE_ID, title='New note', content="New note content", tags=[], notebook=notebook.id, created=NONE_VAL, updated=NONE_VAL, place='', ).struct)) def tearDown(self): if hasattr(self, 'editor'): self.app.data_changed.disconnect( self.editor.init_alternatives, ) del self.app.provider del self.app def test_content_nochange(self): """Test content nochange""" self.editor = Editor(self.note) self.assertEqual( self.editor.note_edit.content, "New note content", ) for content in CONTENTS: self.editor.note_edit.content = content self.assertEqual( self.editor.note_edit.content, content, ) def test_content_changing(self): """Test content changing""" self.editor = Editor(self.note) for prev, current in CHANGING_CONTENTS: self.editor.note_edit.content = prev self.assertEqual( self.editor.note_edit.content, current, ) def test_title_nochange(self): """Test title nochange""" self.editor = Editor(self.note) self.assertEqual( self.editor.note_edit.title, "New note", ) for title in TITLES: self.editor.note_edit.title = title self.assertEqual( self.editor.note_edit.title, title, ) def test_set_links(self): """Test set links""" for orig, result in SET_LINKS: self.assertEqual( set_links(orig), result, ) def test_not_broken_note_links(self): """Test content nochange""" content = '<a href="evernote:///view/123/123/123/">note link</a>' self.note.content = content self.editor = Editor(self.note) self.assertEqual( self.editor.note_edit.content, content, ) def test_open_note_links(self): """Test open note links""" guid = 'guid' note = Note( id=123, ) self.app.open = MagicMock() self.service.get_note_by_guid = MagicMock( return_value=note.struct, ) link = "evernote:///view/123/123/{guid}/123/".format( guid=guid, ) self.editor = Editor(self.note) self.editor.note_edit.link_clicked(QUrl(link)) self.assertEqual( self.service.get_note_by_guid.call_args[0][0], guid, ) self.assertEqual( self.app.open.call_args[0][0].id, note.id, ) del self.app.open
def setUp(self): self.service = ProviderService() self.service._session = get_db_session() models.Note.session = self.service._session # TODO: fix that shit self.session = self.service._session