def test_complex(self):
td = TagDict()
td.add('tag')
rl = RecordList()
dt = datetime(year=2021, month=1, day=15, hour=21, minute=13)
rl.append(Record(dt, note='test'))
ws = WordSet()
with self.assertRaises(Exception):
ws.check_note('test')
ws.check_note('test', update=True)
self.assertEqual('0) tag', str(td))
self.assertEqual('[15.01.2021 21:13:00] <tag> test', str(rl))
ws.check_note('test')
db.save()
db.clear()
self.assertEqual('', str(td))
self.assertEqual('', str(rl))
with self.assertRaises(Exception):
ws.check_note('test')
db.load()
self.assertEqual('0) tag', str(td))
self.assertEqual('[15.01.2021 21:13:00] <tag> test', str(rl))
ws.check_note('test')
class DiaryManager:
def __init__(self):
self.tag_dict = TagDict()
self.word_set = WordSet()
self.record_list = RecordList()
def add_record(
self,
dt: Optional[datetime] = None,
tag: str = '',
is_active: Optional[bool] = None,
note: str = '',
update: bool = False,
):
tag_id = self._tag_to_tag_id(tag)
self.word_set.check_note(note, update)
self.record_list.append(Record(dt, tag_id, is_active, note))
def update_record(
self,
index: int,
dt: Optional[datetime],
tag: str,
is_active: Optional[bool],
note: str,
update: bool = False,
):
tag_id = self._tag_to_tag_id(tag)
self.word_set.check_note(note, update)
self.record_list[index] = Record(dt, tag_id, is_active, note)
def _tag_to_tag_id(self, tag) -> int:
return self.tag_dict.get_id(tag)
def tag_stat(self) -> str:
tag_id_stat = self.record_list.get_tag_id_stat()
for tag_id in self.tag_dict:
if tag_id not in tag_id_stat:
tag_id_stat[tag_id] = 0
result = [(v, self.tag_dict[k]) for k, v in tag_id_stat.items()]
result.sort(reverse=True)
return '\n'.join(f'{item[0]} {item[1]}' for item in result)
def set_tag_id(self, new_id: int, tag: str):
old_id = self.tag_dict.set_id(new_id, tag)
self.record_list.swap_tag_id(old_id, new_id)
def tag_filter(self,
tag: Optional[str] = None) -> Tuple[List[int], List[str]]:
if tag is None:
return (
list(range(len(self.record_list))),
[str(record) for record in self.record_list],
)
else:
return self.record_list.filter_record(
tag_id=self.tag_dict.get_id(tag))
def __init__(self):
self.tag_dict = TagDict()
self.word_set = WordSet()
self.record_list = RecordList()
def setUp(self) -> None:
db.load()
self._tag_dict = TagDict()
self._diary_manager = DiaryManager()
class TestDiaryManager(unittest.TestCase):
def setUp(self) -> None:
db.load()
self._tag_dict = TagDict()
self._diary_manager = DiaryManager()
def test_add_record(self):
self._diary_manager.add_record()
self.assertEqual(
'<KeyError: -1>', str(self._diary_manager.record_list)[22:])
def test_add_record_dt(self):
dt = datetime(year=2021, month=1, day=21, hour=21, minute=15)
self._diary_manager.add_record(dt)
self.assertEqual(
'[21.01.2021 21:15:00] <KeyError: -1>',
str(self._diary_manager.record_list),
)
def test_add_record_tag(self):
self._tag_dict.add('tag')
dt = datetime(year=2021, month=1, day=25, hour=12, minute=37)
self._diary_manager.add_record(dt, 'tag')
self.assertEqual(
'[25.01.2021 12:37:00] <tag>',
str(self._diary_manager.record_list),
)
def test_add_record_is_active(self):
self._tag_dict.add('tag')
dt = datetime(year=2021, month=1, day=25, hour=15, minute=34)
self._diary_manager.add_record(dt, 'tag', is_active=True)
dt = datetime(year=2021, month=1, day=25, hour=15, minute=37)
self._diary_manager.add_record(dt, 'tag', is_active=False)
self.assertEqual(
'[25.01.2021 15:34:00] <tag: start>\n'
'[25.01.2021 15:37:00] <tag: end>',
str(self._diary_manager.record_list),
)
def test_add_record_note(self):
self._tag_dict.add('tag')
dt = datetime(year=2021, month=1, day=25, hour=12, minute=39)
with self.assertRaises(Exception):
self._diary_manager.add_record(dt, 'tag', note='test note')
self._diary_manager.add_record(
dt, 'tag', note='test note', update=True)
self.assertEqual(
'[25.01.2021 12:39:00] <tag> test note',
str(self._diary_manager.record_list),
)
def test_update_record(self):
self._diary_manager.add_record()
self._tag_dict.add('tag')
dt = datetime(year=2021, month=2, day=1, hour=8, minute=57)
self._diary_manager.update_record(
0, dt, 'tag', is_active=True, note='test', update=True)
self.assertEqual(
'[01.02.2021 08:57:00] <tag: start> test',
str(self._diary_manager.record_list),
)
def test_tag_stat(self):
self.assertEqual('', self._diary_manager.tag_stat())
self._tag_dict.add('no tag')
self.assertEqual(
'0 no tag',
self._diary_manager.tag_stat(),
)
self._diary_manager.add_record(tag='no tag')
self.assertEqual(
'1 no tag',
self._diary_manager.tag_stat(),
)
self._tag_dict.add('test tag')
self.assertEqual(
'1 no tag\n'
'0 test tag',
self._diary_manager.tag_stat(),
)
self._diary_manager.add_record(tag='test tag')
self._diary_manager.add_record(tag='test tag')
self.assertEqual(
'2 test tag\n'
'1 no tag',
self._diary_manager.tag_stat(),
)
self._tag_dict.add('"ten" tag')
for _ in range(10):
self._diary_manager.add_record(tag='"ten" tag')
self.assertEqual(
'10 "ten" tag\n'
'2 test tag\n'
'1 no tag',
self._diary_manager.tag_stat(),
)
def test_set_tag_id(self):
dt = datetime(year=2021, month=1, day=27, hour=21, minute=15)
self._tag_dict.add('tag B')
self._diary_manager.add_record(
dt, tag='tag B', note='note B', update=True)
self._tag_dict.add('tag A')
self._diary_manager.add_record(
dt, tag='tag A', note='note A', update=True)
self.assertEqual(
'1) tag A\n'
'0) tag B',
str(self._diary_manager.tag_dict),
)
self._diary_manager.set_tag_id(0, 'tag A')
self.assertEqual(
'0) tag A\n'
'1) tag B',
str(self._diary_manager.tag_dict),
)
self._diary_manager.set_tag_id(3, 'tag A')
self.assertEqual(
'3) tag A\n'
'1) tag B',
str(self._diary_manager.tag_dict),
)
self._diary_manager.set_tag_id(3, 'tag B')
self.assertEqual(
'1) tag A\n'
'3) tag B',
str(self._diary_manager.tag_dict),
)
self._diary_manager.set_tag_id(2, 'tag B')
self.assertEqual(
'1) tag A\n'
'2) tag B',
str(self._diary_manager.tag_dict),
)
self.assertEqual(
'[27.01.2021 21:15:00] <tag B> note B\n'
'[27.01.2021 21:15:00] <tag A> note A',
str(self._diary_manager.record_list),
)
def test_tag_filter(self):
self._tag_dict.add('first tag')
self._tag_dict.add('second tag')
dt = datetime(year=2021, month=1, day=27, hour=12, minute=52)
self._diary_manager.add_record(
dt, 'first tag', note='first note', update=True)
self._diary_manager.add_record(
dt, 'second tag', note='second note', update=True)
self._diary_manager.add_record(
dt, 'first tag', note='third note', update=True)
self._diary_manager.add_record(
dt, 'second tag', note='fourth note', update=True)
indexes, str_records = self._diary_manager.tag_filter()
self.assertEqual([0, 1, 2, 3], indexes)
self.assertEqual([
'[27.01.2021 12:52:00] <first tag> first note',
'[27.01.2021 12:52:00] <second tag> second note',
'[27.01.2021 12:52:00] <first tag> third note',
'[27.01.2021 12:52:00] <second tag> fourth note',
], str_records)
indexes, str_records = self._diary_manager.tag_filter('first tag')
self.assertEqual([0, 2], indexes)
self.assertEqual([
'[27.01.2021 12:52:00] <first tag> first note',
'[27.01.2021 12:52:00] <first tag> third note',
], str_records)
indexes, str_records = self._diary_manager.tag_filter('second tag')
self.assertEqual([1, 3], indexes)
self.assertEqual([
'[27.01.2021 12:52:00] <second tag> second note',
'[27.01.2021 12:52:00] <second tag> fourth note',
], str_records)
def tearDown(self) -> None:
db.clear()
db.save()
def setUp(self) -> None:
db.load()
self._tag_dict = TagDict()
class TestTagDict(unittest.TestCase):
def setUp(self) -> None:
db.load()
self._tag_dict = TagDict()
def test_getitem(self):
self.assertEqual('KeyError: 0', self._tag_dict[0])
def test_add(self):
self.assertEqual(0, self._tag_dict.add('no tag'))
self.assertEqual(1, self._tag_dict.add('test tag'))
self.assertEqual('no tag', self._tag_dict[0])
self.assertEqual('test tag', self._tag_dict[1])
def test_add_the_same(self):
self.assertEqual(0, self._tag_dict.add('no tag'))
self.assertEqual(0, self._tag_dict.add('no tag'))
self.assertEqual('no tag', self._tag_dict[0])
self.assertEqual('KeyError: 1', self._tag_dict[1])
def test_delete(self):
self.assertEqual(0, self._tag_dict.add('no tag'))
self.assertEqual(1, self._tag_dict.add('test tag'))
self.assertEqual('test tag', self._tag_dict[1])
self._tag_dict.delete('test tag')
self.assertEqual('KeyError: 1', self._tag_dict[1])
def test_add_after_delete(self):
self.assertEqual(0, self._tag_dict.add('no tag'))
self.assertEqual(1, self._tag_dict.add('first tag'))
self.assertEqual(2, self._tag_dict.add('second tag'))
self._tag_dict.delete('first tag')
self.assertEqual(1, self._tag_dict.add('third tag'))
def test_get_id(self):
self.assertEqual(-1, self._tag_dict.get_id('no tag'))
self.assertEqual(-1, self._tag_dict.get_id('test tag'))
self.assertEqual(0, self._tag_dict.add('no tag'))
self.assertEqual(1, self._tag_dict.add('test tag'))
self.assertEqual(0, self._tag_dict.get_id('no tag'))
self.assertEqual(1, self._tag_dict.get_id('test tag'))
def test_set_id(self):
# id isn't used, tag isn't exist
self.assertEqual(0, self._tag_dict.set_id(10, 'first tag'))
self.assertEqual('first tag', self._tag_dict[10])
# id isn't used, tag is exist
self.assertEqual(10, self._tag_dict.set_id(20, 'first tag'))
self.assertEqual('KeyError: 10', self._tag_dict[10])
self.assertEqual('first tag', self._tag_dict[20])
# id is used, tag isn't exist
self.assertEqual(0, self._tag_dict.set_id(20, 'second tag'))
self.assertEqual('second tag', self._tag_dict[20])
self.assertEqual('first tag', self._tag_dict[0])
# id is used, tag is exist
self.assertEqual(0, self._tag_dict.set_id(20, 'first tag'))
self.assertEqual('first tag', self._tag_dict[20])
self.assertEqual('second tag', self._tag_dict[0])
def test_rename(self):
self.assertEqual(0, self._tag_dict.add('no tag'))
self._tag_dict.rename('no tag', 'No tag!')
self.assertEqual(0, self._tag_dict.get_id('No tag!'))
def test_str(self):
self._tag_dict.add('tag C')
self._tag_dict.add('tag b')
self._tag_dict.add('tag A')
self.assertEqual(
'2) tag A\n'
'1) tag b\n'
'0) tag C',
str(self._tag_dict),
)
def tearDown(self) -> None:
db.clear()
db.save()
def setUp(self) -> None:
db.load()
td = TagDict()
td.add('no tag')
td.add('test tag')
self._record_list = RecordList()
def setUp(self) -> None:
db.load()
td = TagDict()
td.add('no tag')
td.add('test tag')
from datetime import datetime
from typing import Optional
from tagdict import TagDict
from datetime_format import datetime_to_str
tag_dict = TagDict()
class Record:
def __init__(
self,
dt: Optional[datetime] = None,
tag_id: int = 0,
is_active: Optional[bool] = None,
note: str = '',
):
self._dt = dt if dt else datetime.now()
self._tag_id = tag_id
self._note = note
self._is_active = is_active
def __eq__(self, other):
return (self._dt == other.get_dt()
and self._tag_id == other.get_tag_id()
and self._note == other.get_note())
def __str__(self):
result = '[' + datetime_to_str(self._dt) + ']'
result += ' <' + self._tag_id_and_is_active_to_str() + '>'
if self._note: