odoo-addon-shopfloor 16.0.1.0.0.24__py3-none-any.whl

odoo/addons/shopfloor/tests/test_checkout_base.py

@@ -0,0 +1,81 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from .common import CommonCase
+
+
+# pylint: disable=missing-return
+class CheckoutCommonCase(CommonCase):
+    @classmethod
+    def setUpClassVars(cls, *args, **kwargs):
+        super().setUpClassVars(*args, **kwargs)
+        cls.menu = cls.env.ref("shopfloor.shopfloor_menu_demo_checkout")
+        cls.profile = cls.env.ref("shopfloor.profile_demo_1")
+        cls.picking_type = cls.menu.picking_type_ids
+        cls.wh = cls.picking_type.warehouse_id
+
+    @classmethod
+    def setUpClassBaseData(cls, *args, **kwargs):
+        super().setUpClassBaseData(*args, **kwargs)
+        cls.wh.sudo().delivery_steps = "pick_pack_ship"
+        cls.delivery_packaging = (
+            cls.env["stock.package.type"]
+            .sudo()
+            .create(
+                {
+                    "name": "Pallet",
+                    "package_carrier_type": "none",
+                    "barcode": "PALCODE",
+                }
+            )
+        )
+
+    def setUp(self):
+        super().setUp()
+        self.service = self.get_service(
+            "checkout", menu=self.menu, profile=self.profile
+        )
+
+    def _stock_picking_data(self, picking, **kw):
+        return self.service._data_for_stock_picking(picking, **kw)
+
+    # we test the methods that structure data in test_actions_data.py
+    def _picking_summary_data(self, picking):
+        return self.data.picking(picking)
+
+    def _move_line_data(self, move_line):
+        return self.data.move_line(move_line)
+
+    def _package_data(self, package, picking):
+        return self.data.package(package, picking=picking, with_packaging=True)
+
+    def _packaging_data(self, packaging):
+        return self.data.delivery_packaging(packaging)
+
+    def _data_for_select_line(self, picking, **kw):
+        data = {
+            "picking": self._stock_picking_data(picking),
+            "group_lines_by_location": True,
+            "show_oneline_package_content": False,
+            "need_confirm_pack_all": False,
+        }
+        data.update(kw)
+        return data
+
+    def _assert_select_package_qty_above(self, response, picking):
+        self.assert_response(
+            response,
+            next_state="select_package",
+            data={
+                "selected_move_lines": [
+                    self._move_line_data(ml) for ml in picking.move_line_ids.sorted()
+                ],
+                "picking": self._picking_summary_data(picking),
+                "packing_info": "",
+                "no_package_enabled": True,
+            },
+            message={
+                "message_type": "warning",
+                "body": "The quantity scanned for one or more lines cannot be "
+                "higher than the maximum allowed.",
+            },
+        )

odoo/addons/shopfloor/tests/test_checkout_cancel_line.py

@@ -0,0 +1,154 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from .test_checkout_base import CheckoutCommonCase
+
+
+# pylint: disable=missing-return
+class CheckoutRemovePackageCase(CheckoutCommonCase):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking = picking = cls._create_picking(
+            lines=[
+                (cls.product_a, 10),
+                (cls.product_b, 10),
+                (cls.product_c, 10),
+                (cls.product_d, 10),
+            ]
+        )
+        cls.pack1_moves = picking.move_ids[:2]
+        cls.pack2_moves = picking.move_ids[2]
+        cls.raw_move = picking.move_ids[3]
+        cls._fill_stock_for_moves(cls.pack1_moves, in_package=True)
+        cls._fill_stock_for_moves(cls.pack2_moves, in_package=True)
+        cls._fill_stock_for_moves(cls.raw_move)
+        picking.action_assign()
+
+    def test_cancel_package_ok(self):
+        picking = self.picking
+
+        pack1_lines = self.pack1_moves.move_line_ids
+        pack2_lines = self.pack2_moves.move_line_ids
+        raw_line = self.raw_move.move_line_ids
+
+        # do as we packed the lines in 2 different packages
+        new_package = self.env["stock.quant.package"].create({})
+        (pack1_lines | raw_line).write(
+            {
+                "qty_done": 10,
+                "result_package_id": new_package.id,
+                "shopfloor_checkout_done": True,
+            }
+        )
+        new_package2 = self.env["stock.quant.package"].create({})
+        pack2_lines.write(
+            {
+                "qty_done": 10,
+                "result_package_id": new_package2.id,
+                "shopfloor_checkout_done": True,
+            }
+        )
+
+        # and now, we want to drop the new_package
+        response = self.service.dispatch(
+            "cancel_line",
+            params={"picking_id": picking.id, "package_id": new_package.id},
+        )
+
+        self.assertRecordValues(
+            pack1_lines + raw_line + pack2_lines,
+            [
+                {
+                    "qty_done": 0,
+                    # reset to origin package
+                    "result_package_id": pack1_lines.mapped("package_id").id,
+                    "shopfloor_checkout_done": False,
+                },
+                {
+                    "qty_done": 0,
+                    # reset to origin package
+                    "result_package_id": pack1_lines.mapped("package_id").id,
+                    "shopfloor_checkout_done": False,
+                },
+                {
+                    "qty_done": 0,
+                    # result to an empty package (raw product)
+                    "result_package_id": False,
+                    "shopfloor_checkout_done": False,
+                },
+                # different package, leave untouched
+                {
+                    "qty_done": 10,
+                    "result_package_id": new_package2.id,
+                    "shopfloor_checkout_done": True,
+                },
+            ],
+        )
+
+        self.assert_response(
+            response,
+            next_state="select_line",
+            data=self._data_for_select_line(picking),
+            message={"body": "Package cancelled", "message_type": "success"},
+        )
+
+    def test_cancel_line_ok(self):
+        picking = self.picking
+
+        raw_line = self.raw_move.move_line_ids
+
+        raw_line.write({"qty_done": 10, "shopfloor_checkout_done": True})
+
+        # and now, we want to drop the new_package
+        response = self.service.dispatch(
+            "cancel_line",
+            params={"picking_id": picking.id, "line_id": raw_line.id},
+        )
+
+        self.assertRecordValues(
+            raw_line,
+            [{"qty_done": 0, "shopfloor_checkout_done": False}],
+        )
+
+        self.assert_response(
+            response,
+            next_state="select_line",
+            data=self._data_for_select_line(picking),
+            message={"body": "Line cancelled", "message_type": "success"},
+        )
+
+    def test_cancel_line_error_package_not_found(self):
+        # and now, we want to drop the new_package
+        response = self.service.dispatch(
+            "cancel_line", params={"picking_id": self.picking.id, "package_id": 0}
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": False,
+            },
+            message={
+                "message_type": "error",
+                "body": "The record you were working on does not exist anymore.",
+            },
+        )
+
+    def test_cancel_line_error_line_not_found(self):
+        # and now, we want to drop the new_package
+        response = self.service.dispatch(
+            "cancel_line", params={"picking_id": self.picking.id, "line_id": 0}
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": False,
+            },
+            message={
+                "message_type": "error",
+                "body": "The record you were working on does not exist anymore.",
+            },
+        )

odoo/addons/shopfloor/tests/test_checkout_change_packaging.py

@@ -0,0 +1,184 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from .test_checkout_base import CheckoutCommonCase
+
+
+# pylint: disable=missing-return
+class CheckoutListSetPackagingCase(CheckoutCommonCase):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.env["stock.package.type"].sudo().search([]).active = False
+        pallet_type = (
+            cls.env["product.packaging.level"]
+            .sudo()
+            .create({"name": "Pallet", "code": "P", "sequence": 3})
+        )
+        cls.packaging_pallet = (
+            cls.env["stock.package.type"]
+            .sudo()
+            .create(
+                {
+                    "packaging_level_id": pallet_type.id,
+                    "name": "Pallet",
+                    "barcode": "PPP",
+                    "height": 100,
+                    "width": 100,
+                    "packaging_length": 100,
+                    "sequence": 2,
+                }
+            )
+        )
+        box_type = (
+            cls.env["product.packaging.level"]
+            .sudo()
+            .create({"name": "Box", "code": "B", "sequence": 2})
+        )
+        cls.packaging_box = (
+            cls.env["stock.package.type"]
+            .sudo()
+            .create(
+                {
+                    "packaging_level_id": box_type.id,
+                    "name": "Box",
+                    "barcode": "BBB",
+                    "height": 20,
+                    "width": 20,
+                    "packaging_length": 20,
+                    "sequence": 1,
+                }
+            )
+        )
+        inner_box_type = (
+            cls.env["product.packaging.level"]
+            .sudo()
+            .create({"name": "Inner Box", "code": "I", "sequence": 1})
+        )
+        cls.packaging_inner_box = (
+            cls.env["stock.package.type"]
+            .sudo()
+            .create(
+                {
+                    "packaging_level_id": inner_box_type.id,
+                    "name": "Inner Box",
+                    "barcode": "III",
+                    "height": 10,
+                    "width": 10,
+                    "packaging_length": 10,
+                    "sequence": 0,
+                }
+            )
+        )
+        cls.picking = cls._create_picking(lines=[(cls.product_a, 10)])
+        cls._fill_stock_for_moves(cls.picking.move_ids, in_package=True)
+        cls.picking.action_assign()
+        cls.package = cls.picking.move_line_ids.result_package_id
+        cls.package.package_type_id = cls.packaging_pallet
+        cls.packagings = cls.env["stock.package.type"].search([]).sorted()
+
+    def test_list_packaging_ok(self):
+        response = self.service.dispatch(
+            "list_packaging",
+            params={"picking_id": self.picking.id, "package_id": self.package.id},
+        )
+
+        self.assert_response(
+            response,
+            next_state="change_packaging",
+            data={
+                "picking": self._picking_summary_data(self.picking),
+                "package": self._package_data(self.package, self.picking),
+                "packaging": [
+                    self._packaging_data(packaging)
+                    for packaging in self.packaging_inner_box
+                    + self.packaging_box
+                    + self.packaging_pallet
+                ],
+            },
+        )
+
+    def test_list_packaging_error_package_not_found(self):
+        response = self.service.dispatch(
+            "list_packaging", params={"picking_id": self.picking.id, "package_id": 0}
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": False,
+            },
+            message={
+                "message_type": "error",
+                "body": "The record you were working on does not exist anymore.",
+            },
+        )
+
+    def test_set_packaging_ok(self):
+        response = self.service.dispatch(
+            "set_packaging",
+            params={
+                "picking_id": self.picking.id,
+                "package_id": self.package.id,
+                "package_type_id": self.packaging_inner_box.id,
+            },
+        )
+        self.assertRecordValues(
+            self.package, [{"package_type_id": self.packaging_inner_box.id}]
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": False,
+            },
+            message={
+                "message_type": "success",
+                "body": "Packaging changed on package {}".format(self.package.name),
+            },
+        )
+
+    def test_set_packaging_error_package_not_found(self):
+        response = self.service.dispatch(
+            "set_packaging",
+            params={
+                "picking_id": self.picking.id,
+                "package_id": 0,
+                "package_type_id": self.packaging_inner_box.id,
+            },
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": False,
+            },
+            message={
+                "message_type": "error",
+                "body": "The record you were working on does not exist anymore.",
+            },
+        )
+
+    def test_set_packaging_error_packaging_not_found(self):
+        response = self.service.dispatch(
+            "set_packaging",
+            params={
+                "picking_id": self.picking.id,
+                "package_id": self.package.id,
+                "package_type_id": 0,
+            },
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": False,
+            },
+            message={
+                "message_type": "error",
+                "body": "The record you were working on does not exist anymore.",
+            },
+        )

odoo/addons/shopfloor/tests/test_checkout_done.py

@@ -0,0 +1,133 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from .test_checkout_base import CheckoutCommonCase
+
+
+# pylint: disable=missing-return
+class CheckoutDoneCase(CheckoutCommonCase):
+    def test_done_ok(self):
+        picking = self._create_picking(lines=[(self.product_a, 10)])
+        self._fill_stock_for_moves(picking.move_ids, in_package=True)
+        picking.action_assign()
+        # line is done
+        picking.move_line_ids.write({"qty_done": 10, "shopfloor_checkout_done": True})
+        response = self.service.dispatch("done", params={"picking_id": picking.id})
+
+        self.assertRecordValues(picking, [{"state": "done"}])
+
+        self.assert_response(
+            response,
+            next_state="select_document",
+            message={
+                "message_type": "success",
+                "body": "Transfer {} done".format(picking.name),
+            },
+        )
+
+
+class CheckoutDonePartialCase(CheckoutCommonCase):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking = picking = cls._create_picking(
+            lines=[(cls.product_a, 10), (cls.product_b, 10)]
+        )
+        cls._fill_stock_for_moves(picking.move_ids)
+        picking.action_assign()
+        cls.line1 = picking.move_line_ids[0]
+        cls.line2 = picking.move_line_ids[1]
+        cls.line1.write({"qty_done": 10, "shopfloor_checkout_done": True})
+        cls.line2.write({"qty_done": 2, "shopfloor_checkout_done": True})
+
+    def test_done_partial(self):
+        # line is done
+        response = self.service.dispatch("done", params={"picking_id": self.picking.id})
+
+        self.assertRecordValues(self.picking, [{"state": "assigned"}])
+
+        self.assert_response(
+            response,
+            next_state="confirm_done",
+            data={"picking": self._stock_picking_data(self.picking, done=True)},
+            message=self.service.msg_store.transfer_confirm_done(),
+        )
+
+    def test_done_partial_confirm(self):
+        # lines are done
+        response = self.service.dispatch(
+            "done", params={"picking_id": self.picking.id, "confirmation": True}
+        )
+        # as they are all the lines that relate to the picking, they didn't have
+        # been extracted in a separate transfer. An usual backorder has been
+        # created for the unprocessed qty.
+        self.assertRecordValues(self.picking, [{"state": "done"}])
+        self.assertTrue(self.picking.backorder_ids)
+        self.assertEqual(self.picking.backorder_ids.move_line_ids.reserved_uom_qty, 8)
+
+        self.assert_response(
+            response,
+            next_state="select_document",
+            message=self.service.msg_store.transfer_done_success(self.picking),
+        )
+
+
+class CheckoutDoneRawUnpackedCase(CheckoutCommonCase):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking = picking = cls._create_picking(
+            lines=[(cls.product_a, 10), (cls.product_b, 10)]
+        )
+        cls._fill_stock_for_moves(picking.move_ids)
+        picking.action_assign()
+        cls.line1 = picking.move_line_ids[0]
+        cls.line2 = picking.move_line_ids[1]
+        cls.package = cls.env["stock.quant.package"].create({})
+        cls.line1.write(
+            {
+                "qty_done": 10,
+                "shopfloor_checkout_done": True,
+                "result_package_id": cls.package.id,
+            }
+        )
+        cls.line2.write({"qty_done": 10, "shopfloor_checkout_done": False})
+
+    def test_done_partial(self):
+        # line is done
+        response = self.service.dispatch("done", params={"picking_id": self.picking.id})
+
+        self.assertRecordValues(self.picking, [{"state": "assigned"}])
+
+        self.assert_response(
+            response,
+            next_state="confirm_done",
+            data={"picking": self._stock_picking_data(self.picking, done=True)},
+            message={
+                "message_type": "warning",
+                "body": "Remaining raw product not packed, proceed anyway?",
+            },
+        )
+
+    def test_done_partial_confirm(self):
+        # line is done
+        response = self.service.dispatch(
+            "done", params={"picking_id": self.picking.id, "confirmation": True}
+        )
+
+        # it has been extracted in its own picking, the current one staying open
+        picking_done = self.line1.picking_id
+        self.assertRecordValues(picking_done, [{"state": "done", "backorder_ids": []}])
+        self.assertRecordValues(
+            self.picking, [{"state": "assigned", "backorder_ids": [picking_done.id]}]
+        )
+        self.assertRecordValues(
+            self.line1 + self.line2,
+            [{"result_package_id": self.package.id}, {"result_package_id": False}],
+        )
+        self.assertIn(self.line2, self.picking.move_line_ids)
+
+        self.assert_response(
+            response,
+            next_state="select_document",
+            message=self.service.msg_store.transfer_done_success(picking_done),
+        )

odoo/addons/shopfloor/tests/test_checkout_list_delivery_packaging.py

@@ -0,0 +1,131 @@
+# Copyright 2021 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo_test_helper import FakeModelLoader
+
+from .test_checkout_base import CheckoutCommonCase
+from .test_checkout_select_package_base import CheckoutSelectPackageMixin
+
+
+# pylint: disable=missing-return
+class CheckoutListDeliveryPackagingCase(CheckoutCommonCase, CheckoutSelectPackageMixin):
+    @classmethod
+    def setUpClass(cls):
+        try:
+            super().setUpClass()
+        except BaseException:
+            # ensure that the registry is restored in case of error in setUpClass
+            # since tearDownClass is not called in this case and our _load_test_models
+            # loads fake models
+            if hasattr(cls, "loader"):
+                cls.loader.restore_registry()
+            raise
+
+    @classmethod
+    def _load_test_models(cls):
+        cls.loader = FakeModelLoader(cls.env, cls.__module__)
+        cls.loader.backup_registry()
+        from .models import DeliveryCarrierTest, StockPackageType
+
+        cls.loader.update_registry((DeliveryCarrierTest, StockPackageType))
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.loader.restore_registry()
+        super(CheckoutListDeliveryPackagingCase, cls).tearDownClass()
+
+    @classmethod
+    def setUpClassBaseData(cls, *args, **kwargs):
+        super().setUpClassBaseData(*args, **kwargs)
+        cls._load_test_models()
+        cls.carrier = cls.env["delivery.carrier"].search([], limit=1)
+        cls.carrier.sudo().delivery_type = "test"
+        cls.picking = cls._create_picking(
+            lines=[
+                (cls.product_a, 10),
+                (cls.product_b, 10),
+                (cls.product_c, 10),
+                (cls.product_d, 10),
+            ]
+        )
+        cls.picking.carrier_id = cls.carrier
+        cls.packaging_type = (
+            cls.env["product.packaging.level"]
+            .sudo()
+            .create({"name": "Transport Box", "code": "TB", "sequence": 0})
+        )
+        cls.delivery_packaging1 = (
+            cls.env["stock.package.type"]
+            .sudo()
+            .create(
+                {
+                    "name": "Box 1",
+                    "package_carrier_type": "test",
+                    "barcode": "BOX1",
+                }
+            )
+        )
+        cls.delivery_packaging2 = (
+            cls.env["stock.package.type"]
+            .sudo()
+            .create(
+                {
+                    "name": "Box 2",
+                    "package_carrier_type": "test",
+                    "barcode": "BOX2",
+                }
+            )
+        )
+        cls.delivery_packaging = (
+            cls.delivery_packaging1 | cls.delivery_packaging2
+        ).sorted("name")
+
+    def test_list_delivery_packaging_available(self):
+        self._fill_stock_for_moves(self.picking.move_ids, in_package=True)
+        self.picking.action_assign()
+        selected_lines = self.picking.move_line_ids
+        response = self.service.dispatch(
+            "list_delivery_packaging",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+            },
+        )
+        self.assert_response(
+            response,
+            next_state="select_delivery_packaging",
+            data={
+                "packaging": self.service.data.delivery_packaging_list(
+                    self.delivery_packaging
+                ),
+            },
+        )
+
+    def test_list_delivery_packaging_not_available(self):
+        self.delivery_packaging.package_carrier_type = False
+        self._fill_stock_for_moves(self.picking.move_ids, in_package=True)
+        self.picking.action_assign()
+        selected_lines = self.picking.move_line_ids
+        # for line in selected_lines:
+        #     line.qty_done = line.reserved_uom_qty
+        response = self.service.dispatch(
+            "list_delivery_packaging",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+            },
+        )
+        self.assert_response(
+            response,
+            next_state="select_package",
+            data={
+                "picking": self._picking_summary_data(self.picking),
+                "selected_move_lines": [
+                    self._move_line_data(ml) for ml in selected_lines.sorted()
+                ],
+                "packing_info": self.service._data_for_packing_info(self.picking),
+                "no_package_enabled": not self.service.options.get(
+                    "checkout__disable_no_package"
+                ),
+            },
+            message=self.service.msg_store.no_delivery_packaging_available(),
+        )