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

odoo/addons/shopfloor/tests/test_delivery_set_qty_done_pack.py

@@ -0,0 +1,135 @@
+# 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 DeliverySetQtyDonePackCase(DeliveryCommonCase):
+    """Tests for /set_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),
+                # D in two different packages
+                (cls.product_d, 10),
+            ]
+        )
+        cls.pack1_moves = picking.move_ids[:2]
+        cls.pack2_move = picking.move_ids[2]
+        cls.pack3_move = picking.move_ids[3]
+        cls._fill_stock_for_moves(cls.pack1_moves, in_package=True)
+        cls._fill_stock_for_moves(cls.pack2_move, in_package=True)
+        # Fill stock for D moves (two packages)
+        for __ in range(2):
+            product_d_pkg = cls.env["stock.quant.package"].create({})
+            cls._update_qty_in_location(
+                cls.pack3_move.location_id,
+                cls.pack3_move.product_id,
+                5,
+                package=product_d_pkg,
+            )
+        picking.action_assign()
+
+    def _test_set_qty_done_pack_ok(self, move_lines, package, qties=None):
+        response = self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": package.id, "picking_id": self.picking.id},
+        )
+        self.assert_qty_done(move_lines, qties=qties)
+        self.assert_response_deliver(response, picking=self.picking)
+
+    def test_set_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(
+            "set_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_set_qty_done_pack_picking_canceled(self):
+        move_lines = self.pack1_moves.mapped("move_line_ids")
+        package = move_lines.mapped("package_id")
+        self.picking.action_cancel()
+        response = self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": package.id, "picking_id": self.picking.id},
+        )
+        self.assert_response_deliver(
+            response,
+            message=self.service.msg_store.stock_picking_not_available(self.picking),
+        )
+
+    def test_set_qty_done_pack_package_not_found(self):
+        response = self.service.dispatch(
+            "set_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_set_qty_done_pack_multiple_product_ok(self):
+        move_lines = self.pack1_moves.mapped("move_line_ids")
+        package = move_lines.mapped("package_id")
+        self._test_set_qty_done_pack_ok(move_lines, package)
+
+    def test_set_qty_done_pack_one_product_ok(self):
+        move_lines = self.pack2_move.mapped("move_line_ids")
+        package = move_lines.mapped("package_id")
+        self._test_set_qty_done_pack_ok(move_lines, package)
+
+    def test_set_qty_done_pack_product_in_multiple_packages_ok(self):
+        move_lines = self.pack3_move.mapped("move_line_ids")
+        first_package = move_lines.mapped("package_id")[0]
+        self._test_set_qty_done_pack_ok(
+            move_lines,
+            # first_package done, not the second
+            first_package,
+            qties=[5, 0],
+        )
+
+    def test_set_qty_done_pack_picking_done(self):
+        pack1_move_lines = self.pack1_moves.mapped("move_line_ids")
+        package1 = pack1_move_lines.mapped("package_id")
+        pack2_move_lines = self.pack2_move.mapped("move_line_ids")
+        package2 = pack2_move_lines.mapped("package_id")
+        pack3_move_lines = self.pack3_move.mapped("move_line_ids")
+        packages3 = pack3_move_lines.mapped("package_id")
+        # process first package
+        self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": package1.id, "picking_id": self.picking.id},
+        )
+        self.assertEqual(self.picking.state, "assigned")
+        # process second package
+        self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": package2.id, "picking_id": self.picking.id},
+        )
+        self.assertEqual(self.picking.state, "assigned")
+        # process third package
+        self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": packages3[0].id, "picking_id": self.picking.id},
+        )
+        self.assertEqual(self.picking.state, "assigned")
+        # process last package
+        self.service.dispatch(
+            "set_qty_done_pack",
+            params={"package_id": packages3[1].id, "picking_id": self.picking.id},
+        )
+        # picking is done once all its moves have been processed
+        self.assertEqual(self.picking.state, "done")

odoo/addons/shopfloor/tests/test_delivery_sublocation.py

@@ -0,0 +1,180 @@
+# Copyright 2022 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from .test_delivery_base import DeliveryCommonCase
+
+# pylint: disable=missing-return
+
+
+class DeliveryScanSublocationCase(DeliveryCommonCase):
+    """Tests sublocation with delivery service."""
+
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.product_e.tracking = "lot"
+        # Picking for the top location
+        cls.picking = picking = cls._create_picking(
+            lines=[
+                (cls.product_d, 10),  # D as raw product
+                (cls.product_e, 10),  # E as raw product with a lot
+            ]
+        )
+        cls.raw_move = picking.move_ids[0]
+        cls.raw_lot_move = picking.move_ids[1]
+        cls._fill_stock_for_moves(cls.raw_move)
+        cls._fill_stock_for_moves(cls.raw_lot_move, in_lot=True)
+        picking.action_assign()
+        cls.lot = cls.raw_lot_move.move_line_ids.lot_id
+        # Create a sublocation
+        cls.sublocation = (
+            cls.env["stock.location"]
+            .sudo()
+            .create(
+                {
+                    "name": "Output 1",
+                    "location_id": cls.picking_type.default_location_src_id.id,
+                    "usage": "internal",
+                    "barcode": "WH-OUTPUT-1",
+                }
+            )
+        )
+        # Picking for the sublocation
+        cls.picking_sublocation = cls._create_picking(
+            lines=[
+                (cls.product_d, 10),  # D as raw product
+                (cls.product_e, 10),  # E as raw product with a lot
+            ],
+            location_id=cls.sublocation,
+        )
+        cls.raw_move_sublocation = cls.picking_sublocation.move_ids[0]
+        cls.raw_lot_move_sublocation = cls.picking_sublocation.move_ids[1]
+        cls._fill_stock_for_moves(cls.raw_move_sublocation, location=cls.sublocation)
+        # Use the same lot on product from both picking
+        cls._fill_stock_for_moves(
+            cls.raw_lot_move_sublocation, in_lot=cls.lot, location=cls.sublocation
+        )
+        cls.picking_sublocation.action_assign()
+
+    def test_scan_sublocation_exists(self):
+        """Check scanning a sublocation sets it as sublocation."""
+        response = self.service.dispatch(
+            "scan_deliver",
+            params={
+                "barcode": self.sublocation.barcode,
+                "picking_id": None,
+                "location_id": None,
+            },
+        )
+        self.assert_response_deliver(
+            response,
+            picking=None,
+            location=self.sublocation,
+            message=self.service.msg_store.location_src_set_to_sublocation(
+                self.sublocation
+            ),
+        )
+
+    def test_scan_invalid_barcode_in_sublocation(self):
+        response = self.service.dispatch(
+            "scan_deliver",
+            params={
+                "barcode": "NO VALID BARCODE",
+                "picking_id": None,
+                "location_id": self.sublocation.id,
+            },
+        )
+        self.assert_response_deliver(
+            response,
+            location=self.sublocation,
+            message=self.service.msg_store.barcode_not_found(),
+        )
+
+    def test_scan_barcode_in_sublocation(self):
+        """Scan product barcode that exists in sublocation."""
+
+        response = self.service.dispatch(
+            "scan_deliver",
+            params={
+                "barcode": self.product_d.barcode,
+                "location_id": self.sublocation.id,
+            },
+        )
+        self.assert_response_deliver(
+            response,
+            location=self.sublocation,
+            picking=self.picking_sublocation,
+        )
+
+    def test_scan_product_not_in_sublocation(self):
+        """Scan a product in picking type location but not in sublocation set."""
+        response = self.service.dispatch(
+            "scan_deliver",
+            params={
+                "barcode": self.product_c.barcode,
+                "picking_id": None,
+                "location_id": self.sublocation.id,
+            },
+        )
+        self.assert_response_deliver(
+            response,
+            location=self.sublocation,
+            message=self.service.msg_store.product_not_found_in_pickings(),
+        )
+
+    def test_scan_product_exist_in_multiple_sublocation(self):
+        """Check scan of product in multiple location will ask to scan a location."""
+        response = self.service.dispatch(
+            "scan_deliver",
+            params={
+                "barcode": self.product_d.barcode,
+                "picking_id": None,
+            },
+        )
+        self.assert_response_deliver(
+            response,
+            message=self.service.msg_store.product_in_multiple_sublocation(
+                self.product_d
+            ),
+        )
+
+    def test_list_stock_picking_sublocation(self):
+        """Check manual selection filter picking in sublocation."""
+        response = self.service.dispatch(
+            "list_stock_picking", params={"location_id": self.sublocation.id}
+        )
+        self.assert_response_manual_selection(
+            response,
+            pickings=self.picking_sublocation,
+        )
+
+    def test_scan_lot_in_sublocation(self):
+        """Scan a lot that exists in sublocation."""
+        lot = self.raw_lot_move_sublocation.move_line_ids.lot_id
+        response = self.service.dispatch(
+            "scan_deliver",
+            params={
+                "barcode": lot.name,
+                "picking_id": None,
+                "location_id": self.sublocation.id,
+            },
+        )
+        self.assert_response_deliver(
+            response,
+            location=self.sublocation,
+            picking=self.picking_sublocation,
+        )
+
+    def test_scan_lot_exist_in_multiple_sublocation(self):
+        """Check scanning lot in multiple location, will ask location scan first."""
+        response = self.service.dispatch(
+            "scan_deliver",
+            params={
+                "barcode": self.lot.name,
+                "picking_id": None,
+            },
+        )
+        self.assert_response_deliver(
+            response,
+            message=self.service.msg_store.lot_in_multiple_sublocation(self.lot),
+        )

odoo/addons/shopfloor/tests/test_location_content_transfer_base.py

@@ -0,0 +1,136 @@
+# 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 LocationContentTransferCommonCase(CommonCase):
+    @classmethod
+    def setUpClassVars(cls, *args, **kwargs):
+        super().setUpClassVars(*args, **kwargs)
+        cls.menu = cls.env.ref(
+            "shopfloor.shopfloor_menu_demo_location_content_transfer"
+        )
+        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.content_loc = (
+            cls.env["stock.location"]
+            .sudo()
+            .create(
+                {
+                    "name": "Content Location",
+                    "barcode": "Content",
+                    "location_id": cls.picking_type.default_location_src_id.id,
+                }
+            )
+        )
+
+    def setUp(self):
+        super().setUp()
+        self.service = self.get_service(
+            "location_content_transfer", menu=self.menu, profile=self.profile
+        )
+        self.stock_action = self.service._actions_for("stock")
+
+    def _simulate_selected_move_line(self, move_line):
+        """Mark the move line as picked (as it's done into the scan_location method)"""
+        self.stock_action.mark_move_line_as_picked(move_line)
+
+    @classmethod
+    def _simulate_pickings_selected(cls, pickings):
+        """Create a state as if pickings has been selected
+
+        ... during a Location content transfer.
+
+        It means a user scanned the location with the pickings. They are:
+
+        * assigned to the user
+        * the qty_done of all their move lines is set to they reserved qty
+
+        """
+        pickings.user_id = cls.env.uid
+        for line in pickings.mapped("move_line_ids"):
+            line.qty_done = line.reserved_uom_qty
+
+    def assert_response_start(self, response, message=None, popup=None):
+        self.assert_response(
+            response, next_state="scan_location", message=message, popup=popup
+        )
+
+    def _assert_response_scan_destination_all(
+        self, state, response, pickings, message=None, confirmation_required=False
+    ):
+        # this code is repeated from the implementation, not great, but we
+        # mostly want to ensure the selection of pickings is right, and the
+        # data methods have their own tests
+        move_lines = pickings.move_line_ids
+        lines = move_lines.filtered(lambda line: not line.package_level_id)
+        package_levels = pickings.package_level_ids
+        location = move_lines.location_id
+        self.assert_response(
+            response,
+            next_state=state,
+            data={
+                "move_lines": self.data.move_lines(lines),
+                "package_levels": self.data.package_levels(package_levels),
+                "location": self.data.location(location),
+                "confirmation_required": confirmation_required,
+            },
+            message=message,
+        )
+
+    def assert_response_scan_destination_all(
+        self, response, pickings, message=None, confirmation_required=False
+    ):
+        self._assert_response_scan_destination_all(
+            "scan_destination_all",
+            response,
+            pickings,
+            message=message,
+            confirmation_required=confirmation_required,
+        )
+
+    def assert_response_start_single(
+        self, response, pickings, message=None, popup=None
+    ):
+        sorter = self.service._actions_for("location_content_transfer.sorter")
+        sorter.feed_pickings(pickings)
+        location = pickings.mapped("location_id")
+        self.assert_response(
+            response,
+            next_state="start_single",
+            data=self.service._data_content_line_for_location(location, next(sorter)),
+            message=message,
+            popup=popup,
+        )
+
+    def _assert_response_scan_destination(
+        self, state, response, next_content, message=None, confirmation_required=False
+    ):
+        location = next_content.location_id
+        data = self.service._data_content_line_for_location(location, next_content)
+        data["confirmation_required"] = confirmation_required
+        self.assert_response(
+            response,
+            next_state=state,
+            data=data,
+            message=message,
+        )
+
+    def assert_response_scan_destination(
+        self, response, next_content, message=None, confirmation_required=False
+    ):
+        self._assert_response_scan_destination(
+            "scan_destination",
+            response,
+            next_content,
+            message=message,
+            confirmation_required=confirmation_required,
+        )

odoo/addons/shopfloor/tests/test_location_content_transfer_get_work.py

@@ -0,0 +1,125 @@
+# Copyright 2022 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html)
+
+from .test_location_content_transfer_base import LocationContentTransferCommonCase
+
+# pylint: disable=missing-return
+
+
+class TestLocationContentTransferGetWork(LocationContentTransferCommonCase):
+    """Tests for getting work
+
+    Endpoints:
+
+    * /find_work
+    * /cancel_work
+    """
+
+    @classmethod
+    def setUpClassBaseData(cls):
+        super().setUpClassBaseData()
+        cls.menu.sudo().allow_get_work = True
+        cls.pickings = cls.env["stock.picking"].search(
+            [("location_id", "=", cls.stock_location.id)]
+        )
+        cls.move_lines = cls.pickings.move_line_ids.filtered(
+            lambda line: line.qty_done == 0
+            and line.state in ("assigned", "partially_available")
+            and not line.shopfloor_user_id
+        )
+        products = cls.product_a + cls.product_b + cls.product_c + cls.product_d
+        for product in products:
+            cls.env["stock.putaway.rule"].sudo().create(
+                {
+                    "product_id": product.id,
+                    "location_in_id": cls.stock_location.id,
+                    "location_out_id": cls.shelf1.id,
+                }
+            )
+
+        cls.picking1 = picking1 = cls._create_picking(
+            lines=[(cls.product_a, 10), (cls.product_b, 10)]
+        )
+        cls.picking2 = picking2 = cls._create_picking(
+            lines=[(cls.product_c, 10), (cls.product_d, 10)]
+        )
+        cls.pickings = picking1 | picking2
+        cls.content_loc2 = (
+            cls.env["stock.location"]
+            .sudo()
+            .create(
+                {
+                    "name": "Content Location 2",
+                    "barcode": "Content2",
+                    "location_id": cls.picking_type.default_location_src_id.id,
+                }
+            )
+        )
+        cls._fill_stock_for_moves(
+            picking1.move_ids, in_package=True, location=cls.content_loc
+        )
+        cls._fill_stock_for_moves(picking2.move_ids[0], location=cls.content_loc2)
+        cls._fill_stock_for_moves(picking2.move_ids[1], location=cls.content_loc)
+        cls.pickings.action_assign()
+
+    def _get_location_lines(self, location):
+        return self.env["stock.move.line"].search([("location_id", "=", location.id)])
+
+    def test_get_work(self):
+        """Check the first state is get_work when the option is enabled."""
+        response = self.service.dispatch("start_or_recover", params={})
+        self.assert_response(
+            response,
+            next_state="get_work",
+            data={},
+        )
+
+    def test_find_work_no_work_found(self):
+        """Check the user asked for work but none is found."""
+        # Cancel all moves related to the location we work from
+        self.pickings.move_ids.filtered(lambda r: r.state != "done")._action_cancel()
+        response = self.service.dispatch("find_work", params={})
+        self.assert_response(
+            response,
+            next_state="get_work",
+            data={},
+            message=self.service.msg_store.no_work_found(),
+        )
+
+    def test_find_work_work_found(self):
+        """Check the user is offered a location to work from."""
+        next_location = self.service._find_location_to_work_from()
+        response = self.service.dispatch("find_work", params={})
+        self.assert_response(
+            response,
+            next_state="scan_location",
+            data={
+                "location": self.data.location(next_location),
+            },
+        )
+        lines = self._get_location_lines(next_location)
+        self.assertEqual(lines.shopfloor_user_id, self.env.user)
+        # Confirm the location
+        response = self.service.dispatch(
+            "scan_location", params={"barcode": next_location.name}
+        )
+        self.assertEqual(response["next_state"], "scan_destination_all")
+
+    def test_cancel_work(self):
+        next_location = self.service._find_location_to_work_from()
+        stock = self.service._actions_for("stock")
+        location_lines = self._get_location_lines(next_location)
+        stock.mark_move_line_as_picked(location_lines, quantity=0)
+        location_lines = self._get_location_lines(next_location)
+        self.assertEqual(location_lines.shopfloor_user_id, self.env.user)
+        response = self.service.dispatch(
+            "cancel_work", params={"location_id": next_location.id}
+        )
+        self.assert_response(
+            response,
+            next_state="get_work",
+            data={},
+            message={},
+        )
+        lines = self._get_location_lines(next_location)
+        self.assertFalse(lines.shopfloor_user_id)