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

odoo/addons/shopfloor/tests/test_actions_data_detail.py

@@ -0,0 +1,322 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+import base64
+import io
+
+from markupsafe import Markup
+from PIL import Image
+
+from .test_actions_data_base import ActionsDataDetailCaseBase
+
+
+def fake_colored_image(color="#4169E1", size=(800, 500)):
+    with io.BytesIO() as img_file:
+        Image.new("RGB", size, color).save(img_file, "JPEG")
+        img_file.seek(0)
+        return base64.b64encode(img_file.read())
+
+
+class TestActionsDataDetailCase(ActionsDataDetailCaseBase):
+    def test_data_location(self):
+        location = self.stock_location
+        data = self.data_detail.location_detail(location)
+        self.assert_schema(self.schema_detail.location_detail(), data)
+        move_lines = self.env["stock.move.line"].search(
+            [
+                ("location_id", "child_of", location.id),
+                ("reserved_qty", ">", 0),
+                ("state", "not in", ("done", "cancel")),
+            ]
+        )
+        self.assertDictEqual(
+            data, self._expected_location_detail(location, move_lines=move_lines)
+        )
+
+    def test_data_packaging(self):
+        data = self.data_detail.packaging(self.packaging)
+        self.assert_schema(self.schema_detail.packaging(), data)
+        self.assertDictEqual(data, self._expected_packaging(self.packaging))
+
+    def test_data_lot(self):
+        lot = self.env["stock.lot"].create(
+            {
+                "product_id": self.product_b.id,
+                "company_id": self.env.company.id,
+                "ref": "#FOO",
+                "removal_date": "2020-05-20",
+                "expiration_date": "2020-05-31",
+            }
+        )
+        data = self.data_detail.lot_detail(lot)
+        self.assert_schema(self.schema_detail.lot_detail(), data)
+
+        expected = {
+            "id": lot.id,
+            "name": lot.name,
+            "ref": "#FOO",
+            "expiration_date": "2020-05-31T00:00:00",
+            "product": self._expected_product_detail(self.product_b, full=True),
+        }
+        # ignore time and TZ, we don't care here
+        self.assertEqual(data.pop("removal_date").split("T")[0], "2020-05-20")
+        self.assertEqual(data.pop("expire_date").split("T")[0], "2020-05-31")
+        self.assertDictEqual(data, expected)
+
+    def test_data_package(self):
+        package = self.move_a.move_line_ids.package_id
+        package.product_packaging_id = self.packaging.id
+        package.package_type_id = self.storage_type_pallet
+        # package.invalidate_recordset()
+        data = self.data_detail.package_detail(package, picking=self.picking)
+        self.assert_schema(self.schema_detail.package_detail(), data)
+
+        lines = self.env["stock.move.line"].search(
+            [("package_id", "=", package.id), ("state", "not in", ("done", "cancel"))]
+        )
+        pickings = lines.mapped("picking_id")
+        expected = {
+            "id": package.id,
+            "location": {
+                "id": package.location_id.id,
+                "name": package.location_id.display_name,
+            },
+            "name": package.name,
+            "move_line_count": 1,
+            "packaging": self.data_detail.packaging(package.product_packaging_id),
+            "weight": 20.0,
+            "pickings": self.data_detail.pickings(pickings),
+            "move_lines": self.data_detail.move_lines(lines),
+            "storage_type": {
+                "id": self.storage_type_pallet.id,
+                "name": self.storage_type_pallet.name,
+            },
+        }
+        self.assertDictEqual(data, expected)
+
+    def test_data_picking(self):
+        picking = self.picking
+        carrier = picking.carrier_id.search([], limit=1)
+        picking.write(
+            {
+                "origin": "created by test",
+                "note": Markup("<p>read me</p>"),
+                "priority": "1",
+                "carrier_id": carrier.id,
+            }
+        )
+        picking.move_ids.write({"date": "2020-05-13"})
+        data = self.data_detail.picking_detail(picking)
+        self.assert_schema(self.schema_detail.picking_detail(), data)
+        expected = {
+            "id": picking.id,
+            "move_line_count": 4,
+            "package_level_count": 2,
+            "bulk_line_count": 2,
+            "name": picking.name,
+            "note": Markup("<p>read me</p>"),
+            "origin": "created by test",
+            "ship_carrier": None,
+            "weight": 110.0,
+            "partner": {"id": self.customer.id, "name": self.customer.name},
+            "carrier": {"id": picking.carrier_id.id, "name": picking.carrier_id.name},
+            "priority": "Urgent",
+            "operation_type": {
+                "id": picking.picking_type_id.id,
+                "name": picking.picking_type_id.name,
+            },
+            "move_lines": self.data_detail.move_lines(picking.move_line_ids),
+            "picking_type_code": "outgoing",
+        }
+        self.assertEqual(data.pop("scheduled_date").split("T")[0], "2020-05-13")
+        self.assertDictEqual(data, expected)
+
+    def test_data_picking_with_progress(self):
+        picking = self.picking
+        carrier = picking.carrier_id.search([], limit=1)
+        picking.write(
+            {
+                "origin": "created by test",
+                "note": "read me",
+                "priority": "1",
+                "carrier_id": carrier.id,
+            }
+        )
+        picking.move_ids.write({"date": "2020-05-13"})
+        data = self.data_detail.picking_detail(picking, with_progress=True)
+        self.assert_schema(self.schema_detail.picking_detail(), data)
+        expected = {
+            "id": picking.id,
+            "move_line_count": 4,
+            "package_level_count": 2,
+            "bulk_line_count": 2,
+            "name": picking.name,
+            "note": Markup("<p>read me</p>"),
+            "origin": "created by test",
+            "ship_carrier": None,
+            "weight": 110.0,
+            "partner": {"id": self.customer.id, "name": self.customer.name},
+            "carrier": {"id": picking.carrier_id.id, "name": picking.carrier_id.name},
+            "priority": "Urgent",
+            "operation_type": {
+                "id": picking.picking_type_id.id,
+                "name": picking.picking_type_id.name,
+            },
+            "move_lines": self.data_detail.move_lines(picking.move_line_ids),
+            "picking_type_code": "outgoing",
+            "progress": 0.0,
+        }
+        self.assertEqual(data.pop("scheduled_date").split("T")[0], "2020-05-13")
+        self.assertDictEqual(data, expected)
+
+    def test_data_move_line_package(self):
+        move_line = self.move_a.move_line_ids
+        result_package = self.env["stock.quant.package"].create(
+            {"product_packaging_id": self.packaging.id}
+        )
+        move_line.write({"qty_done": 3.0, "result_package_id": result_package.id})
+        data = self.data_detail.move_line(move_line)
+        self.assert_schema(self.schema_detail.move_line(), data)
+        product = self.product_a.with_context(location=move_line.location_id.id)
+        expected = {
+            "id": move_line.id,
+            "qty_done": 3.0,
+            "quantity": move_line.reserved_uom_qty,
+            "product": self._expected_product_detail(product),
+            "lot": None,
+            "package_src": {
+                "id": move_line.package_id.id,
+                "name": move_line.package_id.name,
+                "move_line_count": 0,
+                "weight": 20.0,
+                "storage_type": None,
+            },
+            "package_dest": {
+                "id": result_package.id,
+                "name": result_package.name,
+                "move_line_count": 1,
+                "weight": 6.0,
+                "storage_type": None,
+            },
+            "location_src": self._expected_location(move_line.location_id),
+            "location_dest": self._expected_location(move_line.location_dest_id),
+            "priority": "1",
+            "progress": 30.0,
+        }
+        self.assertDictEqual(data, expected)
+
+    def test_data_move_line_lot(self):
+        move_line = self.move_b.move_line_ids
+        data = self.data_detail.move_line(move_line)
+        self.assert_schema(self.schema_detail.move_line(), data)
+        product = self.product_b.with_context(location=move_line.location_id.id)
+        expected = {
+            "id": move_line.id,
+            "qty_done": 0.0,
+            "quantity": move_line.reserved_uom_qty,
+            "product": self._expected_product_detail(product),
+            "lot": {
+                "id": move_line.lot_id.id,
+                "name": move_line.lot_id.name,
+                "ref": None,
+                "expiration_date": None,
+            },
+            "package_src": None,
+            "package_dest": None,
+            "location_src": self._expected_location(move_line.location_id),
+            "location_dest": self._expected_location(move_line.location_dest_id),
+            "priority": "1",
+            "progress": 0.0,
+        }
+        self.assertDictEqual(data, expected)
+
+    def test_data_move_line_package_lot(self):
+        move_line = self.move_c.move_line_ids
+        data = self.data_detail.move_line(move_line)
+        self.assert_schema(self.schema_detail.move_line(), data)
+        product = self.product_c.with_context(location=move_line.location_id.id)
+        expected = {
+            "id": move_line.id,
+            "qty_done": 0.0,
+            "quantity": move_line.reserved_uom_qty,
+            "product": self._expected_product_detail(product),
+            "lot": {
+                "id": move_line.lot_id.id,
+                "name": move_line.lot_id.name,
+                "ref": None,
+                "expiration_date": None,
+            },
+            "package_src": {
+                "id": move_line.package_id.id,
+                "name": move_line.package_id.name,
+                "move_line_count": 1,
+                "weight": 30.0,
+                "storage_type": None,
+            },
+            "package_dest": {
+                "id": move_line.result_package_id.id,
+                "name": move_line.result_package_id.name,
+                "move_line_count": 1,
+                "weight": 0.0,
+                "storage_type": None,
+            },
+            "location_src": self._expected_location(move_line.location_id),
+            "location_dest": self._expected_location(move_line.location_dest_id),
+            "priority": "1",
+            "progress": 0.0,
+        }
+        self.assertDictEqual(data, expected)
+
+    def test_data_move_line_raw(self):
+        move_line = self.move_d.move_line_ids
+        data = self.data_detail.move_line(move_line)
+        self.assert_schema(self.schema_detail.move_line(), data)
+        product = self.product_d.with_context(location=move_line.location_id.id)
+        expected = {
+            "id": move_line.id,
+            "qty_done": 0.0,
+            "quantity": move_line.reserved_uom_qty,
+            "product": self._expected_product_detail(product),
+            "lot": None,
+            "package_src": None,
+            "package_dest": None,
+            "location_src": self._expected_location(move_line.location_id),
+            "location_dest": self._expected_location(move_line.location_dest_id),
+            "priority": "1",
+            "progress": 0.0,
+        }
+        self.assertDictEqual(data, expected)
+
+    def test_product(self):
+        move_line = self.move_b.move_line_ids
+        product = move_line.product_id.with_context(location=move_line.location_id.id)
+        Partner = self.env["res.partner"].sudo()
+        manuf = Partner.create({"name": "Manuf 1"})
+        product.sudo().write(
+            {
+                "image_128": fake_colored_image(size=(128, 128)),
+                "manufacturer_id": manuf.id,
+            }
+        )
+        vendor_a = Partner.create({"name": "Supplier A"})
+        vendor_b = Partner.create({"name": "Supplier B"})
+        SupplierInfo = self.env["product.supplierinfo"].sudo()
+        SupplierInfo.create(
+            {
+                "partner_id": vendor_a.id,
+                "product_tmpl_id": product.product_tmpl_id.id,
+                "product_id": product.id,
+                "product_code": "SUPP1",
+            }
+        )
+        SupplierInfo.create(
+            {
+                "partner_id": vendor_b.id,
+                "product_tmpl_id": product.product_tmpl_id.id,
+                "product_id": product.id,
+                "product_code": "SUPP2",
+            }
+        )
+        data = self.data_detail.product_detail(product)
+        self.assert_schema(self.schema_detail.product_detail(), data)
+        expected = self._expected_product_detail(product, full=True)
+        self.assertDictEqual(data, expected)

odoo/addons/shopfloor/tests/test_actions_search.py

@@ -0,0 +1,248 @@
+# Copyright 2021 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+# @author Simone Orsi <simahawk@gmail.com>
+
+from .common import CommonCase
+
+
+# pylint: disable=missing-return
+class TestSearchBaseCase(CommonCase):
+    @classmethod
+    def setUpClassVars(cls):
+        super().setUpClassVars()
+        with cls.work_on_actions(cls) as work:
+            cls.search = work.component(usage="search")
+
+
+class TestSearchCase(TestSearchBaseCase):
+    def test_search_location(self):
+        rec = self.customer_location
+        handler = self.search.location_from_scan
+        self.assertEqual(handler(rec.barcode), rec)
+        self.assertEqual(handler(rec.name), rec)
+        self.assertEqual(handler(False), rec.browse())
+        self.assertEqual(handler("NONE"), rec.browse())
+
+    def test_search_location_with_limit(self):
+        rec = self.customer_location
+        rec2 = self.customer_location.sudo().copy(
+            {"barcode": "CUSTOMERS2", "name": "Customers"}
+        )
+        handler = self.search.location_from_scan
+        res = handler("Customers", 2)
+        self.assertEqual(res, rec + rec2)
+
+    def test_search_package(self):
+        rec = self.env["stock.quant.package"].sudo().create({"name": "1234"})
+        handler = self.search.package_from_scan
+        self.assertEqual(handler(rec.name), rec)
+        self.assertEqual(handler(False), rec.browse())
+        self.assertEqual(handler("NONE"), rec.browse())
+
+    def test_search_picking(self):
+        ptype = self.env.ref("shopfloor.picking_type_single_pallet_transfer_demo")
+        rec = self._create_picking(picking_type=ptype)
+        handler = self.search.picking_from_scan
+        self.assertEqual(handler(rec.name), rec)
+        self.assertEqual(handler(False), rec.browse())
+        self.assertEqual(handler("NONE"), rec.browse())
+
+    def test_search_product(self):
+        rec = self.product_a
+        handler = self.search.product_from_scan
+        self.assertEqual(handler(rec.barcode), rec)
+        self.assertEqual(handler(False), rec.browse())
+        self.assertEqual(handler("NONE"), rec.browse())
+        # It is not possible to search a product by packaging
+        packaging = self.product_a_packaging
+        self.assertFalse(handler(packaging.barcode))
+
+    def test_search_lot_number_unique(self):
+        rec = (
+            self.env["stock.lot"]
+            .sudo()
+            .create(
+                {"product_id": self.product_a.id, "company_id": self.env.company.id}
+            )
+        )
+        handler = self.search.lot_from_scan
+        self.assertEqual(handler(rec.name, products=self.product_a), rec)
+        self.assertEqual(handler(False), rec.browse())
+        self.assertEqual(handler("NONE"), rec.browse())
+
+    def test_search_lot_number_shared_with_multiple_products(self):
+        lot_model = self.env["stock.lot"].sudo()
+        lots = (
+            lot_model.create(
+                {
+                    "name": "TEST",
+                    "product_id": self.product_a.id,
+                    "company_id": self.env.company.id,
+                }
+            ),
+            lot_model.create(
+                {
+                    "name": "TEST",
+                    "product_id": self.product_b.id,
+                    "company_id": self.env.company.id,
+                }
+            ),
+        )
+        handler = self.search.lot_from_scan
+        self.assertEqual(handler(lots[0].name, products=self.product_a), lots[0])
+        self.assertEqual(handler(lots[1].name, products=self.product_a), lots[0])
+        self.assertEqual(handler(lots[0].name, products=self.product_b), lots[1])
+        self.assertEqual(handler(lots[1].name, products=self.product_b), lots[1])
+
+    def test_search_generic_packaging(self):
+        rec = (
+            self.env["product.packaging"]
+            .sudo()
+            .create({"name": "TEST PKG", "barcode": "1234"})
+        )
+        handler = self.search.generic_packaging_from_scan
+        self.assertEqual(handler(rec.barcode), rec)
+        self.assertEqual(handler(False), rec.browse())
+        self.assertEqual(handler("NONE"), rec.browse())
+
+
+class TestFindCase(TestSearchBaseCase):
+    def test_find_api(self):
+        self.assertEqual(self.search.find(False).record, None)
+        self.assertEqual(self.search.find("NONE").record, None)
+        self.assertEqual(self.search.find("foo", types=("not_existing",)).record, None)
+        # TODO: test SearchResult class
+
+    def test_find_location(self):
+        rec = self.customer_location
+        res = self.search.find(rec.barcode, types=("location",))
+        self.assertEqual(res.record, rec)
+        res = self.search.find(rec.name, types=("location",))
+        self.assertEqual(res.record, rec)
+
+    def test_find_location_with_limit(self):
+        rec = self.customer_location
+        rec2 = self.customer_location.sudo().copy(
+            {"barcode": "CUSTOMERS2", "name": "Customers"}
+        )
+        res = self.search.find("Customers", types=("location",))
+        self.assertEqual(res.records, None)
+        res = self.search.find(
+            "Customers", types=("location",), handler_kw=dict(location=dict(limit=2))
+        )
+        self.assertEqual(res.records, rec + rec2)
+
+    def test_find_package(self):
+        rec = self.env["stock.quant.package"].sudo().create({"name": "1234"})
+        res = self.search.find(rec.name, types=("package",))
+        self.assertEqual(res.record, rec)
+
+    def test_find_picking(self):
+        ptype = self.env.ref("shopfloor.picking_type_single_pallet_transfer_demo")
+        rec = self._create_picking(picking_type=ptype)
+        res = self.search.find(rec.name, types=("picking",))
+        self.assertEqual(res.record, rec)
+
+    def test_find_product(self):
+        rec = self.product_a
+        res = self.search.find(rec.barcode, types=("product",))
+        self.assertEqual(res.record, rec)
+        # It is not possible to search a product by packaging
+        packaging = self.product_a_packaging
+        res = self.search.find(packaging.barcode, types=("product",))
+        self.assertEqual(res.record, None)
+
+    def test_find_product_packaging(self):
+        rec = self.product_a_packaging
+        res = self.search.find(rec.barcode, types=("packaging",))
+        self.assertEqual(res.record, rec)
+
+    def test_find_lot_number_unique(self):
+        rec = (
+            self.env["stock.lot"]
+            .sudo()
+            .create(
+                {"product_id": self.product_a.id, "company_id": self.env.company.id}
+            )
+        )
+        res = self.search.find(
+            rec.name, types=("lot",), handler_kw=dict(lot=dict(products=self.product_a))
+        )
+        self.assertEqual(res.record, rec)
+
+    def test_find_lot_number_shared_with_multiple_products(self):
+        lot_model = self.env["stock.lot"].sudo()
+        lots = (
+            lot_model.create(
+                {
+                    "name": "TEST",
+                    "product_id": self.product_a.id,
+                    "company_id": self.env.company.id,
+                }
+            ),
+            lot_model.create(
+                {
+                    "name": "TEST",
+                    "product_id": self.product_b.id,
+                    "company_id": self.env.company.id,
+                }
+            ),
+        )
+        res = self.search.find(
+            lots[0].name,
+            types=("lot",),
+            handler_kw=dict(lot=dict(products=self.product_a)),
+        )
+        self.assertEqual(res.record, lots[0])
+        res = self.search.find(
+            lots[1].name,
+            types=("lot",),
+            handler_kw=dict(lot=dict(products=self.product_a)),
+        )
+        self.assertEqual(res.record, lots[0])
+        res = self.search.find(
+            lots[0].name,
+            types=("lot",),
+            handler_kw=dict(lot=dict(products=self.product_b)),
+        )
+        self.assertEqual(res.record, lots[1])
+        res = self.search.find(
+            lots[1].name,
+            types=("lot",),
+            handler_kw=dict(lot=dict(products=self.product_b)),
+        )
+        self.assertEqual(res.record, lots[1])
+
+    def test_find_chain(self):
+        prod = self.product_a
+        # prod last type -> found
+        res = self.search.find(
+            prod.barcode,
+            types=(
+                "location",
+                "lot",
+                "product",
+            ),
+        )
+        self.assertEqual(res.record, prod)
+        loc = self.customer_location.sudo().copy({"barcode": prod.barcode})
+        # prod last type but a location w/ the same name exists -> location found
+        res = self.search.find(
+            prod.barcode,
+            types=(
+                "location",
+                "lot",
+                "product",
+            ),
+        )
+        self.assertEqual(res.record, loc)
+        # change types order -> prod found
+        res = self.search.find(
+            prod.barcode,
+            types=(
+                "product",
+                "location",
+                "lot",
+            ),
+        )
+        self.assertEqual(res.record, prod)

odoo/addons/shopfloor/tests/test_actions_stock.py

@@ -0,0 +1,48 @@
+# Copyright 2023 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+# from odoo.tests.common import Form
+
+from .common import CommonCase
+
+
+# pylint: disable=missing-return
+class TestActionsStock(CommonCase):
+    """Tests covering methods to work on stock operations."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        with cls.work_on_actions(cls) as work:
+            cls.stock = work.component(usage="stock")
+        cls.picking = cls._create_picking(
+            lines=[(cls.product_a, 10), (cls.product_b, 10)], confirm=True
+        )
+        cls.move0 = cls.picking.move_ids[0]
+        cls.move1 = cls.picking.move_ids[1]
+        cls._fill_stock_for_moves(cls.move0)
+        cls._fill_stock_for_moves(cls.move1)
+        cls.picking.action_assign()
+
+    @classmethod
+    def setUpClassVars(cls):
+        super().setUpClassVars()
+        cls.wh = cls.env.ref("stock.warehouse0")
+        cls.picking_type = cls.wh.out_type_id
+
+    def test_unmark_move_line_as_picked(self):
+        """Check unmarking line as picked works."""
+        lines_picked = self.picking.move_line_ids
+        # all lines (two) are picked
+        self.stock.mark_move_line_as_picked(lines_picked)
+        self.assertTrue(self.picking.user_id)
+        # unpick one line
+        line_unpicked = lines_picked[0]
+        self.stock.unmark_move_line_as_picked(line_unpicked)
+        # because not all lines of the picking have to be unpicked
+        # they should be split to a new picking
+        picking_not_assigned = line_unpicked.picking_id
+        self.assertTrue(line_unpicked.picking_id != lines_picked.picking_id)
+        self.assertTrue(self.picking.user_id)
+        self.assertTrue(self.picking.move_line_ids.shopfloor_user_id)
+        self.assertFalse(picking_not_assigned.move_line_ids.shopfloor_user_id)
+        self.assertFalse(picking_not_assigned.user_id)

odoo/addons/shopfloor/tests/test_checkout_auto_post.py

@@ -0,0 +1,67 @@
+# Copyright 2023 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
+
+
+class CheckoutAutoPostCase(CheckoutCommonCase):
+    def test_auto_posting(self):
+        self.menu.sudo().auto_post_line = True
+        picking = self._create_picking(
+            lines=[(self.product_a, 10), (self.product_b, 20), (self.product_c, 30)]
+        )
+        self._fill_stock_for_moves(picking.move_ids)
+        picking.action_assign()
+        selected_move_line_a = picking.move_line_ids.filtered(
+            lambda l: l.product_id == self.product_a
+        )
+        selected_move_line_a.qty_done = 7
+        selected_move_line_b = picking.move_line_ids.filtered(
+            lambda l: l.product_id == self.product_b
+        )
+        selected_move_line_b.qty_done = 9
+        selected_move_line_c = picking.move_line_ids.filtered(
+            lambda l: l.product_id == self.product_c
+        )
+
+        # User has selected 7 units out of 10 for product_a,
+        # and 9 units out of 20 for product_b.
+        # We would expect a split picking to be created with those two lines and qtys done.
+        self.service.dispatch(
+            "scan_package_action",
+            params={
+                "picking_id": picking.id,
+                "selected_line_ids": [selected_move_line_a.id, selected_move_line_b.id],
+                "barcode": self.delivery_packaging.barcode,
+            },
+        )
+
+        # Check that two new lines for products a and b are in a split picking,
+        # and the line for product c remained in the original picking.
+        self.assertNotEqual(picking, selected_move_line_a.picking_id)
+        self.assertEqual(
+            selected_move_line_a.picking_id, selected_move_line_b.picking_id
+        )
+        self.assertEqual(picking, selected_move_line_c.picking_id)
+
+        # The lines in the new picking must have the expected qty_done,
+        # and the split picking must be marked as "done".
+        self.assertEqual(selected_move_line_a.qty_done, 7)
+        self.assertEqual(selected_move_line_b.qty_done, 9)
+        self.assertEqual(selected_move_line_a.picking_id.state, "done")
+
+        # In the original picking, we should have three lines:
+        # - the original line for product c, unchanged;
+        # - two lines (products a and b) with the non-split qtys.
+        line_a_in_original_picking = picking.move_line_ids.filtered(
+            lambda l: l.product_id == selected_move_line_a.product_id
+        )
+        line_b_in_original_picking = picking.move_line_ids.filtered(
+            lambda l: l.product_id == selected_move_line_b.product_id
+        )
+        self.assertEqual(line_a_in_original_picking.reserved_uom_qty, 3)
+        self.assertEqual(line_b_in_original_picking.reserved_uom_qty, 11)
+        self.assertEqual(selected_move_line_c.reserved_uom_qty, 30)
+
+        self.assertEqual(line_a_in_original_picking.qty_done, 0)
+        self.assertEqual(line_b_in_original_picking.qty_done, 0)
+        self.assertEqual(selected_move_line_c.qty_done, 0)