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

odoo/addons/shopfloor/tests/test_single_pack_transfer_base.py

@@ -0,0 +1,32 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# Copyright 2020 Akretion (http://www.akretion.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from .common import CommonCase
+
+# pylint: disable=missing-return
+
+
+class SinglePackTransferCommonBase(CommonCase):
+    @classmethod
+    def setUpClassVars(cls, *args, **kwargs):
+        super().setUpClassVars(*args, **kwargs)
+        cls.menu = cls.env.ref("shopfloor.shopfloor_menu_demo_single_pallet_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)
+        # we activate the move creation in tests when needed
+        cls.menu.sudo().allow_move_create = False
+
+        # disable the completion on the picking type, we'll have specific test(s)
+        # to check the behavior of this screen
+        cls.picking_type.sudo().display_completion_info = False
+
+    def setUp(self):
+        super().setUp()
+        self.service = self.get_service(
+            "single_pack_transfer", menu=self.menu, profile=self.profile
+        )

odoo/addons/shopfloor/tests/test_single_pack_transfer_putaway.py

@@ -0,0 +1,104 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from .test_single_pack_transfer_base import SinglePackTransferCommonBase
+
+# pylint: disable=missing-return
+
+
+class TestSinglePackTransferPutaway(SinglePackTransferCommonBase):
+    @classmethod
+    def setUpClassVars(cls, *args, **kwargs):
+        super().setUpClassVars(*args, **kwargs)
+        cls.pallets_storage_type = cls.env.ref(
+            "stock_storage_type.package_storage_type_pallets"
+        )
+        cls.main_pallets_location = cls.env.ref(
+            "stock_storage_type.stock_location_pallets"
+        )
+        cls.reserve_pallets_locations = cls.env.ref(
+            "stock_storage_type.stock_location_pallets_reserve"
+        )
+        cls.all_pallets_locations = (
+            cls.main_pallets_location.leaf_location_ids
+            | cls.reserve_pallets_locations.leaf_location_ids
+        )
+
+    @classmethod
+    def setUpClassBaseData(cls, *args, **kwargs):
+        super().setUpClassBaseData(*args, **kwargs)
+        cls.package = cls.env["stock.quant.package"].create(
+            {
+                # this will parameterize the putaway to use pallet locations,
+                # and if not, it will stay on the picking type's default dest.
+                "package_type_id": cls.pallets_storage_type.id,
+            }
+        )
+        cls._update_qty_in_location(cls.shelf1, cls.product_a, 10, package=cls.package)
+        cls.menu.sudo().ignore_no_putaway_available = True
+        cls.menu.sudo().allow_move_create = True
+
+    def test_normal_putaway(self):
+        """Ensure putaway is applied on moves"""
+        response = self.service.dispatch(
+            "start", params={"barcode": self.shelf1.barcode}
+        )
+        self.assert_response(
+            response,
+            next_state="scan_location",
+            data=self.ANY,
+        )
+        package_level_id = response["data"]["scan_location"]["id"]
+        package_level = self.env["stock.package_level"].browse(package_level_id)
+        self.assertIn(package_level.location_dest_id, self.all_pallets_locations)
+
+    def test_ignore_no_putaway_available(self):
+        """Ignore no putaway available is activated on the menu
+
+        In this case, when no putaway is possible, the changes
+        are rollbacked and an error is returned.
+        """
+        for location in self.all_pallets_locations:
+            package = self.env["stock.quant.package"].create(
+                {"package_type_id": self.pallets_storage_type.id}
+            )
+            self._update_qty_in_location(location, self.product_a, 10, package=package)
+
+        response = self.service.dispatch(
+            "start", params={"barcode": self.shelf1.barcode}
+        )
+        self.assert_response(
+            response,
+            next_state="start",
+            message=self.service.msg_store.no_putaway_destination_available(),
+        )
+
+        package_levels = self.env["stock.package_level"].search(
+            [("package_id", "=", self.package.id)]
+        )
+        # no package level created to move the package
+        self.assertFalse(package_levels)
+
+    def test_putaway_move_dest_not_child_of_picking_dest(self):
+        """Putaway is applied on move but the destination location is not a
+        child of the default picking type destination location.
+        Case where the picking is created by scanning a package level. Then the
+        move destination is according to the putaway and valid.
+        """
+        # Change the default destination location of the picking type
+        # to get it outside of the putaway destination
+        self.picking_type.sudo().default_location_dest_id = self.main_pallets_location
+        # Create a standard putaway to move the package from pallet storage
+        # to a unrelated one (outside of the pallet storage tree)
+        self.env["stock.putaway.rule"].sudo().create(
+            {
+                "product_id": self.product_a.id,
+                "location_in_id": self.picking_type.default_location_dest_id.id,
+                "location_out_id": self.env.ref("stock.location_refrigerator_small").id,
+            }
+        )
+        # Check the result
+        response = self.service.dispatch(
+            "start", params={"barcode": self.shelf1.barcode}
+        )
+        self.assert_response(response, next_state="scan_location", data=self.ANY)

odoo/addons/shopfloor/tests/test_stock_split.py

@@ -0,0 +1,204 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+
+# pylint: disable=missing-return
+
+
+@tagged("post_install", "-at_install")
+class TestStockSplit(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super(TestStockSplit, cls).setUpClass()
+        cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
+        cls.warehouse = cls.env.ref("stock.warehouse0")
+        cls.warehouse.delivery_steps = "pick_pack_ship"
+        cls.customer_location = cls.env.ref("stock.stock_location_customers")
+        cls.pack_location = cls.warehouse.wh_pack_stock_loc_id
+        cls.ship_location = cls.warehouse.wh_output_stock_loc_id
+        cls.stock_location = cls.env.ref("stock.stock_location_stock")
+        # Create products
+        cls.product_a = (
+            cls.env["product.product"]
+            .sudo()
+            .create(
+                {
+                    "name": "Product A",
+                    "type": "product",
+                    "default_code": "A",
+                    "barcode": "A",
+                    "weight": 2,
+                }
+            )
+        )
+        cls.product_a_packaging = (
+            cls.env["product.packaging"]
+            .sudo()
+            .create(
+                {
+                    "name": "Box",
+                    "product_id": cls.product_a.id,
+                    "barcode": "ProductABox",
+                }
+            )
+        )
+        cls.product_b = (
+            cls.env["product.product"]
+            .sudo()
+            .create(
+                {
+                    "name": "Product B",
+                    "type": "product",
+                    "default_code": "B",
+                    "barcode": "B",
+                    "weight": 2,
+                }
+            )
+        )
+        cls.product_b_packaging = (
+            cls.env["product.packaging"]
+            .sudo()
+            .create(
+                {
+                    "name": "Box",
+                    "product_id": cls.product_b.id,
+                    "barcode": "ProductBBox",
+                }
+            )
+        )
+        # Put product_a quantities in different packages to get several move lines
+        cls.package_1 = cls.env["stock.quant.package"].create({"name": "PACKAGE_1"})
+        cls.package_2 = cls.env["stock.quant.package"].create({"name": "PACKAGE_2"})
+        cls.package_3 = cls.env["stock.quant.package"].create({"name": "PACKAGE_3"})
+        cls.package_4 = cls.env["stock.quant.package"].create({"name": "PACKAGE_4"})
+        cls._update_qty_in_location(
+            cls.stock_location, cls.product_a, 6, package=cls.package_1
+        )
+        cls._update_qty_in_location(
+            cls.stock_location, cls.product_a, 4, package=cls.package_2
+        )
+        cls._update_qty_in_location(
+            cls.stock_location, cls.product_a, 5, package=cls.package_3
+        )
+        # Put product_b quantities in stock
+        cls._update_qty_in_location(cls.stock_location, cls.product_b, 10)
+        # Create the pick/pack/ship transfer
+        cls.ship_move_a = cls.env["stock.move"].create(
+            {
+                "name": cls.product_a.display_name,
+                "product_id": cls.product_a.id,
+                "product_uom_qty": 15.0,
+                "product_uom": cls.product_a.uom_id.id,
+                "location_id": cls.ship_location.id,
+                "location_dest_id": cls.customer_location.id,
+                "warehouse_id": cls.warehouse.id,
+                "picking_type_id": cls.warehouse.out_type_id.id,
+                "procure_method": "make_to_order",
+                "state": "draft",
+            }
+        )
+        cls.ship_move_b = cls.env["stock.move"].create(
+            {
+                "name": cls.product_b.display_name,
+                "product_id": cls.product_b.id,
+                "product_uom_qty": 4,
+                "product_uom": cls.product_b.uom_id.id,
+                "location_id": cls.ship_location.id,
+                "location_dest_id": cls.customer_location.id,
+                "warehouse_id": cls.warehouse.id,
+                "picking_type_id": cls.warehouse.out_type_id.id,
+                "procure_method": "make_to_order",
+                "state": "draft",
+            }
+        )
+        (cls.ship_move_a | cls.ship_move_b)._assign_picking()
+        (cls.ship_move_a | cls.ship_move_b)._action_confirm(merge=False)
+        cls.pack_move_a = cls.ship_move_a.move_orig_ids[0]
+        cls.pick_move_a = cls.pack_move_a.move_orig_ids[0]
+        cls.pack_move_b = cls.ship_move_b.move_orig_ids[0]
+        cls.pick_move_b = cls.pack_move_b.move_orig_ids[0]
+        cls.picking = cls.pick_move_a.picking_id
+        cls.packing = cls.pack_move_a.picking_id
+        cls.picking.action_assign()
+
+    @classmethod
+    def _update_qty_in_location(
+        cls, location, product, quantity, package=None, lot=None
+    ):
+        quants = cls.env["stock.quant"]._gather(
+            product, location, lot_id=lot, package_id=package, strict=True
+        )
+        # this method adds the quantity to the current quantity, so remove it
+        quantity -= sum(quants.mapped("quantity"))
+        cls.env["stock.quant"]._update_available_quantity(
+            product, location, quantity, package_id=package, lot_id=lot
+        )
+
+    def test_split_pickings_from_source_location(self):
+        dest_location = self.pick_move_a.location_dest_id.sudo().copy(
+            {
+                "name": self.pick_move_a.location_dest_id.name + "_2",
+                "barcode": self.pick_move_a.location_dest_id.barcode + "_2",
+                "location_id": self.pick_move_a.location_dest_id.id,
+            }
+        )
+        # Pick goods from stock and move some of them to a different destination
+        self.assertEqual(self.pick_move_a.state, "assigned")
+        for i, move_line in enumerate(self.pick_move_a.move_line_ids):
+            move_line.qty_done = move_line.reserved_uom_qty
+            if i % 2:
+                move_line.location_dest_id = dest_location
+        self.pick_move_a.extract_and_action_done()
+        self.assertEqual(self.pick_move_a.state, "done")
+        # Pack step, we want to split move lines from common source location
+        self.assertEqual(self.pack_move_a.state, "assigned")
+        move_lines_to_process = self.pack_move_a.move_line_ids.filtered(
+            lambda ml: ml.location_id == dest_location
+        )
+        self.assertEqual(len(self.pack_move_a.move_line_ids), 3)
+        self.assertEqual(len(self.packing.package_level_ids), 3)
+        self.assertEqual(len(move_lines_to_process), 1)
+        new_packing = move_lines_to_process._split_pickings_from_source_location()
+        self.assertEqual(len(self.packing.package_level_ids), 2)
+        self.assertEqual(len(new_packing.package_level_ids), 1)
+        self.assertEqual(len(new_packing.move_line_ids), 1)
+        self.assertTrue(new_packing != self.packing)
+        self.assertEqual(new_packing.backorder_id, self.packing)
+        self.assertEqual(
+            self.pick_move_a.move_dest_ids.picking_id, self.packing | new_packing
+        )
+        self.assertEqual(move_lines_to_process.state, "assigned")
+        self.assertEqual(
+            set(self.pack_move_a.move_line_ids.mapped("state")), {"assigned"}
+        )
+
+    def test_extract_and_action_done_one_assigned_move(self):
+        self.assertFalse(self.picking.backorder_ids)
+        self.assertEqual(self.picking.state, "assigned")
+        for move_line in self.pick_move_b.move_line_ids:
+            move_line.qty_done = move_line.reserved_uom_qty
+        self.pick_move_b.extract_and_action_done()
+        new_picking = self.picking.backorder_ids
+        self.assertTrue(new_picking)
+        # Check move lines repartition
+        self.assertNotIn(self.pick_move_b, self.picking.move_ids)
+        self.assertEqual(new_picking.move_ids, self.pick_move_b)
+        # Check states
+        self.assertEqual(self.picking.state, "assigned")
+        self.assertEqual(self.pick_move_b.state, "done")
+        self.assertEqual(new_picking.state, "done")
+
+    def test_extract_and_action_done_multiple_assigned_moves(self):
+        self.assertFalse(self.picking.backorder_ids)
+        self.assertEqual(self.picking.state, "assigned")
+        for move_line in self.picking.move_line_ids:
+            move_line.qty_done = move_line.reserved_uom_qty
+        self.picking.move_ids.extract_and_action_done()
+        # No backorder as all moves of the picking have been validated
+        new_picking = self.picking.backorder_ids
+        self.assertFalse(new_picking)
+        # Check move lines repartition
+        self.assertEqual(len(self.picking.move_ids), 2)
+        # Check states
+        self.assertEqual(self.picking.state, "done")

odoo/addons/shopfloor/tests/test_user.py

@@ -0,0 +1,42 @@
+# Copyright 2020 Camptocamp SA (http://www.camptocamp.com)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from .test_menu_base import CommonMenuCase
+
+# pylint: disable=missing-return
+
+
+class UserCase(CommonMenuCase):
+    @classmethod
+    def setUpClassVars(cls, *args, **kwargs):
+        super().setUpClassVars(*args, **kwargs)
+        ref = cls.env.ref
+        cls.wms_profile = ref("shopfloor.profile_demo_1")
+        cls.wms_profile2 = ref("shopfloor.profile_demo_2")
+
+    def test_menu_by_profile(self):
+        """Request /user/menu w/ a specific profile but no picking types"""
+
+        service = self.get_service("user", profile=self.wms_profile)
+        menus = (
+            self.env["shopfloor.menu"]
+            .sudo()
+            .search([("profile_id", "=", self.wms_profile.id)])
+        )
+        response = service.dispatch("menu")
+        self.assert_response(
+            response,
+            data={"menus": [self._data_for_menu_item(menu) for menu in menus]},
+        )
+
+        service = self.get_service("user", profile=self.wms_profile2)
+        menus = (
+            self.env["shopfloor.menu"]
+            .sudo()
+            .search([("profile_id", "=", self.wms_profile2.id)])
+        )
+        response = service.dispatch("menu")
+        self.assert_response(
+            response,
+            data={"menus": [self._data_for_menu_item(menu) for menu in menus]},
+        )