printer-core 0.0.1__py3-none-any.whl

printer_core/tests/unitaries/test_cases_output.py

@@ -0,0 +1,189 @@
+import json
+import os
+from pathlib import Path
+from types import SimpleNamespace
+
+import unittest
+from printer_core.dispatchers.kitchen_ticket_dispatcher import KitchenTicketDispatcher
+from printer_core.entities import HeaderData, KitchenProductLine, PrintChannel, PrinterProductGroup
+from printer_core.services.flows.client import ClientPrintFlow
+
+from printer_core.tests.unitaries.helpers import (
+    FakeGateway,
+    FakeHeaderProvider,
+    FakePrintSettingsBuilder,
+    make_kitchen_settings,
+    make_printer,
+    make_product,
+    make_request,
+    make_ticket_settings,
+)
+
+
+def _should_dump_cases() -> bool:
+    return os.getenv("FOODEO_PRINTERS_DUMP_CASES", "").lower() in {"1", "true", "yes"}
+
+
+def _dump_case_output(case_id: str, flow: str, input_data: dict[str, object], ws_payload: object) -> None:
+    if not _should_dump_cases():
+        return
+    dump_dir = Path(os.getenv("FOODEO_PRINTERS_DUMP_DIR", "tmp/foodeo_printers_cases"))
+    dump_dir.mkdir(parents=True, exist_ok=True)
+    path = dump_dir / f"{case_id}_{flow}.json"
+    payload = {
+        "case_id": case_id,
+        "flow": flow,
+        "input": input_data,
+        "ws_payload": ws_payload,
+    }
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump(payload, handle, ensure_ascii=True, indent=2, sort_keys=True)
+
+
+CASES_ALL = [
+    ("CASE01", "local", "web", PrintChannel.LOCAL),
+    ("CASE02", "local", "apk", PrintChannel.LOCAL),
+    ("CASE03", "local", "web_sales", PrintChannel.LOCAL),
+    ("CASE04", "local", "kiosko", PrintChannel.LOCAL),
+    ("CASE05", "barra", "web", PrintChannel.BARRA),
+    ("CASE06", "barra", "apk", PrintChannel.BARRA),
+    ("CASE07", "barra", "web_sales", PrintChannel.BARRA),
+    ("CASE08", "barra", "kiosko", PrintChannel.BARRA),
+    ("CASE09", "kiosko", "web", PrintChannel.KIOSKO),
+    ("CASE10", "kiosko", "apk", PrintChannel.KIOSKO),
+    ("CASE11", "kiosko", "web_sales", PrintChannel.KIOSKO),
+    ("CASE12", "kiosko", "kiosko", PrintChannel.KIOSKO),
+    ("CASE13", "domicilio", "web", PrintChannel.DOMICILE),
+    ("CASE14", "domicilio", "apk", PrintChannel.DOMICILE),
+    ("CASE15", "domicilio", "kiosko", PrintChannel.DOMICILE),
+    ("CASE16", "domicilio", "web_sales", PrintChannel.DOMICILE),
+    ("CASE17", "recoger", "web", PrintChannel.PICKUP),
+    ("CASE18", "recoger", "apk", PrintChannel.PICKUP),
+    ("CASE19", "recoger", "kiosko", PrintChannel.PICKUP),
+    ("CASE20", "recoger", "web_sales", PrintChannel.PICKUP),
+    ("CASE21", "local", "web", PrintChannel.LOCAL),
+    ("CASE22", "local", "apk", PrintChannel.LOCAL),
+    ("CASE23", "local", "web_sales", PrintChannel.LOCAL),
+    ("CASE24", "local", "kiosko", PrintChannel.LOCAL),
+    ("CASE25", "barra", "web", PrintChannel.BARRA),
+    ("CASE26", "barra", "apk", PrintChannel.BARRA),
+    ("CASE27", "barra", "web_sales", PrintChannel.BARRA),
+    ("CASE28", "barra", "kiosko", PrintChannel.BARRA),
+    ("CASE29", "kiosko", "web", PrintChannel.KIOSKO),
+    ("CASE30", "kiosko", "apk", PrintChannel.KIOSKO),
+    ("CASE31", "kiosko", "web_sales", PrintChannel.KIOSKO),
+    ("CASE32", "kiosko", "kiosko", PrintChannel.KIOSKO),
+    ("CASE33", "domicilio", "web", PrintChannel.DOMICILE),
+    ("CASE34", "domicilio", "apk", PrintChannel.DOMICILE),
+    ("CASE35", "domicilio", "web_sales", PrintChannel.DOMICILE),
+    ("CASE36", "domicilio", "kiosko", PrintChannel.DOMICILE),
+    ("CASE37", "recoger", "web", PrintChannel.PICKUP),
+    ("CASE38", "recoger", "apk", PrintChannel.PICKUP),
+    ("CASE39", "recoger", "web_sales", PrintChannel.PICKUP),
+    ("CASE40", "recoger", "kiosko", PrintChannel.PICKUP),
+    ("CASE41", "domicilio", "web", PrintChannel.DOMICILE),
+    ("CASE42", "domicilio", "apk", PrintChannel.DOMICILE),
+    ("CASE43", "domicilio", "web_sales", PrintChannel.DOMICILE),
+    ("CASE44", "domicilio", "kiosko", PrintChannel.DOMICILE),
+    ("CASE45", "recoger", "web", PrintChannel.PICKUP),
+    ("CASE46", "recoger", "apk", PrintChannel.PICKUP),
+    ("CASE47", "recoger", "web_sales", PrintChannel.PICKUP),
+    ("CASE48", "recoger", "kiosko", PrintChannel.PICKUP),
+]
+
+
+class CasesOutputTest(unittest.TestCase):
+    def test_client_flow_outputs_for_cases(self):
+        for case_id, request_type, from_client, channel in CASES_ALL:
+            with self.subTest(case=case_id):
+                gateway = FakeGateway()
+                base_request = make_request(request_type=request_type, from_client=from_client)
+                products = [make_product()]
+                flow = ClientPrintFlow(
+                    gateway=gateway,
+                    header_provider=FakeHeaderProvider(),
+                    print_settings_builder=FakePrintSettingsBuilder(),
+                    currency_symbol_resolver=lambda _: "",
+                    domicile_service_label="Service",
+                )
+                context = SimpleNamespace(
+                    kitchen_settings=make_kitchen_settings(),
+                    ticket_settings=make_ticket_settings(),
+                    main_printer=make_printer(),
+                    worker=None,
+                )
+                flow.execute(
+                    base_request=base_request,
+                    products=products,
+                    context=context,
+                    channel=channel,
+                    tpv_key="TPV1",
+                )
+
+                payload = gateway.calls[0][1][0]
+                _dump_case_output(
+                    case_id=case_id,
+                    flow="client",
+                    input_data={
+                        "request": base_request.model_dump(mode="json", exclude_none=True),
+                        "products": [product.model_dump(mode="json", exclude_none=True) for product in products],
+                        "channel": channel.value,
+                        "tpv_key": "TPV1",
+                        "ticket_settings": vars(context.ticket_settings),
+                        "kitchen_settings": vars(context.kitchen_settings),
+                        "main_printer": context.main_printer.model_dump(mode="json", exclude_none=True),
+                    },
+                    ws_payload=gateway.calls[0][1],
+                )
+                self.assertEqual(payload["data"]["headerData"]["client_name"], f"{request_type}:{from_client}")
+                if channel == PrintChannel.LOCAL:
+                    self.assertEqual(payload["data"]["PrintSettings"]["show_header"], False)
+                else:
+                    self.assertEqual(payload["data"]["PrintSettings"]["show_header"], True)
+
+    def test_kitchen_dispatcher_outputs_for_cases(self):
+        for case_id, request_type, from_client, channel in CASES_ALL:
+            with self.subTest(case=case_id):
+                gateway = FakeGateway()
+                request = make_request(
+                    request_type=request_type,
+                    from_client=from_client,
+                    headerData=HeaderData(client_name=f"{request_type}:{from_client}"),
+                )
+                dispatcher = KitchenTicketDispatcher(gateway=gateway)
+                grouped_products = [
+                    PrinterProductGroup(
+                        printer_name="P1",
+                        tpv_key="TPV1",
+                        printer_width="80",
+                        products=[KitchenProductLine(name="A", qty=1, option=None, printer_r="P1", printer_w="80")],
+                    )
+                ]
+                ticket_settings = make_ticket_settings()
+                kitchen_ticket_settings = make_kitchen_settings()
+
+                dispatcher.dispatch(
+                    request=request,
+                    grouped_products=grouped_products,
+                    ticket_settings=ticket_settings,
+                    kitchen_ticket_settings=kitchen_ticket_settings,
+                    group_products_func=lambda items: [],
+                )
+
+                payload = gateway.calls[0][1][0]
+                _dump_case_output(
+                    case_id=case_id,
+                    flow="kitchen",
+                    input_data={
+                        "request": request.model_dump(mode="json", exclude_none=True),
+                        "grouped_products": [group.model_dump(mode="json", exclude_none=True) for group in grouped_products],
+                        "ticket_settings": vars(ticket_settings),
+                        "kitchen_ticket_settings": vars(kitchen_ticket_settings),
+                    },
+                    ws_payload=gateway.calls[0][1],
+                )
+                expected_model = 1 if request_type == "local" else 2
+                self.assertEqual(payload["model"], expected_model)
+                self.assertEqual(payload["data"]["headerData"]["client_name"], f"{request_type}:{from_client}")
+                self.assertEqual(payload["printer"], "P1")
+                self.assertEqual(payload["company_key"], "TPV1")

printer_core/tests/unitaries/test_client_ticket_builder.py

@@ -0,0 +1,78 @@
+import unittest
+from printer_core.builders.client_ticket_builder import ClientTicketBuilder
+from printer_core.entities import DiscountData
+
+from printer_core.tests.unitaries.helpers import make_printer, make_product, make_request, make_ticket_settings
+
+
+class ClientTicketBuilderTest(unittest.TestCase):
+    def test_build_removes_details_for_local(self):
+        builder = ClientTicketBuilder(currency_symbol_resolver=lambda _: "€")
+        request = make_request(request_type="local", details="Some details")
+        products = [make_product()]
+        printer = make_printer()
+        ticket_settings = make_ticket_settings(ticket_text="Text", qty_client_ticket=2)
+
+        payloads = builder.build(
+            request=request,
+            products=products,
+            printer=printer,
+            ticket_settings=ticket_settings,
+            tpv_key="TPV1",
+        )
+
+        self.assertIsNone(payloads[0].data.details)
+        self.assertEqual(payloads[0].printer_qty, 2)
+        self.assertEqual(payloads[0].data.ticket_text, "Text")
+
+    def test_build_keeps_details_for_domicile(self):
+        builder = ClientTicketBuilder()
+        request = make_request(request_type="domicilio", details=None)
+        products = [make_product()]
+        payloads = builder.build(
+            request=request,
+            products=products,
+            printer=make_printer(),
+            ticket_settings=make_ticket_settings(),
+            tpv_key="TPV1",
+        )
+
+        self.assertEqual(payloads[0].data.details, "")
+
+    def test_build_formats_discount(self):
+        builder = ClientTicketBuilder(currency_symbol_resolver=lambda _: "€")
+        request = make_request()
+        products = [
+            make_product(
+                total_price="90",
+                product_price="100",
+                discount_type="percent",
+                discount=DiscountData(value="10", type="percent"),
+                importe="100",
+            )
+        ]
+        payloads = builder.build(
+            request=request,
+            products=products,
+            printer=make_printer(),
+            ticket_settings=make_ticket_settings(),
+            tpv_key="TPV1",
+        )
+
+        self.assertIn("Dto 10% 10€", payloads[0].data.products[0].name)
+
+    def test_build_adds_domicile_service_line(self):
+        builder = ClientTicketBuilder(domicile_service_label="Service")
+        request = make_request(request_type="domicilio", price_domicile_service="2.00")
+        products = [make_product()]
+
+        payloads = builder.build(
+            request=request,
+            products=products,
+            printer=make_printer(),
+            ticket_settings=make_ticket_settings(),
+            tpv_key="TPV1",
+        )
+
+        self.assertEqual(payloads[0].data.products[-1].name, "Service")
+        self.assertEqual(payloads[0].data.products[-1].price, "2.00")

printer_core/tests/unitaries/test_discount_formatter.py

@@ -0,0 +1,37 @@
+import unittest
+from printer_core.entities import DiscountData
+from printer_core.formatters.discount_formatter import DiscountFormatter
+
+from printer_core.tests.unitaries.helpers import make_product
+
+
+class DiscountFormatterTest(unittest.TestCase):
+    def test_format_number_discount(self):
+        formatter = DiscountFormatter(currency_symbol_resolver=lambda _: "€")
+        product = make_product(total_price="5.00", discount_type="number")
+
+        result = formatter.format(product, "EUR")
+
+        self.assertEqual(result, " (Dto 5.00€)")
+
+    def test_format_percent_discount(self):
+        formatter = DiscountFormatter(currency_symbol_resolver=lambda _: "€")
+        product = make_product(
+            total_price="90",
+            product_price="100",
+            discount_type="percent",
+            discount=DiscountData(value="10", type="percent"),
+            importe="100",
+        )
+
+        result = formatter.format(product, "EUR")
+
+        self.assertEqual(result, " (Dto 10% 10€)")
+
+    def test_format_without_discount(self):
+        formatter = DiscountFormatter(currency_symbol_resolver=lambda _: "€")
+        product = make_product(total_price="90", product_price="100")
+
+        result = formatter.format(product, "EUR")
+
+        self.assertEqual(result, "")

printer_core/tests/unitaries/test_family_product_selector.py

@@ -0,0 +1,28 @@
+import unittest
+from printer_core.entities import FamilyData
+from printer_core.selectors.family_product_selector import FamilyProductSelector
+
+from printer_core.tests.unitaries.helpers import FakeFamilyProvider, make_product
+
+
+class FamilyProductSelectorTest(unittest.TestCase):
+    def test_group_products(self):
+        family_1 = FamilyData(id=1, name="Family 1")
+        family_2 = FamilyData(id=2, name="Family 2")
+        provider = FakeFamilyProvider(
+            families=[family_1, family_2],
+            family_by_category={10: family_1, 20: family_2},
+        )
+        selector = FamilyProductSelector(provider=provider)
+        products = [
+            make_product(name="A", category=10),
+            make_product(name="B", category=20),
+            make_product(name="C", category=None),
+        ]
+
+        families, products_by_family, products_without_family = selector.group_products(products)
+
+        self.assertEqual(families, [family_1, family_2])
+        self.assertEqual([p.product_name for p in products_by_family[1]], ["A"])
+        self.assertEqual([p.product_name for p in products_by_family[2]], ["B"])
+        self.assertEqual([p.product_name for p in products_without_family], ["C"])

printer_core/tests/unitaries/test_flows.py

@@ -0,0 +1,141 @@
+from unittest.mock import patch
+
+import unittest
+from printer_core.entities import PrintChannel
+from printer_core.services.flows.client import ClientPrintFlow
+from printer_core.services.flows.kitchen import KitchenPrintFlow
+
+from printer_core.tests.unitaries.helpers import (
+    FakeGateway,
+    FakeHeaderProvider,
+    FakePrintSettingsBuilder,
+    make_kitchen_settings,
+    make_printer,
+    make_product,
+    make_request,
+    make_ticket_settings,
+)
+
+
+class ClientPrintFlowTest(unittest.TestCase):
+    def test_execute_requires_tpv_key(self):
+        flow = ClientPrintFlow(
+            gateway=FakeGateway(),
+            header_provider=FakeHeaderProvider(),
+            print_settings_builder=FakePrintSettingsBuilder(),
+            currency_symbol_resolver=lambda _: "",
+            domicile_service_label="Service",
+        )
+
+        with self.assertRaises(ValueError):
+            flow.execute(
+                base_request=make_request(),
+                products=[make_product()],
+                context=type("Ctx", (), {"kitchen_settings": make_kitchen_settings(), "ticket_settings": make_ticket_settings(), "main_printer": make_printer(), "worker": None})(),
+                channel=PrintChannel.LOCAL,
+                tpv_key="",
+            )
+
+    def test_execute_sends_payload(self):
+        gateway = FakeGateway()
+        flow = ClientPrintFlow(
+            gateway=gateway,
+            header_provider=FakeHeaderProvider(),
+            print_settings_builder=FakePrintSettingsBuilder(),
+            currency_symbol_resolver=lambda _: "",
+            domicile_service_label="Service",
+        )
+        context = type("Ctx", (), {
+            "kitchen_settings": make_kitchen_settings(),
+            "ticket_settings": make_ticket_settings(),
+            "main_printer": make_printer(),
+            "worker": None,
+        })()
+
+        flow.execute(
+            base_request=make_request(request_type="local", from_client="web"),
+            products=[make_product()],
+            context=context,
+            channel=PrintChannel.LOCAL,
+            tpv_key="TPV1",
+        )
+
+        self.assertEqual(len(gateway.calls), 1)
+        payload = gateway.calls[0][1][0]
+        self.assertEqual(payload["company_key"], "TPV1")
+        self.assertEqual(payload["data"]["PrintSettings"]["show_header"], False)
+        self.assertEqual(payload["data"]["headerData"]["client_name"], "local:web")
+
+
+class KitchenPrintFlowTest(unittest.TestCase):
+    def test_execute_uses_multi_printer_service(self):
+        captured = {}
+
+        class DummyService:
+            def __init__(self, **kwargs):
+                pass
+
+            def build_and_dispatch(self, request, products, main_printer, ticket_settings, kitchen_ticket_settings):
+                captured["request"] = request
+                return []
+
+        with patch("printer_core.services.flows.kitchen.MultiPrinterService", DummyService):
+            flow = KitchenPrintFlow(
+                gateway=FakeGateway(),
+                header_provider=FakeHeaderProvider(),
+                print_settings_builder=FakePrintSettingsBuilder(),
+                family_provider=object(),
+                currency_symbol_resolver=lambda _: "",
+            )
+            context = type("Ctx", (), {
+                "ticket_settings": make_ticket_settings(),
+                "kitchen_settings": make_kitchen_settings(print_by="categories"),
+                "main_printer": make_printer(),
+                "worker": None,
+            })()
+
+            flow.execute(
+                base_request=make_request(request_type="local"),
+                products=[make_product()],
+                context=context,
+                channel=PrintChannel.LOCAL,
+                tpv_key="TPV1",
+            )
+
+        self.assertEqual(captured["request"].print_by, "categories")
+
+    def test_execute_uses_family_service_and_skips_print_by(self):
+        captured = {}
+
+        class DummyFamilyService:
+            def __init__(self, **kwargs):
+                pass
+
+            def build_and_dispatch(self, request, products, main_printer, ticket_settings, kitchen_ticket_settings):
+                captured["request"] = request
+                return []
+
+        with patch("printer_core.services.flows.kitchen.MultiPrinterFamilyService", DummyFamilyService):
+            flow = KitchenPrintFlow(
+                gateway=FakeGateway(),
+                header_provider=FakeHeaderProvider(),
+                print_settings_builder=FakePrintSettingsBuilder(),
+                family_provider=object(),
+                currency_symbol_resolver=lambda _: "",
+            )
+            context = type("Ctx", (), {
+                "ticket_settings": make_ticket_settings(),
+                "kitchen_settings": make_kitchen_settings(print_by="families"),
+                "main_printer": make_printer(),
+                "worker": None,
+            })()
+
+            flow.execute(
+                base_request=make_request(request_type="barra"),
+                products=[make_product()],
+                context=context,
+                channel=PrintChannel.BARRA,
+                tpv_key="TPV1",
+            )
+
+        self.assertIsNone(captured["request"].print_by)

printer_core/tests/unitaries/test_header_builder_foodeo_printers.py

@@ -0,0 +1,87 @@
+import unittest
+from printer_core.builders.header_builder import HeaderBuilder
+from printer_core.entities import PrintRequestData
+
+
+class FakeHeaderDataProvider:
+    def __init__(self):
+        self.calls: list[tuple[str, object | None, object | None]] = []
+
+    def get_company_header(self) -> dict[str, str]:
+        return {"company_name": "Company"}
+
+    def get_worker_header(self, user: object) -> dict[str, str]:
+        return {"worker_name": getattr(user, "first_name", "")}
+
+    def get_pickup_client_header(self, client_id: int | None, from_client: str | None) -> dict[str, str]:
+        self.calls.append(("pickup", client_id, from_client))
+        return {"client_name": f"pickup:{client_id}:{from_client}"}
+
+    def get_domicile_client_header(self, address_id: int | None, from_client: str | None) -> dict[str, str]:
+        self.calls.append(("domicile", address_id, from_client))
+        return {"client_name": f"domicile:{address_id}:{from_client}"}
+
+
+class FakeUser:
+    def __init__(self, first_name: str):
+        self.first_name = first_name
+
+
+class HeaderBuilderTest(unittest.TestCase):
+    def test_build_header_with_worker_and_pickup(self):
+        provider = FakeHeaderDataProvider()
+        builder = HeaderBuilder(provider=provider, show_person_name=True)
+        request = PrintRequestData(
+            id=1,
+            type="recoger",
+            serial="S1",
+            credit_card=False,
+            request_price="10.00",
+            from_client="web",
+            client=10,
+        )
+
+        header = builder.build_header(request, worker=FakeUser("Ana"))
+
+        self.assertEqual(header.company_name, "Company")
+        self.assertEqual(header.worker_name, "Ana")
+        self.assertEqual(header.client_name, "pickup:10:web")
+        self.assertEqual(provider.calls, [("pickup", 10, "web")])
+
+    def test_build_header_domicile_without_worker(self):
+        provider = FakeHeaderDataProvider()
+        builder = HeaderBuilder(provider=provider, show_person_name=False)
+        request = PrintRequestData(
+            id=1,
+            type="domicilio",
+            serial="S1",
+            credit_card=False,
+            request_price="10.00",
+            from_client="apk",
+            address=20,
+        )
+
+        header = builder.build_header(request)
+
+        self.assertEqual(header.company_name, "Company")
+        self.assertIsNone(header.worker_name)
+        self.assertEqual(header.client_name, "domicile:20:apk")
+        self.assertEqual(provider.calls, [("domicile", 20, "apk")])
+
+    def test_build_header_for_other_types(self):
+        provider = FakeHeaderDataProvider()
+        builder = HeaderBuilder(provider=provider, show_person_name=False)
+        request = PrintRequestData(
+            id=1,
+            type="local",
+            serial="S1",
+            credit_card=False,
+            request_price="10.00",
+            from_client="web",
+        )
+
+        header = builder.build_header(request)
+
+        self.assertEqual(header.company_name, "Company")
+        self.assertIsNone(header.client_name)
+        self.assertEqual(provider.calls, [])

printer_core/tests/unitaries/test_kitchen_ticket_dispatcher.py

@@ -0,0 +1,61 @@
+import unittest
+from printer_core.dispatchers.kitchen_ticket_dispatcher import KitchenTicketDispatcher
+from printer_core.entities import KitchenTicketData, KitchenTicketPayload, PrinterProductGroup
+
+from printer_core.tests.unitaries.helpers import FakeGateway
+
+
+class DummyBuilder:
+    def __init__(self):
+        self.calls: list[tuple[str, str]] = []
+
+    def build(self, request, printer_name, tpv_key, printer_width, products, ticket_settings, kitchen_ticket_settings, group_products_func):
+        self.calls.append((printer_name, tpv_key))
+        return KitchenTicketPayload(
+            data=KitchenTicketData(
+                id=request.id,
+                table_name=request.table_name,
+                credit_card=request.credit_card,
+                serial=request.serial,
+                type=request.type,
+            ),
+            currency=request.currency or "",
+            model=1,
+            company_key=tpv_key,
+            printer=printer_name,
+            printer_qty=1,
+            printer_width=printer_width,
+        )
+
+
+class KitchenTicketDispatcherTest(unittest.TestCase):
+    def test_dispatch_sends_payloads(self):
+        gateway = FakeGateway()
+        builder = DummyBuilder()
+        dispatcher = KitchenTicketDispatcher(gateway=gateway, builder=builder)
+        request = type("Request", (), {
+            "id": 1,
+            "table_name": "T1",
+            "credit_card": False,
+            "serial": "S1",
+            "type": "local",
+            "currency": "EUR",
+        })()
+
+        grouped_products = [
+            PrinterProductGroup(printer_name="P1", tpv_key="TPV1", printer_width="80", products=[]),
+            PrinterProductGroup(printer_name="P2", tpv_key="TPV2", printer_width="58", products=[]),
+        ]
+
+        dispatcher.dispatch(
+            request=request,
+            grouped_products=grouped_products,
+            ticket_settings=object(),
+            kitchen_ticket_settings=object(),
+            group_products_func=lambda items: [],
+        )
+
+        self.assertEqual(len(gateway.calls), 2)
+        self.assertEqual(builder.calls, [("P1", "TPV1"), ("P2", "TPV2")])
+        self.assertEqual(gateway.calls[0][1][0]["printer"], "P1")
+        self.assertEqual(gateway.calls[1][1][0]["printer"], "P2")