def test_insert_upper_level_element(saved_structure_instance,
structure_get_schema, attributes):
'''clean up structure tables'''
[_structure.delete_fm_db() for _structure in StructureModel.find()]
'''fill structure table'''
fill_structure()
'''choose constants to work with structure'''
_criterions = {
'view_id': choice(global_constants.get_VIEWS_PKS),
'locale_id': choice(global_constants.get_PKS)
}
_uplev_elem_index = 1
_uplev_elem_items = {
'type': 'hblock',
'subtype': 'pix',
'qnt': '3',
'name': 'fancy name'
}
_first_user_id = randrange(128)
'''update original structure to work with'''
_updating_structure = StructureModel.find_by_ids(_criterions)
_updating_structure.update({'attributes': attributes})
'''insert upper level element'''
_updating_structure.insert_element(_uplev_elem_index, _uplev_elem_items,
_first_user_id)
def test_PageView_load_fm_db(client, view_name, locale, elements):
'''clean up content table'''
[_structure.delete_fm_db() for _structure in StructureModel.find()]
[_content.delete_fm_db() for _content in ContentModel.find()]
_user_id = randrange(128)
_view_name = view_name()
_locale = locale()
_elements = elements()
_page_view = PageView(view_name=_view_name,
locale=_locale,
elements=_elements)
_page_view.save_to_db(user_id=_user_id)
'''success'''
_page_view_fm_db = PageView.load_fm_db(ids={
'view_id': _view_name,
'locale_id': _locale
})
assert _page_view_fm_db.view_name == _page_view.view_name
assert _page_view_fm_db.locale == _page_view.locale
assert len(_page_view_fm_db.elements) == len(_page_view.elements)
for i, element in enumerate(_page_view.elements):
_type = type(element)
assert isinstance(_page_view_fm_db.elements[i], _type)
assert _page_view_fm_db.elements[i].name == element.name
if isinstance(element, ContentElementsBlock):
assert len(_page_view_fm_db.elements[i].elements)\
== len(element.elements)
'''fails'''
_wrong = 'wrong'
_fm_db = PageView.load_fm_db({'view_id': _wrong, 'locale_id': locale})
assert _fm_db is None
def test_StructureModel_find(client, create_test_content):
lng_00 = 'en'
lng_01 = 'ru'
create_test_content(locale=lng_00)
create_test_content(locale=lng_01, clean=False)
_found = StructureModel.find()
assert isinstance(_found, List)
assert len(_found) == 2
_found = StructureModel.find(searching_criterions={'user_id': 0})
assert len(_found) == 2
_found = StructureModel.find(searching_criterions={'user_id': 1})
assert len(_found) == 0
_found = StructureModel.find(searching_criterions={
'user_id': 0,
'locale_id': 'en'
})
assert len(_found) == 1
def test_change_element_qnt(saved_structure_instance, structure_get_schema,
attributes):
'''clean up structure tables'''
[_structure.delete_fm_db() for _structure in StructureModel.find()]
'''Fill structure table'''
fill_structure()
'''Choose constants to work with structure'''
_criterions = {
'view_id': choice(global_constants.get_VIEWS_PKS),
'locale_id': choice(global_constants.get_PKS)
}
_block_index = 1
_qnt = attributes.get(str(_block_index).zfill(2)).get('qnt')
_first_user_id = randrange(128)
'''Update structure'''
_updating_structure = StructureModel.find_by_ids(_criterions)
_updating_structure.update({'attributes': attributes})
_us_dumped = structure_get_schema.dump(_updating_structure)
_element_qnt = _us_dumped.get('attributes').get(
str(_block_index).zfill(2)).get('qnt')
_user_id = _us_dumped.get('user_id')
'''Expect it's updated as per available constants'''
assert _element_qnt == _qnt
assert _user_id == 0
'''add element'''
_updating_structure.change_element_qnt('inc', _block_index, _first_user_id)
'''Get elements and check expectations'''
_updated_structure = StructureModel.find_by_ids(_criterions)
_us_dumped = structure_get_schema.dump(_updated_structure)
_element_qnt = _us_dumped.get('attributes').get(
str(_block_index).zfill(2)).get('qnt')
_user_id = _us_dumped.get('user_id')
'''Expect it's updated as per available constants'''
assert _element_qnt == _qnt + 1
assert _first_user_id == _user_id
# print('\ntest_model_structure:\n test_add_element',
# '\n _updated_structure ->',
# structure_get_schema.dump(_updated_structure),
# '\n _element_qnt ->', _element_qnt)
'''remove element'''
_second_user_id = randrange(128)
_updating_structure.change_element_qnt('dec', _block_index,
_second_user_id)
'''Get elements and check expectations'''
_updated_structure = StructureModel.find_by_ids(_criterions)
_us_dumped = structure_get_schema.dump(_updated_structure)
_element_qnt = _us_dumped.get('attributes').get(
str(_block_index).zfill(2)).get('qnt')
_user_id = _us_dumped.get('user_id')
'''Expect it's updated as per available constants'''
assert _element_qnt == _qnt
assert _second_user_id == _user_id
def test_structure_list_success(client, user_instance, access_token, lng, qnt,
test_word):
'''
Right
'''
'''Fill structure table'''
fill_structure()
'''Admin in db'''
# _admin = user_instance(values={'role_id': 'admin'})
# _admin.save_to_db()
# _access_token = access_token(_admin)
_uuid = uuid4()
sessions.setter(str(_uuid))
_tech_token = create_access_token(_uuid, expires_delta=False)
_headers = {
'Authorization': f"Bearer {_tech_token}",
'Content-Type': 'application/json',
'Accept-Language': lng
}
_resp = client.get(url_for('structure_bp.structurelist'), headers=_headers)
assert _resp.status_code == 200
assert isinstance(_resp.json, Dict)
assert isinstance(_resp.json.get('payload'), List)
assert len(_resp.json.get('payload')) == qnt
assert _resp.json.get('message').find(test_word) != -1
if len(_resp.json.get('payload')) > 0:
assert [
structure.get('locale_id') == lng
for structure in _resp.json.get('payload')
]
print('\ntest_structure_list_success, _resp ->', _resp.status_code)
# print('test_structure_list_success, _resp ->', _resp.json.get('payload')[0])
# print('test_structure_list_success, _resp ->')
# [print(structure) for structure in _resp.json.get('payload')]
'''clean up users tables'''
# if _admin is not None:
# _admin.delete_fm_db()
'''clean up structure tables'''
[_structure.delete_fm_db() for _structure in StructureModel.find()]
def test_PageView_remove_vals(client, view_name, locale, simple_element,
block_element, elements):
'''clean up tables'''
[_content.delete_fm_db() for _content in ContentModel.find()]
[_structure.delete_fm_db() for _structure in StructureModel.find()]
_view_name = view_name()
_locale = locale()
_elements = elements()
_page_view = PageView(view_name=_view_name,
locale=_locale,
elements=_elements)
_length = len(_page_view.elements)
_remove_position = randrange(_length)
_element_in_page = dumps(_page_view.get_element_vals(_remove_position),
sort_keys=True)
_removed_element = dumps(_page_view.remove_vals(_remove_position),
sort_keys=True)
assert len(_page_view.elements) == _length - 1
assert _removed_element == _element_in_page
_last_element = _page_view.get_element_vals(_length - 2)
assert _last_element.get('index') == len(_page_view.elements) - 1
_page_view.save_to_db(user_id=randrange(128))
def test_delete(saved_structure_instance, structure_get_schema, view_id,
attributes):
'''Clean up'''
StructureModel.query.delete()
'''Create structures, it should be 10 of them.'''
_global_view_keys = global_constants.get_VIEWS_PKS
_global_locales_keys = global_constants.get_PKS
[{
'view_id': _view_key,
'locale_id': _locale_key
} for _view_key in _global_view_keys
for _locale_key in _global_locales_keys]
_structure_gens = [
saved_structure_instance({
'view_id': _view_key,
'locale_id': _locale_key,
'attributes': {
'view_id': _view_key,
'locale_id': _locale_key
}
}) for _view_key in _global_view_keys
for _locale_key in _global_locales_keys
]
[next(_structure_gen) for _structure_gen in _structure_gens]
'''Choose random keys to update structure'''
_criterions = {
'view_id': choice(_global_view_keys),
'locale_id': choice(_global_locales_keys)
}
_structure_to_delete = StructureModel.find_by_ids(_criterions)
_structure_to_delete.delete_fm_db()
_deleted_structure = StructureModel.find_by_ids(_criterions)
_left_stractures = StructureModel.find()
assert _deleted_structure is None
assert len(_left_stractures) == 9
'''Clean up'''
[next(_structure_gen) for _structure_gen in _structure_gens]
def test_PageView_save_to_db(client, view_name, locale, elements):
'''clean up content table'''
[_structure.delete_fm_db() for _structure in StructureModel.find()]
[_content.delete_fm_db() for _content in ContentModel.find()]
'''success'''
_user_id = randrange(128)
_view_name = view_name()
_locale = locale()
_elements = elements()
_page_view = PageView(view_name=_view_name,
locale=_locale,
elements=_elements)
_page_view.save_to_db(user_id=_user_id)
# print('\ntest_page_view:\n test_PageView_save_to_db')
# [print(
# ' _elements ->', element.upper_index) for element in _elements]
for element in _page_view.elements:
# print(' elements ->', element.__dict__)
_identity = '_'.join([str(element.upper_index).zfill(2), element.type])
if isinstance(element, ContentElementsBlock):
_identity = '_'.join([_identity, element.subtype])
# print(' _identity ->', _identity)
element_fm_db = element.load_fm_db(identity=_identity,
view_id=_view_name,
locale_id=_locale)
assert element.upper_index == element_fm_db.upper_index
assert element.type == element_fm_db.type
if isinstance(element, ContentElementsBlock):
assert element.subtype == element_fm_db.subtype
for j, item in enumerate(element.elements):
assert item.value == element_fm_db.elements[j].value
# print(' from_db ->', item.value)
# print(' from_db ->', element_fm_db.elements[j].value)
elif isinstance(element, ContentElementsSimple):
assert element.element.value == element_fm_db.element.value
'''failure'''
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_PageView_move_element(client, view_name, locale, simple_element,
block_element, elements):
'''it works I don't like to test success movements'''
'''clean up tables'''
[_content.delete_fm_db() for _content in ContentModel.find()]
[_structure.delete_fm_db() for _structure in StructureModel.find()]
_view_name = view_name()
_locale = locale()
_ids = {'view_id': _view_name, 'locale_id': _locale}
_elements = elements()
_page_view = PageView(view_name=_view_name,
locale=_locale,
elements=_elements)
_page_view.save_to_db(user_id=1)
_length = len(_page_view.elements)
'''success'''
'''moving up'''
# _index = 1
_index = randrange(1, _length)
_direction = 'up'
_moving_element = _page_view.get_element_vals(_index)
_moving_element.pop('index')
_moving_element_json = dumps(_moving_element, sort_keys=True)
_shifting_element = _page_view.get_element_vals(_index - 1)
_shifting_element.pop('index')
_shifting_element_json = dumps(_shifting_element, sort_keys=True)
_page_view.move_element(_index, _direction)
_page_view.save_to_db(user_id=2)
_loaded_view = PageView.load_fm_db(ids=_ids)
_moved_element = _loaded_view.get_element_vals(_index - 1)
_moved_element.pop('index')
_moved_element_json = dumps(_moved_element, sort_keys=True)
_shifted_element = _loaded_view.get_element_vals(_index)
_shifted_element.pop('index')
_shifted_element_json = dumps(_shifted_element, sort_keys=True)
assert _moved_element_json == _moving_element_json
assert _shifted_element_json == _shifting_element_json
# print('\ntest_page_view:\n test_PageView_move_element')
# [print(dumps(element.serialize_to_content, indent=4))
# for element in _loaded_view.elements]
'''moving down'''
_index = randrange(0, _length - 1)
_direction = 'down'
_moving_element = _page_view.get_element_vals(_index)
_moving_element.pop('index')
_moving_element_json = dumps(_moving_element, sort_keys=True)
_shifting_element = _page_view.get_element_vals(_index + 1)
_shifting_element.pop('index')
_shifting_element_json = dumps(_shifting_element, sort_keys=True)
_page_view.move_element(_index, _direction)
_moved_element = _page_view.get_element_vals(_index + 1)
_moved_element.pop('index')
_moved_element_json = dumps(_moved_element, sort_keys=True)
_shifted_element = _page_view.get_element_vals(_index)
_shifted_element.pop('index')
_shifted_element_json = dumps(_shifted_element, sort_keys=True)
assert _moved_element_json == _moving_element_json
assert _shifted_element_json == _shifting_element_json
'''fails'''
'''wrong combination index - direction'''
_direction = 'up'
_index = 0
with pytest.raises(WrongIndexError) as e_info:
_page_view.move_element(_index, _direction)
assert str(e_info.value).find('-1') != -1
_direction = 'down'
_index = _length - 1
with pytest.raises(WrongIndexError) as e_info:
_page_view.move_element(_index, _direction)
assert str(e_info.value).find('4') != -1
'''wrong direction'''
_direction = 'f**k'
with pytest.raises(WrongDirection) as e_info:
_page_view.move_element(_index, _direction)
assert str(e_info.value).find(_direction) != -1
def test_ContentElementsBlock_save_to_db_content_structure(
client, element, elements_dict):
'''clean up content table'''
[_structure.delete_fm_db() for _structure in StructureModel.find()]
[_content.delete_fm_db() for _content in ContentModel.find()]
'''create testing consants'''
_view_id = choice(global_constants.get_VIEWS_PKS)
_locale_id = choice(global_constants.get_PKS)
_upper_index = randrange(100)
_user_id = randrange(128)
_size = 10
# _size = randrange(3, 20)
_type = choice(ContentElementsBlock._types)
_subtype = choice(ContentElementsBlock._subtypes)
_name = f'name of {_type}'
_elements_dict = elements_dict(_size)
'''create ContentElementsBlock instance'''
_block_instance = ContentElementsBlock(upper_index=_upper_index,
type=_type,
subtype=_subtype,
name=_name,
elements=_elements_dict)
assert len(_block_instance.elements) == _size
'''save it to db'''
_block_instance.save_to_db_content(view_id=_view_id,
locale_id=_locale_id,
user_id=_user_id,
save_structure=True)
'''load insance having PKs and check it adequate to source'''
_loaded_instance = ContentElementsBlock.load_fm_db(identity='_'.join(
[str(_upper_index).zfill(2), _type, _subtype]),
view_id=_view_id,
locale_id=_locale_id,
load_name=True)
assert _loaded_instance.upper_index == _upper_index
assert _loaded_instance.type == _type
assert _loaded_instance.subtype == _subtype
assert _loaded_instance.name == _name
for i, element in enumerate(_loaded_instance.elements):
assert element.value == _elements_dict[i]
# print('\ntest_content_elements_block:',
# '\n test_ContentElementsBlock_save_to_db_content',
# '\n _loaded_instance ->', _loaded_instance)
'''get records directly from content table'''
_identity_like = '_'.join([str(_upper_index).zfill(2), _type, _subtype])
_content_model_instance = ContentModel.find_identity_like(
searching_criterions={
'view_id': _view_id,
'locale_id': _locale_id
},
identity_like=f"{_identity_like}%",
)
assert len(_content_model_instance) == _size
for i, element in enumerate(_content_model_instance):
_element_dict = content_get_schema.dump(element)
assert _element_dict == {
'identity': '_'.join([_identity_like,
str(i).zfill(3)]),
'view_id': _view_id,
'locale_id': _locale_id,
'user_id': _user_id,
**_elements_dict[i]
}
'''get record from structure table, check it'''
_structure_dict = StructureModel.find_by_ids({
'view_id': _view_id,
'locale_id': _locale_id
}).get_element(_upper_index)
assert _structure_dict == {
'type': _type,
'subtype': _subtype,
'qnt': _size,
'name': f'name of {_type}'
}
'''correct loaded ContentElementsBlock instance and reduce element
quantity'''
_block_instance.remove(randrange(len(_block_instance.elements)))
_block_instance.remove(randrange(len(_block_instance.elements)))
_index = randrange(len(_block_instance.elements))
_new_title = f"corrected title for element No '{_index}'"
_new_element = {
**_block_instance.get_element(index=_index).value, 'title': _new_title
}
_block_instance.set_element(index=_index, value=_new_element)
'''save it to db'''
_block_instance.save_to_db_content(view_id=_view_id,
locale_id=_locale_id,
user_id=_user_id,
save_structure=True)
'''load new instance and check it adequate to changes'''
_corrected_model_instance = ContentModel.find_identity_like(
searching_criterions={
'view_id': _view_id,
'locale_id': _locale_id
},
identity_like=f"{_identity_like}%",
)
assert len(_corrected_model_instance) == _size - 2
assert _corrected_model_instance[_index].serialize().get('title')\
== _new_title
'''get record from structure table, check it'''
_structure_dict = StructureModel.find_by_ids({
'view_id': _view_id,
'locale_id': _locale_id
}).get_element(_upper_index)
assert _structure_dict == {
'type': _type,
'subtype': _subtype,
'qnt': _size - 2,
'name': f'name of {_type}'
}
def test_ContentElementsBlock_move(client, view_name, locale, element,
elements_dict):
'''clean up content table'''
[_structure.delete_fm_db() for _structure in StructureModel.find()]
[_content.delete_fm_db() for _content in ContentModel.find()]
'''object variables'''
_view_name = view_name()
_locale = locale()
_upper_index = randrange(3, 20)
# _size = 3
_size = randrange(2, 10)
_type = 'vblock'
_subtype = 'txt'
_name = f'name of {_type}'
_elements_dict = elements_dict(_size)
# _element = element(_size)
_block_instance = ContentElementsBlock(upper_index=_upper_index,
type=_type,
subtype=_subtype,
name=_name,
elements=_elements_dict)
assert len(_block_instance._elements) == _size
_block_instance.save_to_db_content(view_id=_view_name,
locale_id=_locale,
user_id=randrange(128),
save_structure=True)
# _index = 1
_index = randrange(_size - 1)
'''fail'''
'''wrong direction'''
_wrong = 'f**k'
with pytest.raises(WrongDirection) as e_info:
_block_instance.move(index=_index, direction=_wrong)
assert str(e_info.value).find(_wrong) != -1
'''success, down'''
_direction = 'down'
_moving_element = _block_instance.get_element(_index)
_replacing_element = _block_instance.get_element(_index + 1)
_block_instance.move(index=_index, direction=_direction)
_block_instance.save_to_db_content(view_id=_view_name,
locale_id=_locale,
user_id=randrange(128))
_loaded_instance = ContentElementsBlock.load_fm_db(identity='_'.join(
[str(_upper_index).zfill(2), _type, _subtype]),
view_id=_view_name,
locale_id=_locale,
load_name=True)
_moved_element = _loaded_instance.get_element(_index + 1)
_replaced_element = _loaded_instance.get_element(_index)
assert _moving_element.value == _moved_element.value
assert _replacing_element.value == _replaced_element.value
'''success, up'''
_index = randrange(1, _size)
_direction = 'up'
_moving_element = _block_instance.get_element(_index)
_replacing_element = _block_instance.get_element(_index - 1)
_block_instance.move(index=_index, direction=_direction)
_block_instance.save_to_db_content(view_id=_view_name,
locale_id=_locale,
user_id=randrange(128))
_loaded_instance = ContentElementsBlock.load_fm_db(identity='_'.join(
[str(_upper_index).zfill(2), _type, _subtype]),
view_id=_view_name,
locale_id=_locale,
load_name=True)
_moved_element = _loaded_instance.get_element(_index - 1)
_replaced_element = _loaded_instance.get_element(_index)
assert _moving_element.value == _moved_element.value
assert _replacing_element.value == _replaced_element.value
'''fail, wrong direction - index combination'''
_index = 0
_direction = 'up'
with pytest.raises(WrongIndexError) as e_info:
_block_instance.move(index=_index, direction=_direction)
assert str(e_info.value).find(str(_index - 1))
_index = len(_block_instance.elements) - 1
_direction = 'down'
with pytest.raises(WrongIndexError) as e_info:
_block_instance.move(index=_index, direction=_direction)
assert str(e_info.value).find(str(_index + 1))
def test_UpperLevelHandling_patch(client, create_test_content, user_instance,
access_token, view_name, locale, elements,
lng, test_word_00, test_word_01,
test_word_02, test_word_03, test_word_04,
test_word_05):
'''clean up tables'''
[_content.delete_fm_db() for _content in ContentModel.find()]
[_structure.delete_fm_db() for _structure in StructureModel.find()]
'''create and save new contents in tables'''
_view_name = view_name()
_locale = lng
_elements = elements()
_page_view = PageView(view_name=_view_name,
locale=_locale,
elements=_elements)
_page_view.save_to_db(user_id=randrange(128))
# _index = 1
'''Create user and admin'''
_user = user_instance({'role_id': 'user'})
_user.save_to_db()
_admin = user_instance({'role_id': 'admin'})
_admin.save_to_db()
'''create tokens'''
_admin_access_token = access_token(_admin)
_user_access_token = access_token(_user)
'''creating headers'''
_admin_headers = {
'Authorization': f'Bearer {_admin_access_token}',
'Content-Type': 'application/json',
'Accept-Language': _locale
}
_user_headers = {
'Authorization': f'Bearer {_user_access_token}',
'Content-Type': 'application/json',
'Accept-Language': _locale
}
'''success'''
'''remove random element'''
_index = randrange(len(_elements) - 1)
_identity = str(_index).zfill(2)
_json = {'view_id': _view_name, 'identity': _identity}
_resp = client.patch(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_admin_headers)
assert _resp.status_code == 200
assert _resp.json.get('message').find(test_word_00) != -1
'''failues'''
'''No tokens'''
_no_token_header = {
k: v
for (k, v) in _admin_headers.items() if k != 'Authorization'
}
_resp = client.patch(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_no_token_header)
assert _resp.status_code == 401
assert _resp.json.get('description').find(test_word_01) != -1
assert _resp.json.get('error') == 'authorization_required'
'''Non admin'''
_resp = client.patch(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_user_headers)
assert _resp.status_code == 401
assert _resp.json.get('message').find(test_word_02) != -1
'''No block identity'''
_json_no_id = {k: v for (k, v) in _json.items() if k != 'identity'}
_resp = client.patch(url_for('contents_bp.upperlevelhandling'),
json=_json_no_id,
headers=_admin_headers)
assert _resp.status_code == 400
assert _resp.json.get('message').find(test_word_03) != -1
assert _resp.json.get('payload') == "'identity'"
'''wrong identity'''
'''first part is not integer'''
_wrong_identity = 'f**k'
_json = {'view_id': _view_name, 'identity': _wrong_identity}
_resp = client.patch(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_admin_headers)
assert _resp.status_code == 400
assert _resp.json == (
f"invalid literal for int() with base 10: '{_wrong_identity}'")
'''index out of range'''
_wrong_identity = '-1'
_json = {'view_id': _view_name, 'identity': _wrong_identity}
_resp = client.patch(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_admin_headers)
assert _resp.status_code == 400
assert _resp.json.get('message').find(test_word_03) != -1
assert _resp.json.get('payload').find(_wrong_identity) != -1
_wrong_identity = str(len(_page_view.elements))
_json = {'view_id': _view_name, 'identity': _wrong_identity}
_resp = client.patch(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_admin_headers)
assert _resp.status_code == 400
assert _resp.json.get('message').find(test_word_03) != -1
assert _resp.json.get('payload').find(_wrong_identity) != -1
def test_UpperLevelHandling_post(client, create_test_content, user_instance,
access_token, view_name, locale, elements,
lng, test_word, test_word_01, test_word_02,
test_word_03, test_word_04):
'''clean up tables'''
[_content.delete_fm_db() for _content in ContentModel.find()]
[_structure.delete_fm_db() for _structure in StructureModel.find()]
'''create and save new contents in tables'''
_view_name = view_name()
_locale = lng
_elements = elements()
_page_view = PageView(view_name=_view_name,
locale=_locale,
elements=_elements)
_page_view.save_to_db(user_id=randrange(128))
# _index = 1
'''Create user and admin'''
_user = user_instance({'role_id': 'user'})
_user.save_to_db()
_admin = user_instance({'role_id': 'admin'})
_admin.save_to_db()
'''create tokens'''
_admin_access_token = access_token(_admin)
_user_access_token = access_token(_user)
'''creating headers'''
_admin_headers = {
'Authorization': f'Bearer {_admin_access_token}',
'Content-Type': 'application/json',
'Accept-Language': _locale
}
_user_headers = {
'Authorization': f'Bearer {_user_access_token}',
'Content-Type': 'application/json',
'Accept-Language': _locale
}
'''success'''
_direction = 'up'
_index = randrange(1, len(_elements))
_index_key = str(_index).zfill(2)
_info_json = _elements[_index].serialize_to_structure
_identity = '_'.join(
[list(_info_json.keys())[0],
_info_json.get(_index_key).get('type')])
if isinstance(_page_view.elements[_index], ContentElementsBlock):
_identity = '_'.join(
[_identity, _info_json.get(_index_key).get('subtype')])
_json = {
'view_id': _view_name,
'identity': _identity,
'direction': _direction
}
_resp = client.post(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_admin_headers)
assert _resp.status_code == 200
assert _resp.json.get('message').find(test_word) != -1
'''down'''
_direction = 'down'
_index = randrange(len(_elements) - 1)
_info_json = _elements[_index].serialize_to_structure
_identity = '_'.join([
list(_info_json.keys())[0],
_info_json.get(str(_index).zfill(2)).get('type')
])
if isinstance(_page_view.elements[_index], ContentElementsBlock):
_identity = '_'.join(
[_identity,
_info_json.get(str(_index).zfill(2)).get('subtype')])
_json = {
'view_id': _view_name,
'identity': _identity,
'direction': _direction
}
_resp = client.post(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_admin_headers)
assert _resp.status_code == 200
assert _resp.json.get('message').find(test_word) != -1
'''failues'''
'''No tokens'''
_no_token_header = {
k: v
for (k, v) in _admin_headers.items() if k != 'Authorization'
}
_resp = client.post(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_no_token_header)
assert _resp.status_code == 401
assert _resp.json.get('description').find(test_word_01) != -1
'''Non admin'''
_resp = client.post(url_for('contents_bp.upperlevelhandling'),
json=_json,
headers=_user_headers)
assert _resp.status_code == 401
assert _resp.json.get('message').find(test_word_02) != -1
'''No block identity'''
_json_no_id = {k: v for (k, v) in _json.items() if k != 'identity'}
_resp = client.post(url_for('contents_bp.upperlevelhandling'),
json=_json_no_id,
headers=_admin_headers)
assert _resp.status_code == 400
assert _resp.json.get('message').find(test_word_03) != -1
assert _resp.json.get('payload') == "'identity'"
'''wrong direction - index combination'''
_index = 0
_direction = 'up'
_index_key = str(_index).zfill(2)
_info_json = _elements[_index].serialize_to_structure
_identity = '_'.join([_index_key, _info_json.get(_index_key).get('type')])
if isinstance(_page_view.elements[_index], ContentElementsBlock):
_identity = '_'.join(
[_identity, _info_json.get(_index_key).get('subtype')])
_json_up = {
'view_id': _view_name,
'identity': _identity,
'direction': _direction
}
_resp = client.post(url_for('contents_bp.upperlevelhandling'),
json=_json_up,
headers=_admin_headers)
assert _resp.status_code == 400
assert _resp.json.get('message').find(test_word_03) != -1
assert _resp.json.get('payload').find(str(_index - 1)) != -1
_index = len(_elements) - 1
_direction = 'down'
_index_key = str(_index).zfill(2)
_info_json = _elements[_index].serialize_to_structure
_identity = '_'.join([_index_key, _info_json.get(_index_key).get('type')])
if isinstance(_page_view.elements[_index], ContentElementsBlock):
_identity = '_'.join(
[_identity, _info_json.get(_index_key).get('subtype')])
_json_down = {
'view_id': _view_name,
'identity': _identity,
'direction': _direction
}
_resp = client.post(url_for('contents_bp.upperlevelhandling'),
json=_json_down,
headers=_admin_headers)
assert _resp.status_code == 400
assert _resp.json.get('message').find(test_word_03) != -1
assert _resp.json.get('payload').find(str(_index + 1)) != -1
'''generate not found error'''
_wrong_view_id = 'wrong'
_wrong_view_id_json = {**_json, 'view_id': _wrong_view_id}
_resp = client.post(url_for('contents_bp.upperlevelhandling'),
json=_wrong_view_id_json,
headers=_admin_headers)
assert _resp.status_code == 404
assert _resp.json.get('message').find(test_word_04) != -1
assert _resp.json.get('message').find(_wrong_view_id) != -1
'''clean up users'''
if _user is not None:
_user.delete_fm_db()
if _admin is not None:
_admin.delete_fm_db()
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