def test_ContentElementsSimple_load_fm_db(client, value):
'''clean up structure and content tables'''
# [_structure.delete_fm_db() for _structure in StructureModel.find()]
[_content.delete_fm_db() for _content in ContentModel.find()]
'''init'''
'''Create test constants'''
_view_id = choice(global_constants.get_VIEWS_PKS)
_locale_id = choice(global_constants.get_PKS)
_record_id = '_'.join([
str(randrange(99)).zfill(2),
choice(ContentElementsSimple._types)])
_value = value('simple element load fm db testing')
'''Fill contents table'''
_record = content_schema.load({
'identity': _record_id, 'view_id': _view_id,
'locale_id': _locale_id, 'title': _value.get('title'),
'content': _value.get('content')
}, session=dbs_global.session)
_record.save_to_db()
content_elements_simple = ContentElementsSimple.load_fm_db(
identity=_record_id, view_id=_view_id, locale_id=_locale_id)
assert content_elements_simple.upper_index\
== int(_record_id.split('_')[0])
assert content_elements_simple.type == _record_id.split('_')[1]
_simple_json = json.dumps(
content_elements_simple.element.value, sort_keys=True)
# _value_json =
assert _simple_json == json.dumps(_value, sort_keys=True)
def _method(
upper_index: int = 0, type: str = '', marker: str = ''):
return ContentElementsSimple(
upper_index=upper_index, type=type, name=f'name of {type}',
element=ContentElement({
'title': f'Title for {type} {marker}',
'content': f'Content for {type} {marker}'
})
)
def test_ContentElementsSimple_init_fail(value):
'''fails'''
'''wrong_type'''
_upper_index = 6
_type = 'header'
_name = 'name'
_wrong_type = 'wrong_type'
with pytest.raises(WrongTypeError) as e_info:
ContentElementsSimple(
upper_index=_upper_index, type=_wrong_type,
name=_name, element=value())
assert str(e_info.value)\
== ("Upper level element could be "
f"'{ContentElementsSimple._type_values}', but "
f"provided type is '{_wrong_type}'.")
'''wrong value key'''
_wrong_key = 'wrong'
_wrong_value = {**value(), _wrong_key: 'new value for wrong key'}
_wrong_value.pop('title')
with pytest.raises(WrongElementKeyError) as e_info:
ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_name, element=_wrong_value)
assert str(e_info.value)\
== ("Content element value key should be either 'title' or "
f"'content', but one of them is '{_wrong_key}'.")
'''wrong value type'''
_wrong_value = 0
with pytest.raises(WrongElementTypeError) as e_info:
ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_name, element=_wrong_value)
assert str(e_info.value)\
== ("Element type should be either 'Dict' or 'ContentElement', "
f"but it's '{type(_wrong_value)}'.")
'''wrong name type'''
_wrong_name = 456
content_elements_simple = ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_wrong_name, element=value())
assert content_elements_simple.name == ''
def test_ContentElementsSimple_init_success(value, content_element):
'''initializing using values'''
_upper_index = 6
_type = 'header'
_name = 'name'
content_elements_simple_value = ContentElementsSimple(
upper_index=_upper_index, type=_type, name=_name, element=value())
assert content_elements_simple_value.upper_index == _upper_index
assert content_elements_simple_value.type == _type
assert content_elements_simple_value.name == _name
assert isinstance(content_elements_simple_value.element,
ContentElement)
assert content_elements_simple_value.element.value == value()
'''initializing using instance'''
content_elements_simple_instance = ContentElementsSimple(
upper_index=_upper_index, type=_type, name=_name, element=value())
assert content_elements_simple_instance.upper_index == _upper_index
assert content_elements_simple_instance.type == _type
assert content_elements_simple_instance.name == _name
assert isinstance(content_elements_simple_instance.element,
ContentElement)
assert content_elements_simple_instance.element.value == value()
def test_ContentElementsSimple_delete_fm_db(client, value):
'''clean up structure and content tables'''
# [_structure.delete_fm_db() for _structure in StructureModel.find()]
[_content.delete_fm_db() for _content in ContentModel.find()]
'''init'''
_view_id = choice(global_constants.get_VIEWS_PKS)
_locale_id = choice(global_constants.get_PKS)
_upper_index = randrange(100)
_type = 'header'
_name = 'name'
_value = value('db value')
_element = value('element value')
_identity = '_'.join([str(_upper_index).zfill(2), _type])
'''creating record in db'''
_record = content_schema.load({
'identity': _identity,
'view_id': _view_id, 'locale_id': _locale_id,
'title': _value.get('title'), 'content': _value.get('content')
}, session=dbs_global.session)
_record.save_to_db()
'''test it exists'''
_found_db_instance = ContentModel.find_by_identity_view_locale(
identity=_identity,
view_id=_view_id, locale_id=_locale_id
)
assert _found_db_instance.identity\
== _identity
assert _found_db_instance.view_id == _view_id
assert _found_db_instance.locale_id == _locale_id
assert _found_db_instance.title == _value.get('title')
assert _found_db_instance.content == _value.get('content')
'''create element instance with same PKs and delete record with
the element'''
_element_instance = ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_name, element=_element)
_element_instance.delete_fm_db(view_id=_view_id, locale_id=_locale_id)
'''check there is nothing in db'''
_found_db_instance = ContentModel.find_by_identity_view_locale(
identity=_identity,
view_id=_view_id, locale_id=_locale_id)
assert _found_db_instance is None
'''try to delete the instance once more'''
with pytest.raises(RecordNotFoundError) as e_info:
_element_instance.delete_fm_db(
view_id=_view_id, locale_id=_locale_id)
# assert str(e_info.value)\
# == (f"Record with identity '{_identity}', view id '{_view_id}' "
# f"and locale id '{_locale_id}' has not been found.")
assert str(e_info.value).find(_identity) != -1
assert str(e_info.value).find(_view_id) != -1
assert str(e_info.value).find(_locale_id) != -1
def test_ContentElementsSimple_set_get(value):
'''init'''
_upper_index = 6
_type = 'header'
_name = 'name'
content_elements_simple = ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_name, element=value())
# _type, _name, value)
assert content_elements_simple.upper_index == _upper_index
assert content_elements_simple.type == _type
assert content_elements_simple.name == _name
assert content_elements_simple.element.value == value()
'''success'''
_new_type = 'footer'
_new_name = 'new name'
_new_content = 'new content!'
_new_value = {'content': _new_content}
content_elements_simple.type = _new_type
assert content_elements_simple.type == _new_type
content_elements_simple.name = _new_name
assert content_elements_simple.name == _new_name
content_elements_simple.element = _new_value
assert content_elements_simple.element.value == {
'title': value().get('title'),
'content': _new_content
}
'''fails'''
'''wrong_type'''
_wrong_type = 'wrong_type'
with pytest.raises(WrongTypeError) as e_info:
content_elements_simple.type = _wrong_type
assert str(e_info.value)\
== ("Upper level element could be '['header', 'footer']', but "
f"provided type is '{_wrong_type}'.")
'''wrong value key'''
_wrong_key = 'wrong'
_wrong_value = {**value(), _wrong_key: 'new value for wrong key'}
_wrong_value.pop('title')
with pytest.raises(WrongElementKeyError) as e_info:
content_elements_simple.element = _wrong_value
assert str(e_info.value)\
== ("Content element value key should be either 'title' or "
f"'content', but one of them is '{_wrong_key}'.")
def test_ContentElementsSimple_serialize_to_structure(value):
'''init'''
_upper_index = 6
_type = 'header'
_name = 'name'
content_element = ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_name, element=value())
assert content_element.upper_index == _upper_index
assert content_element.type == _type
assert content_element.name == _name
assert content_element.element.value == value()
assert content_element.serialize_to_structure\
== {
str(_upper_index).zfill(2): {
'name': _name,
'type': _type
}
}
def test_ContentElementsSimple_serialize_to_content(value):
'''init'''
_upper_index = randrange(100)
_type = 'header'
_name = 'name'
content_element = ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_name, element=value())
assert content_element.upper_index == _upper_index
assert content_element.type == _type
assert content_element.name == _name
assert content_element.element.value == value()
_element_json = json.dumps(content_element.serialize_to_content,
sort_keys=True)
_testing_json = json.dumps({
'identity': '_'.join([str(_upper_index).zfill(2), _type]),
'title': value().get('title'),
'content': value().get('content'),
}, sort_keys=True)
assert _element_json == _testing_json
def _method(locale: str = '', size_00: int = 0, user_id: int = 0,
clean: bool = True):
'''clean up content tables if required'''
if clean:
[_structure.delete_fm_db()
for _structure in StructureModel.find()]
[_content.delete_fm_db() for _content in ContentModel.find()]
'''choose testing constants'''
_view_id = choice(global_constants.get_VIEWS_PKS)
if locale == '':
_locale_id = choice(global_constants.get_PKS)
else:
_locale_id = locale
_upper_index_00 = randrange(100)
_upper_index_01 = randrange(100)
while _upper_index_01 == _upper_index_00:
_upper_index_01 = randrange(100)
_upper_index_02 = randrange(100)
while _upper_index_02 == _upper_index_00\
or _upper_index_02 == _upper_index_01:
_upper_index_02 = randrange(100)
_upper_index_03 = randrange(100)
while _upper_index_03 == _upper_index_00\
or _upper_index_03 == _upper_index_01\
or _upper_index_03 == _upper_index_02:
_upper_index_03 = randrange(100)
if size_00 == 0:
_size_00 = randrange(3, 7)
else:
_size_00 = size_00
_size_01 = randrange(2, 5)
_type_00 = choice(ContentElementsBlock._types)
_type_01 = choice([item for item in ContentElementsBlock._types
if item != _type_00])
_type_02 = choice(ContentElementsSimple._types)
_type_03 = choice([item for item in ContentElementsSimple._types
if item != _type_02])
_subtype_00 = choice(ContentElementsBlock._subtypes)
_subtype_01 = choice(
[item for item in ContentElementsBlock._subtypes
if item != _subtype_00])
_name_00 = f'name of {_type_00}'
_name_01 = f'name of {_type_01}'
_name_02 = f'name of {_type_02}'
_name_03 = f'name of {_type_03}'
_elements_dict_00 = elements_dict(_size_00)
_elements_dict_01 = elements_dict(_size_01)
_element_00 = element(0)
_element_01 = element(1)
_block_instance_00 = ContentElementsBlock(
upper_index=_upper_index_00,
type=_type_00, subtype=_subtype_00,
name=_name_00, elements=_elements_dict_00)
_block_instance_00.save_to_db_content(
view_id=_view_id, locale_id=_locale_id, user_id=user_id,
save_structure=True)
_block_instance_01 = ContentElementsBlock(
upper_index=_upper_index_01,
type=_type_01, subtype=_subtype_01,
name=_name_01, elements=_elements_dict_01)
_block_instance_01.save_to_db_content(
view_id=_view_id, locale_id=_locale_id, user_id=user_id,
save_structure=True)
_simple_instance_00 = ContentElementsSimple(
upper_index=_upper_index_02, type=_type_02,
name=_name_02, element=_element_00)
_simple_instance_00.save_to_db_content(
view_id=_view_id, locale_id=_locale_id, user_id=user_id,
save_structure=True)
_simple_instance_01 = ContentElementsSimple(
upper_index=_upper_index_03, type=_type_03,
name=_name_03, element=_element_01)
_simple_instance_01.save_to_db_content(
view_id=_view_id, locale_id=_locale_id, user_id=user_id,
save_structure=True)
_structure_block_00 = _block_instance_00.serialize_to_structure
_structure_block_01 = _block_instance_01.serialize_to_structure
_structure_simple_00 = _simple_instance_00.serialize_to_structure
_structure_simple_01 = _simple_instance_01.serialize_to_structure
# print('\ntest_api_contents_handling:\n create_test_content',
# '\n _structure_simple_00 ->', _structure_simple_00,
# '\n _structure_simple_01 ->', _structure_simple_01,
# )
return {
'view_id': _view_id,
'locale_id': _locale_id,
'block_00': {
'upper_index': _upper_index_00,
'type': _type_00,
'subtype': _subtype_00,
'name': _name_00,
'qnt': _structure_block_00.get(
str(_upper_index_00).zfill(2)).get('qnt'),
'structure': _structure_block_00
},
'block_01': {
'upper_index': _upper_index_01,
'type': _type_01,
'subtype': _subtype_01,
'name': _name_01,
'qnt': _structure_block_01.get(
str(_upper_index_01).zfill(2)).get('qnt'),
'structure': _structure_block_01
},
'simple_00': {
'upper_index': _upper_index_02,
'type': _type_02,
'name': _name_02,
'structure': _structure_simple_00
},
'simple_01': {
'upper_index': _upper_index_03,
'type': _type_03,
'name': _name_03,
'structure': _structure_simple_01
}
}
def test_ContentElementsSimple_save_to_db_content_structure(
client, value):
'''clean up structure and content tables'''
[_structure.delete_fm_db() for _structure in StructureModel.find()]
[_content.delete_fm_db() for _content in ContentModel.find()]
'''init'''
_view_id = choice(global_constants.get_VIEWS_PKS)
_locale_id = choice(global_constants.get_PKS)
_upper_index = randrange(100)
_user_id = randrange(64)
_type = 'header'
_name = 'name'
# _value = value('db value')
_element = value('element value')
'''creating element for testing'''
_content_element = ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_name, element=_element)
_content_element.save_to_db_content(
view_id=_view_id, locale_id=_locale_id, user_id=_user_id,
save_structure=True)
'''testing useing load'''
_loaded_instance = ContentElementsSimple.load_fm_db(
identity={'_'.join([str(_upper_index).zfill(2), _type])},
view_id=_view_id, locale_id=_locale_id, load_name=True)
'''test loaded element'''
assert _loaded_instance.upper_index == _upper_index
assert _loaded_instance.type == _type
assert _loaded_instance.name == _name
assert _loaded_instance.element.value == _element
'''testing records in tables'''
_found_db_instance = ContentModel.find_by_identity_view_locale(
identity='_'.join([str(_upper_index).zfill(2), _type]),
view_id=_view_id, locale_id=_locale_id
)
assert _found_db_instance.identity\
== '_'.join([str(_upper_index).zfill(2), _type])
assert _found_db_instance.title == _element.get('title')
assert _found_db_instance.content == _element.get('content')
'''update db record with element instance, same PKs'''
_element = value(marker='new value')
_name = f'new {_name}'
# _upper_index = randrange(50, 100)
_user_id = randrange(64, 128)
_new_instance = ContentElementsSimple(
upper_index=_upper_index, type=_type,
name=_name, element=_element)
_new_instance.save_to_db_content(
view_id=_view_id, locale_id=_locale_id,
user_id=_user_id, save_structure=True)
_found_identity = ContentElementsSimple.load_fm_db(
identity='_'.join([str(_upper_index).zfill(2), _type]),
view_id=_view_id,
locale_id=_locale_id,
load_name=True
)
assert _found_identity.upper_index == _upper_index
assert _found_identity.type == _type
# assert _found_identity.name == _name
assert _found_identity.element.value == _element