from __future__ import annotations import tempfile import unittest from pathlib import Path from carddemo.repository import connect, seed_from_legacy from carddemo.service import CardDemoService ROOT = Path(__file__).resolve().parents[2] SOURCE = ROOT / "source" class ServiceTests(unittest.TestCase): def setUp(self) -> None: self.tmp = tempfile.TemporaryDirectory() self.db_path = Path(self.tmp.name) / "carddemo.sqlite" self.counts = seed_from_legacy(SOURCE, self.db_path, reset=True) self.service = CardDemoService(self.db_path) def tearDown(self) -> None: self.tmp.cleanup() def test_seed_counts(self) -> None: self.assertEqual(self.counts["customers"], 50) self.assertEqual(self.counts["accounts"], 50) self.assertEqual(self.counts["cards"], 50) self.assertEqual(self.counts["transactions"], 300) self.assertGreater(self.counts["disclosure_groups"], 0) self.assertGreater(self.counts["transaction_category_balances"], 0) self.assertEqual(self.counts["users"], 10) self.assertEqual(self.counts["pending_authorization_summaries"], 21) self.assertEqual(self.counts["pending_authorization_details"], 202) def test_signon_routes_admin_and_rejects_bad_password(self) -> None: success = self.service.signon("admin001", "password") self.assertTrue(success["authenticated"]) self.assertEqual(success["legacy_transaction"], "CC00") self.assertEqual(success["route_transaction"], "CA00") self.assertEqual(success["route_program"], "COADM01C") self.assertEqual(success["menu"]["option_count"], 6) failure = self.service.signon("ADMIN001", "wrong") self.assertFalse(failure["authenticated"]) self.assertEqual(failure["reason"], "wrong_password") self.assertIn("Wrong Password", failure["message"]) def test_main_and_admin_menus_match_copybook_counts(self) -> None: main = self.service.main_menu() admin = self.service.admin_menu() self.assertEqual(main["legacy_transaction"], "CM00") self.assertEqual(main["option_count"], 11) self.assertEqual(main["options"][9]["program"], "COBIL00C") self.assertEqual(admin["legacy_transaction"], "CA00") self.assertEqual(admin["option_count"], 6) self.assertEqual(admin["options"][1]["program"], "COUSR01C") with self.assertRaises(ValueError): self.service.select_menu_option("CM00", 99) def test_user_maintenance_add_update_delete(self) -> None: payload = { "user_id": "qauser01", "first_name": "Quality", "last_name": "Check", "password": "secret", "user_type": "U", } required_messages = { "user_id": "User ID can NOT be empty...", "first_name": "First Name can NOT be empty...", "last_name": "Last Name can NOT be empty...", "password": "Password can NOT be empty...", "user_type": "User Type can NOT be empty...", } for field, message in required_messages.items(): invalid = dict(payload) invalid[field] = "" with self.assertRaises(ValueError) as err: self.service.add_user(invalid) self.assertEqual(str(err.exception), message) added = self.service.add_user(payload) self.assertEqual(added["legacy_transaction"], "CU01") self.assertEqual(added["user"]["user_id"], "QAUSER01") self.assertEqual(self.service.get_user("qauser01")["password"], "SECRET") with self.assertRaises(ValueError) as err: self.service.add_user(payload) self.assertEqual(str(err.exception), "User ID already exist...") non_admin = self.service.add_user( { "user_id": "qauser02", "first_name": "Quality", "last_name": "Nonadmin", "password": "secret", "user_type": "z", } ) self.assertEqual(non_admin["user"]["user_type"], "Z") self.assertEqual(self.service.signon("qauser02", "secret")["route_transaction"], "CM00") updated = self.service.update_user( "qauser01", { "first_name": "Quality", "last_name": "Updated", "password": "secret2", "user_type": "A", }, ) self.assertEqual(updated["legacy_transaction"], "CU02") self.assertEqual(updated["user"]["last_name"], "Updated") self.assertEqual(updated["user"]["password"], "SECRET2") with self.assertRaises(ValueError) as err: self.service.update_user("qauser01", updated["user"]) self.assertEqual(str(err.exception), "Please modify to update ...") with self.assertRaises(ValueError) as err: self.service.update_user("", updated["user"]) self.assertEqual(str(err.exception), "User ID can NOT be empty...") deleted = self.service.delete_user("qauser01") self.assertEqual(deleted["legacy_transaction"], "CU03") self.assertIsNone(self.service.get_user("qauser01")) self.service.delete_user("qauser02") with self.assertRaises(KeyError) as err: self.service.delete_user("qauser01") self.assertEqual(err.exception.args[0], "User ID NOT found...") def test_account_bundle_joins_customer_card_transaction(self) -> None: bundle = self.service.get_account_bundle(1) self.assertIsNotNone(bundle) assert bundle is not None self.assertEqual(bundle["account"]["account_id"], 1) self.assertGreaterEqual(len(bundle["cards"]), 1) self.assertGreaterEqual(len(bundle["customers"]), 1) def test_card_detail_follows_ccdl_lookup_shape(self) -> None: bundle = self.service.get_account_bundle(1) assert bundle is not None card = bundle["cards"][0] detail = self.service.get_card_detail(card["card_number"], account_id=1) self.assertEqual(detail["legacy_transaction"], "CCDL") self.assertEqual(detail["legacy_program"], "COCRDSLC") self.assertEqual(detail["card"]["card_number"], card["card_number"]) self.assertEqual(detail["card"]["account_id"], 1) self.assertIn("embossed_name", detail["editable_fields"]) with self.assertRaisesRegex(ValueError, "16 digit number"): self.service.get_card_detail("123", account_id=1) with self.assertRaisesRegex(KeyError, "Did not find cards"): self.service.get_card_detail(card["card_number"], account_id=999) def test_card_update_follows_ccup_validation_and_rewrite_shape(self) -> None: bundle = self.service.get_account_bundle(1) assert bundle is not None card = bundle["cards"][0] old_year, old_month, old_day = card["expiration_date"].split("-") updated = self.service.update_card( card["card_number"], { "account_id": 1, "embossed_name": "Trace Holder", "active_status": "N", "expiration_month": "12", "expiration_year": "2030", }, ) self.assertEqual(updated["legacy_transaction"], "CCUP") self.assertEqual(updated["legacy_program"], "COCRDUPC") self.assertEqual(updated["card"]["embossed_name"], "Trace Holder") self.assertEqual(updated["card"]["active_status"], "N") self.assertEqual(updated["card"]["expiration_date"], f"2030-12-{old_day}") self.assertIn("expiration_day", updated["preserved_fields"]) self.assertIn("expiration_date", updated["changed_fields"]) self.assertEqual(updated["card"]["cvv"], card["cvv"]) with self.assertRaisesRegex(ValueError, "No change detected"): self.service.update_card( card["card_number"], { "account_id": 1, "embossed_name": "trace holder", "active_status": "N", "expiration_month": "12", "expiration_year": "2030", }, ) self.assertNotEqual((old_year, old_month), ("2030", "12")) def test_card_update_rejects_ccup_screen_edge_cases(self) -> None: card = self.service.get_account_bundle(1)["cards"][0] with self.assertRaisesRegex(ValueError, "Card name can only contain alphabets"): self.service.update_card(card["card_number"], {"embossed_name": "Bad123"}) with self.assertRaisesRegex(ValueError, "Card Active Status must be Y or N"): self.service.update_card(card["card_number"], {"active_status": "X"}) with self.assertRaisesRegex(ValueError, "Card expiry month must be between 1 and 12"): self.service.update_card(card["card_number"], {"expiration_month": "13"}) with self.assertRaisesRegex(ValueError, "Invalid card expiry year"): self.service.update_card(card["card_number"], {"expiration_year": "2100"}) def test_account_update_follows_caup_validation_and_rewrite_shape(self) -> None: before = self.service.get_account_bundle(1) assert before is not None account = before["account"] updated = self.service.update_account( 1, { "active_status": "N", "credit_limit_cents": account["credit_limit_cents"] + 10000, "cash_credit_limit_cents": account["cash_credit_limit_cents"] + 5000, "group_id": "TRACEGRP", "customer": {"zip_code": "27514"}, }, ) self.assertEqual(updated["legacy_transaction"], "CAUP") self.assertEqual(updated["legacy_program"], "COACTUPC") self.assertEqual(updated["active_status"], "N") self.assertEqual(updated["credit_limit_cents"], account["credit_limit_cents"] + 10000) self.assertEqual(updated["cash_credit_limit_cents"], account["cash_credit_limit_cents"] + 5000) self.assertEqual(updated["group_id"], "TRACEGRP") self.assertEqual(updated["customer"]["zip_code"], "27514") self.assertIn("credit_limit_cents", updated["updated_account_fields"]) self.assertIn("zip_code", updated["updated_customer_fields"]) with self.assertRaisesRegex(ValueError, "No changes"): self.service.update_account( 1, { "active_status": "N", "credit_limit_cents": updated["credit_limit_cents"], "cash_credit_limit_cents": updated["cash_credit_limit_cents"], "group_id": "TRACEGRP", "customer": {"zip_code": "27514"}, }, ) def test_account_update_rejects_caup_screen_edge_cases(self) -> None: with self.assertRaisesRegex(ValueError, "Account Status must be Y or N"): self.service.update_account(1, {"active_status": "X"}) with self.assertRaisesRegex(ValueError, "Credit Limit is not valid"): self.service.update_account(1, {"credit_limit_cents": "not-money"}) with self.assertRaisesRegex(ValueError, "State: is not a valid state code"): self.service.update_account(1, {"customer": {"state": "ZZ"}}) with self.assertRaisesRegex(KeyError, "Account ID NOT found"): self.service.update_account(999999, {"active_status": "N"}) def test_bill_payment_adds_credit_transaction(self) -> None: before = self.service.get_account_bundle(1) assert before is not None before_balance = before["account"]["current_balance_cents"] transaction = self.service.bill_payment(1, before_balance) after = self.service.get_account_bundle(1) assert after is not None self.assertEqual(transaction["type_code"], "02") self.assertEqual(transaction["category_code"], "0002") self.assertEqual(transaction["source"], "POS TERM") self.assertEqual(transaction["amount_cents"], before_balance) self.assertEqual(after["account"]["current_balance_cents"], 0) def test_bill_payment_rejects_partial_payment_for_legacy_full_pay_flow(self) -> None: with self.assertRaises(ValueError): self.service.bill_payment(1, 2500) def test_post_transaction_accepts_and_updates_account_and_category_balance(self) -> None: before = self.service.get_account_bundle(1) assert before is not None account = before["account"] card_number = before["cards"][0]["card_number"] conn = connect(self.db_path) try: starting_tcatbal = conn.execute( """ SELECT balance_cents FROM transaction_category_balances WHERE account_id = ? AND type_code = ? AND category_code = ? """, (1, "01", "0001"), ).fetchone() starting_tcatbal_cents = int(starting_tcatbal["balance_cents"]) if starting_tcatbal else 0 finally: conn.close() result = self.service.post_transaction( { "card_number": card_number, "amount_cents": 100, "type_code": "01", "category_code": "0001", "source": "TEST", "description": "POSTTRAN ACCEPT TEST", "merchant_id": "123456789", "merchant_name": "POSTTRAN TEST", "merchant_city": "BATCH", "merchant_zip": "00000", "original_timestamp": f"{account['expiration_date']} 00:00:00.000000", "processed_timestamp": f"{account['expiration_date']} 00:00:00.000000", } ) self.assertTrue(result["accepted"]) after = self.service.get_account_bundle(1) assert after is not None self.assertEqual(after["account"]["current_balance_cents"], account["current_balance_cents"] + 100) self.assertEqual(after["account"]["current_cycle_credit_cents"], account["current_cycle_credit_cents"] + 100) conn = connect(self.db_path) try: ending_tcatbal = conn.execute( """ SELECT balance_cents FROM transaction_category_balances WHERE account_id = ? AND type_code = ? AND category_code = ? """, (1, "01", "0001"), ).fetchone() finally: conn.close() assert ending_tcatbal is not None self.assertEqual(int(ending_tcatbal["balance_cents"]), starting_tcatbal_cents + 100) def test_post_transaction_rejects_invalid_overlimit_and_expired_cases(self) -> None: before = self.service.get_account_bundle(1) assert before is not None account = before["account"] card_number = before["cards"][0]["card_number"] invalid = self.service.post_transaction( {"card_number": "9999999999999999", "amount_cents": 100}, reject_on_failure=False, ) self.assertFalse(invalid["accepted"]) self.assertEqual(invalid["validation"]["reason_code"], 100) overlimit = self.service.post_transaction( { "card_number": card_number, "amount_cents": account["credit_limit_cents"] + 1, "original_timestamp": f"{account['expiration_date']} 00:00:00.000000", }, reject_on_failure=False, ) self.assertFalse(overlimit["accepted"]) self.assertEqual(overlimit["validation"]["reason_code"], 102) expired = self.service.post_transaction( { "card_number": card_number, "amount_cents": 1, "original_timestamp": "2099-01-01 00:00:00.000000", }, reject_on_failure=False, ) self.assertFalse(expired["accepted"]) self.assertEqual(expired["validation"]["reason_code"], 103) def test_transaction_add_follows_ct02_validation_and_transact_write(self) -> None: before = self.service.get_account_bundle(1) assert before is not None before_balance = before["account"]["current_balance_cents"] transaction = self.service.add_transaction( { "account_id": 1, "type_code": "01", "category_code": "0001", "source": "POS TERM", "description": "CT02 SOURCE VALIDATION", "amount_cents": -1234, "original_timestamp": "2022-01-30", "processed_timestamp": "2022-01-31", "merchant_id": "123456789", "merchant_name": "CT02 MERCHANT", "merchant_city": "SEATTLE", "merchant_zip": "98101", "confirm": "Y", } ) after = self.service.get_account_bundle(1) assert after is not None self.assertEqual(transaction["legacy_transaction"], "CT02") self.assertEqual(transaction["legacy_program"], "COTRN02C") self.assertEqual(transaction["account_id"], 1) self.assertEqual(transaction["legacy_amount"], "-00000012.34") self.assertEqual(transaction["original_timestamp"], "2022-01-30") self.assertEqual(after["account"]["current_balance_cents"], before_balance) self.assertTrue(any(row["transaction_id"] == transaction["transaction_id"] for row in after["transactions"])) def test_transaction_add_rejects_ct02_screen_edge_cases(self) -> None: base = { "card_number": self.service.get_account_bundle(1)["cards"][0]["card_number"], "type_code": "01", "category_code": "0001", "source": "POS TERM", "description": "CT02 REJECT TEST", "amount": "+00000012.34", "original_timestamp": "2022-01-30", "processed_timestamp": "2022-01-31", "merchant_id": "123456789", "merchant_name": "CT02 MERCHANT", "merchant_city": "SEATTLE", "merchant_zip": "98101", } with self.assertRaisesRegex(ValueError, "Confirm to add"): self.service.add_transaction(base) with self.assertRaisesRegex(ValueError, "Amount should be"): self.service.add_transaction({**base, "amount": "12.34", "confirm": "Y"}) with self.assertRaisesRegex(ValueError, "Proc Date - Not a valid date"): self.service.add_transaction({**base, "processed_timestamp": "2022-02-31", "confirm": "Y"}) with self.assertRaisesRegex(ValueError, "Merchant ID must be Numeric"): self.service.add_transaction({**base, "merchant_id": "ABC", "confirm": "Y"}) def test_transaction_type_list_follows_ctli_cursor_filters(self) -> None: first_page = self.service.transaction_types(page_size=3) self.assertEqual(first_page["legacy_transaction"], "CTLI") self.assertEqual(first_page["legacy_program"], "COTRTLIC") self.assertEqual(first_page["page"]["page_size"], 3) self.assertEqual([row["type_code"] for row in first_page["types"]], ["01", "02", "03"]) self.assertEqual(first_page["page"]["next_start_key"], "04") next_page = self.service.transaction_types(start_key=first_page["page"]["next_start_key"], page_size=3) self.assertEqual([row["type_code"] for row in next_page["types"]], ["04", "05", "06"]) previous_page = self.service.transaction_types(start_key="07", direction="backward", page_size=3) self.assertEqual([row["type_code"] for row in previous_page["types"]], ["04", "05", "06"]) type_filtered = self.service.transaction_types(type_filter="1") self.assertEqual([row["type_code"] for row in type_filtered["types"]], ["01"]) description_filtered = self.service.transaction_types(description_filter="%PAYMENT%") self.assertGreaterEqual(len(description_filtered["types"]), 1) self.assertTrue(all("PAYMENT" in row["description"].upper() for row in description_filtered["types"])) def test_transaction_type_maintenance_follows_cttu_validation_and_write_shape(self) -> None: inserted = self.service.upsert_transaction_type({"type_code": "8", "description": "Manual Review"}) self.assertEqual(inserted["legacy_transaction"], "CTTU") self.assertEqual(inserted["legacy_program"], "COTRTUPC") self.assertEqual(inserted["type_code"], "08") self.assertEqual(inserted["action"], "inserted") updated = self.service.upsert_transaction_type({"type_code": "08", "description": "Manual Review 2"}) self.assertEqual(updated["action"], "updated") self.assertEqual(updated["description"], "Manual Review 2") with self.assertRaisesRegex(ValueError, "No change detected"): self.service.upsert_transaction_type({"type_code": "08", "description": "manual review 2"}) deleted = self.service.delete_transaction_type("08") self.assertTrue(deleted["deleted"]) with self.assertRaisesRegex(KeyError, "No record found"): self.service.delete_transaction_type("08") def test_transaction_type_maintenance_rejects_cttu_screen_edge_cases(self) -> None: with self.assertRaisesRegex(ValueError, "Tran Type code must be supplied"): self.service.upsert_transaction_type({"type_code": "", "description": "Valid Desc"}) with self.assertRaisesRegex(ValueError, "Tran Type code must be numeric"): self.service.upsert_transaction_type({"type_code": "A1", "description": "Valid Desc"}) with self.assertRaisesRegex(ValueError, "Tran Type code must not be zero"): self.service.upsert_transaction_type({"type_code": "00", "description": "Valid Desc"}) with self.assertRaisesRegex(ValueError, "Transaction Desc must be supplied"): self.service.upsert_transaction_type({"type_code": "08", "description": ""}) with self.assertRaisesRegex(ValueError, "Transaction Desc can have numbers or alphabets only"): self.service.upsert_transaction_type({"type_code": "08", "description": "Bad-Desc"}) with self.assertRaisesRegex(ValueError, "Please delete associated child records first"): self.service.delete_transaction_type("01") def test_batch_transaction_type_maintenance_follows_mnttrdb2_fixed_record_flow(self) -> None: result = self.service.maintain_transaction_types( [ "*COMMENT".ljust(53), "A09" + "Batch Review".ljust(50), "U09" + "Batch Review 2".ljust(50), "D09" + "".ljust(50), ] ) self.assertEqual(result["legacy_job"], "MNTTRDB2") self.assertEqual(result["legacy_program"], "COBTUPDT") self.assertEqual(result["legacy_driver"], "IKJEFT01") self.assertEqual(result["input_dd"], "INPFILE") self.assertEqual(result["return_code"], 0) self.assertEqual(result["counts"]["input_record_count"], 4) self.assertEqual(result["counts"]["comment_count"], 1) self.assertEqual(result["counts"]["applied_count"], 3) self.assertEqual([row["status"] for row in result["actions"]], ["comment_ignored", "inserted", "updated", "deleted"]) conn = connect(self.db_path) try: self.assertIsNone( conn.execute("SELECT type_code FROM transaction_types WHERE type_code = '09'").fetchone() ) finally: conn.close() def test_batch_transaction_type_maintenance_reports_cobol_return_code_for_errors(self) -> None: result = self.service.maintain_transaction_types( [ "X09" + "Bad Action".ljust(50), "U98" + "Missing Update".ljust(50), "D98" + "".ljust(50), "A01" + "Duplicate Purchase".ljust(50), "D01" + "".ljust(50), ] ) self.assertEqual(result["return_code"], 4) self.assertEqual(result["counts"]["applied_count"], 0) self.assertEqual(result["counts"]["error_count"], 5) messages = [row["message"] for row in result["actions"]] self.assertIn("ERROR: TYPE NOT VALID", messages) self.assertIn("No records found.", messages) self.assertIn("Error accessing: TRANSACTION_TYPE table. SQLCODE:-803", messages) self.assertIn("Error accessing: TRANSACTION_TYPE table. SQLCODE:-532", messages) def test_transaction_report_groups_seed_data_by_account(self) -> None: report = self.service.transaction_report(account_id=1, limit=1000) self.assertEqual(report["legacy_job"], "TRANREPT") self.assertGreater(report["totals"]["transaction_count"], 0) self.assertTrue(all(row["account_id"] == 1 for row in report["rows"])) self.assertEqual( report["totals"]["total_amount_cents"], sum(row["amount_cents"] for row in report["rows"]), ) def test_account_statement_materializes_legacy_sections(self) -> None: statement = self.service.account_statement(1) self.assertEqual(statement["legacy_job"], "CREASTMT") self.assertEqual(statement["legacy_programs"], ["CBSTM03A", "CBSTM03B"]) self.assertEqual(statement["source_sort_key"], "card_number,transaction_id") self.assertIn("START OF STATEMENT", statement["plain_text_lines"][0]) self.assertIn("END OF STATEMENT", statement["plain_text_lines"][-1]) self.assertTrue(all(len(line) == statement["statement_lines_lrecl"] for line in statement["plain_text_lines"])) self.assertTrue(all(len(line) <= statement["html_lines_lrecl"] for line in statement["html_lines"])) self.assertGreater(statement["transaction_count"], 0) self.assertEqual(statement["transaction_count"], len(statement["statement_rows"])) self.assertEqual( statement["total_expense_cents"], sum(row["amount_cents"] for row in statement["statement_rows"]), ) sort_keys = [(row["card_number"], row["transaction_id"]) for row in statement["statement_rows"]] self.assertEqual(sort_keys, sorted(sort_keys)) def test_interest_projection_uses_disclosure_rates_and_formula(self) -> None: projection = self.service.interest_projection(limit=20) self.assertEqual(projection["legacy_job"], "INTCALC") self.assertGreater(len(projection["rows"]), 0) first = projection["rows"][0] expected = int( (first["balance_cents"] * first["interest_rate_basis_points"]) / 120000 ) self.assertEqual(first["monthly_interest_cents"], expected) self.assertEqual(projection["generated_transactions"][0]["type_code"], "01") self.assertEqual(projection["generated_transactions"][0]["category_code"], "0005") def test_transaction_master_backup_models_tranbkp_repro_and_ksds_redefine(self) -> None: backup = self.service.transaction_master_backup(limit=5) self.assertEqual(backup["legacy_job"], "TRANBKP") self.assertEqual(backup["legacy_proc"], "REPROC") self.assertEqual(backup["source_dataset"], "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS") self.assertEqual(backup["backup_dataset"], "AWS.M2.CARDDEMO.TRANSACT.BKUP(+1)") self.assertEqual(backup["define_cluster"]["keys"], {"length": 16, "offset": 0}) self.assertEqual(backup["define_cluster"]["record_size"], {"min": 350, "max": 350}) self.assertEqual(backup["record_count"], 300) self.assertEqual(len(backup["preview_records"]), 5) self.assertTrue(all(row["record_length"] == 350 for row in backup["preview_records"])) keys = [row["key"] for row in backup["preview_records"]] self.assertEqual(keys, sorted(keys)) def test_transaction_type_extract_models_tranextr_dsntiaul_records(self) -> None: extract = self.service.transaction_type_extract() self.assertEqual(extract["legacy_job"], "TRANEXTR") self.assertEqual(extract["legacy_program"], "DSNTIAUL") self.assertEqual(extract["legacy_plan"], "DSNTIAUL") self.assertEqual(extract["lrecl"], 60) self.assertEqual(extract["counts"]["transaction_types"], 7) self.assertEqual(extract["counts"]["transaction_categories"], 18) type_records = extract["records"]["transaction_types"] category_records = extract["records"]["transaction_categories"] self.assertTrue(all(len(record) == 60 for record in type_records + category_records)) self.assertEqual(type_records[0][:2], "01") self.assertTrue(type_records[0].endswith("0" * 8)) self.assertEqual(category_records[0][:6], "010001") self.assertTrue(category_records[0].endswith("0" * 4)) def test_db2_reference_setup_models_creadb21_schema_and_loads(self) -> None: setup = self.service.db2_reference_setup() self.assertEqual(setup["legacy_job"], "CREADB21") self.assertEqual(setup["legacy_jcl_job"], "CREADB2") self.assertEqual(setup["db2_system"], "DAZ1") self.assertEqual(setup["database"]["name"], "CARDDEMO") self.assertEqual([step["step"] for step in setup["steps"]], ["FREEPLN", "CRCRDDB", "RUNTEP2", "LDTCCAT"]) self.assertEqual(setup["tables"]["transaction_type"]["load_count"], 7) self.assertEqual(setup["tables"]["transaction_type_category"]["load_count"], 18) self.assertEqual( setup["tables"]["transaction_type_category"]["foreign_key"]["references"], "CARDDEMO.TRANSACTION_TYPE(TR_TYPE)", ) self.assertEqual(setup["tables"]["transaction_type_category"]["foreign_key"]["on_delete"], "RESTRICT") def test_mq_system_date_cdrd_formats_source_reply(self) -> None: result = self.service.mq_system_date({"request_message": "ANYTHING"}, now="2026-05-23T11:12:13") self.assertEqual(result["legacy_transaction"], "CDRD") self.assertEqual(result["legacy_program"], "CODATE01") self.assertEqual(result["reply_queue"], "CARD.DEMO.REPLY.DATE") self.assertEqual(result["system_date"], "05-23-2026") self.assertEqual(result["system_time"], "11:12:13") self.assertEqual(result["reply_message"], "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13") def test_mq_account_inquiry_cdra_reads_account_and_rejects_invalid_requests(self) -> None: result = self.service.mq_account_inquiry({"function": "INQA", "account_id": 1}) self.assertEqual(result["legacy_transaction"], "CDRA") self.assertEqual(result["legacy_program"], "COACCT01") self.assertTrue(result["valid_request"]) self.assertEqual(result["request"]["account_id_text"], "00000000001") self.assertEqual(result["account_data"]["account_id"], 1) self.assertIn("ACCOUNT ID : 00000000001", result["reply_message"]) self.assertIn("ACCOUNT STATUS : Y", result["reply_message"]) self.assertIn("GROUP ID : ", result["reply_message"]) from_raw = self.service.mq_account_inquiry({"request_message": "INQA00000000001"}) self.assertTrue(from_raw["valid_request"]) self.assertEqual(from_raw["account_data"]["account_id"], 1) not_found = self.service.mq_account_inquiry({"function": "INQA", "account_id": 99999999999}) self.assertFalse(not_found["valid_request"]) self.assertIn("INVALID REQUEST PARAMETERS ACCT ID : 99999999999", not_found["reply_message"]) bad_function = self.service.mq_account_inquiry({"function": "BAD", "account_id": 1}) self.assertFalse(bad_function["valid_request"]) self.assertIn("FUNCTION : BAD ", bad_function["reply_message"]) def test_batch_resource_setup_models_remaining_gdg_vsam_aix_and_cics_jobs(self) -> None: setup = self.service.batch_resource_setup() self.assertEqual(setup["legacy_jobs"], ["DEFGDGB", "DEFGDGD", "ESDSRRDS", "TRANIDX", "CLOSEFIL", "OPENFIL"]) self.assertEqual(setup["resource_count"], 6) gdg_base = self.service.batch_resource_setup("DEFGDGB") self.assertEqual(len(gdg_base["gdg_bases"]), 6) self.assertEqual(gdg_base["gdg_bases"][0]["name"], "AWS.M2.CARDDEMO.TRANSACT.BKUP") self.assertEqual(gdg_base["gdg_bases"][0]["limit"], 5) self.assertTrue(gdg_base["gdg_bases"][0]["scratch"]) db2_gdg = self.service.batch_resource_setup("DEFGDGD") self.assertEqual(db2_gdg["steps"][1]["target"], "AWS.M2.CARDDEMO.TRANTYPE.BKUP(+1)") self.assertEqual(db2_gdg["steps"][1]["lrecl"], 60) self.assertEqual(db2_gdg["steps"][1]["record_count"], 7) self.assertEqual(db2_gdg["steps"][5]["record_count"], 51) esds_rrds = self.service.batch_resource_setup("ESDSRRDS") self.assertEqual(esds_rrds["instream_user_records"], 10) self.assertEqual([cluster["organization"] for cluster in esds_rrds["clusters"]], ["NONINDEXED", "NUMBERED"]) self.assertEqual(esds_rrds["clusters"][0]["record_size"], [80, 80]) tranidx = self.service.batch_resource_setup("TRANIDX") self.assertEqual(tranidx["alternate_index"]["keys"], {"length": 26, "offset": 304}) self.assertEqual(tranidx["path"]["pathentry"], "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX") self.assertEqual(tranidx["bldindex"]["source_record_count"], 300) closefil = self.service.batch_resource_setup("CLOSEFIL") openfil = self.service.batch_resource_setup("OPENFIL") self.assertEqual(closefil["cemt_code"], "CLO") self.assertEqual(openfil["cemt_code"], "OPE") self.assertEqual(closefil["files"], ["TRANSACT", "CCXREF", "ACCTDAT", "CXACAIX", "USRSEC"]) self.assertEqual(openfil["files"], closefil["files"]) def test_pending_authorization_summary_and_detail_use_ims_seed(self) -> None: summary = self.service.pending_authorization_summary(1, page_size=5) self.assertEqual(summary["legacy_transaction"], "CPVS") self.assertEqual(summary["summary"]["approved_auth_count"], 6) self.assertEqual(summary["summary"]["approved_auth_amount_cents"], 944) self.assertEqual(len(summary["authorizations"]), 5) self.assertTrue(summary["next_page"]) first = summary["authorizations"][0] detail = self.service.pending_authorization_detail(1, authorization_key=first["authorization_key"]) self.assertEqual(detail["legacy_transaction"], "CPVD") self.assertEqual(detail["authorization"]["transaction_id"], "960b9b5480d045a") self.assertEqual(detail["authorization"]["authorization_date"], "10/27/23") self.assertEqual(detail["authorization"]["authorization_response"], "A") def test_authorization_request_updates_summary_and_inserts_detail(self) -> None: before = self.service.pending_authorization_summary(1, page_size=1) result = self.service.process_authorization_request( { "card_number": "9680294154603697", "auth_date": "260523", "auth_time": "111213", "card_expiry_date": "1129", "transaction_amount_cents": 100, "merchant_category_code": "5442", "merchant_id": "123501000675423", "merchant_name": "Amazon.com", "merchant_city": "Wilmington", "merchant_state": "DE", "merchant_zip": "19801", "transaction_id": "AUTHREQ00000001", "processing_datetime": "2026-05-23T11:12:13.456", } ) self.assertEqual(result["legacy_transaction"], "CP00") self.assertTrue(result["approved"]) self.assertEqual(result["response"]["auth_resp_code"], "00") self.assertTrue(result["written_to_pending_authorizations"]) after = self.service.pending_authorization_summary(1, page_size=1) self.assertEqual(after["summary"]["approved_auth_count"], before["summary"]["approved_auth_count"] + 1) detail = self.service.pending_authorization_detail(1, transaction_id="AUTHREQ00000001") self.assertEqual(detail["authorization"]["approved_amount_cents"], 100) self.assertEqual(detail["authorization"]["auth_id_code"], "111213") def test_authorization_declines_invalid_card_without_write(self) -> None: result = self.service.process_authorization_request( { "card_number": "9999999999999999", "transaction_amount_cents": 100, "transaction_id": "AUTHREQBAD0001", } ) self.assertFalse(result["approved"]) self.assertEqual(result["response"]["auth_resp_code"], "05") self.assertEqual(result["response"]["auth_resp_reason"], "3100") self.assertFalse(result["written_to_pending_authorizations"]) def test_authorization_fraud_mark_writes_authfrds_shadow_table(self) -> None: summary = self.service.pending_authorization_summary(1, page_size=1) auth_key = summary["authorizations"][0]["authorization_key"] result = self.service.mark_authorization_fraud(1, auth_key, action="report", report_date="20260523") self.assertEqual(result["legacy_program"], "COPAUS1C/COPAUS2C") self.assertEqual(result["fraud_status"], "F") detail = self.service.pending_authorization_detail(1, authorization_key=auth_key) self.assertEqual(detail["authorization"]["auth_fraud"], "F") conn = connect(self.db_path) try: count = conn.execute("SELECT COUNT(*) FROM authorization_frauds").fetchone()[0] finally: conn.close() self.assertEqual(count, 1) def test_purge_expired_authorizations_dry_run_and_apply(self) -> None: dry_run = self.service.purge_expired_authorizations(current_yyddd=23305, expiry_days=5, dry_run=True) self.assertEqual(dry_run["legacy_job"], "CBPAUP0J") self.assertGreater(dry_run["purged_count"], 0) applied = self.service.purge_expired_authorizations(current_yyddd=23305, expiry_days=5) self.assertGreater(applied["purged_count"], 0) with self.assertRaises(KeyError): self.service.pending_authorization_summary(1, page_size=10) def test_combined_transactions_includes_seed_and_interest_previews(self) -> None: combined = self.service.combined_transactions(limit=1000) self.assertEqual(combined["legacy_job"], "COMBTRAN") self.assertEqual(combined["source_datasets"][0], "AWS.M2.CARDDEMO.TRANSACT.BKUP(0)") self.assertEqual(combined["source_datasets"][1], "AWS.M2.CARDDEMO.SYSTRAN(0)") self.assertEqual(combined["sort"]["symbol"], "TRAN-ID") self.assertEqual(combined["sort"]["start"], 1) self.assertEqual(combined["sort"]["length"], 16) self.assertEqual(combined["sort"]["order"], "A") self.assertEqual(combined["sortout_dataset"], "AWS.M2.CARDDEMO.TRANSACT.COMBINED(+1)") self.assertEqual(combined["repro_target"], "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS") self.assertEqual(combined["source_counts"]["transaction_master"], 300) self.assertGreater(combined["source_counts"]["interest_projection"], 0) self.assertEqual( combined["source_counts"]["total_combined"], combined["source_counts"]["transaction_master"] + combined["source_counts"]["interest_projection"], ) self.assertEqual(combined["source_counts"]["returned"], len(combined["rows"])) transaction_ids = [row["transaction_id"] for row in combined["rows"]] self.assertEqual(transaction_ids, sorted(transaction_ids)) if __name__ == "__main__": unittest.main()