1237 lines
52 KiB
Python
1237 lines
52 KiB
Python
|
# -*- coding: utf-8 -*-
|
||
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||
|
|
|
||
|
|
from datetime import timedelta
|
||
|
|
|
||
|
|
from odoo.tests import Form, TransactionCase, tagged
|
||
|
|
from odoo.addons.account.tests.common import AccountTestInvoicingCommon
|
||
|
|
from odoo import fields
|
||
|
|
from odoo.fields import Command
|
||
|
|
|
||
|
|
|
||
|
|
@tagged('post_install', '-at_install')
|
||
|
|
class TestPurchaseMrpFlow(AccountTestInvoicingCommon):
|
||
|
|
|
||
|
|
@classmethod
|
||
|
|
def setUpClass(cls):
|
||
|
|
super().setUpClass()
|
||
|
|
# Useful models
|
||
|
|
cls.UoM = cls.env['uom.uom']
|
||
|
|
cls.categ_unit = cls.env.ref('uom.product_uom_categ_unit')
|
||
|
|
cls.categ_kgm = cls.env.ref('uom.product_uom_categ_kgm')
|
||
|
|
cls.warehouse = cls.env['stock.warehouse'].search([('company_id', '=', cls.env.company.id)])
|
||
|
|
cls.stock_location = cls.warehouse.lot_stock_id
|
||
|
|
|
||
|
|
grp_uom = cls.env.ref('uom.group_uom')
|
||
|
|
group_user = cls.env.ref('base.group_user')
|
||
|
|
group_user.write({'implied_ids': [(4, grp_uom.id)]})
|
||
|
|
cls.env.user.write({'groups_id': [(4, grp_uom.id)]})
|
||
|
|
|
||
|
|
cls.uom_kg = cls.env['uom.uom'].search([('category_id', '=', cls.categ_kgm.id), ('uom_type', '=', 'reference')],
|
||
|
|
limit=1)
|
||
|
|
cls.uom_kg.write({
|
||
|
|
'name': 'Test-KG',
|
||
|
|
'rounding': 0.000001})
|
||
|
|
cls.uom_gm = cls.UoM.create({
|
||
|
|
'name': 'Test-G',
|
||
|
|
'category_id': cls.categ_kgm.id,
|
||
|
|
'uom_type': 'smaller',
|
||
|
|
'factor': 1000.0,
|
||
|
|
'rounding': 0.001})
|
||
|
|
cls.uom_unit = cls.env['uom.uom'].search(
|
||
|
|
[('category_id', '=', cls.categ_unit.id), ('uom_type', '=', 'reference')], limit=1)
|
||
|
|
cls.uom_unit.write({
|
||
|
|
'name': 'Test-Unit',
|
||
|
|
'rounding': 0.01})
|
||
|
|
cls.uom_dozen = cls.UoM.create({
|
||
|
|
'name': 'Test-DozenA',
|
||
|
|
'category_id': cls.categ_unit.id,
|
||
|
|
'factor_inv': 12,
|
||
|
|
'uom_type': 'bigger',
|
||
|
|
'rounding': 0.001})
|
||
|
|
|
||
|
|
# Creating all components
|
||
|
|
cls.component_a = cls._create_product_with_form('Comp A', cls.uom_unit)
|
||
|
|
cls.component_b = cls._create_product_with_form('Comp B', cls.uom_unit)
|
||
|
|
cls.component_c = cls._create_product_with_form('Comp C', cls.uom_unit)
|
||
|
|
cls.component_d = cls._create_product_with_form('Comp D', cls.uom_unit)
|
||
|
|
cls.component_e = cls._create_product_with_form('Comp E', cls.uom_unit)
|
||
|
|
cls.component_f = cls._create_product_with_form('Comp F', cls.uom_unit)
|
||
|
|
cls.component_g = cls._create_product_with_form('Comp G', cls.uom_unit)
|
||
|
|
|
||
|
|
# Create a kit 'kit_1' :
|
||
|
|
# -----------------------
|
||
|
|
#
|
||
|
|
# kit_1 --|- component_a x2
|
||
|
|
# |- component_b x1
|
||
|
|
# |- component_c x3
|
||
|
|
|
||
|
|
cls.kit_1 = cls._create_product_with_form('Kit 1', cls.uom_unit)
|
||
|
|
|
||
|
|
cls.bom_kit_1 = cls.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': cls.kit_1.product_tmpl_id.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'type': 'phantom'})
|
||
|
|
|
||
|
|
BomLine = cls.env['mrp.bom.line']
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.component_a.id,
|
||
|
|
'product_qty': 2.0,
|
||
|
|
'bom_id': cls.bom_kit_1.id})
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.component_b.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'bom_id': cls.bom_kit_1.id})
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.component_c.id,
|
||
|
|
'product_qty': 3.0,
|
||
|
|
'bom_id': cls.bom_kit_1.id})
|
||
|
|
|
||
|
|
# Create a kit 'kit_parent' :
|
||
|
|
# ---------------------------
|
||
|
|
#
|
||
|
|
# kit_parent --|- kit_2 x2 --|- component_d x1
|
||
|
|
# | |- kit_1 x2 -------|- component_a x2
|
||
|
|
# | |- component_b x1
|
||
|
|
# | |- component_c x3
|
||
|
|
# |
|
||
|
|
# |- kit_3 x1 --|- component_f x1
|
||
|
|
# | |- component_g x2
|
||
|
|
# |
|
||
|
|
# |- component_e x1
|
||
|
|
|
||
|
|
# Creating all kits
|
||
|
|
cls.kit_2 = cls._create_product_with_form('Kit 2', cls.uom_unit)
|
||
|
|
cls.kit_3 = cls._create_product_with_form('kit 3', cls.uom_unit)
|
||
|
|
cls.kit_parent = cls._create_product_with_form('Kit Parent', cls.uom_unit)
|
||
|
|
|
||
|
|
# Linking the kits and the components via some 'phantom' BoMs
|
||
|
|
bom_kit_2 = cls.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': cls.kit_2.product_tmpl_id.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'type': 'phantom'})
|
||
|
|
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.component_d.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'bom_id': bom_kit_2.id})
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.kit_1.id,
|
||
|
|
'product_qty': 2.0,
|
||
|
|
'bom_id': bom_kit_2.id})
|
||
|
|
|
||
|
|
bom_kit_parent = cls.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': cls.kit_parent.product_tmpl_id.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'type': 'phantom'})
|
||
|
|
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.component_e.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'bom_id': bom_kit_parent.id})
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.kit_2.id,
|
||
|
|
'product_qty': 2.0,
|
||
|
|
'bom_id': bom_kit_parent.id})
|
||
|
|
|
||
|
|
bom_kit_3 = cls.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': cls.kit_3.product_tmpl_id.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'type': 'phantom'})
|
||
|
|
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.component_f.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'bom_id': bom_kit_3.id})
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.component_g.id,
|
||
|
|
'product_qty': 2.0,
|
||
|
|
'bom_id': bom_kit_3.id})
|
||
|
|
|
||
|
|
BomLine.create({
|
||
|
|
'product_id': cls.kit_3.id,
|
||
|
|
'product_qty': 2.0,
|
||
|
|
'bom_id': bom_kit_parent.id})
|
||
|
|
|
||
|
|
@classmethod
|
||
|
|
def _create_product_with_form(cls, name, uom_id, routes=()):
|
||
|
|
p = Form(cls.env['product.product'])
|
||
|
|
p.name = name
|
||
|
|
p.is_storable = True
|
||
|
|
p.uom_id = uom_id
|
||
|
|
p.uom_po_id = uom_id
|
||
|
|
p.route_ids.clear()
|
||
|
|
for r in routes:
|
||
|
|
p.route_ids.add(r)
|
||
|
|
return p.save()
|
||
|
|
|
||
|
|
# Helper to process quantities based on a dict following this structure :
|
||
|
|
#
|
||
|
|
# qty_to_process = {
|
||
|
|
# product_id: qty
|
||
|
|
# }
|
||
|
|
|
||
|
|
def _process_quantities(self, moves, quantities_to_process):
|
||
|
|
""" Helper to process quantities based on a dict following this structure :
|
||
|
|
qty_to_process = {
|
||
|
|
product_id: qty
|
||
|
|
}
|
||
|
|
"""
|
||
|
|
moves_to_process = moves.filtered(lambda m: m.product_id in quantities_to_process.keys())
|
||
|
|
for move in moves_to_process:
|
||
|
|
move.quantity = quantities_to_process[move.product_id]
|
||
|
|
move.picked = True
|
||
|
|
|
||
|
|
def _assert_quantities(self, moves, quantities_to_process):
|
||
|
|
""" Helper to check expected quantities based on a dict following this structure :
|
||
|
|
qty_to_process = {
|
||
|
|
product_id: qty
|
||
|
|
...
|
||
|
|
}
|
||
|
|
"""
|
||
|
|
moves_to_process = moves.filtered(lambda m: m.product_id in quantities_to_process.keys())
|
||
|
|
for move in moves_to_process:
|
||
|
|
self.assertEqual(move.product_uom_qty, quantities_to_process[move.product_id])
|
||
|
|
|
||
|
|
def _create_move_quantities(self, qty_to_process, components, warehouse):
|
||
|
|
""" Helper to creates moves in order to update the quantities of components
|
||
|
|
on a specific warehouse. This ensure that all compute fields are triggered.
|
||
|
|
The structure of qty_to_process should be the following :
|
||
|
|
|
||
|
|
qty_to_process = {
|
||
|
|
component: (qty, uom),
|
||
|
|
...
|
||
|
|
}
|
||
|
|
"""
|
||
|
|
for comp in components:
|
||
|
|
f = Form(self.env['stock.move'])
|
||
|
|
f.name = 'Test Receipt Components'
|
||
|
|
f.location_id = self.env.ref('stock.stock_location_suppliers')
|
||
|
|
f.location_dest_id = warehouse.lot_stock_id
|
||
|
|
f.product_id = comp
|
||
|
|
f.product_uom = qty_to_process[comp][1]
|
||
|
|
f.product_uom_qty = qty_to_process[comp][0]
|
||
|
|
move = f.save()
|
||
|
|
move._action_confirm()
|
||
|
|
move._action_assign()
|
||
|
|
move_line = move.move_line_ids[0]
|
||
|
|
move_line.quantity = qty_to_process[comp][0]
|
||
|
|
move._action_done()
|
||
|
|
|
||
|
|
def test_kit_component_cost(self):
|
||
|
|
# Set kit and componnet product to automated FIFO
|
||
|
|
self.kit_1.categ_id.property_cost_method = 'fifo'
|
||
|
|
self.kit_1.categ_id.property_valuation = 'real_time'
|
||
|
|
|
||
|
|
self.kit_1.bom_ids.product_qty = 3
|
||
|
|
|
||
|
|
po = Form(self.env['purchase.order'])
|
||
|
|
po.partner_id = self.env['res.partner'].create({'name': 'Testy'})
|
||
|
|
with po.order_line.new() as line:
|
||
|
|
line.product_id = self.kit_1
|
||
|
|
line.product_qty = 120
|
||
|
|
line.price_unit = 1260
|
||
|
|
po = po.save()
|
||
|
|
po.button_confirm()
|
||
|
|
po.picking_ids.button_validate()
|
||
|
|
|
||
|
|
# Unit price equaly dived among bom lines (cost share not set)
|
||
|
|
# # price further divided by product qty of each component
|
||
|
|
components = [
|
||
|
|
self.component_a,
|
||
|
|
self.component_b,
|
||
|
|
self.component_c,
|
||
|
|
]
|
||
|
|
|
||
|
|
self.assertEqual(sum([k.standard_price * k.qty_available for k in components]), 120 * 1260)
|
||
|
|
|
||
|
|
def test_kit_component_cost_multi_currency(self):
|
||
|
|
# Set kit and component product to automated FIFO
|
||
|
|
kit = self._create_product_with_form('Kit', self.uom_unit)
|
||
|
|
cmp = self._create_product_with_form('CMP', self.uom_unit)
|
||
|
|
|
||
|
|
bom_kit = self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': kit.product_tmpl_id.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'type': 'phantom'
|
||
|
|
})
|
||
|
|
self.env['mrp.bom.line'].create({
|
||
|
|
'product_id': cmp.id,
|
||
|
|
'product_qty': 3.0,
|
||
|
|
'bom_id': bom_kit.id})
|
||
|
|
|
||
|
|
kit.categ_id.property_cost_method = 'fifo'
|
||
|
|
kit.categ_id.property_valuation = 'real_time'
|
||
|
|
|
||
|
|
mock_currency = self.env['res.currency'].create({
|
||
|
|
'name': 'MOCK',
|
||
|
|
'symbol': 'MC',
|
||
|
|
})
|
||
|
|
self.env['res.currency.rate'].create({
|
||
|
|
'name': '2023-01-01',
|
||
|
|
'company_rate': 100.0,
|
||
|
|
'currency_id': mock_currency.id,
|
||
|
|
'company_id': self.env.company.id,
|
||
|
|
})
|
||
|
|
|
||
|
|
po = Form(self.env['purchase.order'])
|
||
|
|
po.partner_id = self.env['res.partner'].create({'name': 'Testy'})
|
||
|
|
po.currency_id = mock_currency
|
||
|
|
|
||
|
|
with po.order_line.new() as line:
|
||
|
|
line.product_id = kit
|
||
|
|
line.product_qty = 1
|
||
|
|
line.price_unit = 300.00
|
||
|
|
|
||
|
|
po = po.save()
|
||
|
|
po.button_confirm()
|
||
|
|
po.picking_ids.button_validate()
|
||
|
|
|
||
|
|
layer = po.picking_ids.move_ids.stock_valuation_layer_ids
|
||
|
|
self.assertEqual(layer.unit_cost, 1)
|
||
|
|
|
||
|
|
def test_01_sale_mrp_kit_qty_delivered(self):
|
||
|
|
""" Test that the quantities delivered are correct when
|
||
|
|
a kit with subkits is ordered with multiple backorders and returns
|
||
|
|
"""
|
||
|
|
|
||
|
|
# 'kit_parent' structure:
|
||
|
|
# ---------------------------
|
||
|
|
#
|
||
|
|
# kit_parent --|- kit_2 x2 --|- component_d x1
|
||
|
|
# | |- kit_1 x2 -------|- component_a x2
|
||
|
|
# | |- component_b x1
|
||
|
|
# | |- component_c x3
|
||
|
|
# |
|
||
|
|
# |- kit_3 x1 --|- component_f x1
|
||
|
|
# | |- component_g x2
|
||
|
|
# |
|
||
|
|
# |- component_e x1
|
||
|
|
|
||
|
|
# Creation of a sale order for x7 kit_parent
|
||
|
|
partner = self.env['res.partner'].create({'name': 'My Test Partner'})
|
||
|
|
f = Form(self.env['purchase.order'])
|
||
|
|
f.partner_id = partner
|
||
|
|
with f.order_line.new() as line:
|
||
|
|
line.product_id = self.kit_parent
|
||
|
|
line.product_qty = 7.0
|
||
|
|
line.price_unit = 10
|
||
|
|
|
||
|
|
po = f.save()
|
||
|
|
po.button_confirm()
|
||
|
|
|
||
|
|
# Check picking creation, its move lines should concern
|
||
|
|
# only components. Also checks that the quantities are corresponding
|
||
|
|
# to the PO
|
||
|
|
self.assertEqual(len(po.picking_ids), 1)
|
||
|
|
order_line = po.order_line[0]
|
||
|
|
picking_original = po.picking_ids[0]
|
||
|
|
move_ids = picking_original.move_ids
|
||
|
|
products = move_ids.mapped('product_id')
|
||
|
|
kits = [self.kit_parent, self.kit_3, self.kit_2, self.kit_1]
|
||
|
|
components = [self.component_a, self.component_b, self.component_c, self.component_d, self.component_e,
|
||
|
|
self.component_f, self.component_g]
|
||
|
|
expected_quantities = {
|
||
|
|
self.component_a: 56.0,
|
||
|
|
self.component_b: 28.0,
|
||
|
|
self.component_c: 84.0,
|
||
|
|
self.component_d: 14.0,
|
||
|
|
self.component_e: 7.0,
|
||
|
|
self.component_f: 14.0,
|
||
|
|
self.component_g: 28.0
|
||
|
|
}
|
||
|
|
|
||
|
|
self.assertEqual(len(move_ids), 7)
|
||
|
|
self.assertTrue(not any(kit in products for kit in kits))
|
||
|
|
self.assertTrue(all(component in products for component in components))
|
||
|
|
self._assert_quantities(move_ids, expected_quantities)
|
||
|
|
|
||
|
|
# Process only 7 units of each component
|
||
|
|
qty_to_process = 7
|
||
|
|
move_ids.write({'quantity': qty_to_process, 'picked': True})
|
||
|
|
|
||
|
|
# Create a backorder for the missing componenents
|
||
|
|
pick = po.picking_ids[0]
|
||
|
|
Form.from_action(self.env, pick.button_validate()).save().process()
|
||
|
|
|
||
|
|
# Check that a backorded is created
|
||
|
|
self.assertEqual(len(po.picking_ids), 2)
|
||
|
|
backorder_1 = po.picking_ids - picking_original
|
||
|
|
self.assertEqual(backorder_1.backorder_id.id, picking_original.id)
|
||
|
|
|
||
|
|
# Even if some components are received completely,
|
||
|
|
# no KitParent should be received
|
||
|
|
self.assertEqual(order_line.qty_received, 0)
|
||
|
|
|
||
|
|
# Process just enough components to make 1 kit_parent
|
||
|
|
qty_to_process = {
|
||
|
|
self.component_a: 1,
|
||
|
|
self.component_c: 5,
|
||
|
|
}
|
||
|
|
self._process_quantities(backorder_1.move_ids, qty_to_process)
|
||
|
|
|
||
|
|
# Create a backorder for the missing componenents
|
||
|
|
Form.from_action(self.env, backorder_1.button_validate()).save().process()
|
||
|
|
|
||
|
|
# Only 1 kit_parent should be received at this point
|
||
|
|
self.assertEqual(order_line.qty_received, 1)
|
||
|
|
|
||
|
|
# Check that the second backorder is created
|
||
|
|
self.assertEqual(len(po.picking_ids), 3)
|
||
|
|
backorder_2 = po.picking_ids - picking_original - backorder_1
|
||
|
|
self.assertEqual(backorder_2.backorder_id.id, backorder_1.id)
|
||
|
|
|
||
|
|
# Set the components quantities that backorder_2 should have
|
||
|
|
expected_quantities = {
|
||
|
|
self.component_a: 48,
|
||
|
|
self.component_b: 21,
|
||
|
|
self.component_c: 72,
|
||
|
|
self.component_d: 7,
|
||
|
|
self.component_f: 7,
|
||
|
|
self.component_g: 21
|
||
|
|
}
|
||
|
|
|
||
|
|
# Check that the computed quantities are matching the theorical ones.
|
||
|
|
# Since component_e was totally processed, this componenent shouldn't be
|
||
|
|
# present in backorder_2
|
||
|
|
self.assertEqual(len(backorder_2.move_ids), 6)
|
||
|
|
move_comp_e = backorder_2.move_ids.filtered(lambda m: m.product_id.id == self.component_e.id)
|
||
|
|
self.assertFalse(move_comp_e)
|
||
|
|
self._assert_quantities(backorder_2.move_ids, expected_quantities)
|
||
|
|
|
||
|
|
# Process enough components to make x3 kit_parents
|
||
|
|
qty_to_process = {
|
||
|
|
self.component_a: 16,
|
||
|
|
self.component_b: 5,
|
||
|
|
self.component_c: 24,
|
||
|
|
self.component_g: 5
|
||
|
|
}
|
||
|
|
self._process_quantities(backorder_2.move_ids, qty_to_process)
|
||
|
|
|
||
|
|
# Create a backorder for the missing componenents
|
||
|
|
Form.from_action(self.env, backorder_2.button_validate()).save().process()
|
||
|
|
|
||
|
|
# Check that x3 kit_parents are indeed received
|
||
|
|
self.assertEqual(order_line.qty_received, 3)
|
||
|
|
|
||
|
|
# Check that the third backorder is created
|
||
|
|
self.assertEqual(len(po.picking_ids), 4)
|
||
|
|
backorder_3 = po.picking_ids - (picking_original + backorder_1 + backorder_2)
|
||
|
|
self.assertEqual(backorder_3.backorder_id.id, backorder_2.id)
|
||
|
|
|
||
|
|
# Check the components quantities that backorder_3 should have
|
||
|
|
expected_quantities = {
|
||
|
|
self.component_a: 32,
|
||
|
|
self.component_b: 16,
|
||
|
|
self.component_c: 48,
|
||
|
|
self.component_d: 7,
|
||
|
|
self.component_f: 7,
|
||
|
|
self.component_g: 16
|
||
|
|
}
|
||
|
|
self._assert_quantities(backorder_3.move_ids, expected_quantities)
|
||
|
|
|
||
|
|
# Process all missing components
|
||
|
|
self._process_quantities(backorder_3.move_ids, expected_quantities)
|
||
|
|
|
||
|
|
# Validating the last backorder now it's complete.
|
||
|
|
# All kits should be received
|
||
|
|
backorder_3.button_validate()
|
||
|
|
self.assertEqual(order_line.qty_received, 7.0)
|
||
|
|
|
||
|
|
# Return all components processed by backorder_3
|
||
|
|
stock_return_picking_form = Form(self.env['stock.return.picking']
|
||
|
|
.with_context(active_ids=backorder_3.ids, active_id=backorder_3.ids[0],
|
||
|
|
active_model='stock.picking'))
|
||
|
|
return_wiz = stock_return_picking_form.save()
|
||
|
|
for return_move in return_wiz.product_return_moves:
|
||
|
|
return_move.write({
|
||
|
|
'quantity': expected_quantities[return_move.product_id],
|
||
|
|
'to_refund': True
|
||
|
|
})
|
||
|
|
res = return_wiz.action_create_returns()
|
||
|
|
return_pick = self.env['stock.picking'].browse(res['res_id'])
|
||
|
|
|
||
|
|
# Process all components and validate the picking
|
||
|
|
return_pick.button_validate()
|
||
|
|
|
||
|
|
# Now quantity received should be 3 again
|
||
|
|
self.assertEqual(order_line.qty_received, 3)
|
||
|
|
|
||
|
|
stock_return_picking_form = Form(self.env['stock.return.picking']
|
||
|
|
.with_context(active_ids=return_pick.ids, active_id=return_pick.ids[0],
|
||
|
|
active_model='stock.picking'))
|
||
|
|
return_wiz = stock_return_picking_form.save()
|
||
|
|
for move in return_wiz.product_return_moves:
|
||
|
|
move.quantity = expected_quantities[move.product_id]
|
||
|
|
res = return_wiz.action_create_returns()
|
||
|
|
return_of_return_pick = self.env['stock.picking'].browse(res['res_id'])
|
||
|
|
|
||
|
|
# Process all components except one of each
|
||
|
|
for move in return_of_return_pick.move_ids:
|
||
|
|
move.write({
|
||
|
|
'quantity': expected_quantities[move.product_id] - 1,
|
||
|
|
'to_refund': True
|
||
|
|
})
|
||
|
|
|
||
|
|
Form.from_action(self.env, return_of_return_pick.button_validate()).save().process()
|
||
|
|
|
||
|
|
# As one of each component is missing, only 6 kit_parents should be received
|
||
|
|
self.assertEqual(order_line.qty_received, 6)
|
||
|
|
|
||
|
|
# Check that the 4th backorder is created.
|
||
|
|
self.assertEqual(len(po.picking_ids), 7)
|
||
|
|
backorder_4 = po.picking_ids - (
|
||
|
|
picking_original + backorder_1 + backorder_2 + backorder_3 + return_of_return_pick + return_pick)
|
||
|
|
self.assertEqual(backorder_4.backorder_id.id, return_of_return_pick.id)
|
||
|
|
|
||
|
|
# Check the components quantities that backorder_4 should have
|
||
|
|
for move in backorder_4.move_ids:
|
||
|
|
self.assertEqual(move.product_qty, 1)
|
||
|
|
|
||
|
|
def test_concurent_procurements(self):
|
||
|
|
""" Check a production created to fulfill a procurement will not
|
||
|
|
replenish more that needed if others procurements have the same products
|
||
|
|
than the production component. """
|
||
|
|
|
||
|
|
warehouse = self.warehouse
|
||
|
|
buy_route = warehouse.buy_pull_id.route_id
|
||
|
|
manufacture_route = warehouse.manufacture_pull_id.route_id
|
||
|
|
|
||
|
|
vendor1 = self.env['res.partner'].create({'name': 'aaa', 'email': 'from.test@example.com'})
|
||
|
|
supplier_info1 = self.env['product.supplierinfo'].create({
|
||
|
|
'partner_id': vendor1.id,
|
||
|
|
'price': 50,
|
||
|
|
})
|
||
|
|
|
||
|
|
component = self.env['product.product'].create({
|
||
|
|
'name': 'component',
|
||
|
|
'is_storable': True,
|
||
|
|
'route_ids': [(4, buy_route.id)],
|
||
|
|
'seller_ids': [(6, 0, [supplier_info1.id])],
|
||
|
|
})
|
||
|
|
finished = self.env['product.product'].create({
|
||
|
|
'name': 'finished',
|
||
|
|
'is_storable': True,
|
||
|
|
'route_ids': [(4, manufacture_route.id)],
|
||
|
|
})
|
||
|
|
self.env['stock.warehouse.orderpoint'].create({
|
||
|
|
'name': 'A RR',
|
||
|
|
'location_id': warehouse.lot_stock_id.id,
|
||
|
|
'product_id': component.id,
|
||
|
|
'route_id': buy_route.id,
|
||
|
|
'product_min_qty': 0,
|
||
|
|
'product_max_qty': 0,
|
||
|
|
})
|
||
|
|
self.env['stock.warehouse.orderpoint'].create({
|
||
|
|
'name': 'A RR',
|
||
|
|
'location_id': warehouse.lot_stock_id.id,
|
||
|
|
'product_id': finished.id,
|
||
|
|
'route_id': manufacture_route.id,
|
||
|
|
'product_min_qty': 0,
|
||
|
|
'product_max_qty': 0,
|
||
|
|
})
|
||
|
|
|
||
|
|
self.env['mrp.bom'].create({
|
||
|
|
'product_id': finished.id,
|
||
|
|
'product_tmpl_id': finished.product_tmpl_id.id,
|
||
|
|
'product_uom_id': self.uom_unit.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'consumption': 'flexible',
|
||
|
|
'operation_ids': [
|
||
|
|
],
|
||
|
|
'type': 'normal',
|
||
|
|
'bom_line_ids': [
|
||
|
|
(0, 0, {'product_id': component.id, 'product_qty': 1}),
|
||
|
|
]})
|
||
|
|
|
||
|
|
# Delivery to trigger replenishment
|
||
|
|
picking_form = Form(self.env['stock.picking'])
|
||
|
|
picking_form.picking_type_id = warehouse.out_type_id
|
||
|
|
with picking_form.move_ids_without_package.new() as move:
|
||
|
|
move.product_id = finished
|
||
|
|
move.product_uom_qty = 3
|
||
|
|
with picking_form.move_ids_without_package.new() as move:
|
||
|
|
move.product_id = component
|
||
|
|
move.product_uom_qty = 2
|
||
|
|
picking = picking_form.save()
|
||
|
|
picking.action_confirm()
|
||
|
|
|
||
|
|
# Find PO
|
||
|
|
purchase = self.env['purchase.order.line'].search([
|
||
|
|
('product_id', '=', component.id),
|
||
|
|
]).order_id
|
||
|
|
self.assertTrue(purchase)
|
||
|
|
self.assertEqual(purchase.order_line.product_qty, 5)
|
||
|
|
|
||
|
|
def test_01_purchase_mrp_kit_qty_change(self):
|
||
|
|
self.partner = self.env['res.partner'].create({'name': 'Test Partner'})
|
||
|
|
|
||
|
|
# Create a PO with one unit of the kit product
|
||
|
|
self.po = self.env['purchase.order'].create({
|
||
|
|
'partner_id': self.partner.id,
|
||
|
|
'order_line': [(0, 0, {'name': self.kit_1.name, 'product_id': self.kit_1.id, 'product_qty': 1, 'product_uom': self.kit_1.uom_id.id, 'price_unit': 60.0, 'date_planned': fields.Datetime.now()})],
|
||
|
|
})
|
||
|
|
# Validate the PO
|
||
|
|
self.po.button_confirm()
|
||
|
|
|
||
|
|
# Check the component qty in the created picking
|
||
|
|
self.assertEqual(self.po.picking_ids.move_ids_without_package[0].product_uom_qty, 2, "The quantity of components must be created according to the BOM")
|
||
|
|
self.assertEqual(self.po.picking_ids.move_ids_without_package[1].product_uom_qty, 1, "The quantity of components must be created according to the BOM")
|
||
|
|
self.assertEqual(self.po.picking_ids.move_ids_without_package[2].product_uom_qty, 3, "The quantity of components must be created according to the BOM")
|
||
|
|
|
||
|
|
# Update the kit quantity in the PO
|
||
|
|
self.po.order_line[0].product_qty = 2
|
||
|
|
# Check the component qty after the update
|
||
|
|
self.assertEqual(self.po.picking_ids.move_ids_without_package[0].product_uom_qty, 4, "The amount of the kit components must be updated when changing the quantity of the kit.")
|
||
|
|
self.assertEqual(self.po.picking_ids.move_ids_without_package[1].product_uom_qty, 2, "The amount of the kit components must be updated when changing the quantity of the kit.")
|
||
|
|
self.assertEqual(self.po.picking_ids.move_ids_without_package[2].product_uom_qty, 6, "The amount of the kit components must be updated when changing the quantity of the kit.")
|
||
|
|
|
||
|
|
def test_procurement_with_preferred_route(self):
|
||
|
|
"""
|
||
|
|
3-steps receipts. Suppose a product that has both buy and manufacture
|
||
|
|
routes. The user runs an orderpoint with the preferred route defined to
|
||
|
|
"Buy". A purchase order should be generated.
|
||
|
|
"""
|
||
|
|
self.warehouse.reception_steps = 'three_steps'
|
||
|
|
|
||
|
|
manu_route = self.warehouse.manufacture_pull_id.route_id
|
||
|
|
buy_route = self.warehouse.buy_pull_id.route_id
|
||
|
|
|
||
|
|
# un-prioritize the buy rules
|
||
|
|
self.env['stock.rule'].search([]).sequence = 1
|
||
|
|
buy_route.rule_ids.sequence = 2
|
||
|
|
|
||
|
|
vendor = self.env['res.partner'].create({'name': 'super vendor'})
|
||
|
|
|
||
|
|
product = self.env['product.product'].create({
|
||
|
|
'name': 'super product',
|
||
|
|
'is_storable': True,
|
||
|
|
'seller_ids': [(0, 0, {'partner_id': vendor.id})],
|
||
|
|
'route_ids': [(4, manu_route.id), (4, buy_route.id)],
|
||
|
|
})
|
||
|
|
|
||
|
|
rr = self.env['stock.warehouse.orderpoint'].create({
|
||
|
|
'name': product.name,
|
||
|
|
'location_id': self.warehouse.lot_stock_id.id,
|
||
|
|
'product_id': product.id,
|
||
|
|
'product_min_qty': 1,
|
||
|
|
'product_max_qty': 1,
|
||
|
|
'route_id': buy_route.id,
|
||
|
|
})
|
||
|
|
rr.action_replenish()
|
||
|
|
|
||
|
|
po = self.env['purchase.order'].search([('partner_id', '=', vendor.id)])
|
||
|
|
self.assertTrue(po)
|
||
|
|
|
||
|
|
po.button_confirm()
|
||
|
|
|
||
|
|
def test_procurement_with_preferred_route_2(self):
|
||
|
|
"""
|
||
|
|
Check that the route set in the product is taken into account
|
||
|
|
when the product have a supplier and bom.
|
||
|
|
"""
|
||
|
|
manu_route = self.warehouse.manufacture_pull_id.route_id
|
||
|
|
buy_route = self.warehouse.buy_pull_id.route_id
|
||
|
|
|
||
|
|
vendor = self.env['res.partner'].create({'name': 'super vendor'})
|
||
|
|
|
||
|
|
product = self.env['product.product'].create({
|
||
|
|
'name': 'super product',
|
||
|
|
'is_storable': True,
|
||
|
|
'seller_ids': [(0, 0, {'partner_id': vendor.id})],
|
||
|
|
'route_ids': buy_route,
|
||
|
|
})
|
||
|
|
self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': product.product_tmpl_id.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'product_uom_id': product.uom_id.id,
|
||
|
|
})
|
||
|
|
# create a need of the product with a picking
|
||
|
|
warehouse = self.env['stock.warehouse'].search([('company_id', '=', self.env.company.id)], limit=1)
|
||
|
|
picking = self.env['stock.picking'].create({
|
||
|
|
'location_id': warehouse.lot_stock_id.id,
|
||
|
|
'location_dest_id': self.env.ref('stock.stock_location_customers').id,
|
||
|
|
'picking_type_id': warehouse.out_type_id.id,
|
||
|
|
'move_ids': [(0, 0, {
|
||
|
|
'name': product.name,
|
||
|
|
'product_id': product.id,
|
||
|
|
'product_uom': product.uom_id.id,
|
||
|
|
'product_uom_qty': 1,
|
||
|
|
'location_id': warehouse.lot_stock_id.id,
|
||
|
|
'location_dest_id': self.env.ref('stock.stock_location_customers').id,
|
||
|
|
})]
|
||
|
|
})
|
||
|
|
picking.action_assign()
|
||
|
|
self.env['stock.warehouse.orderpoint']._get_orderpoint_action()
|
||
|
|
orderpoint_product = self.env['stock.warehouse.orderpoint'].search(
|
||
|
|
[('product_id', '=', product.id)])
|
||
|
|
self.assertEqual(orderpoint_product.route_id, buy_route, "The route buy should be set on the orderpoint")
|
||
|
|
# Delete the orderpoint to generate a new one with the manufacture route
|
||
|
|
orderpoint_product.unlink()
|
||
|
|
# switch the product route to manufacture
|
||
|
|
product.write({'route_ids': [(3, buy_route.id), (4, manu_route.id)]})
|
||
|
|
self.env['stock.warehouse.orderpoint']._get_orderpoint_action()
|
||
|
|
orderpoint_product = self.env['stock.warehouse.orderpoint'].search(
|
||
|
|
[('product_id', '=', product.id)])
|
||
|
|
self.assertEqual(orderpoint_product.route_id, manu_route, "The route manufacture should be set on the orderpoint")
|
||
|
|
|
||
|
|
def test_compute_bom_days_00(self):
|
||
|
|
"""Check Days to prepare Manufacturing Order are correctly computed when
|
||
|
|
Security Lead Time and Days to Purchase are set.
|
||
|
|
"""
|
||
|
|
purchase_route = self.env.ref("purchase_stock.route_warehouse0_buy")
|
||
|
|
manufacture_route = self.env['stock.route'].search([('name', '=', 'Manufacture')])
|
||
|
|
vendor = self.env['res.partner'].create({'name': 'super vendor'})
|
||
|
|
|
||
|
|
company_1 = self.kit_parent.bom_ids.company_id
|
||
|
|
company_2 = self.env['res.company'].create({
|
||
|
|
'name': 'TestCompany2',
|
||
|
|
})
|
||
|
|
|
||
|
|
company_1.po_lead = 0
|
||
|
|
company_1.days_to_purchase = 0
|
||
|
|
company_1.manufacturing_lead = 0
|
||
|
|
company_2.po_lead = 0
|
||
|
|
company_2.days_to_purchase = 0
|
||
|
|
company_2.manufacturing_lead = 0
|
||
|
|
|
||
|
|
components = self.component_a | self.component_b | self.component_c | self.component_d | self.component_e | self.component_f | self.component_g
|
||
|
|
kits = self.kit_parent | self.kit_1 | self.kit_2 | self.kit_3
|
||
|
|
kits.route_ids = [(6, 0, manufacture_route.ids)]
|
||
|
|
components.write({
|
||
|
|
'route_ids': [(6, 0, purchase_route.ids)],
|
||
|
|
'seller_ids': [(0, 0, {
|
||
|
|
'partner_id': vendor.id,
|
||
|
|
'min_qty': 1,
|
||
|
|
'price': 1,
|
||
|
|
'delay': 1,
|
||
|
|
})],
|
||
|
|
})
|
||
|
|
|
||
|
|
bom_kit_parent = self.kit_parent.bom_ids
|
||
|
|
bom_kit_parent.action_compute_bom_days()
|
||
|
|
self.assertEqual(bom_kit_parent.days_to_prepare_mo, 1)
|
||
|
|
|
||
|
|
# set "Security Lead Time" for Purchase and manufacturing, and "Days to Purchase"
|
||
|
|
company_1.po_lead = 10
|
||
|
|
company_1.days_to_purchase = 10
|
||
|
|
company_1.manufacturing_lead = 10
|
||
|
|
company_2.po_lead = 20
|
||
|
|
company_2.days_to_purchase = 20
|
||
|
|
company_2.manufacturing_lead = 20
|
||
|
|
|
||
|
|
# check "Security Lead Time" and "Days to Purchase" will also be included if bom has company_id
|
||
|
|
bom_kit_parent.action_compute_bom_days()
|
||
|
|
self.assertEqual(bom_kit_parent.days_to_prepare_mo, 10 + 10 + 10 + 10 + 1)
|
||
|
|
|
||
|
|
self.kit_1.bom_ids.company_id = company_2
|
||
|
|
bom_kit_parent.action_compute_bom_days()
|
||
|
|
self.assertEqual(bom_kit_parent.days_to_prepare_mo, 20 + 20 + 20 + 10 + 1)
|
||
|
|
|
||
|
|
# check "Security Lead Time" and "Days to Purchase" will won't be included if bom doesn't have company_id
|
||
|
|
kits.bom_ids.company_id = False
|
||
|
|
bom_kit_parent.action_compute_bom_days()
|
||
|
|
self.assertEqual(bom_kit_parent.days_to_prepare_mo, 1)
|
||
|
|
|
||
|
|
def test_orderpoint_with_manufacture_security_lead_time(self):
|
||
|
|
"""
|
||
|
|
Test that a manufacturing order is created with the correct date_start
|
||
|
|
when we have an order point with the preferred route set to "manufacture"
|
||
|
|
and the current company has a manufacturing security lead time set.
|
||
|
|
"""
|
||
|
|
# set purchase security lead time to 20 days
|
||
|
|
self.env.company.po_lead = 20
|
||
|
|
# set manufacturing security lead time to 25 days
|
||
|
|
self.env.company.manufacturing_lead = 25
|
||
|
|
product = self.env['product.product'].create({
|
||
|
|
'name': 'super product',
|
||
|
|
'is_storable': True,
|
||
|
|
#set route to manufacture + buy
|
||
|
|
'route_ids': [
|
||
|
|
(4, self.env.ref('mrp.route_warehouse0_manufacture').id),
|
||
|
|
(4, self.env.ref('purchase_stock.route_warehouse0_buy').id)
|
||
|
|
],
|
||
|
|
'seller_ids': [(0, 0, {
|
||
|
|
'partner_id': self.env['res.partner'].create({'name': 'super vendor'}).id,
|
||
|
|
'min_qty': 1,
|
||
|
|
'price': 1,
|
||
|
|
})],
|
||
|
|
})
|
||
|
|
self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': product.product_tmpl_id.id,
|
||
|
|
'produce_delay': 1,
|
||
|
|
'product_qty': 1,
|
||
|
|
})
|
||
|
|
# create a orderpoint to generate a need of the product with perefered route manufacture
|
||
|
|
orderpoint = self.env['stock.warehouse.orderpoint'].create({
|
||
|
|
'product_id': product.id,
|
||
|
|
'qty_to_order': 5,
|
||
|
|
'warehouse_id': self.warehouse.id,
|
||
|
|
'route_id': self.env.ref('mrp.route_warehouse0_manufacture').id,
|
||
|
|
})
|
||
|
|
# lead_days_date should be today + manufacturing security lead time + product manufacturing lead time
|
||
|
|
self.assertEqual(orderpoint.lead_days_date, (fields.Date.today() + timedelta(days=25) + timedelta(days=1)))
|
||
|
|
orderpoint.action_replenish()
|
||
|
|
mo = self.env['mrp.production'].search([('product_id', '=', product.id)])
|
||
|
|
self.assertEqual(mo.product_uom_qty, 5)
|
||
|
|
self.assertEqual(mo.date_start.date(), fields.Date.today())
|
||
|
|
|
||
|
|
def test_mo_overview(self):
|
||
|
|
component = self.env['product.product'].create({
|
||
|
|
'name': 'component',
|
||
|
|
'is_storable': True,
|
||
|
|
'standard_price': 80,
|
||
|
|
'seller_ids': [(0, 0, {
|
||
|
|
'partner_id': self.env['res.partner'].create({'name': 'super vendor'}).id,
|
||
|
|
'min_qty': 3,
|
||
|
|
'price': 10,
|
||
|
|
})],
|
||
|
|
})
|
||
|
|
finished_product = self.env['product.product'].create({
|
||
|
|
'name': 'finished_product',
|
||
|
|
'is_storable': True,
|
||
|
|
})
|
||
|
|
self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': finished_product.product_tmpl_id.id,
|
||
|
|
'product_qty': 1,
|
||
|
|
'bom_line_ids': [(0, 0, {
|
||
|
|
'product_id': component.id,
|
||
|
|
'product_qty': 2,
|
||
|
|
'product_uom_id': component.uom_id.id
|
||
|
|
})],
|
||
|
|
})
|
||
|
|
mo = self.env['mrp.production'].create({
|
||
|
|
'product_id': finished_product.id,
|
||
|
|
'product_qty': 1,
|
||
|
|
'product_uom_id': finished_product.uom_id.id,
|
||
|
|
})
|
||
|
|
self.env.flush_all() # flush to correctly build report
|
||
|
|
report_values = self.env['report.mrp.report_mo_overview']._get_report_data(mo.id)['components'][0]['summary']
|
||
|
|
self.assertEqual(report_values['name'], component.name)
|
||
|
|
self.assertEqual(report_values['quantity'], 2)
|
||
|
|
self.assertEqual(report_values['mo_cost'], 160)
|
||
|
|
# Create a second MO with the minimum seller quantity to check that the cost is correctly calculated using the seller's price
|
||
|
|
mo_2 = self.env['mrp.production'].create({
|
||
|
|
'product_id': finished_product.id,
|
||
|
|
'product_qty': 2,
|
||
|
|
'product_uom_id': finished_product.uom_id.id,
|
||
|
|
})
|
||
|
|
self.env.flush_all()
|
||
|
|
report_values = self.env['report.mrp.report_mo_overview']._get_report_data(mo_2.id)['components'][0]['summary']
|
||
|
|
self.assertEqual(report_values['quantity'], 4)
|
||
|
|
self.assertEqual(report_values['mo_cost'], 40)
|
||
|
|
|
||
|
|
def test_bom_report_incoming_po(self):
|
||
|
|
""" Test report bom structure with duplicated components
|
||
|
|
With enough stock for the first line and two incoming
|
||
|
|
POs for the second line and third line.
|
||
|
|
"""
|
||
|
|
location = self.stock_location
|
||
|
|
uom_unit = self.env.ref('uom.product_uom_unit')
|
||
|
|
final_product_tmpl = self.env['product.template'].create({'name': 'Final Product', 'is_storable': True})
|
||
|
|
component_product = self.env['product.product'].create({'name': 'Compo 1', 'is_storable': True})
|
||
|
|
|
||
|
|
self.env['stock.quant']._update_available_quantity(component_product, location, 3.0)
|
||
|
|
|
||
|
|
bom = self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': final_product_tmpl.id,
|
||
|
|
'product_uom_id': self.uom_unit.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'type': 'normal',
|
||
|
|
'bom_line_ids': [
|
||
|
|
Command.create({
|
||
|
|
'product_id': component_product.id,
|
||
|
|
'product_qty': 3,
|
||
|
|
'product_uom_id': uom_unit.id,
|
||
|
|
}),
|
||
|
|
Command.create({
|
||
|
|
'product_id': component_product.id,
|
||
|
|
'product_qty': 3,
|
||
|
|
'product_uom_id': uom_unit.id,
|
||
|
|
}),
|
||
|
|
Command.create({
|
||
|
|
'product_id': component_product.id,
|
||
|
|
'product_qty': 4,
|
||
|
|
'product_uom_id': uom_unit.id,
|
||
|
|
})
|
||
|
|
]
|
||
|
|
})
|
||
|
|
def create_order(product_id, partner_id, date_order):
|
||
|
|
f = Form(self.env['purchase.order'])
|
||
|
|
f.partner_id = partner_id
|
||
|
|
f.date_order = date_order
|
||
|
|
with f.order_line.new() as line:
|
||
|
|
line.product_id = product_id
|
||
|
|
line.product_qty = 3.0
|
||
|
|
line.price_unit = 10
|
||
|
|
return f.save()
|
||
|
|
partner = self.env['res.partner'].create({'name': 'My Test Partner'})
|
||
|
|
# Create and confirm two POs with 3 component_product at different date
|
||
|
|
po_today = create_order(component_product, partner, fields.Datetime.now())
|
||
|
|
po_5days = create_order(component_product, partner, fields.Datetime.now() + timedelta(days=5))
|
||
|
|
|
||
|
|
po_today.button_confirm()
|
||
|
|
po_5days.button_confirm()
|
||
|
|
report_values = self.env['report.mrp.report_bom_structure']._get_report_data(bom_id=bom.id)
|
||
|
|
line_values = report_values['lines']['components'][0]
|
||
|
|
self.assertEqual(line_values['availability_state'], 'estimated', 'The merged components should be estimated.')
|
||
|
|
|
||
|
|
def test_bom_report_incoming_po2(self):
|
||
|
|
""" Test report bom structure with duplicated components
|
||
|
|
With an incoming PO for the first and second line.
|
||
|
|
"""
|
||
|
|
uom_unit = self.env.ref('uom.product_uom_unit')
|
||
|
|
final_product_tmpl = self.env['product.template'].create({'name': 'Final Product', 'is_storable': True})
|
||
|
|
component_product = self.env['product.product'].create({'name': 'Compo 1', 'is_storable': True})
|
||
|
|
|
||
|
|
bom = self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': final_product_tmpl.id,
|
||
|
|
'product_uom_id': self.uom_unit.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'type': 'normal',
|
||
|
|
'bom_line_ids': [
|
||
|
|
Command.create({
|
||
|
|
'product_id': component_product.id,
|
||
|
|
'product_qty': 3,
|
||
|
|
'product_uom_id': uom_unit.id,
|
||
|
|
}),
|
||
|
|
Command.create({
|
||
|
|
'product_id': component_product.id,
|
||
|
|
'product_qty': 3,
|
||
|
|
'product_uom_id': uom_unit.id,
|
||
|
|
}),
|
||
|
|
]
|
||
|
|
})
|
||
|
|
partner = self.env['res.partner'].create({'name': 'My Test Partner'})
|
||
|
|
# Create and confirm one PO with 6 component_products.
|
||
|
|
f = Form(self.env['purchase.order'])
|
||
|
|
f.partner_id = partner
|
||
|
|
f.date_order = fields.Datetime.now()
|
||
|
|
with f.order_line.new() as line:
|
||
|
|
line.product_id = component_product
|
||
|
|
line.product_qty = 6.0
|
||
|
|
line.price_unit = 10
|
||
|
|
po_today = f.save()
|
||
|
|
po_today.button_confirm()
|
||
|
|
report_values = self.env['report.mrp.report_bom_structure']._get_report_data(bom_id=bom.id)
|
||
|
|
line_values = report_values['lines']['components'][0]
|
||
|
|
self.assertEqual(line_values['availability_state'], 'expected', 'The first component should be expected as there is an incoming PO.')
|
||
|
|
|
||
|
|
def test_purchase_multistep_kit_qty_change(self):
|
||
|
|
self.warehouse.write({"reception_steps": "two_steps"})
|
||
|
|
self.partner = self.env['res.partner'].create({'name': 'Test Partner'})
|
||
|
|
|
||
|
|
kit_prod = self._create_product_with_form('kit_prod', self.uom_unit)
|
||
|
|
sub_kit = self._create_product_with_form('sub_kit', self.uom_unit)
|
||
|
|
component = self._create_product_with_form('component', self.uom_unit)
|
||
|
|
|
||
|
|
# 6 kit_prod == 5 component
|
||
|
|
self.env['mrp.bom'].create([{ # 2 kit_prod == 5 sub_kit
|
||
|
|
'product_tmpl_id': kit_prod.product_tmpl_id.id,
|
||
|
|
'product_qty': 2.0,
|
||
|
|
'type': 'phantom',
|
||
|
|
'bom_line_ids': [(0, 0, {
|
||
|
|
'product_id': sub_kit.id,
|
||
|
|
'product_qty': 5,
|
||
|
|
})],
|
||
|
|
}, { # 3 sub_kit == 1 component
|
||
|
|
'product_tmpl_id': sub_kit.product_tmpl_id.id,
|
||
|
|
'product_qty': 3.0,
|
||
|
|
'type': 'phantom',
|
||
|
|
'bom_line_ids': [(0, 0, {
|
||
|
|
'product_id': component.id,
|
||
|
|
'product_qty': 1,
|
||
|
|
})],
|
||
|
|
}])
|
||
|
|
|
||
|
|
po = self.env['purchase.order'].create({
|
||
|
|
'partner_id': self.partner.id,
|
||
|
|
'order_line': [(0, 0, {
|
||
|
|
'name': kit_prod.name,
|
||
|
|
'product_id': kit_prod.id,
|
||
|
|
'product_qty': 30,
|
||
|
|
})],
|
||
|
|
})
|
||
|
|
# Validate the PO
|
||
|
|
po.button_confirm()
|
||
|
|
picking = po.picking_ids
|
||
|
|
# Check the component qty in the created picking should be 25
|
||
|
|
self.assertEqual(picking.move_line_ids.quantity_product_uom, 30 * 5 / 6)
|
||
|
|
|
||
|
|
# Update the kit quantity in the PO
|
||
|
|
po.order_line[0].product_qty = 60
|
||
|
|
# Check the component qty after the update should be 50
|
||
|
|
self.assertEqual(picking.move_line_ids.quantity_product_uom, 60 * 5 / 6)
|
||
|
|
|
||
|
|
# Recieve half the quantity 25 component == 30 kit_prod
|
||
|
|
picking.move_line_ids.quantity = 25
|
||
|
|
picking.with_context(skip_backorder=True).button_validate()
|
||
|
|
self.assertEqual(po.order_line.qty_received, 25 / 5 * 6)
|
||
|
|
|
||
|
|
# Return 10 components
|
||
|
|
stock_return_picking_form = Form(self.env['stock.return.picking']
|
||
|
|
.with_context(active_ids=picking.ids, active_id=picking.id,
|
||
|
|
active_model='stock.picking'))
|
||
|
|
return_wiz = stock_return_picking_form.save()
|
||
|
|
for return_move in return_wiz.product_return_moves:
|
||
|
|
return_move.write({
|
||
|
|
'quantity': 10,
|
||
|
|
'to_refund': True
|
||
|
|
})
|
||
|
|
res = return_wiz.action_create_returns()
|
||
|
|
return_pick = self.env['stock.picking'].browse(res['res_id'])
|
||
|
|
|
||
|
|
# Process all components and validate the return
|
||
|
|
return_pick.button_validate()
|
||
|
|
self.assertEqual(po.order_line.qty_received, 15 / 5 * 6)
|
||
|
|
|
||
|
|
def test_bom_report_vendor_quantities(self):
|
||
|
|
""" Test bom overview with different vendor minimum quantities, see if it picks the right ones.
|
||
|
|
"""
|
||
|
|
buy_route = self.warehouse.buy_pull_id.route_id
|
||
|
|
final = self.env['product.product'].create({'name': 'Final', 'type': 'consu', 'is_storable': True})
|
||
|
|
# Compo A has 2 vendors, one faster but with a min qty of 5, the other with more delay but without a min qty
|
||
|
|
self.component_a.write({
|
||
|
|
'route_ids': [Command.link(buy_route.id)],
|
||
|
|
'seller_ids': [
|
||
|
|
Command.create({'partner_id': self.partner_a.id, 'min_qty': 0, 'delay': 5}),
|
||
|
|
Command.create({'partner_id': self.partner_b.id, 'min_qty': 5, 'delay': 1}),
|
||
|
|
],
|
||
|
|
})
|
||
|
|
# Compo B has 1 vendor with a min qty of 5
|
||
|
|
self.component_b.write({
|
||
|
|
'route_ids': [Command.link(buy_route.id)],
|
||
|
|
'seller_ids': [
|
||
|
|
Command.create({'partner_id': self.partner_a.id, 'min_qty': 5}),
|
||
|
|
]
|
||
|
|
})
|
||
|
|
# Compo C has 1 vendor with a min qty of 5
|
||
|
|
self.component_c.write({
|
||
|
|
'route_ids': [Command.link(buy_route.id)],
|
||
|
|
'seller_ids': [
|
||
|
|
Command.create({'partner_id': self.partner_a.id, 'min_qty': 5}),
|
||
|
|
]
|
||
|
|
})
|
||
|
|
# Compo D has 1 vendor with a min qty of 1 dozen
|
||
|
|
self.component_d.write({
|
||
|
|
'uom_po_id': self.uom_dozen.id,
|
||
|
|
'route_ids': [Command.link(buy_route.id)],
|
||
|
|
'seller_ids': [
|
||
|
|
Command.create({'partner_id': self.partner_a.id, 'min_qty': 1, 'price': 10}),
|
||
|
|
]
|
||
|
|
})
|
||
|
|
|
||
|
|
bom = self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': final.product_tmpl_id.id,
|
||
|
|
'product_uom_id': self.uom_unit.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'type': 'normal',
|
||
|
|
'bom_line_ids': [
|
||
|
|
Command.create({
|
||
|
|
'product_id': self.component_a.id,
|
||
|
|
'product_qty': 10,
|
||
|
|
'product_uom_id': self.uom_unit.id,
|
||
|
|
}),
|
||
|
|
Command.create({
|
||
|
|
'product_id': self.component_b.id,
|
||
|
|
'product_qty': 3,
|
||
|
|
'product_uom_id': self.uom_unit.id,
|
||
|
|
}),
|
||
|
|
Command.create({
|
||
|
|
'product_id': self.component_c.id,
|
||
|
|
'product_qty': 1,
|
||
|
|
'product_uom_id': self.uom_dozen.id,
|
||
|
|
}),
|
||
|
|
Command.create({
|
||
|
|
'product_id': self.component_d.id,
|
||
|
|
'product_qty': 3,
|
||
|
|
'product_uom_id': self.uom_unit.id,
|
||
|
|
})
|
||
|
|
]
|
||
|
|
})
|
||
|
|
|
||
|
|
report_values = self.env['report.mrp.report_bom_structure']._get_report_data(bom_id=bom.id)
|
||
|
|
|
||
|
|
compo_a_values = report_values['lines']['components'][0]
|
||
|
|
self.assertEqual(compo_a_values['route_detail'], self.partner_b.display_name, "Compo A should have picked the fastest supplier")
|
||
|
|
compo_b_values = report_values['lines']['components'][1]
|
||
|
|
self.assertEqual(compo_b_values['route_detail'], self.partner_a.display_name, "Compo B should have found the supplier, even without enough qty")
|
||
|
|
self.assertTrue(compo_b_values['route_alert'], "Should be true as there isn't enough quantity for this vendor")
|
||
|
|
compo_c_values = report_values['lines']['components'][2]
|
||
|
|
self.assertEqual(compo_c_values['route_detail'], self.partner_a.display_name)
|
||
|
|
self.assertFalse(compo_c_values['route_alert'], "Should be false as 1 dozen > 5 units for this vendor")
|
||
|
|
compo_d_values = report_values['lines']['components'][3]
|
||
|
|
self.assertEqual(compo_d_values['route_detail'], self.partner_a.display_name, "Compo D should have found the supplier, even without enough qty")
|
||
|
|
self.assertTrue(compo_d_values['route_alert'], "Should be true as 3 units < 1 dozen for this vendor")
|
||
|
|
|
||
|
|
def test_valuation_with_backorder(self):
|
||
|
|
fifo_category = self.env['product.category'].create({
|
||
|
|
'name': 'FIFO',
|
||
|
|
'property_cost_method': 'fifo',
|
||
|
|
'property_valuation': 'real_time'
|
||
|
|
})
|
||
|
|
kit, cmp1, cmp2 = self.env['product.product'].create([{
|
||
|
|
'name': name,
|
||
|
|
'standard_price': 0,
|
||
|
|
'is_storable': True,
|
||
|
|
'categ_id': fifo_category.id,
|
||
|
|
} for name in ['Kit', 'Cmp1', 'Cmp2']])
|
||
|
|
kit.uom_id = self.uom_gm.id
|
||
|
|
cmp1.uom_id = self.uom_gm.id
|
||
|
|
cmp2.uom_id = self.uom_kg.id
|
||
|
|
|
||
|
|
self.env['mrp.bom'].create({
|
||
|
|
'product_uom_id': self.uom_kg.id,
|
||
|
|
'product_qty': 3,
|
||
|
|
'product_tmpl_id': kit.product_tmpl_id.id,
|
||
|
|
'type': 'phantom',
|
||
|
|
'bom_line_ids': [
|
||
|
|
(0, 0, {'product_id': cmp1.id, 'product_qty': 2, 'product_uom_id': self.uom_kg.id}),
|
||
|
|
(0, 0, {'product_id': cmp2.id, 'product_qty': 1, 'product_uom_id': self.uom_gm.id})]
|
||
|
|
})
|
||
|
|
|
||
|
|
po_form = Form(self.env['purchase.order'])
|
||
|
|
partner = self.env['res.partner'].create({'name': 'My Test Partner'})
|
||
|
|
po_form.partner_id = partner
|
||
|
|
with po_form.order_line.new() as pol_form:
|
||
|
|
pol_form.product_id = kit
|
||
|
|
pol_form.product_qty = 30
|
||
|
|
pol_form.product_uom = self.uom_kg
|
||
|
|
pol_form.price_unit = 90000
|
||
|
|
pol_form.taxes_id.clear()
|
||
|
|
po = po_form.save()
|
||
|
|
po.button_confirm()
|
||
|
|
|
||
|
|
receipt = po.picking_ids
|
||
|
|
receipt.move_line_ids[0].quantity = 4
|
||
|
|
receipt.move_line_ids[1].quantity = 2
|
||
|
|
Form.from_action(self.env, receipt.button_validate()).save().process()
|
||
|
|
# Price Unit for 1 gm of the kit = 90000/1000 = 90
|
||
|
|
# unit_cost for cmp1 = 90 *1000* 3 / 2 / 2 / 1000 = 67.5
|
||
|
|
# unit_cost for cmp2 = 90 *1000* 3 / 2 / 1 * 1000 = 135000000
|
||
|
|
svl = po.picking_ids[0].move_ids.stock_valuation_layer_ids
|
||
|
|
self.assertEqual(svl[0].unit_cost, 67.5)
|
||
|
|
self.assertEqual(svl[1].unit_cost, 135000000)
|
||
|
|
|
||
|
|
def test_mo_overview_mto_purchase_with_backorders(self):
|
||
|
|
self.warehouse.reception_steps = 'two_steps'
|
||
|
|
# Enable MTO route for Component
|
||
|
|
self.env.ref('stock.route_warehouse0_mto').active = True
|
||
|
|
route_buy = self.warehouse.buy_pull_id.route_id
|
||
|
|
route_mto = self.warehouse.mto_pull_id.route_id
|
||
|
|
route_mto.rule_ids.procure_method = "make_to_order"
|
||
|
|
self.component_a.write({
|
||
|
|
'seller_ids': [
|
||
|
|
Command.create({'partner_id': self.partner_a.id},
|
||
|
|
)],
|
||
|
|
'route_ids': [
|
||
|
|
Command.link(route_buy.id),
|
||
|
|
Command.link(route_mto.id),
|
||
|
|
],
|
||
|
|
})
|
||
|
|
|
||
|
|
bom = self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': self.component_b.product_tmpl_id.id,
|
||
|
|
'product_qty': 1.0,
|
||
|
|
'bom_line_ids': [
|
||
|
|
Command.create({
|
||
|
|
'product_id': self.component_a.id,
|
||
|
|
'product_qty': 2.0,
|
||
|
|
}),
|
||
|
|
],
|
||
|
|
})
|
||
|
|
with Form(self.env['mrp.production']) as prod_form:
|
||
|
|
prod_form.product_id = self.component_b
|
||
|
|
prod_form.bom_id = bom
|
||
|
|
prod_form.product_qty = 3
|
||
|
|
production = prod_form.save()
|
||
|
|
production.action_confirm()
|
||
|
|
self.assertEqual(production.purchase_order_count, 1)
|
||
|
|
purchase = production.procurement_group_id.stock_move_ids.created_purchase_line_ids.order_id
|
||
|
|
self.assertEqual(len(purchase), 1)
|
||
|
|
|
||
|
|
with Form(production) as prod_form:
|
||
|
|
prod_form.qty_producing = 1
|
||
|
|
production = prod_form.save()
|
||
|
|
backorder_action = production.button_mark_done()
|
||
|
|
backorder_wizard = Form(self.env['mrp.production.backorder'].with_context(**backorder_action['context']))
|
||
|
|
backorder_wizard.save().action_backorder()
|
||
|
|
|
||
|
|
backorder = production.procurement_group_id.mrp_production_ids - production
|
||
|
|
self.assertEqual(len(backorder), 1)
|
||
|
|
self.assertEqual(backorder.product_qty, 2)
|
||
|
|
report_values = self.env['report.mrp.report_mo_overview']._get_report_data(backorder.id)
|
||
|
|
self.assertEqual(report_values['summary']['quantity'], backorder.product_qty)
|
||
|
|
self.assertEqual(report_values['components'][0]['summary']['quantity'], 4)
|
||
|
|
replenishments = report_values['components'][0]['replenishments']
|
||
|
|
self.assertEqual(len(replenishments), 1)
|
||
|
|
self.assertEqual(replenishments[0]['summary']['name'], purchase.name)
|
||
|
|
|
||
|
|
def test_total_cost_share_rounded_to_precision(self):
|
||
|
|
kit, compo01, compo02 = self.env['product.product'].create([{
|
||
|
|
'name': name,
|
||
|
|
'standard_price': price,
|
||
|
|
} for name, price in [('Kit', 30), ('Compo 01', 10), ('Compo 02', 20)]])
|
||
|
|
|
||
|
|
bom = self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': kit.product_tmpl_id.id,
|
||
|
|
'type': 'phantom',
|
||
|
|
'bom_line_ids': [(0, 0, {
|
||
|
|
'product_id': compo01.id,
|
||
|
|
'product_qty': 1,
|
||
|
|
'cost_share': 99.99,
|
||
|
|
}), (0, 0, {
|
||
|
|
'product_id': compo02.id,
|
||
|
|
'product_qty': 1,
|
||
|
|
'cost_share': 0.01,
|
||
|
|
})],
|
||
|
|
})
|
||
|
|
self.assertTrue(bom)
|
||
|
|
|
||
|
|
def test_kit_price_without_rounding(self):
|
||
|
|
warehouse = self.warehouse
|
||
|
|
buy_route = warehouse.buy_pull_id.route_id
|
||
|
|
manufacture_route = warehouse.manufacture_pull_id.route_id
|
||
|
|
|
||
|
|
avco_category = self.env['product.category'].create({
|
||
|
|
'name': 'AVCO',
|
||
|
|
'property_cost_method': 'average',
|
||
|
|
'property_valuation': 'real_time'
|
||
|
|
})
|
||
|
|
|
||
|
|
prod, compo = self.env['product.product'].create([{
|
||
|
|
'name': name,
|
||
|
|
'type': 'consu',
|
||
|
|
'categ_id': avco_category.id,
|
||
|
|
'route_ids': [(4, route_id)],
|
||
|
|
} for name, route_id in [('product a', manufacture_route.id), ('component a', buy_route.id)]])
|
||
|
|
|
||
|
|
self.env['mrp.bom'].create({
|
||
|
|
'product_tmpl_id': prod.product_tmpl_id.id,
|
||
|
|
'type': 'phantom',
|
||
|
|
'bom_line_ids': [(0, 0, {
|
||
|
|
'product_id': compo.id,
|
||
|
|
'product_qty': 12,
|
||
|
|
})]
|
||
|
|
})
|
||
|
|
|
||
|
|
po_form = Form(self.env['purchase.order'])
|
||
|
|
partner = self.env['res.partner'].create({'name': 'Testy'})
|
||
|
|
po_form.partner_id = partner
|
||
|
|
with po_form.order_line.new() as pol_form:
|
||
|
|
pol_form.product_id = prod
|
||
|
|
pol_form.product_qty = 1
|
||
|
|
pol_form.price_unit = 100
|
||
|
|
pol_form.taxes_id.clear()
|
||
|
|
po = po_form.save()
|
||
|
|
po.button_confirm()
|
||
|
|
receipt = po.picking_ids
|
||
|
|
receipt.button_validate()
|
||
|
|
move = receipt.move_ids[0]
|
||
|
|
# the price unit for 1 unit of the kit is 100
|
||
|
|
# calculating the unit cost per component: 100 / 12 = 8.33333333333
|
||
|
|
# total cost for 12 components: 8.33 * 12 = 99.96
|
||
|
|
# however, due to rounding differences, the expected value is 100
|
||
|
|
svl_val = self.env['stock.valuation.layer'].search([('stock_move_id', '=', move.id)]).value
|
||
|
|
self.assertEqual(svl_val, 100)
|