def test_type_relationship(self, item): word = dar(Word, item) type_data = [t for t in types if t["id"] == word.type_id][0] type_ = dar(Type, type_data) type_from_db = Type.get_by_id(word.type_id) assert isinstance(type_, Type) assert isinstance(type_from_db, Type) assert type_from_db == type_ == word.type
def test_link_keys_from_definition_body(self): db_add_objects(Key, keys) d = dar(Definition, definition_1) assert d.keys.count() == 0 d.link_keys_from_definition_body() assert d.keys.count() == 2 assert sorted([k.word for k in d.keys]) == sorted(["test", "examine"])
def test_definitions_relationship(self): word = dar(Word, word_1) definitions_to_add = [ d for d in definitions if d["word_id"] == word.id ] db_add_objects(Definition, definitions_to_add) assert word._definitions.count() == len(definitions_to_add) == 5 assert isinstance(word._definitions[0], Definition)
def test_link_key_from_str(self): db_add_objects(Key, keys) d = dar(Definition, definition_2) assert d.keys.count() == 0 key_to_add = "tester" d.link_key_from_str(key_to_add) assert d.keys.count() == 1 assert d.keys.first().word == key_to_add
def test_create_from_dict_with_data(self, item): """Get Word by ID.""" key = dar(Key, item) key_from_db = Key.get_by_id(item["id"]) assert key == key_from_db assert isinstance(key, Key) assert isinstance(key.id, int) assert isinstance(key.word, str) assert isinstance(key.language, (str, type(None)))
def test_create_from_dict_with_data(self, item): """Get Word by ID.""" author = dar(Author, item) author_from_db = Author.get_by_id(item["id"]) assert author == author_from_db assert isinstance(author, Author) assert isinstance(author.id, int) assert isinstance(author.abbreviation, str) assert isinstance(author.full_name, (str, type(None))) assert isinstance(author.notes, (str, type(None)))
def test_create_from_dict_with_data(self, item): """Get Word by ID.""" syllable = dar(Syllable, item) syllable_from_db = Syllable.get_by_id(item["id"]) assert syllable == syllable_from_db assert isinstance(syllable, Syllable) assert isinstance(syllable.id, int) assert isinstance(syllable.name, str) assert isinstance(syllable.type, str) assert isinstance(syllable.allowed, (bool, type(None)))
def test_create_from_dict_with_data(self, item): """Get Word by ID.""" setting = dar(Setting, item) setting_from_db = Setting.get_by_id(item["id"]) assert setting == setting_from_db assert isinstance(setting, Setting) assert isinstance(setting.id, int) assert isinstance(setting.date, (datetime.datetime, type(None))) assert isinstance(setting.db_version, int) assert isinstance(setting.last_word_id, int) assert isinstance(setting.db_release, str)
def test_create_from_dict_with_data(self, item): type_ = dar(Type, item) type_from_db = Type.get_by_id(item["id"]) assert type_ == type_from_db assert isinstance(type_.id, int) assert isinstance(type_.type, str) assert isinstance(type_.type_x, str) assert isinstance(type_.group, (str, type(None))) assert isinstance(type_.parentable, bool) assert isinstance(type_.description, (str, type(None))) with pytest.raises(Exception) as _: assert type_.type == "A-Prim"
def test_uniqueness(self): db_add_objects(Key, [ un_key_1, un_key_2, ]) result = [k.word for k in Key.get_all()] assert result == [ "examine", "examine", ] with pytest.raises(sqlalchemy.exc.IntegrityError) as _: assert isinstance(dar(Key, un_key_3), Key)
def test_link_keys(self): db_add_objects(Key, keys) d0 = dar(Definition, definitions[0]) assert d0.keys.count() == 0 keys_to_add_str = ["test", "examine"] d0.link_keys(keys_to_add_str) assert d0.keys.count() == 2 d1 = dar(Definition, definitions[1]) assert d1.keys.count() == 0 key_to_add_str = "tester" d1.link_keys(key_to_add_str) assert d1.keys.count() == 1 d2 = dar(Definition, definitions[10]) assert d2.keys.count() == 0 d2.link_keys() assert d2.keys.count() == 2 d3 = dar(Definition, definitions[3]) es_word, es_code = "probar", "es" ru_word, ru_code = "тест", "ru" db_add_object(Key, {"word": es_word, "language": es_code}) db_add_object(Key, {"word": ru_word, "language": ru_code}) d3.link_keys(source=ru_word, language=ru_code) assert d3.keys.first().language == ru_code d3.link_keys(source=es_word, language=es_code) assert d3.keys.count() == 2 assert sorted([k.language for k in d3.keys.all()]) == [es_code, ru_code] d4 = dar(Definition, definitions[4]) with pytest.raises(TypeError) as _: d4.link_keys(source=1234) with pytest.raises(TypeError) as _: d4.link_keys(source=[1234, 4321])
def test_event_relationship(self, item): db_add_objects(Event, all_events) word = dar(Word, item) event_start_from_db = Event.get_by_id(word.event_start_id) assert isinstance(event_start_from_db, Event) assert event_start_from_db == word.event_start if word.event_end_id: event_end_from_db = Event.get_by_id(word.event_end_id) assert isinstance(event_end_from_db, Event) assert event_end_from_db == word.event_start else: assert word.event_end is None
def test_create_from_dict_with_data(self, item): """Get Word by ID.""" event = dar(Event, item) event_from_db = Event.get_by_id(item["id"]) assert event == event_from_db assert isinstance(event, Event) assert isinstance(event.id, int) assert isinstance(event.date, datetime.date) assert isinstance(event.name, str) assert isinstance(event.definition, str) assert isinstance(event.annotation, str) assert isinstance(event.suffix, str)
def test_create_from_dict_with_data(self, item): definition = dar(Definition, item) definition_from_db = Definition.get_by_id(item["id"]) assert definition == definition_from_db assert isinstance(definition.id, int) assert isinstance(definition.word_id, int) assert isinstance(definition.position, int) assert isinstance(definition.usage, (str, type(None))) assert isinstance(definition.grammar_code, (str, type(None))) assert isinstance(definition.slots, (int, type(None))) assert isinstance(definition.case_tags, (str, type(None))) assert isinstance(definition.body, str) assert isinstance(definition.language, (str, type(None))) assert isinstance(definition.notes, (str, type(None)))
def test_create_from_dict_with_data(self, item): """Get Word by ID.""" word = dar(Word, item) word_from_db = Word.get_by_id(item["id"]) assert word == word_from_db assert isinstance(word.id, int) assert isinstance(word.id_old, int) assert isinstance(word.name, str) assert isinstance(word.origin, (str, type(None))) assert isinstance(word.origin_x, (str, type(None))) assert isinstance(word.match, (str, type(None))) assert isinstance(word.rank, (str, type(None))) assert isinstance(word.year, (datetime.date, type(None))) assert isinstance(word.notes, (dict, type(None))) assert isinstance(word.TID_old, (int, type(None)))