printer-core 0.0.1__py3-none-any.whl

printer_core/tests/unitaries/test_kitchen_ticket_payload_builder.py

@@ -0,0 +1,113 @@
+import unittest
+from printer_core.builders.kitchen_ticket_payload_builder import KitchenTicketPayloadBuilder
+from printer_core.entities import KitchenProductLine, PrintSettingsData, ProductsGroup
+
+from printer_core.tests.unitaries.helpers import FakeClock, make_kitchen_settings, make_request, make_ticket_settings
+
+
+class KitchenTicketPayloadBuilderTest(unittest.TestCase):
+    def test_build_sets_model_and_created_at(self):
+        builder = KitchenTicketPayloadBuilder(clock=FakeClock("2024-01-02 12:00"))
+        request = make_request(request_type="local")
+        products = [KitchenProductLine(name="A", qty=1, option=None, printer_r="P1", printer_w="80")]
+        ticket_settings = make_ticket_settings(qty_kitchen_ticket=2)
+        kitchen_settings = make_kitchen_settings(show_total_price=False, show_command_guests=False)
+
+        payload = builder.build(
+            request=request,
+            printer_name="P1",
+            tpv_key="TPV1",
+            printer_width="80",
+            products=products,
+            ticket_settings=ticket_settings,
+            kitchen_ticket_settings=kitchen_settings,
+            group_products_func=lambda items: [ProductsGroup(group="G", products=items)],
+        )
+
+        self.assertEqual(payload.model, 1)
+        self.assertEqual(payload.data.created_at, "2024-01-02 12:00")
+        self.assertEqual(payload.printer_qty, 2)
+
+    def test_build_uses_shift_time_for_domicile(self):
+        builder = KitchenTicketPayloadBuilder(clock=FakeClock("2024-01-02 12:00"))
+        request = make_request(
+            request_type="domicilio",
+            shift_time="10:30",
+            delivery_date="2024-03-10",
+        )
+        products = [KitchenProductLine(name="A", qty=1, option=None, printer_r="P1", printer_w="80")]
+        payload = builder.build(
+            request=request,
+            printer_name="P1",
+            tpv_key="TPV1",
+            printer_width="80",
+            products=products,
+            ticket_settings=make_ticket_settings(),
+            kitchen_ticket_settings=make_kitchen_settings(),
+            group_products_func=lambda items: [ProductsGroup(group="G", products=items)],
+        )
+
+        self.assertEqual(payload.data.created_at, "2024-03-10 10:30")
+        self.assertEqual(payload.model, 2)
+
+    def test_build_includes_total_and_command_guests(self):
+        builder = KitchenTicketPayloadBuilder(clock=FakeClock())
+        request = make_request(request_type="local", total="12.00", request_price="10.00", command_guests=3)
+        products = [KitchenProductLine(name="A", qty=1, option=None, printer_r="P1", printer_w="80")]
+        kitchen_settings = make_kitchen_settings(show_total_price=True, show_command_guests=True)
+
+        payload = builder.build(
+            request=request,
+            printer_name="P1",
+            tpv_key="TPV1",
+            printer_width="80",
+            products=products,
+            ticket_settings=make_ticket_settings(),
+            kitchen_ticket_settings=kitchen_settings,
+            group_products_func=lambda items: [ProductsGroup(group="G", products=items)],
+        )
+
+        self.assertEqual(payload.data.total, "12.00")
+        self.assertEqual(payload.data.request_price, "10.00")
+        self.assertEqual(payload.data.command_guests, 3)
+
+    def test_build_groups_products_when_enabled(self):
+        builder = KitchenTicketPayloadBuilder(clock=FakeClock())
+        request = make_request(request_type="local", group_by_orders=True)
+        products = [KitchenProductLine(name="A", qty=1, option=None, printer_r="P1", printer_w="80")]
+        kitchen_settings = make_kitchen_settings(show_total_price=False, show_command_guests=False)
+
+        payload = builder.build(
+            request=request,
+            printer_name="P1",
+            tpv_key="TPV1",
+            printer_width="80",
+            products=products,
+            ticket_settings=make_ticket_settings(),
+            kitchen_ticket_settings=kitchen_settings,
+            group_products_func=lambda items: [ProductsGroup(group="G", products=items)],
+        )
+
+        self.assertIsNone(payload.data.products)
+        self.assertEqual(payload.data.products_groups[0].group, "G")
+
+    def test_build_print_settings_overrides_show_header(self):
+        builder = KitchenTicketPayloadBuilder(clock=FakeClock())
+        request = make_request(
+            request_type="local",
+            PrintSettings=PrintSettingsData(show_header=True, show_local_header=False),
+        )
+        products = [KitchenProductLine(name="A", qty=1, option=None, printer_r="P1", printer_w="80")]
+
+        payload = builder.build(
+            request=request,
+            printer_name="P1",
+            tpv_key="TPV1",
+            printer_width="80",
+            products=products,
+            ticket_settings=make_ticket_settings(),
+            kitchen_ticket_settings=make_kitchen_settings(),
+            group_products_func=lambda items: [ProductsGroup(group="G", products=items)],
+        )
+
+        self.assertEqual(payload.PrintSettings.show_header, False)

printer_core/tests/unitaries/test_march_printer_service.py

@@ -0,0 +1,31 @@
+import unittest
+from printer_core.entities import MarchCommandData, PrintSettingsData
+from printer_core.services.march_printer_service import MarchPrinterService
+
+from printer_core.tests.unitaries.helpers import FakeClock, FakeGateway, make_printer
+
+
+class MarchPrinterServiceTest(unittest.TestCase):
+    def test_build_and_send(self):
+        gateway = FakeGateway()
+        clock = FakeClock("2024-02-01 09:00")
+        service = MarchPrinterService(gateway=gateway, clock=clock)
+        printers = [make_printer(name="P1", tpv="TPV1"), make_printer(name="P2", tpv="TPV1")]
+        command_data = MarchCommandData(table_name="T1", credit_card=False, serial="S1", type="local")
+        print_settings = PrintSettingsData(show_header=False)
+
+        payloads = service.build_and_send(
+            printers=printers,
+            command_data=command_data,
+            order_type_text="Marchar primeros",
+            tpv_key="TPV1",
+            currency="EUR",
+            print_settings=print_settings,
+            printer_qty=2,
+        )
+
+        self.assertEqual(len(payloads), 2)
+        self.assertEqual(payloads[0].data.created_at, "2024-02-01 09:00")
+        self.assertEqual(payloads[0].printer_qty, 2)
+        self.assertEqual(len(gateway.calls), 2)
+        self.assertEqual(gateway.calls[0][1][0]["printer"], "P1")

printer_core/tests/unitaries/test_multi_printer_family_service.py

@@ -0,0 +1,53 @@
+from unittest.mock import patch
+
+import unittest
+from printer_core.entities import FamilyData
+from printer_core.services.multi_printer_family_service import MultiPrinterFamilyService
+
+from printer_core.tests.unitaries.helpers import FakeFamilyProvider, make_kitchen_settings, make_printer, make_product, make_request, make_ticket_settings
+
+
+class MultiPrinterFamilyServiceTest(unittest.TestCase):
+    def test_build_and_dispatch_by_family(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},
+        )
+        request = make_request(order_by="name")
+        products = [
+            make_product(name="A", category=10, printer=[make_printer(name="P1")]),
+            make_product(name="B", category=20, printer=[make_printer(name="P2")]),
+            make_product(name="C", category=None),
+        ]
+        kitchen_settings = make_kitchen_settings(show_price_per_unit=False)
+        ticket_settings = make_ticket_settings()
+        dispatch_calls: list[int] = []
+
+        class DummyDispatcher:
+            def __init__(self, gateway):
+                self._gateway = gateway
+
+            def dispatch(self, request, grouped_products, ticket_settings, kitchen_ticket_settings, group_products_func):
+                dispatch_calls.append(len(grouped_products))
+                return []
+
+        with patch("printer_core.services.multi_printer_family_service.KitchenTicketDispatcher", DummyDispatcher):
+            service = MultiPrinterFamilyService(
+                gateway=object(),
+                family_provider=provider,
+                currency_symbol_resolver=lambda _: "",
+                order_by_func=lambda items: items,
+                group_products_func=lambda items: [],
+            )
+            service.build_and_dispatch(
+                request=request,
+                products=products,
+                main_printer=make_printer(name="Main"),
+                ticket_settings=ticket_settings,
+                kitchen_ticket_settings=kitchen_settings,
+            )
+
+        self.assertEqual(len(dispatch_calls), 3)
+        self.assertTrue(all(count >= 1 for count in dispatch_calls))

printer_core/tests/unitaries/test_multi_printer_service.py

@@ -0,0 +1,51 @@
+from unittest.mock import patch
+
+import unittest
+from printer_core.services.multi_printer_service import MultiPrinterService
+
+from printer_core.tests.unitaries.helpers import FakeGateway, make_kitchen_settings, make_printer, make_product, make_request, make_ticket_settings
+
+
+class MultiPrinterServiceTest(unittest.TestCase):
+    def test_build_and_dispatch_groups_by_printer(self):
+        gateway = FakeGateway()
+        request = make_request(order_by="name")
+        products = [
+            make_product(name="B", printer=[make_printer(name="P1", printer_width="80", tpv="TPV1")]),
+            make_product(name="A", printer=[make_printer(name="P2", printer_width="58", tpv="TPV2")]),
+        ]
+        kitchen_settings = make_kitchen_settings(show_price_per_unit=False)
+        ticket_settings = make_ticket_settings()
+        captured: dict[str, object] = {}
+
+        class DummyDispatcher:
+            def __init__(self, gateway):
+                self._gateway = gateway
+
+            def dispatch(self, request, grouped_products, ticket_settings, kitchen_ticket_settings, group_products_func):
+                captured["grouped"] = grouped_products
+                captured["group_func"] = group_products_func
+                return []
+
+        def reverse_order(items):
+            return list(reversed(items))
+
+        with patch("printer_core.services.multi_printer_service.KitchenTicketDispatcher", DummyDispatcher):
+            service = MultiPrinterService(
+                gateway=gateway,
+                currency_symbol_resolver=lambda _: "",
+                order_by_func=reverse_order,
+                group_products_func=lambda items: [],
+            )
+            service.build_and_dispatch(
+                request=request,
+                products=products,
+                main_printer=make_printer(name="Main"),
+                ticket_settings=ticket_settings,
+                kitchen_ticket_settings=kitchen_settings,
+            )
+
+        grouped = captured["grouped"]
+        self.assertEqual(len(grouped), 2)
+        self.assertEqual({group.printer_name for group in grouped}, {"P1", "P2"})
+        self.assertEqual(captured["group_func"].__name__, "<lambda>")

printer_core/tests/unitaries/test_order_print_service.py

@@ -0,0 +1,144 @@
+import unittest
+from printer_core.entities import PrintChannel, PrintJob
+from printer_core.services.order_print_service import OrderPrintService
+from printer_core.services.print_policy import FlowTarget
+
+from printer_core.tests.unitaries.helpers import (
+    FakeClock,
+    make_discount,
+    make_global_settings,
+    make_kitchen_settings,
+    make_product,
+    make_request,
+    make_ticket_settings,
+)
+
+
+class FakeFlow:
+    def __init__(self, target: FlowTarget, return_value: list[object]):
+        self.target = target
+        self.return_value = return_value
+        self.calls: list[dict[str, object]] = []
+
+    def execute(self, base_request, products, context, channel, tpv_key=None):
+        self.calls.append({
+            "base_request": base_request,
+            "products": products,
+            "context": context,
+            "channel": channel,
+            "tpv_key": tpv_key,
+        })
+        return self.return_value
+
+
+class OrderPrintServiceTest(unittest.TestCase):
+    def test_print_job_enriches_request_and_runs_flows(self):
+        kitchen_flow = FakeFlow(FlowTarget.KITCHEN, return_value=[{"kitchen": True}])
+        client_flow = FakeFlow(FlowTarget.CLIENT, return_value=[{"client": True}])
+        service = OrderPrintService(
+            gateway=object(),
+            header_provider=object(),
+            print_settings_builder=object(),
+            family_provider=object(),
+            currency_symbol_resolver=lambda _: "",
+            flows=[kitchen_flow, client_flow],
+        )
+        request = make_request(
+            request_type="local",
+            currency=None,
+            discount=make_discount(),
+            price_domicile_service="2.00",
+        )
+        job = PrintJob(request=request, products=[make_product()], tpv_key="TPV1")
+        context = type("Ctx", (), {
+            "ticket_settings": make_ticket_settings(ticket_kitchen_local=True, ticket_client_local=True),
+            "kitchen_settings": make_kitchen_settings(print_by="categories"),
+            "global_settings": make_global_settings(currency="EUR", iva=21),
+        })()
+
+        result = service.print_job(job, context, PrintChannel.LOCAL)
+
+        self.assertEqual(result.multi_printer, [{"kitchen": True}])
+        self.assertEqual(result.ticket_client, [{"client": True}])
+        enriched = kitchen_flow.calls[0]["base_request"]
+        self.assertIsNone(enriched.discount)
+        self.assertEqual(enriched.currency, "EUR")
+        self.assertEqual(enriched.price_domicile_service, None)
+        self.assertIsNotNone(enriched.ivaData)
+
+    def test_print_job_domicile_total_includes_service_price(self):
+        kitchen_flow = FakeFlow(FlowTarget.KITCHEN, return_value=[])
+        service = OrderPrintService(
+            gateway=object(),
+            header_provider=object(),
+            print_settings_builder=object(),
+            family_provider=object(),
+            currency_symbol_resolver=lambda _: "",
+            flows=[kitchen_flow],
+        )
+        service._clock = FakeClock("2024-05-01 08:00")
+        request = make_request(
+            request_type="domicilio",
+            request_price="10.00",
+            price_domicile_service="2.00",
+        )
+        job = PrintJob(request=request, products=[make_product()], tpv_key="TPV1")
+        context = type("Ctx", (), {
+            "ticket_settings": make_ticket_settings(ticket_kitchen_domicile_or_pickup=True),
+            "kitchen_settings": make_kitchen_settings(print_by="categories"),
+            "global_settings": make_global_settings(currency="EUR", iva=21),
+        })()
+
+        service.print_job(job, context, PrintChannel.DOMICILE)
+
+        enriched = kitchen_flow.calls[0]["base_request"]
+        self.assertEqual(enriched.total, "12.00")
+        self.assertEqual(enriched.price_domicile_service, "2.00")
+
+    def test_print_job_overrides_created_at_for_barra(self):
+        kitchen_flow = FakeFlow(FlowTarget.KITCHEN, return_value=[])
+        service = OrderPrintService(
+            gateway=object(),
+            header_provider=object(),
+            print_settings_builder=object(),
+            family_provider=object(),
+            currency_symbol_resolver=lambda _: "",
+            flows=[kitchen_flow],
+        )
+        service._clock = FakeClock("2024-05-01 08:00")
+        request = make_request(request_type="barra", created_at="old")
+        job = PrintJob(request=request, products=[make_product()], tpv_key="TPV1")
+        context = type("Ctx", (), {
+            "ticket_settings": make_ticket_settings(ticket_kitchen_barra=True),
+            "kitchen_settings": make_kitchen_settings(print_by="categories"),
+            "global_settings": make_global_settings(currency="EUR", iva=21),
+        })()
+
+        service.print_job(job, context, PrintChannel.BARRA)
+
+        enriched = kitchen_flow.calls[0]["base_request"]
+        self.assertEqual(enriched.created_at, "2024-05-01 08:00")
+
+    def test_print_job_skips_flows_when_disabled(self):
+        kitchen_flow = FakeFlow(FlowTarget.KITCHEN, return_value=[])
+        service = OrderPrintService(
+            gateway=object(),
+            header_provider=object(),
+            print_settings_builder=object(),
+            family_provider=object(),
+            currency_symbol_resolver=lambda _: "",
+            flows=[kitchen_flow],
+        )
+        request = make_request(request_type="local")
+        job = PrintJob(request=request, products=[make_product()], tpv_key="TPV1")
+        context = type("Ctx", (), {
+            "ticket_settings": make_ticket_settings(ticket_kitchen_local=False, ticket_client_local=False),
+            "kitchen_settings": make_kitchen_settings(print_by="categories"),
+            "global_settings": make_global_settings(currency="EUR", iva=21),
+        })()
+
+        result = service.print_job(job, context, PrintChannel.LOCAL)
+
+        self.assertEqual(kitchen_flow.calls, [])
+        self.assertIsNone(result.multi_printer)
+        self.assertIsNone(result.ticket_client)

printer_core/tests/unitaries/test_payload_dispatcher.py

@@ -0,0 +1,61 @@
+import unittest
+from printer_core.dispatchers.payload_dispatcher import PayloadDispatcher
+from printer_core.entities import ClientTicketData, ClientTicketPayload
+
+from printer_core.tests.unitaries.helpers import FakeGateway
+
+
+class PayloadDispatcherTest(unittest.TestCase):
+    def test_send_model_payload(self):
+        gateway = FakeGateway()
+        dispatcher = PayloadDispatcher(gateway=gateway)
+        payload = ClientTicketPayload(
+            data=ClientTicketData(
+                id=1,
+                type="local",
+                serial="S1",
+                credit_card=False,
+                request_price="10.00",
+            ),
+            currency="EUR",
+            model=2,
+            company_key="TPV1",
+            printer="P1",
+            printer_qty=1,
+            printer_width="80",
+        )
+
+        dispatcher.send("TPV1", payload)
+
+        self.assertEqual(len(gateway.calls), 1)
+        tpv_key, data = gateway.calls[0]
+        self.assertEqual(tpv_key, "TPV1")
+        self.assertEqual(data["printer"], "P1")
+
+    def test_send_list_payload(self):
+        gateway = FakeGateway()
+        dispatcher = PayloadDispatcher(gateway=gateway)
+        payloads = [
+            ClientTicketPayload(
+                data=ClientTicketData(
+                    id=1,
+                    type="local",
+                    serial="S1",
+                    credit_card=False,
+                    request_price="10.00",
+                ),
+                currency="EUR",
+                model=2,
+                company_key="TPV1",
+                printer="P1",
+                printer_qty=1,
+                printer_width="80",
+            )
+        ]
+
+        dispatcher.send("TPV1", payloads)
+
+        self.assertEqual(len(gateway.calls), 1)
+        tpv_key, data = gateway.calls[0]
+        self.assertEqual(tpv_key, "TPV1")
+        self.assertEqual(data[0]["printer"], "P1")

printer_core/tests/unitaries/test_print_policy.py

@@ -0,0 +1,45 @@
+import unittest
+from printer_core.entities import PrintChannel
+from printer_core.services.print_policy import FlowTarget, PrintPolicy
+
+from printer_core.tests.unitaries.helpers import make_global_settings, make_request, make_ticket_settings
+
+
+class PrintPolicyTest(unittest.TestCase):
+    def test_plan_local(self):
+        ticket_settings = make_ticket_settings(
+            ticket_kitchen_local=True,
+            ticket_client_local=True,
+        )
+        policy = PrintPolicy(PrintChannel.LOCAL, ticket_settings, make_global_settings())
+
+        plan = policy.plan(make_request())
+
+        self.assertIn(FlowTarget.KITCHEN, plan.enabled_flows)
+        self.assertIn(FlowTarget.CLIENT, plan.enabled_flows)
+
+    def test_plan_barra_suppresses_client_for_credit_card(self):
+        ticket_settings = make_ticket_settings(
+            ticket_kitchen_barra=True,
+            ticket_client_barra=True,
+        )
+        global_settings = make_global_settings(use_payment_terminal=True)
+        policy = PrintPolicy(PrintChannel.BARRA, ticket_settings, global_settings)
+        request = make_request(credit_card=True)
+
+        plan = policy.plan(request)
+
+        self.assertIn(FlowTarget.KITCHEN, plan.enabled_flows)
+        self.assertNotIn(FlowTarget.CLIENT, plan.enabled_flows)
+
+    def test_plan_domicile(self):
+        ticket_settings = make_ticket_settings(
+            ticket_kitchen_domicile_or_pickup=True,
+            ticket_client_domicile_or_pickup=False,
+        )
+        policy = PrintPolicy(PrintChannel.DOMICILE, ticket_settings, make_global_settings())
+
+        plan = policy.plan(make_request(request_type="domicilio"))
+
+        self.assertIn(FlowTarget.KITCHEN, plan.enabled_flows)
+        self.assertNotIn(FlowTarget.CLIENT, plan.enabled_flows)

printer_core/tests/unitaries/test_printer_helpers.py

@@ -0,0 +1,71 @@
+from decimal import Decimal
+
+import unittest
+from printer_core.entities import KitchenProductLine
+from printer_core.utils.printer_helpers import build_iva_data, group_products_by_orders, order_products_by_name
+
+
+class PrinterHelpersTest(unittest.TestCase):
+    def test_order_products_by_name(self):
+        products = [
+            KitchenProductLine(name="Zeta", qty=1, option=None, printer_r="P1", printer_w="80"),
+            KitchenProductLine(name="Alpha", qty=1, option=None, printer_r="P1", printer_w="80"),
+        ]
+
+        sorted_products = order_products_by_name(products)
+
+        self.assertEqual([item.name for item in sorted_products], ["Alpha", "Zeta"])
+
+    def test_group_products_by_orders(self):
+        products = [
+            KitchenProductLine(
+                name="A",
+                qty=1,
+                option=None,
+                printer_r="P1",
+                printer_w="80",
+                order="2",
+                order_readable="Mesa 2",
+            ),
+            KitchenProductLine(
+                name="B",
+                qty=1,
+                option=None,
+                printer_r="P1",
+                printer_w="80",
+                order="1",
+                order_readable="Mesa 1",
+            ),
+            KitchenProductLine(
+                name="C",
+                qty=1,
+                option=None,
+                printer_r="P1",
+                printer_w="80",
+                order=None,
+            ),
+            KitchenProductLine(
+                name="D",
+                qty=1,
+                option=None,
+                printer_r="P1",
+                printer_w="80",
+                order="not-a-number",
+            ),
+        ]
+
+        grouped = group_products_by_orders(products)
+
+        self.assertEqual(grouped[0].group, "Mesa 1")
+        self.assertEqual(grouped[0].products[0].order, "1")
+        self.assertEqual(grouped[1].group, "Mesa 2")
+        self.assertEqual(grouped[1].products[0].order, "2")
+        self.assertEqual(grouped[2].group, "Sin orden")
+        self.assertEqual([item.name for item in grouped[2].products], ["C"])
+
+    def test_build_iva_data(self):
+        data = build_iva_data(Decimal("121.00"), Decimal("21"))
+
+        self.assertEqual(data.Base, "100.00")
+        self.assertEqual(data.impo, "21.00")
+        self.assertEqual(data.iva, "21")

printer_core/tests/unitaries/test_printer_products_grouper.py

@@ -0,0 +1,20 @@
+import unittest
+from printer_core.builders.printer_products_grouper import PrinterProductsGrouper
+from printer_core.entities import KitchenProductLine
+
+
+class PrinterProductsGrouperTest(unittest.TestCase):
+    def test_group_by_printer_key(self):
+        products = [
+            KitchenProductLine(name="A", qty=1, option=None, printer_r="P1", printer_w="80", tpv="TPV1"),
+            KitchenProductLine(name="B", qty=1, option=None, printer_r="P1", printer_w="80", tpv="TPV1"),
+            KitchenProductLine(name="C", qty=1, option=None, printer_r="P2", printer_w="58", tpv="TPV2"),
+        ]
+
+        grouped = PrinterProductsGrouper.group_by_printer_key(products)
+
+        self.assertEqual(len(grouped), 2)
+        self.assertEqual(grouped[0].printer_name, "P1")
+        self.assertEqual(len(grouped[0].products), 2)
+        self.assertEqual(grouped[1].printer_name, "P2")
+        self.assertEqual(len(grouped[1].products), 1)