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

odoo/addons/shopfloor/tests/test_zone_picking_set_line_destination_no_prefill_qty.py

@@ -0,0 +1,146 @@
+# Copyright 2022 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from .test_zone_picking_base import ZonePickingCommonCase
+
+
+# pylint: disable=missing-return
+class ZonePickingSetLineDestinationNoPrefillQtyCase(ZonePickingCommonCase):
+    """Tests for endpoint used from set_line_destination
+
+    With the no prefill quantity option set
+
+    * /set_destination
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.service.work.current_picking_type = self.picking2.picking_type_id
+        self.menu.sudo().no_prefill_qty = True
+
+    def test_set_destination_increment_with_product(self):
+        """Check increment quantity by scanning the product."""
+        picking_type = self.picking2.picking_type_id
+        move_line = self.picking2.move_line_ids[0]
+        # Scan twice the product in a row to increment the quantity
+        for qty_done in range(2):
+            response = self.service.dispatch(
+                "set_destination",
+                params={
+                    "move_line_id": move_line.id,
+                    "barcode": move_line.product_id.barcode,
+                    "quantity": qty_done,
+                },
+            )
+            qty_done += 1
+            # Check response
+            self.assert_response_set_line_destination(
+                response,
+                self.zone_location,
+                picking_type,
+                move_line,
+                qty_done=qty_done,
+            )
+
+    def test_set_destination_increment_with_wrong_package(self):
+        """Check scanning wrong package incremented quantity is not lost."""
+        wrong_package = self.picking1.move_line_ids.package_id
+        picking_type = self.picking2.picking_type_id
+        move_line = self.picking2.move_line_ids[0]
+        # Simulate the product has been scanned twice
+        qty_done = 2
+        response = self.service.dispatch(
+            "set_destination",
+            params={
+                "move_line_id": move_line.id,
+                "barcode": wrong_package.name,
+                "quantity": qty_done,
+            },
+        )
+        # Check response
+        self.assert_response_set_line_destination(
+            response,
+            self.zone_location,
+            picking_type,
+            move_line,
+            qty_done=qty_done,
+            message={
+                "body": "Package {} is not empty.".format(wrong_package.name),
+                "message_type": "warning",
+            },
+        )
+
+    def test_set_destination_increment_with_wrong_product(self):
+        """Check increment quantity by scanning the wrong product."""
+        picking_type = self.picking2.picking_type_id
+        move_line = self.picking2.move_line_ids[0]
+        # Scan twice the product in a row to increment the quantity
+        qty_done = 2
+        response = self.service.dispatch(
+            "set_destination",
+            params={
+                "move_line_id": move_line.id,
+                "barcode": self.product_a.barcode,
+                "quantity": qty_done,
+            },
+        )
+        # Check response
+        self.assert_response_set_line_destination(
+            response,
+            self.zone_location,
+            picking_type,
+            move_line,
+            qty_done=qty_done,
+            message={"body": "The package A doesn't exist", "message_type": "error"},
+        )
+
+    def test_set_destination_increment_with_lot(self):
+        """Check increment quantity by scanning the lot."""
+        picking_type = self.picking2.picking_type_id
+        move_line = self.picking2.move_line_ids.filtered("lot_id")[0]
+        # Scan twice the lot in a row to increment the quantity
+        for qty_done in range(2):
+            response = self.service.dispatch(
+                "set_destination",
+                params={
+                    "move_line_id": move_line.id,
+                    "barcode": move_line.lot_id.name,
+                    "quantity": qty_done,
+                },
+            )
+            qty_done += 1
+            # Check response
+            self.assert_response_set_line_destination(
+                response,
+                self.zone_location,
+                picking_type,
+                move_line,
+                qty_done=qty_done,
+            )
+
+    def test_set_destination_location_zero_quantity(self):
+        """Scanned barcode is the destination location.
+
+        Quantity to move is zero -> error raised, user can try again.
+
+        """
+        zone_location = self.zone_location
+        picking_type = self.picking1.picking_type_id
+        move_line = self.picking1.move_ids.move_line_ids
+        response = self.service.dispatch(
+            "set_destination",
+            params={
+                "move_line_id": move_line.id,
+                "barcode": self.packing_location.barcode,
+                "quantity": 0,
+            },
+        )
+        # Check response
+        self.assert_response_set_line_destination(
+            response,
+            zone_location,
+            picking_type,
+            move_line,
+            message=self.service.msg_store.picking_zero_quantity(),
+            # And that the quantity done is zero
+            qty_done=0,
+        )

odoo/addons/shopfloor/tests/test_zone_picking_set_line_destination_pick_pack.py

@@ -0,0 +1,241 @@
+# 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_zone_picking_base import ZonePickingCommonCase
+
+
+# pylint: disable=missing-return
+class ZonePickingSetLineDestinationPickPackCase(ZonePickingCommonCase):
+    """Tests set_line_destination when `pick_pack_same_time` is one
+
+    * /set_destination
+
+    """
+
+    @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().tearDownClass()
+
+    @classmethod
+    def setUpClassBaseData(cls, *args, **kwargs):
+        super().setUpClassBaseData(*args, **kwargs)
+        cls._load_test_models()
+        cls.carrier = cls.env["delivery.carrier"].search([], limit=1)
+        delivery_packaging_type = (
+            cls.env["stock.package.type"]
+            .sudo()
+            .create({"name": "TEST DEFAULT", "package_carrier_type": "test"})
+        )
+        cls.carrier.sudo().write(
+            {
+                "delivery_type": "test",
+                "integration_level": "rate",  # avoid sending emails
+                "test_default_packaging_id": delivery_packaging_type.id,
+            }
+        )
+
+    def setUp(self):
+        super().setUp()
+        self.service.work.current_picking_type = self.picking1.picking_type_id
+        self.menu.sudo().pick_pack_same_time = True
+
+    def test_set_destination_location_no_carrier(self):
+        """Scan location but carrier not set on picking"""
+        zone_location = self.zone_location
+        picking_type = self.picking1.picking_type_id
+        move_line = self.picking1.move_line_ids
+        move_line.location_dest_id = self.shelf1
+        quantity_done = move_line.reserved_uom_qty
+        previous_qty_done = move_line.qty_done
+        # Confirm the destination with the right destination
+        response = self.service.dispatch(
+            "set_destination",
+            params={
+                "move_line_id": move_line.id,
+                "barcode": self.packing_location.barcode,
+                "quantity": quantity_done,
+                "confirmation": True,
+            },
+        )
+        self.assertEqual(move_line.qty_done, previous_qty_done)
+        self.assert_response_set_line_destination(
+            response,
+            zone_location,
+            picking_type,
+            move_line,
+            message=self.service.msg_store.picking_without_carrier_cannot_pack(
+                move_line.picking_id
+            ),
+            qty_done=quantity_done,
+        )
+
+    def test_set_destination_location_ok_carrier(self):
+        """When carried is set goods are packed into new delivery package."""
+        existing_packages = self.env["stock.quant.package"].search([])
+        zone_location = self.zone_location
+        picking_type = self.picking1.picking_type_id
+        move_line = self.picking1.move_line_ids
+        move_line.location_dest_id = self.shelf1
+        move_line.picking_id.carrier_id = self.carrier
+        response = self.service.dispatch(
+            "set_destination",
+            params={
+                "move_line_id": move_line.id,
+                "barcode": self.packing_location.barcode,
+                "quantity": move_line.reserved_uom_qty,
+                "confirmation": True,
+            },
+        )
+        # Check response
+        move_lines = self.service._find_location_move_lines()
+        move_lines = move_lines.sorted(lambda l: l.move_id.priority, reverse=True)
+        delivery_pkg = move_line.result_package_id
+        self.assertNotIn(delivery_pkg, existing_packages)
+        self.assertEqual(
+            delivery_pkg.package_type_id, self.carrier.test_default_packaging_id
+        )
+        message = self.msg_store.confirm_pack_moved()
+        message["body"] += "\n" + self.msg_store.goods_packed_in(delivery_pkg)["body"]
+        self.assert_response_select_line(
+            response,
+            zone_location,
+            picking_type,
+            move_lines,
+            message=message,
+        )
+
+    def test_set_destination_package_full_qty_no_carrier(self):
+        """Scan destination package, no carrier on picking."""
+        zone_location = self.zone_location
+        picking_type = self.picking1.picking_type_id
+        moves_before = self.picking1.move_ids
+        self.assertEqual(len(moves_before), 1)
+        self.assertEqual(len(moves_before.move_line_ids), 1)
+        move_line = moves_before.move_line_ids
+        quantity_done = move_line.reserved_uom_qty
+        response = self.service.dispatch(
+            "set_destination",
+            params={
+                "move_line_id": move_line.id,
+                "barcode": self.free_package.name,
+                "quantity": quantity_done,
+                "confirmation": True,
+            },
+        )
+        self.assert_response_set_line_destination(
+            response,
+            zone_location,
+            picking_type,
+            move_line,
+            message=self.service.msg_store.picking_without_carrier_cannot_pack(
+                move_line.picking_id
+            ),
+            qty_done=quantity_done,
+        )
+
+    def test_set_destination_package_full_qty_ok_carrier_bad_package(self):
+        """Scan destination package, carrier on picking, package invalid."""
+        zone_location = self.zone_location
+        picking_type = self.picking1.picking_type_id
+        moves_before = self.picking1.move_ids
+        self.assertEqual(len(moves_before), 1)
+        self.assertEqual(len(moves_before.move_line_ids), 1)
+        move_line = moves_before.move_line_ids
+        move_line.picking_id.carrier_id = self.carrier
+        quantity_done = move_line.reserved_uom_qty
+        response = self.service.dispatch(
+            "set_destination",
+            params={
+                "move_line_id": move_line.id,
+                "barcode": self.free_package.name,
+                "quantity": quantity_done,
+                "confirmation": False,
+            },
+        )
+        self.assert_response_set_line_destination(
+            response,
+            zone_location,
+            picking_type,
+            move_line,
+            message=self.service.msg_store.packaging_invalid_for_carrier(
+                self.free_package.product_packaging_id, self.carrier
+            ),
+            qty_done=quantity_done,
+        )
+
+    def test_set_destination_package_full_qty_ok_carrier_ok_package(self):
+        """Scan destination package, carrier on picking, package valid."""
+        zone_location = self.zone_location
+        picking_type = self.picking1.picking_type_id
+        moves_before = self.picking1.move_ids
+        self.assertEqual(len(moves_before), 1)
+        self.assertEqual(len(moves_before.move_line_ids), 1)
+        move_line = moves_before.move_line_ids
+        move_line.picking_id.carrier_id = self.carrier
+        packaging = (
+            self.env["product.packaging"]
+            .sudo()
+            .create(
+                {
+                    "name": "TEST DEFAULT",
+                    "package_type_id": self.carrier.test_default_packaging_id.id,
+                }
+            )
+        )
+
+        self.free_package.product_packaging_id = packaging
+        response = self.service.dispatch(
+            "set_destination",
+            params={
+                "move_line_id": move_line.id,
+                "barcode": self.free_package.name,
+                "quantity": move_line.reserved_uom_qty,
+                "confirmation": True,
+            },
+        )
+        # Check picking data
+        moves_after = self.picking1.move_ids
+        self.assertEqual(moves_before, moves_after)
+        self.assertRecordValues(
+            move_line,
+            [
+                {
+                    "result_package_id": self.free_package.id,
+                    "reserved_uom_qty": 10,
+                    "qty_done": 10,
+                    "shopfloor_user_id": self.env.user.id,
+                },
+            ],
+        )
+        # Check response
+        move_lines = self.service._find_location_move_lines()
+        move_lines = move_lines.sorted(lambda l: l.move_id.priority, reverse=True)
+        self.assert_response_select_line(
+            response,
+            zone_location,
+            picking_type,
+            move_lines,
+            message=self.service.msg_store.confirm_pack_moved(),
+        )

odoo/addons/shopfloor/tests/test_zone_picking_start.py

@@ -0,0 +1,206 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from .test_zone_picking_base import ZonePickingCommonCase
+
+# pylint: disable=missing-return
+
+
+class ZonePickingStartCase(ZonePickingCommonCase):
+    """Tests for endpoint used from start
+
+    * /scan_location
+
+    """
+
+    @classmethod
+    def setUpClassBaseData(cls, *args, **kwargs):
+        super().setUpClassBaseData(*args, **kwargs)
+        # create a picking w/ a different picking type
+        # which should be excluded from picking types list
+        bad_picking_type = cls.picking_type.sudo().copy(
+            {
+                "name": "Bad type",
+                "sequence_code": "WH/BAD",
+                "default_location_src_id": cls.zone_location.id,
+                "shopfloor_menu_ids": False,
+            }
+        )
+        cls.extra_picking = extra_picking = cls._create_picking(
+            lines=[(cls.product_b, 10)],
+            picking_type=bad_picking_type,
+        )
+        cls._fill_stock_for_moves(
+            extra_picking.move_ids, in_package=True, location=cls.zone_sublocation1
+        )
+        cls._update_qty_in_location(cls.zone_sublocation1, cls.product_b, 10)
+        extra_picking.action_assign()
+
+    def test_data_for_zone(self):
+        op_type_data = self.data.picking_type(self.menu.picking_type_ids[0])
+        zones_data = self.service._response_for_start()["data"]["start"]["zones"]
+        expected_sub1 = dict(
+            self.data.location(self.zone_sublocation1),
+            lines_count=1,
+            picking_count=1,
+            priority_lines_count=0,
+            priority_picking_count=0,
+            operation_types=[
+                dict(
+                    op_type_data,
+                    lines_count=1,
+                    picking_count=1,
+                    priority_lines_count=0,
+                    priority_picking_count=0,
+                )
+            ],
+        )
+        expected_sub2 = dict(
+            self.data.location(self.zone_sublocation2),
+            lines_count=2,
+            picking_count=2,
+            priority_lines_count=0,
+            priority_picking_count=0,
+            operation_types=[
+                dict(
+                    op_type_data,
+                    lines_count=2,
+                    picking_count=2,
+                    priority_lines_count=0,
+                    priority_picking_count=0,
+                )
+            ],
+        )
+        expected_sub3 = dict(
+            self.data.location(self.zone_sublocation3),
+            lines_count=2,
+            picking_count=2,
+            priority_lines_count=0,
+            priority_picking_count=0,
+            operation_types=[
+                dict(
+                    op_type_data,
+                    lines_count=2,
+                    picking_count=2,
+                    priority_lines_count=0,
+                    priority_picking_count=0,
+                )
+            ],
+        )
+        expected_sub4 = dict(
+            self.data.location(self.zone_sublocation4),
+            lines_count=3,
+            picking_count=3,
+            priority_lines_count=0,
+            priority_picking_count=0,
+            operation_types=[
+                dict(
+                    op_type_data,
+                    lines_count=3,
+                    picking_count=3,
+                    priority_lines_count=0,
+                    priority_picking_count=0,
+                )
+            ],
+        )
+        expected_sub5 = dict(
+            self.data.location(self.zone_sublocation5),
+            lines_count=2,
+            picking_count=1,
+            priority_lines_count=0,
+            priority_picking_count=0,
+            operation_types=[
+                dict(
+                    op_type_data,
+                    lines_count=2,
+                    picking_count=1,
+                    priority_lines_count=0,
+                    priority_picking_count=0,
+                )
+            ],
+        )
+        self.assertEqual(
+            zones_data,
+            [expected_sub1, expected_sub2, expected_sub3, expected_sub4, expected_sub5],
+        )
+
+    def test_select_zone(self):
+        """Scanned location invalid, no location found."""
+        response = self.service.dispatch("select_zone")
+        self.assert_response_start(response)
+
+    def test_select_zone_with_loaded_buffer(self):
+        """Check loaded buffer info in select zone answer."""
+        zone_location = self.zone_location
+        picking_type = self.picking1.picking_type_id
+        move_line = self.picking5.move_line_ids[1]
+        # change the destination location on the move line
+        move_line.location_dest_id = self.zone_sublocation3
+        # and set the destination package
+        self.service._set_destination_package(
+            move_line,
+            move_line.reserved_uom_qty,
+            self.free_package,
+        )
+        response = self.service.dispatch("select_zone")
+        data = {
+            "zones": self.service._data_for_select_zone(zone_location.child_ids),
+            "buffer": {
+                "zone_location": self.service.data.location(zone_location),
+                "picking_type": self.service.data.picking_type(picking_type),
+            },
+        }
+        self.assert_response(
+            response,
+            next_state="start",
+            data=data,
+        )
+
+    def test_scan_location_wrong_barcode(self):
+        """Scanned location invalid, no location found."""
+        response = self.service.dispatch(
+            "scan_location",
+            params={"barcode": "UNKNOWN LOCATION"},
+        )
+        self.assert_response_start(
+            response,
+            message=self.service.msg_store.no_location_found(),
+        )
+
+    def test_scan_location_not_allowed(self):
+        """Scanned location not allowed because it's not a child of picking
+        types' source location.
+        """
+        response = self.service.dispatch(
+            "scan_location",
+            params={"barcode": self.customer_location.barcode},
+        )
+        self.assert_response_start(
+            response,
+            message=self.service.msg_store.location_not_allowed(),
+        )
+
+    def test_scan_location_no_move_lines(self):
+        """Scanned location valid, but no move lines found in it."""
+        sub1_lines = self.service._find_location_move_lines(self.zone_sublocation1)
+        # no more lines available
+        sub1_lines.picking_id.action_cancel()
+        response = self.service.dispatch(
+            "scan_location",
+            params={"barcode": self.zone_sublocation1.barcode},
+        )
+        self.assert_response_start(
+            response,
+            message=self.service.msg_store.no_lines_to_process(),
+        )
+
+    def test_scan_location_ok(self):
+        """Scanned location valid, list of picking types of related move lines."""
+        response = self.service.dispatch(
+            "scan_location",
+            params={"barcode": self.zone_location.barcode},
+        )
+        self.assert_response_select_picking_type(
+            response,
+            zone_location=self.zone_location,
+            picking_types=self.picking_type,
+        )