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 create(self, attach=None, notebook_id=NONE_ID):
note_struct = Note( # maybe replace NONE's to somthing better
id=NONE_ID,
title=self.tr('New note'),
content=self.tr("New note content"),
tags=dbus.Array([], signature='i'),
notebook=notebook_id,
created=NONE_VAL,
updated=NONE_VAL,
place='',
).struct
note = Note.from_tuple(self.app.provider.create_note(note_struct), )
editor = self.open(note)
if attach:
editor.resource_edit.add_attach(attach)
def get_note(self):
return Note(
id=randint(1, 100000),
title=deepcopy(self._title),
content=deepcopy(self._content),
created=randint(1000000, 9000000),
updated=randint(1000000, 9000000),
notebook=randint(1, 100000),
tags=deepcopy(self._tags),
place=deepcopy(self._place),
pinnded=True,
conflict_parent=randint(1, 100000),
conflict_items=range(10),
share_date=randint(1000000, 9000000),
share_url=deepcopy(self._url),
)
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_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 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 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 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)
