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

odoo/addons/base_report_to_printer/tests/test_ir_actions_report.py

@@ -0,0 +1,350 @@
+# Copyright 2016 LasLabs Inc.
+# Copyright 2016 SYLEAM
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+import logging
+from unittest import mock
+
+from odoo.tests.common import TransactionCase
+
+model = "odoo.addons.base.models.ir_actions_report.IrActionsReport"
+
+
+class TestIrActionsReportXml(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.Model = self.env["ir.actions.report"].with_context(
+            skip_printer_exception=True
+        )
+        self.vals = {}
+
+        self.report = self.Model.search([], limit=1)
+        self.server = self.env["printing.server"].create({})
+
+    def new_action(self):
+        return self.env["printing.action"].create(
+            {"name": "Printing Action", "action_type": "server"}
+        )
+
+    def new_printing_action(self):
+        return self.env["printing.report.xml.action"].create(
+            {
+                "report_id": self.report.id,
+                "user_id": self.env.ref("base.user_demo").id,
+                "action": "server",
+            }
+        )
+
+    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 new_tray(self, vals=None, defaults=None):
+        values = dict(defaults)
+        if vals is not None:
+            values.update(vals)
+        return self.env["printing.tray"].create(values)
+
+    def test_print_action_for_report_name_gets_report(self):
+        """It should get report by name"""
+        with mock.patch(f"{model}._get_report_from_name") as mk:
+            expect = "test"
+            self.Model.print_action_for_report_name(expect)
+            mk.assert_called_once_with(expect)
+
+    def test_print_action_for_report_name_returns_if_no_report(self):
+        """It should return empty dict when no matching report"""
+        with mock.patch(f"{model}._get_report_from_name") as mk:
+            expect = "test"
+            mk.return_value = False
+            res = self.Model.print_action_for_report_name(expect)
+            self.assertDictEqual({}, res)
+
+    def test_print_action_for_report_name_returns_if_report(self):
+        """It should return correct serializable result for behaviour"""
+        with mock.patch(f"{model}._get_report_from_name") as mk:
+            res = self.Model.print_action_for_report_name("test")
+            behaviour = mk().behaviour()
+            expect = {
+                "action": behaviour["action"],
+                "printer_name": behaviour["printer"].name,
+            }
+            self.assertDictEqual(expect, res, f"Expect {expect}, Got {res}")
+
+    def test_behaviour_default_values(self):
+        """It should return the default action and printer"""
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = False
+        self.env.user.printing_printer_id = False
+        report.property_printing_action_id = False
+        report.printing_printer_id = False
+        self.assertEqual(
+            report.behaviour(),
+            {
+                "action": "client",
+                "printer": self.env["printing.printer"],
+                "tray": False,
+            },
+        )
+
+    def test_behaviour_user_values(self):
+        """It should return the action and printer from user"""
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "client"
+        self.env.user.printing_printer_id = self.new_printer()
+        with (
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            self.assertEqual(
+                report.behaviour(),
+                {
+                    "action": "client",
+                    "printer": self.env.user.printing_printer_id,
+                    "tray": False,
+                },
+            )
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    def test_behaviour_report_values(self):
+        """It should return the action and printer from report"""
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "client"
+        report.property_printing_action_id = self.new_action()
+        report.printing_printer_id = self.new_printer()
+        with (
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            self.assertEqual(
+                report.behaviour(),
+                {
+                    "action": report.property_printing_action_id.action_type,
+                    "printer": report.printing_printer_id,
+                    "tray": False,
+                },
+            )
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    def test_behaviour_user_action(self):
+        """It should return the action and printer from user action"""
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "client"
+        report.property_printing_action_id.action_type = "user_default"
+        self.assertEqual(
+            report.behaviour(),
+            {"action": "client", "printer": report.printing_printer_id, "tray": False},
+        )
+
+    def test_behaviour_printing_action_on_wrong_user(self):
+        """It should return the action and printer ignoring printing action"""
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "client"
+        printing_action = self.new_printing_action()
+        printing_action.user_id = self.env["res.users"].search(
+            [("id", "!=", self.env.user.id)], limit=1
+        )
+        self.assertEqual(
+            report.behaviour(),
+            {"action": "client", "printer": report.printing_printer_id, "tray": False},
+        )
+
+    def test_behaviour_printing_action_on_wrong_report(self):
+        """It should return the action and printer ignoring printing action"""
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "client"
+        printing_action = self.new_printing_action()
+        printing_action.user_id = self.env.user
+        printing_action.report_id = self.Model.search(
+            [("id", "!=", report.id)], limit=1
+        )
+        self.assertEqual(
+            report.behaviour(),
+            {"action": "client", "printer": report.printing_printer_id, "tray": False},
+        )
+
+    def test_behaviour_printing_action_with_no_printer(self):
+        """It should return the action from printing action and printer from
+        other
+        """
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "client"
+        printing_action = self.new_printing_action()
+        printing_action.user_id = self.env.user
+        printing_action.report_id = report
+        self.assertEqual(
+            report.behaviour(),
+            {
+                "action": printing_action.action,
+                "printer": report.printing_printer_id,
+                "tray": False,
+            },
+        )
+
+    def test_behaviour_printing_action_with_printer(self):
+        """It should return the action and printer from printing action"""
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "client"
+        printing_action = self.new_printing_action()
+        printing_action.user_id = self.env.user
+        printing_action.printer_id = self.new_printer()
+        with (
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            self.assertEqual(
+                report.behaviour(),
+                {
+                    "action": printing_action.action,
+                    "printer": printing_action.printer_id,
+                    "tray": False,
+                },
+            )
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    def test_behaviour_printing_action_user_defaults(self):
+        """It should return the action and printer from user with printing
+        action
+        """
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "client"
+        printing_action = self.new_printing_action()
+        printing_action.user_id = self.env.user
+        printing_action.action = "user_default"
+        self.assertEqual(
+            report.behaviour(),
+            {"action": "client", "printer": report.printing_printer_id, "tray": False},
+        )
+
+    def test_print_tray_behaviour(self):
+        """
+        It should return the correct tray
+        """
+        with (
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            report = self.Model.search([], limit=1)
+            action = self.env["printing.report.xml.action"].create(
+                {
+                    "user_id": self.env.user.id,
+                    "report_id": report.id,
+                    "action": "server",
+                }
+            )
+            printer = self.new_printer()
+            tray_vals = {
+                "name": "Tray",
+                "system_name": "Tray",
+                "printer_id": printer.id,
+            }
+            user_tray = self.new_tray({"system_name": "User tray"}, tray_vals)
+            report_tray = self.new_tray({"system_name": "Report tray"}, tray_vals)
+            action_tray = self.new_tray({"system_name": "Action tray"}, tray_vals)
+
+            # No report passed
+            self.env.user.printer_tray_id = False
+            options = printer.print_options()
+            self.assertFalse("InputSlot" in options)
+
+            # No tray defined
+            self.env.user.printer_tray_id = False
+            report.printer_tray_id = False
+            action.printer_tray_id = False
+            options = report.behaviour()
+            self.assertTrue("tray" in options)
+
+            # Only user tray is defined
+            self.env.user.printer_tray_id = user_tray
+            report.printer_tray_id = False
+            action.printer_tray_id = False
+            self.assertEqual("User tray", report.behaviour()["tray"])
+
+            # Only report tray is defined
+            self.env.user.printer_tray_id = False
+            report.printer_tray_id = report_tray
+            action.printer_tray_id = False
+            self.assertEqual("Report tray", report.behaviour()["tray"])
+
+            # Only action tray is defined
+            self.env.user.printer_tray_id = False
+            report.printer_tray_id = False
+            action.printer_tray_id = action_tray
+            self.assertEqual("Action tray", report.behaviour()["tray"])
+
+            # User and report tray defined
+            self.env.user.printer_tray_id = user_tray
+            report.printer_tray_id = report_tray
+            action.printer_tray_id = False
+            self.assertEqual("Report tray", report.behaviour()["tray"])
+
+            # All trays are defined
+            self.env.user.printer_tray_id = user_tray
+            report.printer_tray_id = report_tray
+            action.printer_tray_id = action_tray
+            self.assertEqual("Action tray", report.behaviour()["tray"])
+            self.assertEqual(len(logs.records), 6)
+            for record in logs.records:
+                self.assertEqual(record.levelno, logging.WARNING)
+
+    def test_onchange_printer_tray_id_empty(self):
+        action = self.Model.new({"printer_tray_id": False})
+        action.onchange_printing_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.Model.new({"printer_tray_id": tray.id})
+        self.assertEqual(action.printer_tray_id, tray)
+        action.onchange_printing_printer_id()
+        self.assertFalse(action.printer_tray_id)
+
+    def test_print_in_new_thread(self):
+        """It should return the action and printer from printing action in other
+        thread"""
+        report = self.Model.search([], limit=1)
+        self.env.user.printing_action = "server"
+        printing_action = self.new_printing_action()
+        printing_action.user_id = self.env.user
+        printing_action.printer_id = self.new_printer()
+        printing_action.printer_id.multi_thread = True
+        with (
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            self.assertEqual(
+                report.behaviour(),
+                {
+                    "action": printing_action.action,
+                    "printer": printing_action.printer_id,
+                    "tray": False,
+                },
+            )
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)

odoo/addons/base_report_to_printer/tests/test_printing_job.py

@@ -0,0 +1,70 @@
+# 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"
+
+
+class TestPrintingJob(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_cancel_job_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
+            printer = self.new_printer()
+            job = self.new_job(printer, {"job_id_cups": 2})
+            job.action_cancel()
+            cups.Connection.side_effect = None
+            self.assertEqual(cups.Connection().cancelJob.call_count, 0)
+
+            self.assertEqual(len(logs.records), 3)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    @mock.patch(f"{model}.cups")
+    def test_cancel_job(self, cups):
+        """It should catch any exception from CUPS and update status"""
+        printer = self.new_printer()
+        job = self.new_job(printer)
+        job.cancel()
+        cups.Connection().cancelJob.assert_called_once_with(
+            job.job_id_cups, purge_job=False
+        )

odoo/addons/base_report_to_printer/tests/test_printing_printer.py

@@ -0,0 +1,198 @@
+# Copyright 2016 LasLabs Inc.
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+import logging
+import tempfile
+from unittest import mock
+
+from odoo.exceptions import UserError
+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"
+
+
+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_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.report = self.env["ir.actions.report"].search([], limit=1)
+
+    def new_record(self):
+        return self.Model.create(self.printer_vals)
+
+    def test_option_tray(self):
+        """
+        It should put the value in InputSlot
+        """
+        self.assertEqual(
+            self.Model._set_option_tray(None, "Test Tray"), {"InputSlot": "Test Tray"}
+        )
+        self.assertEqual(self.Model._set_option_tray(None, False), {})
+
+    def test_option_noops(self):
+        """
+        Noops should return an empty dict
+        """
+        self.assertEqual(self.Model._set_option_action(None, "printer"), {})
+        self.assertEqual(self.Model._set_option_printer(None, self.Model), {})
+
+    def test_option_doc_format(self):
+        """
+        Raw documents should set raw boolean.
+        """
+        self.assertEqual(
+            self.Model._set_option_doc_format(None, "raw"), {"raw": "True"}
+        )
+        # Deprecate _set_option_format in v12.
+        self.assertEqual(self.Model._set_option_format(None, "raw"), {"raw": "True"})
+
+        self.assertEqual(self.Model._set_option_doc_format(None, "pdf"), {})
+        # Deprecate _set_option_format in v12.
+        self.assertEqual(self.Model._set_option_format(None, "pdf"), {})
+
+    def test_print_options(self):
+        """It should generate the right options dictionnary"""
+        # TODO: None here used as report - tests here should be merged
+        # with tests in test_printing_printer_tray from when modules merged
+        report = self.env["ir.actions.report"].search([], limit=1)
+        self.assertEqual(self.Model.print_options(doc_format="raw"), {"raw": "True"})
+        self.assertEqual(
+            self.Model.print_options(report, doc_format="pdf", copies=2),
+            {"copies": "2"},
+        )
+        self.assertEqual(
+            self.Model.print_options(report, doc_format="raw", copies=2),
+            {"raw": "True", "copies": "2"},
+        )
+        self.assertTrue("InputSlot" in self.Model.print_options(report, tray="Test"))
+
+    @mock.patch(f"{server_model}.cups")
+    def test_print_report(self, cups):
+        """It should print a report through CUPS"""
+        fd, file_name = tempfile.mkstemp()
+        with mock.patch(f"{model}.mkstemp") as mkstemp:
+            mkstemp.return_value = fd, file_name
+            printer = self.new_record()
+            printer.print_document(self.report, b"content to print", doc_format="pdf")
+            cups.Connection().printFile.assert_called_once_with(
+                printer.system_name, file_name, file_name, options={}
+            )
+
+    def test_print_report_error(self):
+        """It should print a report through CUPS"""
+        with (
+            mock.patch(f"{model}.cups") as cups,
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            cups.Connection.side_effect = Exception
+            fd, file_name = tempfile.mkstemp()
+            with mock.patch(f"{model}.mkstemp") as mkstemp:
+                mkstemp.return_value = fd, file_name
+                printer = self.new_record()
+                with self.assertRaises(UserError):
+                    printer.print_document(
+                        self.report, b"content to print", doc_format="pdf"
+                    )
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    def test_print_file(self):
+        """It should print a file through CUPS"""
+        with (
+            mock.patch(f"{server_model}.cups") as cups,
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            file_name = "file_name"
+            printer = self.new_record()
+            printer.print_file(file_name, "pdf")
+            cups.Connection().printFile.assert_called_once_with(
+                printer.system_name, file_name, file_name, options={}
+            )
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    def test_print_file_error(self):
+        """It should print a file through CUPS"""
+        with (
+            mock.patch(f"{server_model}.cups") as cups,
+            self.assertLogs(level=logging.WARNING) as logs,
+        ):
+            cups.Connection.side_effect = Exception
+            file_name = "file_name"
+            printer = self.new_record()
+            with self.assertRaises(UserError):
+                printer.print_file(file_name)
+            self.assertEqual(len(logs.records), 1)
+            self.assertEqual(logs.records[0].levelno, logging.WARNING)
+
+    def test_set_default(self):
+        """It should set a single record as default"""
+        printer = self.new_record()
+        self.assertTrue(printer.default)
+        other_printer = self.new_record()
+        other_printer.set_default()
+        self.assertFalse(printer.default)
+        self.assertTrue(other_printer.default)
+        # Check that calling the method on an empty recordset does nothing
+        self.Model.set_default()
+        self.assertEqual(other_printer, self.Model.get_default())
+
+    def test_unset_default(self):
+        """It should unset the default state of the printer"""
+        printer = self.new_record()
+        self.assertTrue(printer.default)
+        printer.unset_default()
+        self.assertFalse(printer.default)
+
+    @mock.patch(f"{server_model}.cups")
+    def test_cancel_all_jobs(self, cups):
+        """It should cancel all jobs"""
+        printer = self.new_record()
+        printer.action_cancel_all_jobs()
+        cups.Connection().cancelAllJobs.assert_called_once_with(
+            name=printer.system_name, purge_jobs=False
+        )
+
+    @mock.patch(f"{server_model}.cups")
+    def test_cancel_and_purge_all_jobs(self, cups):
+        """It should cancel all jobs"""
+        printer = self.new_record()
+        printer.cancel_all_jobs(purge_jobs=True)
+        cups.Connection().cancelAllJobs.assert_called_once_with(
+            name=printer.system_name, purge_jobs=True
+        )
+
+    @mock.patch(f"{server_model}.cups")
+    def test_enable_printer(self, cups):
+        """It should enable the printer"""
+        printer = self.new_record()
+        printer.enable()
+        cups.Connection().enablePrinter.assert_called_once_with(printer.system_name)
+
+    @mock.patch(f"{server_model}.cups")
+    def test_disable_printer(self, cups):
+        """It should disable the printer"""
+        printer = self.new_record()
+        printer.disable()
+        cups.Connection().disablePrinter.assert_called_once_with(printer.system_name)
+
+    @mock.patch(f"{server_model}.cups")
+    def test_print_test_page(self, cups):
+        """It should print a test page"""
+        printer = self.new_record()
+        printer.print_test_page()
+        cups.Connection().printTestPage.assert_called_once_with(printer.system_name)