def serialize_text_element(parent: ET.Element,
tag: str,
text: Optional[str],
namespace: str,
attribs: Dict = None) -> Optional[ET.Element]:
if text is None:
return None
result = ET.SubElement(parent, get_full_tag(namespace, tag),
attribs if attribs else {})
result.text = text
return result
def serialize_user(data: dto.UserHeader) -> ET.Element:
result = ET.Element(get_full_tag(ns.COMMON, 'user'))
serialize_text_element(result, 'login', data.login, ns.COMMON)
serialize_text_element(result, 'passwordHash', data.password_hash.value,
ns.COMMON,
{'cryptoType': data.password_hash.crypto_type})
serialize_text_element(result, 'taxNumber', data.tax_number, ns.COMMON)
serialize_text_element(result, 'requestSignature',
data.request_signature.value, ns.COMMON,
{'cryptoType': data.request_signature.crypto_type})
return result
def serialize_header(data: dto.BasicHeader) -> ET.Element:
result = ET.Element(get_full_tag(ns.COMMON, 'header'))
serialize_text_element(result, 'requestId', data.request_id, ns.COMMON)
serialize_text_element(
result, 'timestamp',
f'{data.timestamp.astimezone(tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3]}Z',
ns.COMMON)
serialize_text_element(result, 'requestVersion', data.request_version,
ns.COMMON)
serialize_text_element(result, 'headerVersion', data.header_version,
ns.COMMON)
return result
def test_serialize_header(request_id: str, timestamp: datetime,
expected_timestamp: str):
data = dto.BasicHeader(request_id=request_id,
timestamp=timestamp,
request_version=ois.REQUEST_VERSION,
header_version=ois.HEADER_VERSION)
result = serialize_header(data)
assert get_full_tag(ns.COMMON, 'header') == result.tag
children = [i for i in result]
assert len(children) == 4
validate_element(children[0], ns.COMMON, 'requestId', request_id)
validate_element(children[1], ns.COMMON, 'timestamp', expected_timestamp)
validate_element(children[2], ns.COMMON, 'requestVersion',
ois.REQUEST_VERSION)
validate_element(children[3], ns.COMMON, 'headerVersion',
ois.HEADER_VERSION)
def test_serialize_software(id_: str, name: str, operation: dto.SoftwareOperation, main_version: str, dev_name: str,
dev_contact: str, dev_country_code: str, dev_tax_number: str):
data = dto.Software(
software_id=id_,
software_name=name,
software_operation=operation,
software_main_version=main_version,
software_dev_name=dev_name,
software_dev_contact=dev_contact,
software_dev_country_code=dev_country_code,
software_dev_tax_number=dev_tax_number
)
result = serialize_software(data)
assert get_full_tag(ns.API, 'software') == result.tag
children = [i for i in result]
count_of_none_params = 0
if dev_country_code is None:
count_of_none_params += 1
if dev_tax_number is None:
count_of_none_params += 1
assert len(children) == 8 - count_of_none_params
validate_element(children[0], ns.API, 'softwareId', id_)
validate_element(children[1], ns.API, 'softwareName', name)
validate_element(children[2], ns.API, 'softwareOperation', operation.value)
validate_element(children[3], ns.API, 'softwareMainVersion', main_version)
validate_element(children[4], ns.API, 'softwareDevName', dev_name)
validate_element(children[5], ns.API, 'softwareDevContact', dev_contact)
if dev_country_code:
validate_element(children[6], ns.API, 'softwareDevCountryCode', dev_country_code)
if dev_tax_number:
index_of_dev_tax_number = 7 if dev_country_code else 6
validate_element(children[index_of_dev_tax_number], ns.API, 'softwareDevTaxNumber', dev_tax_number)
def serialize_software(data: dto.Software) -> ET.Element:
result = ET.Element(get_full_tag(ns.API, 'software'))
serialize_text_element(result, 'softwareId', data and data.software_id,
ns.API)
serialize_text_element(result, 'softwareName', data and data.software_name,
ns.API)
serialize_text_element(
result, 'softwareOperation', data and data.software_operation
and data.software_operation.value, ns.API)
serialize_text_element(result, 'softwareMainVersion', data
and data.software_main_version, ns.API)
serialize_text_element(result, 'softwareDevName', data
and data.software_dev_name, ns.API)
serialize_text_element(result, 'softwareDevContact', data
and data.software_dev_contact, ns.API)
serialize_text_element(result, 'softwareDevCountryCode', data
and data.software_dev_country_code, ns.API)
serialize_text_element(result, 'softwareDevTaxNumber', data
and data.software_dev_tax_number, ns.API)
return result
def test_serialize_token_exchange_request(
request_id: str, timestamp: datetime, request_signature: str,
password_hash: str, login: str, tax_number: str, software_id: str,
software_name: str, software_operation: dto.SoftwareOperation,
software_main_version: str, software_dev_name: str,
software_dev_contact: str):
data = dto.BasicOnlineInvoiceRequest(
header=dto.BasicHeader(request_id=request_id,
timestamp=timestamp,
request_version=ois.REQUEST_VERSION,
header_version=ois.HEADER_VERSION),
user=dto.UserHeader(
login=login,
tax_number=tax_number,
request_signature=dto.Crypto(value=request_signature,
crypto_type='shaaaaa'),
password_hash=dto.Crypto(value=password_hash,
crypto_type='shhaaaa')),
software=dto.Software(software_id=software_id,
software_name=software_name,
software_operation=software_operation,
software_main_version=software_main_version,
software_dev_name=software_dev_name,
software_dev_contact=software_dev_contact,
software_dev_country_code=None,
software_dev_tax_number=None))
result = serialize_token_exchange_request(data)
assert get_full_tag(ns.API, 'TokenExchangeRequest') == result.tag
children = [i for i in result]
assert len(children) == 3
validate_tag_name(children[0], ns.COMMON, 'header')
validate_tag_name(children[1], ns.COMMON, 'user')
validate_tag_name(children[2], ns.API, 'software')
def test_serialize_user(login: str, tax_number: str, password_hash: str,
password_hash_type: str, request_signature: str,
request_signature_type: str):
data = dto.UserHeader(login=login,
password_hash=dto.Crypto(value=password_hash,
crypto_type='shaaa'),
tax_number=tax_number,
request_signature=dto.Crypto(value=request_signature,
crypto_type='shaaa'))
result = serialize_user(data=data)
assert get_full_tag(ns.COMMON, 'user') == result.tag
children = [i for i in result]
assert len(children) == 4
validate_element(children[0], ns.COMMON, 'login', login)
validate_element(children[1], ns.COMMON, 'passwordHash', password_hash)
validate_element(children[2], ns.COMMON, 'taxNumber', tax_number)
validate_element(children[3], ns.COMMON, 'requestSignature',
request_signature)
def validate_tag_name(element: ET.Element, namespace: str, tag_name: str):
assert get_full_tag(namespace, tag_name) == element.tag
