def uio1_user_exit(self, node: KeyValue) -> str:
r2 = self.regs.get_value("R2")
if r2 != 0:
ui2cnn = r2 + macros["UI2PF"].lookup("UI2CNN").dsp
ui2uio = r2 + macros["UI2PF"].lookup("UI2UIO").dsp
canned_number = self.vm.get_unsigned_value(ui2cnn, 1)
if self.vm.all_bits_on(ui2uio, 0x01): # UI2SEC = 0x01
canned_number += 256
message_string = next((canned["message"] for canned in UI2CNN
if int(canned["number"]) == canned_number),
None)
if not message_string:
raise UserDefinedMacroExecutionError(node)
self.messages.append(message_string)
return node.fall_down
ebw000_address: int = self.regs.get_value(
"R9") + macros["EB0EB"].evaluate("EBW000")
ebw000: bytearray = self.vm.get_bytes(ebw000_address, 72)
eom = DataType("C", input="+").to_bytes()[0]
if not any(eom == byte for byte in ebw000):
raise UserDefinedMacroExecutionError(node)
message: bytearray = bytearray()
for byte in ebw000:
if byte == eom:
break
message.append(byte)
message_string = DataType("X", bytes=message).decode
self.messages.append(message_string)
return node.fall_down
def _tjr_setup(self, iy_chain_count: int = 0, variation: int = 0):
fixed_file = FixedFile()
fixed_file.variation = variation
fixed_file.rec_id = DataType("C", input="TJ").value
fixed_file.macro_name = "TJ0TJ"
fixed_file.fixed_type = macros["SYSEQC"].evaluate("#TJRRI")
fixed_file.fixed_ordinal = 0x17F
pool_file = PoolFile()
fixed_file.pool_files.append(pool_file)
pool_file.macro_name = "IY1IY"
pool_file.rec_id = DataType("C", input="IY").value
pool_file.index_macro_name = "TJ0TJ"
pool_file.index_field = "TJ0ATH"
pool_file.forward_chain_label = "IY1FCH"
pool_file.forward_chain_count = iy_chain_count
item = FileItem()
pool_file.file_items.append(item)
item.macro_name = "IY1IY"
item.field = "IY1ATH"
item.field_data = deepcopy(self.iy_item)
item.count_field = "IY1CTR"
file_dict = fixed_file.cascade_to_dict()
del file_dict["id"]
del file_dict["pool_files"][0]["id"]
del file_dict["pool_files"][0]["file_items"][0]["id"]
self.test_data.create_fixed_file(file_dict, persistence=False)
return
def dp(self, node: FieldLenFieldLen) -> str:
if node.field_len2.length + 1 > 8:
raise PackExecutionError
source_address = self.regs.get_address(node.field_len2.base,
node.field_len2.dsp)
target_address = self.regs.get_address(node.field_len1.base,
node.field_len1.dsp)
dividend = DataType(
'P',
bytes=self.vm.get_bytes(target_address,
node.field_len1.length + 1)).value
divisor = DataType(
'P',
bytes=self.vm.get_bytes(source_address,
node.field_len2.length + 1)).value
quotient = int(dividend // divisor)
remainder = dividend % divisor
remainder_len = node.field_len2.length + 1
quotient_len = node.field_len1.length + 1 - remainder_len
self.vm.set_bytes(
DataType('P', input=str(quotient)).to_bytes(quotient_len),
target_address, quotient_len)
self.vm.set_bytes(
DataType('P', input=str(remainder)).to_bytes(remainder_len),
target_address + quotient_len, remainder_len)
return node.fall_down
def _mini_tjr_setup(self, tj2qaa) -> None:
fixed_file = FixedFile()
fixed_file.rec_id = DataType("C", input="P9").value
fixed_file.macro_name = "TJ2TJ"
fixed_file.fixed_type = macros["SYSEQC"].evaluate("#PR9RI") # 390
fixed_file.fixed_ordinal = 0x17F // macros["TJ2TJ"].evaluate(
"#TJ2MAX") # 38 0x26
item = FileItem()
item.macro_name = "TJ2TJ"
item.field = "TJ2ITM"
item.adjust = True
item.field_data = [
{
"field": "TJ2QAA",
"data": b64encode(DataType("X",
input=tj2qaa).to_bytes()).decode()
},
]
item.repeat = 0x17F % macros["TJ2TJ"].evaluate("#TJ2MAX") + 1 # 4
fixed_file.file_items.append(item)
file_dict = fixed_file.doc_to_dict()
file_dict["file_items"] = [
item.doc_to_dict() for item in fixed_file.file_items
]
self.test_data.create_fixed_file(file_dict, persistence=False)
return
def test_eta1_e_no_error(self):
self.test_data.set_field("MI0ACC", DataType("C", input="E").to_bytes())
self.test_data.set_field("WA0FNS", DataType("X", input="10").to_bytes())
self.test_data.set_field("WA0UB4", DataType("X", input="08").to_bytes())
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("ETAX265.6", self.output.last_line, self.output.last_node)
self.assertIn("UNABLE TO END TRANSACTION - NO PNR PRESENT IN WORK AREA", self.output.messages)
def test_etaz_rcvd_from(self) -> None:
self.test_data.set_field("WA0ET5", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0ASC", DataType("X", input="01").to_bytes())
self.test_data.add_pnr_element(["NAYAN"], RCVD_FROM)
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("FMSG0100", self.output.last_line, self.output.last_node)
self.assertIn("NEED PHONE FIELD - USE 9", self.output.messages)
def test_etaz_vanilla(self) -> None:
self.test_data.set_field("WA0ET5", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0ASC", DataType("X", input="01").to_bytes())
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("ETAZ1950.1", self.output.last_line, self.output.last_node)
self.assertIn("NEED RECEIVED FROM FIELD - USE 6", self.output.messages)
self.assertEqual(list(), self.output.dumps)
def test_eta1_el_restricted(self):
self.test_data.add_fields([("EBW000", 10)], "EB0EB")
self.test_data.set_field("MI0ACC", DataType("C", input="EL").to_bytes())
self.test_data.set_field("WA0FNS", DataType("X", input="10").to_bytes())
self.test_data.set_field("WA0UB4", DataType("X", input="08").to_bytes())
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("$$UIO1$$.2", self.output.last_line, self.output.last_node)
self.assertIn("RESTRICTED" + 40 * " ", self.output.messages)
def test_eta4_vanilla(self) -> None:
self.test_data.set_field("WA0ET5", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0ASC", DataType("X", input="01").to_bytes())
self.test_data.add_pnr_element(["NAYAN"], RCVD_FROM)
self.test_data.add_pnr_element(["123456"], PHONE)
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("ETA5420.9", self.output.last_line, self.output.last_node)
self.assertIn("NEED NAME IN PNR TO COMPLETE TRANSACTION", self.output.messages)
def test_A1B1(self):
self.test_data.set_field('EBX003',
DataType('C', input='A1B1').to_bytes())
test_data = self.tpf_server.run('TS22', self.test_data)
self.assertEqual('TS22EXIT.1', test_data.output.last_line)
self.assertEqual(0, test_data.output.regs['R0'])
self.assertEqual(
'A1B1 ',
DataType('X', input=test_data.get_field('EBX003')).decode)
self.assertEqual('006DCB', test_data.get_field('EBX000'))
self.assertEqual('006DCB', test_data.get_field('EBX008'))
def compare_logical_character_mask(self, node: RegisterDataField) -> str:
if node.data == 0:
self.set_number_cc(0)
return node.fall_down
bytes1 = self.regs.get_bytes_from_mask(node.reg, node.data)
address = self.regs.get_address(node.field.base, node.field.dsp)
bytes2 = self.vm.get_bytes(address, bin(node.data).count('1'))
value1 = DataType('X', bytes=bytes1).value
value2 = DataType('X', bytes=bytes2).value
self.set_number_cc(value1 - value2)
return node.fall_down
def unpack(self, node: FieldLenFieldLen) -> str:
source_address = self.regs.get_address(node.field_len2.base,
node.field_len2.dsp)
target_address = self.regs.get_address(node.field_len1.base,
node.field_len1.dsp)
packed_bytes = self.vm.get_bytes(source_address,
node.field_len2.length + 1)
value = DataType('P', bytes=packed_bytes).value
zoned_bytes = DataType(
'Z', input=str(value)).to_bytes(node.field_len1.length + 1)
self.vm.set_bytes(zoned_bytes, target_address,
node.field_len1.length + 1)
return node.fall_down
def test_etaa_remarks_insurance(self) -> None:
self.test_data.set_field("WA0ET5", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0ASC", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0TSC", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0POR", DataType("X", input="00017F").to_bytes())
self.test_data.set_field("WA0FNS", DataType("X", input="10").to_bytes())
self.test_data.add_pnr_element(["1ZAVERI/NAYAN"], NAME)
self.test_data.add_pnr_element(["NAYAN"], RCVD_FROM)
self.test_data.add_pnr_element(["123456"], PHONE)
self.test_data.add_pnr_element(["I$INSURANCE SEGMENT"], REMARKS)
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("ETAA590.2", self.output.last_line, f"{self.output.last_node}--{self.output.dumps}")
self.assertIn("5I$ REMARK EXISTS-NEED INS SEGMENT OR REMOVE 5I$ REMARK", self.output.messages)
def zap(self, node: FieldLenFieldLen) -> str:
source_address = self.regs.get_address(node.field_len2.base,
node.field_len2.dsp)
target_address = self.regs.get_address(node.field_len1.base,
node.field_len1.dsp)
value = DataType('P',
bytes=self.vm.get_bytes(
source_address, node.field_len2.length + 1)).value
self.vm.set_bytes(
DataType('P',
input=str(value)).to_bytes(node.field_len1.length + 1),
target_address, node.field_len1.length + 1)
self.set_number_cc(value)
return node.fall_down
def test_etaw_vanilla(self) -> None:
self.test_data.set_field("WA0ET5",
DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0ASC",
DataType("X", input="01").to_bytes())
self.test_data.add_pnr_element(["1ZAVERI/NAYAN"], NAME)
self.test_data.add_pnr_element(["NAYAN"], RCVD_FROM)
self.test_data.add_pnr_element(["123456"], PHONE)
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("FMSG0100", self.output.last_line,
self.output.last_node)
self.assertIn("INVLD ITIN", self.output.messages,
self.output.get_traces("ETAW"))
def test_etaa_remarks(self) -> None:
self.test_data.set_field("WA0ET5", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0ASC", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0TSC", DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0POR", DataType("X", input="00017F").to_bytes())
self.test_data.set_field("WA0FNS", DataType("X", input="10").to_bytes())
self.test_data.add_pnr_element(["1ZAVERI/NAYAN"], NAME)
self.test_data.add_pnr_element(["NAYAN"], RCVD_FROM)
self.test_data.add_pnr_element(["123456"], PHONE)
self.test_data.add_pnr_element(["SOME REMARKS"], REMARKS)
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual(self.ETG1_TJR_END, self.output.last_line, f"{self.output.last_node}--{self.output.dumps}")
self.assertIn("019005", self.output.dumps) # TJR Face Error
def pack(self, node: FieldLenFieldLen) -> str:
source_address = self.regs.get_address(node.field_len2.base,
node.field_len2.dsp)
target_address = self.regs.get_address(node.field_len1.base,
node.field_len1.dsp)
source_bytes = self.vm.get_bytes(source_address,
node.field_len2.length + 1)
number = DataType('X', bytes=source_bytes).decode
if not number.isdigit():
raise PackExecutionError
packed_bytes = DataType(
'P', input=number).to_bytes(node.field_len1.length + 1)
self.vm.set_bytes(packed_bytes, target_address,
node.field_len1.length + 1)
return node.fall_down
def _main_tjr_setup(self):
fixed_file = FixedFile()
fixed_file.rec_id = DataType("C", input="TJ").value
fixed_file.macro_name = "TJ0TJ"
fixed_file.fixed_type = macros["SYSEQC"].evaluate("#TJRRI")
fixed_file.fixed_ordinal = 0x17F
fixed_file.field_data = [
{
"field": "TJ0BID",
"data": b64encode(DataType("C",
input="TJ").to_bytes()).decode()
},
]
file_dict = fixed_file.doc_to_dict()
self.test_data.create_fixed_file(file_dict, persistence=False)
def test_eta1_el_plus_off_queue(self):
self.test_data.set_field("MI0ACC", DataType("C", input="EL+").to_bytes())
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("$$UIO1$$.2", self.output.last_line, self.output.last_node)
off_queue = "CANNOT DO THIS IF OFF QUEUE"
self.assertIn(off_queue + (50 - len(off_queue)) * " ", self.output.messages)
def get_pnr_data(
pnr_locator: str,
key: str,
item_number: int,
packed: bool = False,
starts_with: Optional[str] = None
) -> Tuple[Optional[bytearray], int]:
# item_number starts from 1 for the 1st item (index 0)
try:
pnr_doc = next(pnr["doc"] for pnr in Pnr.DB
if pnr["id"] == pnr_locator)
data_list = [
element["data"] for element in pnr_doc if element["key"] == key
]
except StopIteration:
raise PnrLocatorNotFoundError
starts_with = DataType(
"C",
input=starts_with).to_bytes() if starts_with is not None else None
attribute = Pnr.get_attribute_by_key(key)
if not attribute:
raise PnrElementError
start = (len(Pnr.STD_PREFIX_BYTES) + len(attribute.std_fix) + len(attribute.std_var)) \
if packed else len(attribute.std_var)
for item_number in range(item_number, len(data_list) + 1):
data = data_list[item_number - 1]
data = data[len(Pnr.STD_PREFIX_BYTES) +
len(attribute.std_fix):] if not packed else data
if starts_with is None:
return data, item_number
elif data[start:start + len(starts_with)] == starts_with:
return data, item_number
return None, item_number
def convert_binary(self, node: RegisterFieldIndex):
address = self.regs.get_address(node.field.base, node.field.dsp,
node.field.index)
packed_bytes = self.vm.get_bytes(address, 8)
value = DataType('P', bytes=packed_bytes).value
self.regs.set_value(value, node.reg)
return node.fall_down
def convert_decimal(self, node: RegisterFieldIndex):
address = self.regs.get_address(node.field.base, node.field.dsp,
node.field.index)
value = self.regs.get_value(node.reg)
packed_bytes = DataType('P', input=str(value)).to_bytes(8)
self.vm.set_bytes(packed_bytes, address, 8)
return node.fall_down
def test_b4t0(self):
self.test_data.set_field('EBX003',
DataType('C', input='B4T0').to_bytes())
test_data = self.tpf_server.run('TS22', self.test_data)
self.assertEqual('TS22EXIT.1', test_data.output.last_line)
self.assertEqual(0, test_data.output.regs['R0'])
self.assertEqual(
'B4T0 ',
DataType('X', input=test_data.get_field('EBX003')).decode)
self.assertEqual('C2F4E3', test_data.get_field('EBX000'))
self.assertEqual('00017F', test_data.get_field('EBX008'))
# TODO remove once the scenario for it is present
tnaa_bytes = DataType(
'X', input='00003EF8000002A40000001A00040000').to_bytes()
self.assertEqual(tnaa_bytes,
segments['SUB1'].get_constant_bytes('SUB2TNAA', 16))
def test_etax_efc(self):
self.test_data.set_field("MI0ACC", DataType("C", input="EF$").to_bytes())
self.test_data.add_fields(["UI2CNN"], "UI2PF", "R7")
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("$$UIO1$$.2", self.output.last_line, self.output.last_node)
self.assertEqual("33", test_data.get_field("UI2CNN"))
def entnc(self, node: SegmentCall) -> str:
if node.keys[0] not in segments:
raise SegmentNotFoundError
self.fields["CE3ENTPGM"] = DataType("C",
input=self.seg.name).to_bytes()
self._init_seg(node.keys[0])
return node.goes
def test_etaw_wa0tsc(self) -> None:
self.test_data.set_field("WA0ET5",
DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0ASC",
DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0TSC",
DataType("X", input="01").to_bytes())
self.test_data.set_field("WA0POR",
DataType("X", input="00017F").to_bytes())
self.test_data.add_pnr_element(["1ZAVERI/NAYAN"], NAME)
self.test_data.add_pnr_element(["NAYAN"], RCVD_FROM)
self.test_data.add_pnr_element(["123456"], PHONE)
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual(self.SUCCESS_END, self.output.last_line,
self.output.last_node)
def test_etax_efs(self):
self.test_data.set_field("MI0ACC", DataType("C", input="EF*").to_bytes())
self.test_data.add_fields(["UI2CNN"], "UI2PF", "R7")
test_data = self.tpf_server.run("ETA1", self.test_data)
self.output = test_data.output
self.assertEqual("ETAX265.6", self.output.last_line, self.output.last_node)
self.assertIn("UNABLE TO END TRANSACTION - NO PNR PRESENT IN WORK AREA", self.output.messages)
def _tjr_setup(self) -> None:
fixed_file = FixedFile()
fixed_file.rec_id = DataType("C", input="TJ").value
fixed_file.macro_name = "TJ0TJ"
fixed_file.fixed_type = macros["SYSEQC"].evaluate("#TJRRI")
fixed_file.fixed_ordinal = 0x17F
fixed_file.field_data = [
{
"field": "TJ0PCC",
"data": b64encode(DataType("C", input="B4T").to_bytes()).decode()
},
]
file_dict = fixed_file.cascade_to_dict()
del file_dict["id"]
self.test_data.create_fixed_file(file_dict, persistence=False)
return
def test_branch_validation_fail_lok_off(self) -> None:
self.iy_item[0]["data"] = b64encode(
DataType("X", input="00006F2F").to_bytes()).decode()
self._tjr_setup(2)
test_data = self.tpf_server.run("TS21", self.test_data)
self.assertEqual("$$ETK4$$.1", test_data.output.last_line)
self.assertEqual(8, test_data.output.regs["R6"])
def set_partition(self, partition: str) -> None:
if partition not in config.PARTITION:
raise PartitionError
haalc = config.GLOBAL + macros["GLOBAL"].evaluate("@HAALC")
ce1uid = config.ECB + macros["EB0EB"].evaluate("CE1$UID")
self.vm.set_bytes(DataType("C", input=partition).to_bytes(), haalc, 2)
self.vm.set_value(config.PARTITION[partition], ce1uid, 1)