odoo-addon-base-report-to-printer 18.0.1.1.6__py3-none-any.whl

odoo/addons/base_report_to_printer/tests/test_printing_printer_tray.py

@@ -0,0 +1,256 @@
+# Copyright 2016 LasLabs Inc.
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+import errno
+import tempfile
+from unittest import mock
+
+from odoo.tests.common import TransactionCase
+
+model = "odoo.addons.base_report_to_printer.models.printing_printer"
+server_model = "odoo.addons.base_report_to_printer.models.printing_server"
+
+ppd_header = '*PPD-Adobe: "4.3"'
+ppd_input_slot_header = """
+*OpenUI *InputSlot: PickOne
+*DefaultInputSlot: Auto
+*InputSlot Auto/Auto (Default): "
+    << /DeferredMediaSelection true /ManualFeed false
+        /MediaPosition null /MediaType null >> setpagedevice
+        userdict /TSBMediaType 0 put"
+*End
+"""
+ppd_input_slot_body = """
+*InputSlot {name}/{text}: "
+    << /DeferredMediaSelection true /ManualFeed false
+        /MediaPosition null /MediaType null >> setpagedevice
+        userdict /TSBMediaType 0 put"
+*End
+"""
+ppd_input_slot_footer = """
+*CloseUI: *InputSlot
+"""
+
+
+class TestPrintingPrinter(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.Model = self.env["printing.printer"]
+        self.ServerModel = self.env["printing.server"]
+        self.server = self.env["printing.server"].create({})
+        self.printer = self.env["printing.printer"].create(
+            {
+                "name": "",
+                "server_id": self.server.id,
+                "system_name": "Sys Name",
+                "default": True,
+                "status": "unknown",
+                "status_message": "Msg",
+                "model": "res.users",
+                "location": "Location",
+                "uri": "URI",
+            }
+        )
+        self.tray_vals = {
+            "name": "Tray",
+            "system_name": "TrayName",
+            "printer_id": self.printer.id,
+        }
+
+    def new_tray(self, vals=None):
+        values = self.tray_vals
+        if vals is not None:
+            values.update(vals)
+        return self.env["printing.tray"].create(values)
+
+    def build_ppd(self, input_slots=None):
+        """
+        Builds a fake PPD file declaring defined input slots
+        """
+        ppd_contents = ppd_header
+        ppd_contents += ppd_input_slot_header
+        if input_slots is not None:
+            for input_slot in input_slots:
+                ppd_contents += ppd_input_slot_body.format(
+                    name=input_slot["name"], text=input_slot["text"]
+                )
+        ppd_contents += ppd_input_slot_footer
+
+        return ppd_contents
+
+    def mock_cups_ppd(self, cups, file_name=None, input_slots=None):
+        """
+        Create a fake PPD file (if needed), then mock the getPPD3 method
+        return value to give that file
+        """
+        if file_name is None:
+            fd, file_name = tempfile.mkstemp()
+
+        if file_name:
+            ppd_contents = self.build_ppd(input_slots=input_slots)
+            with open(file_name, "w") as fp:
+                fp.write(ppd_contents)
+
+        cups.Connection().getPPD3.return_value = (200, 0, file_name)
+        cups.Connection().getPrinters.return_value = {
+            self.printer.system_name: {
+                "printer-info": "info",
+                "printer-uri-supported": "uri",
+            }
+        }
+
+    @mock.patch(f"{server_model}.cups")
+    def test_update_printers(self, cups):
+        """
+        Check that the update_printers method calls _prepare_update_from_cups
+        """
+        self.mock_cups_ppd(cups, file_name=False)
+        self.ServerModel.update_printers()
+        self.assertEqual(self.printer.name, "info")
+        self.printer.name = "My custom name"
+        self.ServerModel.update_printers()
+        self.assertEqual(self.printer.name, "My custom name")
+
+    @mock.patch(f"{server_model}.cups")
+    def test_prepare_update_from_cups_no_ppd(self, cups):
+        """
+        Check that the tray_ids field has no value when no PPD is available
+        """
+        self.mock_cups_ppd(cups, file_name=False)
+
+        connection = cups.Connection()
+        cups_printer = connection.getPrinters()[self.printer.system_name]
+
+        vals = self.printer._prepare_update_from_cups(connection, cups_printer)
+        self.assertFalse("tray_ids" in vals)
+
+    @mock.patch(f"{server_model}.cups")
+    def test_prepare_update_from_cups_empty_ppd(self, cups):
+        """
+        Check that the tray_ids field has no value when the PPD file has
+        no input slot declared
+        """
+        fd, file_name = tempfile.mkstemp()
+        self.mock_cups_ppd(cups, file_name=file_name)
+        # Replace the ppd file's contents by an empty file
+        with open(file_name, "w") as fp:
+            fp.write(ppd_header)
+
+        connection = cups.Connection()
+        cups_printer = connection.getPrinters()[self.printer.system_name]
+
+        vals = self.printer._prepare_update_from_cups(connection, cups_printer)
+        self.assertFalse("tray_ids" in vals)
+
+    @mock.patch(f"{server_model}.cups")
+    @mock.patch("os.unlink")
+    def test_prepare_update_from_cups_unlink_error(self, os_unlink, cups):
+        """
+        When OSError other than ENOENT is encountered, the exception is raised
+        """
+        # Break os.unlink
+        os_unlink.side_effect = OSError(errno.EIO, "Error")
+
+        self.mock_cups_ppd(cups)
+
+        connection = cups.Connection()
+        cups_printer = connection.getPrinters()[self.printer.system_name]
+
+        with self.assertRaises(OSError):
+            self.printer._prepare_update_from_cups(connection, cups_printer)
+
+    @mock.patch(f"{server_model}.cups")
+    @mock.patch("os.unlink")
+    def test_prepare_update_from_cups_unlink_error_enoent(self, os_unlink, cups):
+        """
+        When a ENOENT error is encountered, the file has already been unlinked
+        This is not an issue, as we were trying to delete the file.
+        The update can continue.
+        """
+        # Break os.unlink
+        os_unlink.side_effect = OSError(errno.ENOENT, "Error")
+
+        self.mock_cups_ppd(cups)
+
+        connection = cups.Connection()
+        cups_printer = connection.getPrinters()[self.printer.system_name]
+
+        vals = self.printer._prepare_update_from_cups(connection, cups_printer)
+        self.assertEqual(
+            vals["tray_ids"],
+            [(0, 0, {"name": "Auto (Default)", "system_name": "Auto"})],
+        )
+
+    @mock.patch(f"{server_model}.cups")
+    def test_prepare_update_from_cups(self, cups):
+        """
+        Check the return value when adding a single tray
+        """
+        self.mock_cups_ppd(cups)
+
+        connection = cups.Connection()
+        cups_printer = connection.getPrinters()[self.printer.system_name]
+
+        vals = self.printer._prepare_update_from_cups(connection, cups_printer)
+        self.assertEqual(
+            vals["tray_ids"],
+            [(0, 0, {"name": "Auto (Default)", "system_name": "Auto"})],
+        )
+
+    @mock.patch(f"{server_model}.cups")
+    def test_prepare_update_from_cups_with_multiple_trays(self, cups):
+        """
+        Check the return value when adding multiple trays at once
+        """
+        self.mock_cups_ppd(cups, input_slots=[{"name": "Tray1", "text": "Tray 1"}])
+
+        connection = cups.Connection()
+        cups_printer = connection.getPrinters()[self.printer.system_name]
+
+        vals = self.printer._prepare_update_from_cups(connection, cups_printer)
+        self.assertItemsEqual(
+            vals["tray_ids"],
+            [
+                (0, 0, {"name": "Auto (Default)", "system_name": "Auto"}),
+                (0, 0, {"name": "Tray 1", "system_name": "Tray1"}),
+            ],
+        )
+
+    @mock.patch(f"{server_model}.cups")
+    def test_prepare_update_from_cups_already_known_trays(self, cups):
+        """
+        Check that calling the method twice doesn't create the trays multiple
+        times
+        """
+        self.mock_cups_ppd(cups, input_slots=[{"name": "Tray1", "text": "Tray 1"}])
+
+        connection = cups.Connection()
+        cups_printer = connection.getPrinters()[self.printer.system_name]
+
+        # Create a tray which is in the PPD file
+        self.new_tray({"system_name": "Tray1"})
+
+        vals = self.printer._prepare_update_from_cups(connection, cups_printer)
+        self.assertEqual(
+            vals["tray_ids"],
+            [(0, 0, {"name": "Auto (Default)", "system_name": "Auto"})],
+        )
+
+    @mock.patch(f"{server_model}.cups")
+    def test_prepare_update_from_cups_unknown_trays(self, cups):
+        """
+        Check that trays which are not in the PPD file are removed from Odoo
+        """
+        self.mock_cups_ppd(cups)
+
+        connection = cups.Connection()
+        cups_printer = connection.getPrinters()[self.printer.system_name]
+
+        # Create a tray which is absent from the PPD file
+        tray = self.new_tray()
+
+        vals = self.printer._prepare_update_from_cups(connection, cups_printer)
+        self.assertEqual(
+            vals["tray_ids"],
+            [(0, 0, {"name": "Auto (Default)", "system_name": "Auto"}), (2, tray.id)],
+        )

odoo/addons/base_report_to_printer/tests/test_printing_printer_wizard.py

@@ -0,0 +1,94 @@
+# Copyright 2016 LasLabs Inc.
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+import logging
+from unittest import mock
+
+from odoo.exceptions import UserError
+from odoo.tests.common import TransactionCase
+
+model = "odoo.addons.base_report_to_printer.models.printing_server"
+
+
+class StopTest(Exception):
+    pass
+
+
+class TestPrintingPrinterWizard(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.Model = self.env["printing.printer.update.wizard"]
+        self.server = self.env["printing.server"].create({})
+        self.printer_vals = {
+            "printer-info": "Info",
+            "printer-make-and-model": "Make and Model",
+            "printer-location": "location",
+            "device-uri": "URI",
+            "printer-uri-supported": "uri",
+        }
+
+    def _record_vals(self, sys_name="sys_name"):
+        return {
+            "name": self.printer_vals["printer-info"],
+            "server_id": self.server.id,
+            "system_name": sys_name,
+            "model": self.printer_vals["printer-make-and-model"],
+            "location": self.printer_vals["printer-location"],
+            "uri": self.printer_vals["device-uri"],
+        }
+
+    @mock.patch(f"{model}.cups")
+    def test_action_ok_inits_connection(self, cups):
+        """It should initialize CUPS connection"""
+        self.Model.action_ok()
+        cups.Connection.assert_called_once_with(
+            host=self.server.address, port=self.server.port
+        )
+
+    @mock.patch(f"{model}.cups")
+    def test_action_ok_gets_printers(self, cups):
+        """It should get printers from CUPS"""
+        cups.Connection().getPrinters.return_value = {"sys_name": self.printer_vals}
+        cups.Connection().getPPD3.return_value = (200, 0, "")
+        self.Model.action_ok()
+        cups.Connection().getPrinters.assert_called_once_with()
+
+    def test_action_ok_raises_warning_on_error(self):
+        """It should raise Warning on any error"""
+        with (
+            mock.patch(f"{model}.cups") as cups,
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            cups.Connection.side_effect = StopTest
+            with self.assertRaises(UserError):
+                self.Model.action_ok()
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    @mock.patch(f"{model}.cups")
+    def test_action_ok_creates_new_printer(self, cups):
+        """It should create new printer w/ proper vals"""
+        cups.Connection().getPrinters.return_value = {"sys_name": self.printer_vals}
+        cups.Connection().getPPD3.return_value = (200, 0, "")
+        self.Model.action_ok()
+        rec_id = self.env["printing.printer"].search(
+            [("system_name", "=", "sys_name")], limit=1
+        )
+        self.assertTrue(rec_id)
+        for key, val in self._record_vals().items():
+            if rec_id._fields[key].type == "many2one":
+                val = self.env[rec_id._fields[key].comodel_name].browse(val)
+
+            self.assertEqual(val, rec_id[key])
+
+    @mock.patch(f"{model}.cups")
+    def test_action_ok_skips_existing_printer(self, cups):
+        """It should not recreate existing printers"""
+        cups.Connection().getPrinters.return_value = {"sys_name": self.printer_vals}
+        cups.Connection().getPPD3.return_value = (200, 0, "")
+        self.env["printing.printer"].create(self._record_vals())
+        self.Model.action_ok()
+        res_ids = self.env["printing.printer"].search(
+            [("system_name", "=", "sys_name")]
+        )
+        self.assertEqual(1, len(res_ids))

odoo/addons/base_report_to_printer/tests/test_printing_report_xml_action.py

@@ -0,0 +1,98 @@
+# Copyright 2016 SYLEAM
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from odoo.tests.common import TransactionCase
+
+
+class TestPrintingReportXmlAction(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.Model = self.env["printing.report.xml.action"]
+
+        self.report = self.env["ir.actions.report"].search([], limit=1)
+        self.server = self.env["printing.server"].create({})
+
+        self.report_vals = {
+            "report_id": self.report.id,
+            "user_id": self.env.ref("base.user_demo").id,
+            "action": "server",
+        }
+
+    def new_record(self, vals=None):
+        values = self.report_vals
+        if vals is not None:
+            values.update(vals)
+
+        return self.Model.create(values)
+
+    def new_printer(self):
+        return self.env["printing.printer"].create(
+            {
+                "name": "Printer",
+                "server_id": self.server.id,
+                "system_name": "Sys Name",
+                "default": True,
+                "status": "unknown",
+                "status_message": "Msg",
+                "model": "res.users",
+                "location": "Location",
+                "uri": "URI",
+            }
+        )
+
+    def test_behaviour(self):
+        """It should return some action's data, unless called on empty
+        recordset
+        """
+        xml_action = self.new_record()
+        self.assertEqual(
+            xml_action.behaviour(),
+            {
+                "action": xml_action.action,
+                "printer": xml_action.printer_id,
+                "tray": False,
+            },
+        )
+
+        xml_action = self.new_record({"printer_id": self.new_printer().id})
+        self.assertEqual(
+            xml_action.behaviour(),
+            {
+                "action": xml_action.action,
+                "printer": xml_action.printer_id,
+                "tray": False,
+            },
+        )
+
+        self.assertEqual(self.Model.behaviour(), {})
+
+    def test_onchange_printer_tray_id_empty(self):
+        action = self.env["printing.report.xml.action"].new({"printer_tray_id": False})
+        action.onchange_printer_id()
+        self.assertFalse(action.printer_tray_id)
+
+    def test_onchange_printer_tray_id_not_empty(self):
+        server = self.env["printing.server"].create({})
+        printer = self.env["printing.printer"].create(
+            {
+                "name": "Printer",
+                "server_id": server.id,
+                "system_name": "Sys Name",
+                "default": True,
+                "status": "unknown",
+                "status_message": "Msg",
+                "model": "res.users",
+                "location": "Location",
+                "uri": "URI",
+            }
+        )
+        tray = self.env["printing.tray"].create(
+            {"name": "Tray", "system_name": "TrayName", "printer_id": printer.id}
+        )
+
+        action = self.env["printing.report.xml.action"].new(
+            {"printer_tray_id": tray.id}
+        )
+        self.assertEqual(action.printer_tray_id, tray)
+        action.onchange_printer_id()
+        self.assertFalse(action.printer_tray_id)

odoo/addons/base_report_to_printer/tests/test_printing_server.py

@@ -0,0 +1,219 @@
+# Copyright 2016 LasLabs Inc.
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+import logging
+from unittest import mock
+
+from odoo import fields
+from odoo.tests.common import TransactionCase
+
+model = "odoo.addons.base_report_to_printer.models.printing_server"
+model_base = "odoo.models.BaseModel"
+
+
+class TestPrintingServer(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.Model = self.env["printing.server"]
+        self.server = self.Model.create({})
+        self.printer_vals = {
+            "name": "Printer",
+            "server_id": self.server.id,
+            "system_name": "Sys Name",
+            "default": True,
+            "status": "unknown",
+            "status_message": "Msg",
+            "model": "res.users",
+            "location": "Location",
+            "uri": "URI",
+        }
+        self.job_vals = {
+            "server_id": self.server.id,
+            "job_id_cups": 1,
+            "job_media_progress": 0,
+            "time_at_creation": fields.Datetime.now(),
+        }
+
+    def new_printer(self):
+        return self.env["printing.printer"].create(self.printer_vals)
+
+    def new_job(self, printer, vals=None):
+        values = self.job_vals
+        if vals is not None:
+            values.update(vals)
+        values["printer_id"] = printer.id
+        return self.env["printing.job"].create(values)
+
+    def test_update_printers_error(self):
+        """It should catch any exception from CUPS and update status"""
+        with (
+            mock.patch(f"{model}.cups") as cups,
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            cups.Connection.side_effect = Exception
+            rec_id = self.new_printer()
+            self.Model.update_printers()
+            self.assertEqual("server-error", rec_id.status)
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    @mock.patch(f"{model}.cups")
+    def test_update_printers_inits_cups(self, cups):
+        """It should init CUPS connection"""
+        self.new_printer()
+        self.Model.update_printers()
+        cups.Connection.assert_called_once_with(
+            host=self.server.address, port=self.server.port
+        )
+
+    @mock.patch(f"{model}.cups")
+    def test_update_printers_gets_all_printers(self, cups):
+        """It should get all printers from CUPS server"""
+        self.new_printer()
+        self.Model.update_printers()
+        cups.Connection().getPrinters.assert_called_once_with()
+
+    @mock.patch(f"{model}.cups")
+    def test_update_printers_search(self, cups):
+        """It should search all when no domain"""
+        with mock.patch(f"{model_base}.search") as search:
+            self.Model.update_printers()
+            search.assert_called_once_with([])
+
+    @mock.patch(f"{model}.cups")
+    def test_update_printers_search_domain(self, cups):
+        """It should use specific domain for search"""
+        with mock.patch(f"{model_base}.search") as search:
+            expect = [("id", ">", 0)]
+            self.Model.update_printers(expect)
+            search.assert_called_once_with(expect)
+
+    @mock.patch(f"{model}.cups")
+    def test_update_printers_update_unavailable(self, cups):
+        """It should update status when printer is unavailable"""
+        rec_id = self.new_printer()
+        cups.Connection().getPrinters().get.return_value = False
+        self.Model.action_update_printers()
+        self.assertEqual("unavailable", rec_id.status)
+
+    @mock.patch(f"{model}.cups")
+    def test_update_archived_printers(self, cups):
+        """It should update status even if printer is archived"""
+        rec_id = self.new_printer()
+        rec_id.toggle_active()
+        self.server.invalidate_model()
+        cups.Connection().getPrinters().get.return_value = False
+        self.Model.action_update_printers()
+        self.assertEqual(
+            "unavailable",
+            rec_id.status,
+        )
+
+    @mock.patch(f"{model}.cups")
+    def test_update_jobs_cron(self, cups):
+        """It should get all jobs from CUPS server"""
+        self.new_printer()
+        self.Model.action_update_jobs()
+        cups.Connection().getPrinters.assert_called_once_with()
+        cups.Connection().getJobs.assert_called_once_with(
+            which_jobs="all",
+            first_job_id=-1,
+            requested_attributes=[
+                "job-name",
+                "job-id",
+                "printer-uri",
+                "job-media-progress",
+                "time-at-creation",
+                "job-state",
+                "job-state-reasons",
+                "time-at-processing",
+                "time-at-completed",
+            ],
+        )
+
+    @mock.patch(f"{model}.cups")
+    def test_update_jobs_button(self, cups):
+        """It should get all jobs from CUPS server"""
+        self.new_printer()
+        self.server.action_update_jobs()
+        cups.Connection().getPrinters.assert_called_once_with()
+        cups.Connection().getJobs.assert_called_once_with(
+            which_jobs="all",
+            first_job_id=-1,
+            requested_attributes=[
+                "job-name",
+                "job-id",
+                "printer-uri",
+                "job-media-progress",
+                "time-at-creation",
+                "job-state",
+                "job-state-reasons",
+                "time-at-processing",
+                "time-at-completed",
+            ],
+        )
+
+    def test_update_jobs_error(self):
+        """It should catch any exception from CUPS and update status"""
+        with (
+            mock.patch(f"{model}.cups") as cups,
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            cups.Connection.side_effect = Exception
+            self.new_printer()
+            self.server.update_jobs()
+            cups.Connection.assert_called_with(
+                host=self.server.address, port=self.server.port
+            )
+            self.assertEqual(len(logs.records), 2)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    @mock.patch(f"{model}.cups")
+    def test_update_jobs_uncompleted(self, cups):
+        """
+        It should search which jobs have been completed since last update
+        """
+        printer = self.new_printer()
+        self.new_job(printer, vals={"job_state": "completed"})
+        self.new_job(printer, vals={"job_id_cups": 2, "job_state": "processing"})
+        self.server.update_jobs(which="not-completed")
+        cups.Connection().getJobs.assert_any_call(
+            which_jobs="completed",
+            first_job_id=2,
+            requested_attributes=[
+                "job-name",
+                "job-id",
+                "printer-uri",
+                "job-media-progress",
+                "time-at-creation",
+                "job-state",
+                "job-state-reasons",
+                "time-at-processing",
+                "time-at-completed",
+            ],
+        )
+
+    @mock.patch(f"{model}.cups")
+    def test_update_jobs(self, cups):
+        """
+        It should update all jobs, known or not
+        """
+        printer = self.new_printer()
+        printer_uri = "hostname:port/" + printer.system_name
+        cups.Connection().getJobs.return_value = {
+            1: {"printer-uri": printer_uri},
+            2: {"printer-uri": printer_uri, "job-state": 9},
+            4: {"printer-uri": printer_uri, "job-state": 5},
+        }
+        self.new_job(printer, vals={"job_state": "completed"})
+        completed_job = self.new_job(
+            printer, vals={"job_id_cups": 2, "job_state": "processing"}
+        )
+        purged_job = self.new_job(
+            printer, vals={"job_id_cups": 3, "job_state": "processing"}
+        )
+        self.server.update_jobs()
+        new_job = self.env["printing.job"].search([("job_id_cups", "=", 4)])
+        self.assertEqual(completed_job.job_state, "completed")
+        self.assertEqual(purged_job.active, False)
+        self.assertEqual(new_job.job_state, "processing")