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 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])
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())
