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

odoo/addons/shopfloor/tests/test_checkout_select_line.py

@@ -0,0 +1,130 @@
+# 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
+from .test_checkout_select_package_base import CheckoutSelectPackageMixin
+
+
+# pylint: disable=missing-return
+class CheckoutSelectLineCase(CheckoutCommonCase, CheckoutSelectPackageMixin):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        picking = cls._create_picking(
+            lines=[(cls.product_a, 10), (cls.product_b, 10), (cls.product_c, 10)]
+        )
+        cls.moves_pack = picking.move_ids[:2]
+        cls.move_single = picking.move_ids[2:]
+        cls._fill_stock_for_moves(cls.moves_pack, in_package=True)
+        cls._fill_stock_for_moves(cls.move_single)
+        picking.action_assign()
+        cls.picking = picking
+
+    def test_select_line_package_ok(self):
+        selected_lines = self.moves_pack.move_line_ids
+        # we want to check that when we give the package id, we get
+        # all its move lines
+        response = self.service.dispatch(
+            "select_line",
+            params={
+                "picking_id": self.picking.id,
+                "package_id": selected_lines.package_id.id,
+            },
+        )
+        self._assert_selected(response, selected_lines)
+
+    def test_select_line_no_package_disabled(self):
+        selected_lines = self.moves_pack.move_line_ids
+        self.service.work.options = {"checkout__disable_no_package": True}
+        response = self.service.dispatch(
+            "select_line",
+            params={
+                "picking_id": self.picking.id,
+                "package_id": selected_lines.package_id.id,
+            },
+        )
+        self._assert_selected(response, selected_lines, no_package_enabled=False)
+
+    def test_select_line_move_line_package_ok(self):
+        selected_lines = self.moves_pack.move_line_ids
+        # When we select a single line but the line is part of a package,
+        # we select all the lines. Note: not really supposed to happen as
+        # the client application should use send a package id when there is
+        # a package and use the move line id only for lines without package
+        response = self.service.dispatch(
+            "select_line",
+            params={
+                "picking_id": self.picking.id,
+                "move_line_id": selected_lines[0].id,
+            },
+        )
+        self._assert_selected(response, selected_lines)
+
+    def test_select_line_move_line_ok(self):
+        selected_lines = self.move_single.move_line_ids
+        response = self.service.dispatch(
+            "select_line",
+            params={
+                "picking_id": self.picking.id,
+                "move_line_id": selected_lines[0].id,
+            },
+        )
+        self._assert_selected(response, selected_lines)
+
+    def _test_select_line_error(self, params, message):
+        """Test errors for /select_line
+
+        :param params: params sent to /select_line
+        :param message: the dict of expected error message
+        """
+        response = self.service.dispatch("select_line", params=params)
+        self.assert_response(
+            response,
+            next_state="select_line",
+            data=self._data_for_select_line(self.picking),
+            message=message,
+        )
+
+    def test_select_line_package_error_not_found(self):
+        selected_lines = self.move_single.move_line_ids
+        selected_lines.unlink()
+        self._test_select_line_error(
+            {"picking_id": self.picking.id, "package_id": selected_lines[0].id},
+            {
+                "message_type": "error",
+                "body": "The record you were working on does not exist anymore.",
+            },
+        )
+
+    def test_select_line_move_line_error_not_found(self):
+        selected_lines = self.move_single.move_line_ids
+        selected_lines.unlink()
+        self._test_select_line_error(
+            {"picking_id": self.picking.id, "move_line_id": selected_lines[0].id},
+            {
+                "message_type": "error",
+                "body": "The record you were working on does not exist anymore.",
+            },
+        )
+
+    def test_select_line_all_lines_done(self):
+        # set all lines as done
+        self.picking.move_line_ids.write(
+            {"qty_done": 10.0, "shopfloor_checkout_done": True}
+        )
+        response = self.service.dispatch(
+            "select_line",
+            params={
+                "picking_id": self.picking.id,
+                # doesn't matter as all lines are done, we should be
+                # redirected to the summary
+                "package_id": self.picking.move_line_ids[0].package_id.id,
+            },
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": True,
+            },
+        )

odoo/addons/shopfloor/tests/test_checkout_select_package_base.py

@@ -0,0 +1,64 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+
+class CheckoutSelectPackageMixin:
+    def _assert_selected_response(
+        self,
+        response,
+        selected_lines,
+        message=None,
+        packing_info="",
+        no_package_enabled=True,
+    ):
+        picking = selected_lines.mapped("picking_id")
+        self.assert_response(
+            response,
+            next_state="select_package",
+            data={
+                "selected_move_lines": [
+                    self._move_line_data(ml) for ml in selected_lines.sorted()
+                ],
+                "picking": self._picking_summary_data(picking),
+                "packing_info": packing_info,
+                "no_package_enabled": no_package_enabled,
+            },
+            message=message,
+        )
+
+    def _assert_selected_qties(
+        self,
+        response,
+        selected_lines,
+        lines_quantities,
+        message=None,
+        packing_info="",
+    ):
+        picking = selected_lines.mapped("picking_id")
+        deselected_lines = picking.move_line_ids - selected_lines
+        self.assertEqual(
+            sorted(selected_lines.ids), sorted([line.id for line in lines_quantities])
+        )
+        for line, quantity in lines_quantities.items():
+            self.assertEqual(line.qty_done, quantity)
+        for line in deselected_lines:
+            self.assertEqual(line.qty_done, 0, "Lines deselected must have no qty done")
+        self._assert_selected_response(
+            response, selected_lines, message=message, packing_info=packing_info
+        )
+
+    def _assert_selected(
+        self, response, selected_lines, related_lines=None, message=None, **kw
+    ):
+        related_lines = related_lines or self.env["stock.move.line"]
+        picking = selected_lines.mapped("picking_id")
+        unselected_lines = picking.move_line_ids - selected_lines
+        for line in selected_lines - related_lines:
+            self.assertEqual(
+                line.qty_done,
+                line.reserved_uom_qty,
+                "Scanned lines must have their qty done set to the reserved quantity",
+            )
+        for line in unselected_lines + related_lines:
+            self.assertEqual(line.qty_done, 0)
+        self._assert_selected_response(response, selected_lines, message=message, **kw)

odoo/addons/shopfloor/tests/test_checkout_set_qty.py

@@ -0,0 +1,257 @@
+# 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
+from .test_checkout_select_package_base import CheckoutSelectPackageMixin
+
+# pylint: disable=missing-return
+
+
+class CheckoutSetQtyCommonCase(CheckoutCommonCase, CheckoutSelectPackageMixin):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        picking = cls._create_picking(
+            lines=[(cls.product_a, 10), (cls.product_b, 10), (cls.product_c, 10)]
+        )
+        cls.moves_pack1 = picking.move_ids[:2]
+        cls.moves_pack2 = picking.move_ids[2:]
+        cls._fill_stock_for_moves(cls.moves_pack1, in_package=True)
+        cls._fill_stock_for_moves(cls.moves_pack2, in_package=True)
+        picking.action_assign()
+        cls.picking = picking
+
+    def setUp(self):
+        super().setUp()
+        # we assume we have called /select_line on pack one, so by default, we
+        # expect the lines for product a and b to have their qty_done set to
+        # their reserved_uom_qty at the start of the tests
+        self.selected_lines = self.moves_pack1.move_line_ids
+        self.deselected_lines = self.moves_pack2.move_line_ids
+        self.service._select_lines(self.selected_lines)
+        self.assertTrue(
+            all(line.qty_done == line.reserved_uom_qty for line in self.selected_lines)
+        )
+        self.assertTrue(all(line.qty_done == 0 for line in self.deselected_lines))
+
+
+class CheckoutResetLineQtyCase(CheckoutSetQtyCommonCase):
+    def test_reset_line_qty_ok(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        line_to_reset = selected_lines[0]
+        line_with_qty = selected_lines[1]
+        # we want to check that when we give the package id, we get
+        # all its move lines
+        response = self.service.dispatch(
+            "reset_line_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": line_to_reset.id,
+            },
+        )
+        self._assert_selected_qties(
+            response,
+            selected_lines,
+            {line_to_reset: 0, line_with_qty: line_with_qty.reserved_uom_qty},
+        )
+
+    def test_reset_line_qty_not_found(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        response = self.service.dispatch(
+            "reset_line_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": 0,
+            },
+        )
+        # if the move line is not found, ignore and return to the
+        # screen
+        self._assert_selected_qties(
+            response,
+            selected_lines,
+            {line: line.reserved_uom_qty for line in selected_lines},
+            message={
+                "body": "The record you were working on does not exist anymore.",
+                "message_type": "error",
+            },
+        )
+
+
+class CheckoutSetLineQtyCase(CheckoutSetQtyCommonCase):
+    def test_set_line_qty_ok(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        # do as if the user removed the qties of the 2 selected lines
+        selected_lines.qty_done = 0
+        line_to_set = selected_lines[0]
+        line_no_qty = selected_lines[1]
+        # we want to check that when we give the package id, we get
+        # all its move lines
+        response = self.service.dispatch(
+            "set_line_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": line_to_set.id,
+            },
+        )
+        self.assertEqual(line_to_set.qty_done, line_to_set.reserved_uom_qty)
+        self.assertEqual(line_no_qty.qty_done, 0)
+        self._assert_selected_qties(
+            response,
+            selected_lines,
+            {line_to_set: line_to_set.reserved_uom_qty, line_no_qty: 0},
+        )
+
+    def test_set_line_qty_not_found(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        response = self.service.dispatch(
+            "set_line_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": 0,
+            },
+        )
+        # if the move line is not found, ignore and return to the
+        # screen
+        self._assert_selected_qties(
+            response,
+            selected_lines,
+            {line: line.reserved_uom_qty for line in selected_lines},
+            message={
+                "body": "The record you were working on does not exist anymore.",
+                "message_type": "error",
+            },
+        )
+
+
+class CheckoutSetCustomQtyCase(CheckoutSetQtyCommonCase):
+    def test_set_custom_qty_ok(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        line_to_change = selected_lines[0]
+        line_keep_qty = selected_lines[1]
+        # Process full qty
+        new_qty = line_to_change.reserved_uom_qty
+        # we want to check that when we give the package id, we get
+        # all its move lines
+        response = self.service.dispatch(
+            "set_custom_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": line_to_change.id,
+                "qty_done": new_qty,
+            },
+        )
+        self.assertEqual(line_to_change.qty_done, new_qty)
+        self.assertEqual(line_keep_qty.qty_done, line_keep_qty.reserved_uom_qty)
+        self._assert_selected_qties(
+            response,
+            selected_lines,
+            {line_to_change: new_qty, line_keep_qty: line_keep_qty.reserved_uom_qty},
+        )
+
+    def test_set_custom_qty_not_found(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        response = self.service.dispatch(
+            "set_custom_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": 0,
+                "qty_done": 3,
+            },
+        )
+        # if the move line is not found, ignore and return to the
+        # screen
+        self._assert_selected_qties(
+            response,
+            selected_lines,
+            {line: line.reserved_uom_qty for line in selected_lines},
+            message={
+                "body": "The record you were working on does not exist anymore.",
+                "message_type": "error",
+            },
+        )
+
+    def test_set_custom_qty_above(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        line1 = selected_lines[0]
+        # modify so we can check that a too high quantity set the max
+        line1.qty_done = 1
+        line2 = selected_lines[1]
+        response = self.service.dispatch(
+            "set_custom_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": line1.id,
+                "qty_done": line1.reserved_uom_qty + 1,
+            },
+        )
+        self._assert_selected_qties(
+            response,
+            selected_lines,
+            {line1: line1.reserved_uom_qty + 1, line2: line2.reserved_uom_qty},
+            message={
+                "body": "Please note that the scanned quantity "
+                "is higher than the maximum allowed.",
+                "message_type": "warning",
+            },
+        )
+
+    def test_set_custom_qty_negative(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        line1 = selected_lines[0]
+        line2 = selected_lines[1]
+        response = self.service.dispatch(
+            "set_custom_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": line1.id,
+                "qty_done": -1,
+            },
+        )
+        self._assert_selected_qties(
+            response,
+            selected_lines,
+            {line1: line1.reserved_uom_qty, line2: line2.reserved_uom_qty},
+            message={
+                "body": "Negative quantity not allowed.",
+                "message_type": "error",
+            },
+        )
+
+    def test_set_custom_qty_partial(self):
+        selected_lines = self.moves_pack1.move_line_ids
+        line_to_change = selected_lines[0]
+        line_keep_qty = selected_lines[1]
+        # split 1 qty
+        new_qty = line_to_change.reserved_uom_qty - 1
+        response = self.service.dispatch(
+            "set_custom_qty",
+            params={
+                "picking_id": self.picking.id,
+                "selected_line_ids": selected_lines.ids,
+                "move_line_id": line_to_change.id,
+                "qty_done": new_qty,
+            },
+        )
+        self.assertEqual(line_to_change.qty_done, new_qty)
+        self.assertEqual(line_keep_qty.qty_done, line_keep_qty.reserved_uom_qty)
+        new_lines = [
+            x for x in self.moves_pack1.move_line_ids if x not in selected_lines
+        ]
+        # Lines are not being split anymore
+        self.assertFalse(new_lines)
+        self._assert_selected_qties(
+            response,
+            self.moves_pack1.move_line_ids,
+            {
+                line_to_change: new_qty,
+                line_keep_qty: line_keep_qty.reserved_uom_qty,
+            },
+        )

odoo/addons/shopfloor/tests/test_checkout_summary.py

@@ -0,0 +1,69 @@
+# 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 CheckoutSummaryCase(CheckoutCommonCase):
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.picking = cls._create_picking(
+            lines=[
+                (cls.product_a, 10),
+                (cls.product_b, 10),
+                (cls.product_c, 10),
+                (cls.product_d, 10),
+            ]
+        )
+
+    def test_summary_picking_not_ready(self):
+        response = self.service.dispatch(
+            "summary", params={"picking_id": self.picking.id}
+        )
+        self.assert_response(
+            response,
+            next_state="select_document",
+            data={},
+            message=self.service.msg_store.stock_picking_not_available(self.picking),
+        )
+
+    def test_summary_not_fully_processed(self):
+        self._fill_stock_for_moves(self.picking.move_ids, in_package=True)
+        self.picking.action_assign()
+        # satisfy only few lines
+        for ml in self.picking.move_line_ids[:2]:
+            ml.qty_done = ml.reserved_uom_qty
+            ml.shopfloor_checkout_done = True
+        response = self.service.dispatch(
+            "summary", params={"picking_id": self.picking.id}
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": False,
+            },
+        )
+
+    def test_summary_fully_processed(self):
+        self._fill_stock_for_moves(self.picking.move_ids, in_package=True)
+        self.picking.action_assign()
+        # satisfy only all lines
+        for ml in self.picking.move_line_ids:
+            ml.qty_done = ml.reserved_uom_qty
+            ml.shopfloor_checkout_done = True
+        response = self.service.dispatch(
+            "summary", params={"picking_id": self.picking.id}
+        )
+        self.assert_response(
+            response,
+            next_state="summary",
+            data={
+                "picking": self._stock_picking_data(self.picking, done=True),
+                "all_processed": True,
+            },
+        )

odoo/addons/shopfloor/tests/test_cluster_picking_base.py

@@ -0,0 +1,83 @@
+# 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, PickingBatchMixin
+
+# pylint: disable=missing-return
+
+
+class ClusterPickingCommonCase(CommonCase, PickingBatchMixin):
+    @classmethod
+    def setUpClassVars(cls, *args, **kwargs):
+        super().setUpClassVars(*args, **kwargs)
+        cls.menu = cls.env.ref("shopfloor.shopfloor_menu_demo_cluster_picking")
+        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"
+
+    def setUp(self):
+        super().setUp()
+        self.service = self.get_service(
+            "cluster_picking", menu=self.menu, profile=self.profile
+        )
+
+    def _line_data(self, move_line, qty=None, package_dest=False, qty_done=None, **kw):
+        picking = move_line.picking_id
+        # A package exists on the move line, because the quant created
+        # by ``_simulate_batch_selected`` has a package.
+        data = self.data.move_line(move_line)
+        if not package_dest:
+            data["package_dest"] = None
+        if qty:
+            data["quantity"] = qty
+        if qty_done:
+            data["qty_done"] = qty_done
+        data.update(
+            {
+                "batch": self.data.picking_batch(picking.batch_id),
+                "picking": self.data.picking(picking),
+                "scan_location_or_pack_first": False,
+            }
+        )
+        data.update(kw)
+        return data
+
+    @classmethod
+    def _set_dest_package_and_done(cls, move_lines, dest_package):
+        """Simulate what would have been done in the previous steps"""
+        for line in move_lines:
+            line.write(
+                {
+                    "qty_done": line.reserved_uom_qty,
+                    "result_package_id": dest_package.id,
+                }
+            )
+
+    def _data_for_batch(self, batch, location, pack=None):
+        data = self.data.picking_batch(batch)
+        data["location_dest"] = self.data.location(location)
+        if pack:
+            data["package"] = self.data.package(pack)
+        return data
+
+
+class ClusterPickingLineCommonCase(ClusterPickingCommonCase):
+    @classmethod
+    def setUpClassBaseData(cls, *args, **kwargs):
+        super().setUpClassBaseData(*args, **kwargs)
+        # quants already existing are from demo data
+        cls.env["stock.quant"].sudo().search(
+            [("location_id", "=", cls.stock_location.id)]
+        ).unlink()
+        cls.batch = cls._create_picking_batch(
+            [[cls.BatchProduct(product=cls.product_a, quantity=1)]]
+        )
+
+    def _line_data(self, move_line, qty=1.0, **kw):
+        # just force qty to 1.0
+        return super()._line_data(move_line, qty=qty, **kw)