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