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

odoo/addons/shopfloor/tests/test_delivery_base.py

@@ -0,0 +1,155 @@
+# 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 DeliveryCommonCase(CommonCase):
+    @classmethod
+    def setUpClassVars(cls, *args, **kwargs):
+        super().setUpClassVars(*args, **kwargs)
+        cls.menu = cls.env.ref("shopfloor.shopfloor_menu_demo_delivery")
+        cls.profile = cls.env.ref("shopfloor_base.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.product_e = (
+            cls.env["product.product"]
+            .sudo()
+            .create(
+                {
+                    "name": "Product E",
+                    "type": "product",
+                    "default_code": "E",
+                    "barcode": "E",
+                    "weight": 3,
+                }
+            )
+        )
+        cls.product_e_packaging = (
+            cls.env["product.packaging"]
+            .sudo()
+            .create(
+                {
+                    "name": "Box",
+                    "product_id": cls.product_e.id,
+                    "barcode": "ProductEBox",
+                }
+            )
+        )
+        cls.product_f = (
+            cls.env["product.product"]
+            .sudo()
+            .create(
+                {
+                    "name": "Product F",
+                    "type": "product",
+                    "default_code": "F",
+                    "barcode": "F",
+                    "weight": 3,
+                }
+            )
+        )
+        cls.product_f_packaging = (
+            cls.env["product.packaging"]
+            .sudo()
+            .create(
+                {
+                    "name": "Box",
+                    "product_id": cls.product_f.id,
+                    "barcode": "ProductFBox",
+                }
+            )
+        )
+        cls.product_g = (
+            cls.env["product.product"]
+            .sudo()
+            .create(
+                {
+                    "name": "Product G",
+                    "type": "product",
+                    "default_code": "G",
+                    "barcode": "G",
+                    "weight": 1,
+                }
+            )
+        )
+        cls.product_g_packaging = (
+            cls.env["product.packaging"]
+            .sudo()
+            .create(
+                {
+                    "name": "Box",
+                    "product_id": cls.product_g.id,
+                    "barcode": "ProductGBox",
+                }
+            )
+        )
+
+    def setUp(self):
+        super().setUp()
+        self.service = self.get_service(
+            "delivery", menu=self.menu, profile=self.profile
+        )
+
+    def _stock_picking_data(self, picking):
+        return self.service.data_detail.picking_detail(picking)
+
+    def _stock_location_data(self, location):
+        return self.service.data.location(location, with_operation_progress=True)
+
+    def assert_response_deliver(
+        self, response, picking=None, message=None, location=None
+    ):
+        self.assert_response(
+            response,
+            next_state="deliver",
+            data={
+                "picking": self._stock_picking_data(picking) if picking else None,
+                "sublocation": self._stock_location_data(location)
+                if location
+                else None,
+            },
+            message=message,
+        )
+
+    def assert_response_manual_selection(self, response, pickings=None, message=None):
+        self.assert_response(
+            response,
+            next_state="manual_selection",
+            data={
+                "pickings": [self._stock_picking_data(picking) for picking in pickings]
+            },
+            message=message,
+        )
+
+    def assert_qty_done(self, move_lines, qties=None):
+        """Ensure that the quantities done are the expected ones.
+
+        If `qties` is not defined, the expected qties are `product_uom_qty`
+        of the move lines.
+        `qties` parameter is a list of move lines qty (same order).
+        """
+        if qties:
+            assert len(move_lines) == len(qties), "'qties' doesn't match 'move_lines'"
+            expected_qties = []
+            for qty in qties:
+                expected_qties.append({"qty_done": qty})
+        else:
+            expected_qties = [
+                {"qty_done": line.reserved_uom_qty} for line in move_lines
+            ]
+        self.assertRecordValues(move_lines, expected_qties)
+        package_level = move_lines.package_level_id
+        if package_level:
+            values = [{"is_done": True}]
+            if qties:
+                values = [{"is_done": bool(qty)} for qty in qties]
+            # we have a package level only when there is a package
+            self.assertRecordValues(package_level, values)

odoo/addons/shopfloor/tests/test_delivery_done.py

@@ -0,0 +1,108 @@
+# Copyright 2020 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from .test_delivery_base import DeliveryCommonCase
+
+# pylint: disable=missing-return
+
+
+class DeliveryDoneCase(DeliveryCommonCase):
+    """Tests for /done"""
+
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking = picking = cls._create_picking(
+            lines=[
+                # we'll put A and B in a single package
+                (cls.product_a, 10),
+                (cls.product_b, 10),
+                # C as raw product
+                (cls.product_c, 10),
+            ]
+        )
+        cls.pack1_moves = picking.move_ids[:2]
+        cls.raw_move = cls.picking.move_ids[2]
+        cls._fill_stock_for_moves(cls.pack1_moves, in_package=True)
+        cls._fill_stock_for_moves(cls.raw_move)
+        cls.picking.action_assign()
+
+    def assert_response_confirm_done(self, response, picking=None, message=None):
+        self.assert_response(
+            response,
+            next_state="confirm_done",
+            data={"picking": self._stock_picking_data(picking) if picking else None},
+            message=message,
+        )
+
+    def test_done_picking_not_found(self):
+        response = self.service.dispatch("done", params={"picking_id": -1})
+        self.assert_response_deliver(
+            response, message=self.service.msg_store.stock_picking_not_found()
+        )
+
+    def test_done_all_qty_done(self):
+        # Do not use the /set_qty_done_line endpoint to set done qties to not
+        # update the picking to 'done' state automatically
+        for move_line in self.picking.move_line_ids:
+            move_line.qty_done = move_line.reserved_uom_qty
+        response = self.service.dispatch("done", params={"picking_id": self.picking.id})
+        self.assert_response_deliver(
+            response,
+            message=self.service.msg_store.transfer_complete(self.picking),
+        )
+        self.assertEqual(self.picking.state, "done")
+
+    def test_done_no_qty_done(self):
+        response = self.service.dispatch("done", params={"picking_id": self.picking.id})
+        self.assert_response_confirm_done(
+            response,
+            picking=self.picking,
+            message=self.service.msg_store.transfer_confirm_done(),
+        )
+        self.assertEqual(self.picking.state, "assigned")
+
+    def test_done_some_qty_done(self):
+        move_line = self.raw_move.move_line_ids[0]
+        self.service.dispatch(
+            "set_qty_done_line",
+            params={"move_line_id": move_line.id, "picking_id": self.picking.id},
+        )
+        response = self.service.dispatch("done", params={"picking_id": self.picking.id})
+        self.assert_response_confirm_done(
+            response,
+            picking=self.picking,
+            message=self.service.msg_store.transfer_confirm_done(),
+        )
+        self.assertEqual(self.picking.state, "assigned")
+
+    def test_done_no_qty_done_confirm(self):
+        self.assertEqual(self.picking.state, "assigned")
+        response = self.service.dispatch(
+            "done", params={"picking_id": self.picking.id, "confirm": True}
+        )
+        self.assert_response_deliver(
+            response,
+            message=self.service.msg_store.transfer_no_qty_done(),
+        )
+        self.assertEqual(self.picking.state, "assigned")
+
+    def test_done_some_qty_done_confirm(self):
+        move_line = self.raw_move.move_line_ids[0]
+        self.service.dispatch(
+            "set_qty_done_line",
+            params={"move_line_id": move_line.id, "picking_id": self.picking.id},
+        )
+        self.assertEqual(self.picking.state, "assigned")
+        response = self.service.dispatch(
+            "done", params={"picking_id": self.picking.id, "confirm": True}
+        )
+        self.assert_response_deliver(
+            response,
+            message=self.service.msg_store.transfer_complete(self.picking),
+        )
+        self.assertEqual(self.picking.state, "done")
+        self.assertEqual(self.picking.move_ids, self.raw_move)
+        backorder = self.picking.backorder_ids
+        self.assertTrue(backorder)
+        self.assertEqual(self.pack1_moves.picking_id, backorder)

odoo/addons/shopfloor/tests/test_delivery_list_stock_picking.py

@@ -0,0 +1,49 @@
+# Copyright 2020 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from .test_delivery_base import DeliveryCommonCase
+
+# pylint: disable=missing-return
+
+
+class DeliveryListStockPickingCase(DeliveryCommonCase):
+    """Tests for /list_stock_picking"""
+
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking1 = cls._create_picking(
+            lines=[(cls.product_a, 10), (cls.product_b, 10)]
+        )
+        cls.picking2 = cls._create_picking(
+            lines=[(cls.product_a, 10), (cls.product_b, 10)]
+        )
+
+    def test_list_stock_picking_ko(self):
+        """No picking is ready, no picking to list."""
+        response = self.service.dispatch("list_stock_picking", params={})
+        self.assert_response_manual_selection(
+            response,
+            pickings=[],
+        )
+
+    def test_list_stock_picking_ok(self):
+        """Picking ready to list."""
+        # prepare 1st picking
+        self._fill_stock_for_moves(self.picking1.move_ids)
+        self.picking1.action_assign()
+        response = self.service.dispatch("list_stock_picking", params={})
+        # picking1 only available
+        self.assert_response_manual_selection(
+            response,
+            pickings=self.picking1,
+        )
+        # prepare 2nd picking
+        self._fill_stock_for_moves(self.picking2.move_ids)
+        self.picking2.action_assign()
+        response = self.service.dispatch("list_stock_picking", params={})
+        # all pickings available
+        self.assert_response_manual_selection(
+            response,
+            pickings=self.picking1 + self.picking2,
+        )

odoo/addons/shopfloor/tests/test_delivery_reset_qty_done_line.py

@@ -0,0 +1,119 @@
+# Copyright 2020 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from .test_delivery_base import DeliveryCommonCase
+
+# pylint: disable=missing-return
+
+
+class DeliveryResetQtyDoneLineCase(DeliveryCommonCase):
+    """Tests for /reset_qty_done_line"""
+
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking = picking = cls._create_picking(
+            lines=[
+                # we'll put A and B in a single package
+                (cls.product_a, 10),
+                (cls.product_b, 10),
+                # C as raw product
+                (cls.product_c, 10),
+            ]
+        )
+        cls.pack1_moves = picking.move_ids[:2]
+        cls.raw_move = picking.move_ids[2]
+        cls._fill_stock_for_moves(cls.pack1_moves, in_package=True)
+        cls._fill_stock_for_moves(cls.raw_move)
+        picking.action_assign()
+        # Some records not related at all to the processed picking
+        cls.free_picking = cls._create_picking(lines=[(cls.product_d, 10)])
+        cls.free_raw_move = cls.free_picking.move_ids[0]
+        cls._fill_stock_for_moves(cls.free_raw_move)
+        cls.free_picking.action_assign()
+
+    def test_reset_qty_done_line_picking_not_found(self):
+        move_lines = self.pack1_moves.mapped("move_line_ids")
+        response = self.service.dispatch(
+            "reset_qty_done_line",
+            params={"move_line_id": move_lines[0].id, "picking_id": -1},
+        )
+        self.assert_response_deliver(
+            response, message=self.service.msg_store.stock_picking_not_found()
+        )
+
+    def test_reset_qty_done_line_line_not_found(self):
+        response = self.service.dispatch(
+            "reset_qty_done_line",
+            params={"move_line_id": -1, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(
+            response,
+            picking=self.picking,
+            message=self.service.msg_store.record_not_found(),
+        )
+
+    def test_reset_qty_done_line_line_not_available_in_picking(self):
+        move_line = self.free_raw_move.mapped("move_line_ids")
+        response = self.service.dispatch(
+            "reset_qty_done_line",
+            params={"move_line_id": move_line.id, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(
+            response,
+            picking=self.picking,
+            message=self.service.msg_store.line_not_available_in_picking(self.picking),
+        )
+
+    def test_reset_qty_done_line_ok(self):
+        move_line = self.raw_move.mapped("move_line_ids")
+        # Set qty done on a line
+        self.service.dispatch(
+            "set_qty_done_line",
+            params={"move_line_id": move_line.id, "picking_id": self.picking.id},
+        )
+        self.assertTrue(move_line.qty_done == move_line.reserved_uom_qty)
+        # Reset it, no related move lines are "done"
+        response = self.service.dispatch(
+            "reset_qty_done_line",
+            params={"move_line_id": move_line.id, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(response, picking=self.picking)
+        self.assertFalse(move_line.qty_done)
+
+    def test_reset_qty_done_line_with_package(self):
+        move_line = self.pack1_moves[0].mapped("move_line_ids")
+        response = self.service.dispatch(
+            "set_qty_done_line",
+            params={"move_line_id": move_line.id, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(
+            response,
+            picking=self.picking,
+            message=self.service.msg_store.line_has_package_scan_package(),
+        )
+
+    def test_reset_qty_done_pack_picking_status(self):
+        move_lines = self.picking.move_line_ids
+        raw_move_line = self.raw_move.mapped("move_line_ids")
+        # Set qty done for all lines (some are linked to packages here),
+        # picking is automatically set to done
+        for package in move_lines.mapped("package_id"):
+            self.service.dispatch(
+                "set_qty_done_pack",
+                params={"package_id": package.id, "picking_id": self.picking.id},
+            )
+        self.service.dispatch(
+            "set_qty_done_line",
+            params={"move_line_id": raw_move_line.id, "picking_id": self.picking.id},
+        )
+        self.assertEqual(self.picking.state, "done")
+        # Try to reset one of them => picking already processed
+        response = self.service.dispatch(
+            "reset_qty_done_line",
+            params={"move_line_id": raw_move_line.id, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(
+            response, message=self.service.msg_store.already_done()
+        )
+        self.assertEqual(self.picking.state, "done")

odoo/addons/shopfloor/tests/test_delivery_reset_qty_done_pack.py

@@ -0,0 +1,107 @@
+# Copyright 2020 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from .test_delivery_base import DeliveryCommonCase
+
+# pylint: disable=missing-return
+
+
+class DeliveryResetQtyDonePackCase(DeliveryCommonCase):
+    """Tests for /reset_qty_done_pack"""
+
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking = picking = cls._create_picking(
+            lines=[
+                # we'll put A and B in a single package
+                (cls.product_a, 10),
+                (cls.product_b, 10),
+                # C alone in a package
+                (cls.product_c, 10),
+            ]
+        )
+        cls.pack1_moves = picking.move_ids[:2]
+        cls.pack2_move = picking.move_ids[2]
+        cls._fill_stock_for_moves(cls.pack1_moves, in_package=True)
+        cls._fill_stock_for_moves(cls.pack2_move, in_package=True)
+        picking.action_assign()
+        # Some records not related at all to the processed picking
+        cls.free_package = cls.env["stock.quant.package"].create(
+            {"name": "FREE_PACKAGE"}
+        )
+
+    def test_reset_qty_done_pack_picking_not_found(self):
+        move_lines = self.pack1_moves.mapped("move_line_ids")
+        package = move_lines.mapped("package_id")
+        response = self.service.dispatch(
+            "reset_qty_done_pack", params={"package_id": package.id, "picking_id": -1}
+        )
+        self.assert_response_deliver(
+            response, message=self.service.msg_store.stock_picking_not_found()
+        )
+
+    def test_reset_qty_done_pack_package_not_found(self):
+        response = self.service.dispatch(
+            "reset_qty_done_pack",
+            params={"package_id": -1, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(
+            response,
+            picking=self.picking,
+            message=self.service.msg_store.package_not_found(),
+        )
+
+    def test_reset_qty_done_pack_package_not_available_in_picking(self):
+        response = self.service.dispatch(
+            "reset_qty_done_pack",
+            params={"package_id": self.free_package.id, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(
+            response,
+            picking=self.picking,
+            message=self.service.msg_store.package_not_available_in_picking(
+                self.free_package, self.picking
+            ),
+        )
+
+    def test_reset_qty_done_pack_ok(self):
+        move_lines = self.pack1_moves.mapped("move_line_ids")
+        package = move_lines.mapped("package_id")
+        # Set qty done on a package, related move lines are "done"
+        self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": package.id, "picking_id": self.picking.id},
+        )
+        self.assertTrue(all(ml.qty_done == ml.reserved_uom_qty for ml in move_lines))
+        # Reset it, no related move lines are "done"
+        response = self.service.dispatch(
+            "reset_qty_done_pack",
+            params={"package_id": package.id, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(response, picking=self.picking)
+        self.assertFalse(any(ml.qty_done > 0 for ml in move_lines))
+
+    def test_reset_qty_done_pack_picking_status(self):
+        package1 = self.pack1_moves.mapped("move_line_ids").mapped("package_id")
+        package2 = self.pack2_move.mapped("move_line_ids").mapped("package_id")
+        # Set qty done for all lines (all linked to packages here), picking is
+        # automatically set to done
+        self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": package1.id, "picking_id": self.picking.id},
+        )
+        self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": package2.id, "picking_id": self.picking.id},
+        )
+        self.assertEqual(self.picking.state, "done")
+        # Try to reset one of them => picking already processed
+        response = self.service.dispatch(
+            "reset_qty_done_pack",
+            params={"package_id": package1.id, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(
+            response, message=self.service.msg_store.already_done()
+        )
+        self.assertEqual(self.picking.state, "done")