def test_UpperLevelElement_get_all(block_raw_data):
'''create valid structures'''
block_upper_level_element = UpperLevelElement(block_raw_data)
block_common_elemements = block_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in block_raw_data.items()}.items()
assert len(block_upper_level_element.__dict__) \
== len(block_raw_data) == len(block_common_elemements)
result = block_upper_level_element.get_all()
block_common_elemements = result.items()\
& block_raw_data.items()
assert len(result) == len(block_raw_data)\
== len(block_common_elemements)
def vblock():
return UpperLevelElement({
'qnt': 5,
'name': 'vblock00',
'type': 'vblock',
'subtype': 'txt'
})
def hblock():
return UpperLevelElement({
'qnt': 7,
'name': 'hblock00',
'type': 'hblock',
'subtype': 'pix'
})
def test_UpperLevelElement_getter_success(block_raw_data, simple_raw_data):
'''create valid structures'''
block_upper_level_element = UpperLevelElement(block_raw_data)
simple_upper_level_element = UpperLevelElement(simple_raw_data)
block_common_elemements = block_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in block_raw_data.items()}.items()
assert len(block_upper_level_element.__dict__) \
== len(block_raw_data) == len(block_common_elemements)
simple_common_elemements =\
simple_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in simple_raw_data.items()}.items()
assert len(simple_upper_level_element.__dict__) \
== len(simple_raw_data) == len(simple_common_elemements)
'''block element'''
_keys = ['type', 'subtype', 'name', 'qnt']
result = block_upper_level_element.getter(_keys)
block_common_elemements = result.items()\
& block_raw_data.items()
assert len(result) == len(block_raw_data)\
== len(block_common_elemements)
'''simple element'''
_keys = ['type', 'name']
result = simple_upper_level_element.getter(_keys)
simple_common_elemements = result.items()\
& simple_raw_data.items()
assert len(result) == len(simple_raw_data)\
== len(simple_common_elemements)
def test_UpperLevelElement_init(block_raw_data, simple_raw_data):
'''It tests correct keys are workable only'''
'''success'''
_block_raw_data = {f'_{k}': v for (k, v) in block_raw_data.items()}
_simple_raw_data = {f'_{k}': v for (k, v) in simple_raw_data.items()}
block_upper_level_element = UpperLevelElement(block_raw_data)
header_upper_level_element = UpperLevelElement(simple_raw_data)
# print('\ntest_upper_level_element_structure:',
# '\n test_UpperLevelElement_init'
# '\n block_upper_level_element ->', block_upper_level_element.__dict__,
# '\n header_upper_level_element ->', header_upper_level_element.__dict__
# )
block_common_items = \
block_upper_level_element.__dict__.items() & \
_block_raw_data.items()
header_common_items = \
header_upper_level_element.__dict__.items() & \
_simple_raw_data.items()
assert len(block_upper_level_element.__dict__) == len(
block_raw_data) == len(block_common_items)
assert len(header_upper_level_element.__dict__) == len(
simple_raw_data) == len(header_common_items)
'''wrong keys'''
for k in block_raw_data.keys():
wrong_raw_data = {**block_raw_data}
wrong_raw_data.pop(k)
wrong_raw_data[f'{k}_'] = block_raw_data.get(k)
with pytest.raises(UpperLevelElementWrongKey) as e_info:
UpperLevelElement(wrong_raw_data)
assert str(e_info.value) == f'_{k}_'
for k in simple_raw_data.keys():
wrong_raw_data = {**simple_raw_data}
wrong_raw_data.pop(k)
wrong_raw_data[f'{k}_'] = simple_raw_data.get(k)
with pytest.raises(UpperLevelElementWrongKey) as e_info:
UpperLevelElement(wrong_raw_data)
assert str(e_info.value) == f'_{k}_'
'''wrong type'''
wrong_raw_data = {
**block_raw_data, 'type': f'{block_raw_data.get("type")}_'
}
with pytest.raises(UpperLevelElementWrongValue) as e_info:
UpperLevelElement((wrong_raw_data))
assert str(e_info.value) == wrong_raw_data.get('type')
'''wrong subtype'''
wrong_raw_data = {
**block_raw_data, 'subtype': f'{block_raw_data.get("subtype")}_'
}
with pytest.raises(UpperLevelElementWrongValue) as e_info:
UpperLevelElement((wrong_raw_data))
assert str(e_info.value) == wrong_raw_data.get('subtype')
def test_UpperLevelElement_getter_fail(block_raw_data, simple_raw_data):
'''create valid structures'''
block_upper_level_element = UpperLevelElement(block_raw_data)
simple_upper_level_element = UpperLevelElement(simple_raw_data)
block_common_elemements = block_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in block_raw_data.items()}.items()
assert len(block_upper_level_element.__dict__) \
== len(block_raw_data) == len(block_common_elemements)
simple_common_elemements =\
simple_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in simple_raw_data.items()}.items()
assert len(simple_upper_level_element.__dict__) \
== len(simple_raw_data) == len(simple_common_elemements)
'''get unknown key element'''
_wrong_type = 'wrong_type'
with pytest.raises(UpperLevelElementWrongKey) as e_info:
block_upper_level_element.getter([_wrong_type])
assert str(e_info.value) == _wrong_type
'''block element key on simple one'''
_wrong_type = 'subtype'
with pytest.raises(UpperLevelElementWrongKey) as e_info:
simple_upper_level_element.getter([_wrong_type])
assert str(e_info.value) == _wrong_type
def test_UpperLevelElement_set_get_success(block_raw_data, simple_raw_data):
'''create valid structures'''
block_upper_level_element = UpperLevelElement(block_raw_data)
simple_upper_level_element = UpperLevelElement(simple_raw_data)
block_common_elemements = block_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in block_raw_data.items()}.items()
assert len(block_upper_level_element.__dict__) \
== len(block_raw_data) == len(block_common_elemements)
simple_common_elemements =\
simple_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in simple_raw_data.items()}.items()
assert len(simple_upper_level_element.__dict__) \
== len(simple_raw_data) == len(simple_common_elemements)
'''success, no upper level element complexity changed'''
_block_type = 'vblock'
_simple_type = 'footer'
_name = 'fancy_name'
block_upper_level_element.setter({'type': _block_type, 'name': _name})
simple_upper_level_element.setter({'type': _simple_type, 'name': _name})
assert block_upper_level_element.type == _block_type
assert simple_upper_level_element.type == _simple_type
assert block_upper_level_element.name\
== simple_upper_level_element.name == _name
'''success, block to simple'''
_type = 'footer'
_name = 'block_to_simple'
block_upper_level_element.setter({'type': _type, 'name': _name})
assert block_upper_level_element.type == _type
assert block_upper_level_element.name == _name
assert block_upper_level_element.subtype is None
assert block_upper_level_element.qnt is None
'''success, simple to block, default'''
_type = 'vblock'
_name = 'simple_to_block'
_qnt = 15
simple_upper_level_element.setter({
'type': _type,
'name': _name,
'qnt': _qnt
})
assert simple_upper_level_element.type == _type
assert simple_upper_level_element.name == _name
assert simple_upper_level_element.qnt == _qnt
assert simple_upper_level_element.subtype\
== global_constants.get_UPPER_LEVEL_SUBTYPES_PKS[0]
print('\ntest_upper_level_element_structure:',
'\n test_UpperLevelElement_set_get_success',
'\n block_upper_level_element.__dict__ ->',
simple_upper_level_element.__dict__)
def test_UpperLevelElement_remove_element(block_raw_data, simple_raw_data):
'''create valid structures'''
block_upper_level_element = UpperLevelElement(block_raw_data)
simple_upper_level_element = UpperLevelElement(simple_raw_data)
block_common_elemements = block_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in block_raw_data.items()}.items()
assert len(block_upper_level_element.__dict__) \
== len(block_raw_data) == len(block_common_elemements)
simple_common_elemements =\
simple_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in simple_raw_data.items()}.items()
assert len(simple_upper_level_element.__dict__) \
== len(simple_raw_data) == len(simple_common_elemements)
'''success'''
block_upper_level_element.remove_element()
assert block_upper_level_element.qnt == block_raw_data.get('qnt') - 1
'''fails'''
'''no attribute'''
with pytest.raises(UpperLevelElementIncorrectQntAction) as e_info:
simple_upper_level_element.remove_element()
_type = simple_raw_data.get('type')
assert str(e_info.value) == f'Element type {_type} has no qnt attribute.'
'''qnt above limit'''
block_upper_level_element.setter({'qnt': 1})
with pytest.raises(UpperLevelElementIncorrectQntAction) as e_info:
block_upper_level_element.remove_element()
assert str(e_info.value) == f'Attribute qnt is already - {1}.'
def test_UpperLevelElement_set_get_fail(block_raw_data, simple_raw_data):
'''create valid structures'''
block_upper_level_element = UpperLevelElement(block_raw_data)
simple_upper_level_element = UpperLevelElement(simple_raw_data)
block_common_elemements = block_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in block_raw_data.items()}.items()
assert len(block_upper_level_element.__dict__) \
== len(block_raw_data) == len(block_common_elemements)
simple_common_elemements =\
simple_upper_level_element.__dict__.items()\
& {f'_{k}': v for (k, v) in simple_raw_data.items()}.items()
assert len(simple_upper_level_element.__dict__) \
== len(simple_raw_data) == len(simple_common_elemements)
'''send wrong type'''
_type = 'wrong'
_name = 'some_name'
with pytest.raises(UpperLevelElementWrongValue) as e_info:
block_upper_level_element.setter({'type': _type, 'name': _name})
assert str(e_info.value) == _type
with pytest.raises(UpperLevelElementWrongValue) as e_info:
simple_upper_level_element.setter({'type': _type, 'name': _name})
assert str(e_info.value) == _type
'''wrong key set for specific type'''
_type = 'vblock'
_subtype = 'txt'
with pytest.raises(UpperLevelElementWrongKey) as e_info:
block_upper_level_element.setter({'type': _type, 'wrong': _subtype})
# print(e_info.value)
assert str(e_info.value) == 'wrong'
_type = 'footer'
_subtype = 'txt'
with pytest.raises(UpperLevelElementWrongKey) as e_info:
block_upper_level_element.setter({'type': _type, 'subtype': _subtype})
assert str(e_info.value) == 'subtype'
'''wrong key values'''
'''subtype'''
_type = 'vblock'
_subtype = 'wrong'
with pytest.raises(UpperLevelElementWrongValue) as e_info:
block_upper_level_element.setter({'type': _type, 'subtype': _subtype})
# print(e_info.value)
assert str(e_info.value) == _subtype
'''qnt'''
_type = 'vblock'
_qnt = 120
with pytest.raises(UpperLevelElementWrongValue) as e_info:
block_upper_level_element.setter({'type': _type, 'qnt': _qnt})
assert int(str(e_info.value)) == _qnt
def footer():
return UpperLevelElement({'type': 'footer', 'name': 'footer_name'})
def header():
return UpperLevelElement({'type': 'header', 'name': 'header_name'})
def test_ViewPageStructure_set(view_page_structure):
_view_page_structure = view_page_structure
_length = _view_page_structure.len()
_index = 2
_element_name = 'inserted_element_name'
_element_type = 'footer'
assert _length == 4
'''add element out of range'''
_wrong_index = -1
with pytest.raises(UpperLevelStructureWrongIndex) as e_info:
_view_page_structure.set_element(
_wrong_index,
UpperLevelElement({
'type': _element_type,
'name': _element_name
}))
assert str(e_info.value) == f'Index {_wrong_index} has been out of range.'
_wrong_index = _length
with pytest.raises(UpperLevelStructureWrongIndex) as e_info:
_view_page_structure.set_element(
_wrong_index,
UpperLevelElement({
'type': _element_type,
'name': _element_name
}))
assert str(e_info.value) == f'Index {_wrong_index} has been out of range.'
'''add upper level element as a class instance'''
_view_page_structure.set_element(
_index,
UpperLevelElement({
'type': _element_type,
'name': _element_name
}))
_element = _view_page_structure.get_element(_index)
assert isinstance(_element, UpperLevelElement)
'''add dictionary to construct UpperLevelElement'''
_element_name = 'next_element_name'
_view_page_structure.set_element(_index, {
'type': _element_type,
'name': _element_name
})
_element = _view_page_structure.get_element(_index)
assert isinstance(_element, UpperLevelElement)
# print('test_view_page_structure:\n test_UpperLevelElement_set',
# '\n _element type ->', type(_element),
# '\n _element ->', _element)
'''add dictionary extending view page structure'''
_index = _length
with pytest.raises(UpperLevelStructureWrongIndex) as e_info:
_view_page_structure.set_element(_index, {
'type': _element_type,
'name': _element_name
})
assert str(e_info.value) == f'Index {_index} has been out of range.'
_view_page_structure.set_element(_index, {
'type': _element_type,
'name': _element_name
},
ext=True)
_element = _view_page_structure.get_element(_index)
assert isinstance(_element, UpperLevelElement)