tests/test_uDB.py - main - VolcanoByte/vbNotes

tests/test_uDB.py
224 строки8 KB
Eugene Gavrilyuk
feat: Меню Последние открытые файлы
24 июл 2025, 17:19
24 июл 2025, 17:19d742c57
from unittest import TestCase

from PyQt6.QtWidgets import QApplication
import os
import sys
from copy import copy
from time import sleep

from sources.uDB import DB
from sources.uNote import Note

TEST_DB = 'test.db'
TEST_GIST_ID = 'GistId0000'

app = QApplication(sys.argv)

class TestDB(TestCase):
    def setUp(self):
        if os.path.exists(TEST_DB):
            os.remove(TEST_DB)
        self.db = DB()
        self.db.open(TEST_DB)

    def tearDown(self):
        self.db.close()

    @staticmethod
    def makeNote(tags: set = None) -> Note:
        """Создает тестовую заметку с указанным тегами и id гиста, если нужно"""

        note = Note()

        note.data = {
            'fldNoteTitle': 'Test note',
            'fldNoteDescription': 'Test description',
            'fldNoteText': 'Test note text',
        }

        note.tags = copy(tags)

        return note

    def test_open(self):
        self.assertTrue(self.db.conn.isOpen())
        self.assertTrue(os.path.exists(TEST_DB), 'База данных не создана')

    def test_reopen(self):
        self.db.open(TEST_DB)
        self.db.close()
        self.db.reopen()
        self.assertTrue(self.db.conn.isOpen())
        self.assertTrue(os.path.exists(TEST_DB), 'База данных не создана')

    def test_close(self):
        self.db.open(TEST_DB)
        self.db.close()
        self.assertFalse(self.db.conn.isOpen())

    def test_create_tables(self):
        self.assertTrue(os.path.exists('test.db'), 'База данных не создана')
        self.assertTrue('tblNotes' in self.db.conn.tables(),
                        'В базе отсутствует таблица tblNotes')
        self.assertTrue('tblTags' in self.db.conn.tables(),
                        'В базе отсутствует таблица tblTags')
        self.assertTrue('tblNoteTag' in self.db.conn.tables(),
                        'В базе отсутствует таблица tblNoteTag')
        self.assertTrue('tblProperties' in self.db.conn.tables(),
                        'В базе отсутствует таблица tblProperties')

    def test_prepare_tags(self):
        #  Добавляем заметку с двумя тегами
        id1 = self.db.addNote(self.makeNote({'kotlin', 'python'}))
        # Удаляем тег у заметки
        self.db.deleteNoteTag(id1, 'kotlin')
        #  Добавляем тег без привязки
        self.db.addTags({'delphi'})
        self.assertEqual(self.db.getRecCount('tblTags'), 3)
        self.db.prepareTags()
        self.assertEqual(self.db.getRecCount('tblTags'), 1)

    def test_getSyncId(self):
        syncId = self.db.getSyncId()
        self.assertIsNotNone(syncId)
        self.assertEqual(syncId, 'test')

    def test_setSyncId(self):
        self.db.setSyncId('new_test')
        self.assertIsNotNone(self.db.syncId)
        self.assertEqual(self.db.syncId, 'new_test')

    def test_timestamp(self):
        ts = self.db.getTimestamp()
        self.assertIsNone(ts)
        self.db.setTimestamp()
        ts = self.db.getTimestamp()
        self.assertIsNotNone(ts)

    def test_get_field_indexes(self):
        self.db.query.exec('SELECT fldNoteId, fldNoteTitle FROM tblNotes')
        _fields = self.db.getFieldIndexes(self.db.query)
        self.assertTrue(len(_fields) == 2)
        self.assertTrue(_fields['fldNoteId'] == 0)
        self.assertTrue(_fields['fldNoteTitle'] == 1)
        self.assertFalse('fldNoteGist' in _fields.keys())

    def test_get_rec_count(self):
        self.db.addNote(self.makeNote({'kotlin'}))
        self.db.addNote(self.makeNote({'kotlin', 'python'}))
        self.assertTrue(self.db.getRecCount('tblNotes') == 2)

    def test_add_note(self):
        _id = self.db.addNote(self.makeNote({'kotlin', 'python'}))
        self.assertIsNotNone(_id)
        self.assertTrue(self.db.getRecCount('tblNotes') == 1)

    def test_update_note(self):
        note = self.makeNote({'kotlin', 'python'})
        _id = self.db.addNote(note)
        _note1 = self.db.getNote(_id)
        sleep(1)

        note.data['fldNoteTitle'] = 'New title'
        self.db.updateNote(_id, note)
        _note2 = self.db.getNote(_id)

        self.assertTrue(_note1.data['fldNoteUpdatedAt'] != _note2.data[
            'fldNoteUpdatedAt'])
        self.assertTrue(_note2.data['fldNoteTitle'] == 'New title')

    def test_set_note_updated_at(self):
        note = self.makeNote({'kotlin', 'python'})
        _id = self.db.addNote(note)
        self.db.setNoteUpdatedAt(_id, '2025-07-05T12:00:00Z')
        _note1 = self.db.getNote(_id)
        self.assertEqual('2025-07-05T12:00:00Z', _note1.data['fldNoteUpdatedAt'])

    def test_get_note(self):
        note = self.makeNote({'kotlin', 'python'})
        _id = self.db.addNote(note)
        _note1 = self.db.getNote(_id)
        self.assertEqual(_id, int(_note1.data['fldNoteId']))

    def test_delete_note(self):
        note = self.makeNote({'kotlin', 'python'})
        _id = self.db.addNote(note)
        self.db.deleteNote(_id)
        self.assertIsNone(self.db.getNote(_id))

    def test_delete_notes(self):
        note = self.makeNote({'kotlin', 'python'})
        _id1 = self.db.addNote(note)
        note = self.makeNote({'kotlin', 'pascal'})
        _id2 = self.db.addNote(note)
        self.db.deleteNotes((_id1, _id2))
        self.assertIsNone(self.db.getNote(_id1))
        self.assertIsNone(self.db.getNote(_id2))

    def test_add_tag(self):
        note = self.makeNote({'kotlin', 'python'})
        _id = self.db.addNote(note)
        self.db.addTag('delphi')
        self.assertEqual(3, self.db.getRecCount('tblTags'))

    def test_add_tags(self):
        self.db.addTags(('kotlin', 'python', 'delphi'))
        self.assertEqual(3, self.db.getRecCount('tblTags'))

    def test_get_tag_name(self):
        self.db.addTag('kotlin')
        _id = self.db.addTag('delphi')
        self.db.addTag('python')
        self.assertEqual('delphi', self.db.getTagName(_id))

    def test_get_tag_id(self):
        self.db.addTag('kotlin')
        _id = self.db.addTag('delphi')
        self.db.addTag('python')
        self.assertEqual(_id, self.db.getTagId('DElphi'))

    def test_delete_tag(self):
        self.db.addTags(('kotlin', 'python', 'delphi'))
        self.assertEqual(3, self.db.getRecCount('tblTags'))
        self.db.deleteTag('delphi')
        self.assertEqual(2, self.db.getRecCount('tblTags'))

    def test_add_note_tag(self):
        note = self.makeNote({'kotlin', 'python'})
        _id = self.db.addNote(note)
        self.db.addNoteTag(_id, 'delphi')
        tags = self.db.getNotesTags((_id,))
        self.assertEqual(3, len(tags))

    def test_add_note_tags(self):
        note = self.makeNote({'kotlin'})
        _id = self.db.addNote(note)
        self.db.addNoteTags(_id, ('python', 'delphi', 'kotlin'))
        tags = self.db.getNotesTags((_id,))
        self.assertEqual(3, len(tags))

    def test_get_note_tag_names(self):
        note = self.makeNote({'kotlin', 'python','delphi'})
        _id = self.db.addNote(note)
        tags = self.db.getNotesTags((_id,))
        self.assertEqual(3, len(tags))

    def test_delete_note_tag(self):
        note = self.makeNote({'kotlin', 'python','delphi'})
        _id = self.db.addNote(note)
        self.db.deleteNoteTag(_id, 'Delphi')
        tags = self.db.getNotesTags((_id,))
        self.assertEqual(2, len(tags))

    def test_clear_note_tags(self):
        note = self.makeNote({'kotlin', 'python','delphi'})
        _id = self.db.addNote(note)
        self.db.clearNoteTags(_id)
        tags = self.db.getNotesTags((_id,))
        self.assertEqual(0, len(tags))

    def test_get_note_tags(self):
        note = self.makeNote({'kotlin', 'python','delphi'})
        _id = self.db.addNote(note)
        tags = self.db.getNotesTags((_id,))
        self.assertEqual(3, len(tags))