378 lines
19 KiB
Python
378 lines
19 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo, Flectra. See LICENSE file for full copyright and licensing details.
|
|
|
|
from datetime import datetime
|
|
|
|
from flectra.tests import common
|
|
from flectra.exceptions import UserError
|
|
|
|
|
|
class TestSaleMrpFlow(common.TransactionCase):
|
|
|
|
def setUp(self):
|
|
super(TestSaleMrpFlow, self).setUp()
|
|
# Useful models
|
|
self.SaleOrderLine = self.env['sale.order.line']
|
|
self.SaleOrder = self.env['sale.order']
|
|
self.MrpBom = self.env['mrp.bom']
|
|
self.StockMove = self.env['stock.move']
|
|
self.MrpBomLine = self.env['mrp.bom.line']
|
|
self.ProductUom = self.env['product.uom']
|
|
self.MrpProduction = self.env['mrp.production']
|
|
self.Product = self.env['product.product']
|
|
self.Inventory = self.env['stock.inventory']
|
|
self.InventoryLine = self.env['stock.inventory.line']
|
|
self.ProductProduce = self.env['mrp.product.produce']
|
|
|
|
self.partner_agrolite = self.env.ref('base.res_partner_2')
|
|
self.categ_unit = self.env.ref('product.product_uom_categ_unit')
|
|
self.categ_kgm = self.env.ref('product.product_uom_categ_kgm')
|
|
self.stock_location = self.env.ref('stock.stock_location_stock')
|
|
self.warehouse = self.env.ref('stock.warehouse0')
|
|
|
|
def test_00_sale_mrp_flow(self):
|
|
""" Test sale to mrp flow with diffrent unit of measure."""
|
|
route_manufacture = self.warehouse.manufacture_pull_id.route_id.id
|
|
route_mto = self.warehouse.mto_pull_id.route_id.id
|
|
|
|
def create_product(name, uom_id, route_ids=[]):
|
|
return self.Product.create({
|
|
'name': name,
|
|
'type': 'product',
|
|
'uom_id': uom_id,
|
|
'uom_po_id': uom_id,
|
|
'route_ids': route_ids})
|
|
|
|
def create_bom_lines(bom_id, product_id, qty, uom_id, procure_method): #TODO: remove procure_method
|
|
self.MrpBomLine.create({
|
|
'product_id': product_id,
|
|
'product_qty': qty,
|
|
'bom_id': bom_id,
|
|
'product_uom_id': uom_id})
|
|
|
|
def create_bom(product_tmpl_id, qty, uom_id, type):
|
|
return self.MrpBom.create({
|
|
'product_tmpl_id': product_tmpl_id,
|
|
'product_qty': qty,
|
|
'type': type,
|
|
'product_uom_id': uom_id})
|
|
|
|
self.uom_kg = self.ProductUom.create({
|
|
'name': 'Test-KG',
|
|
'category_id': self.categ_kgm.id,
|
|
'factor_inv': 1,
|
|
'factor': 1,
|
|
'uom_type': 'reference',
|
|
'rounding': 0.000001})
|
|
self.uom_gm = self.ProductUom.create({
|
|
'name': 'Test-G',
|
|
'category_id': self.categ_kgm.id,
|
|
'uom_type': 'smaller',
|
|
'factor': 1000.0,
|
|
'rounding': 0.001})
|
|
self.uom_unit = self.ProductUom.create({
|
|
'name': 'Test-Unit',
|
|
'category_id': self.categ_unit.id,
|
|
'factor': 1,
|
|
'uom_type': 'reference',
|
|
'rounding': 1.0})
|
|
self.uom_dozen = self.ProductUom.create({
|
|
'name': 'Test-DozenA',
|
|
'category_id': self.categ_unit.id,
|
|
'factor_inv': 12,
|
|
'uom_type': 'bigger',
|
|
'rounding': 0.001})
|
|
|
|
# Create product A, B, C, D.
|
|
# --------------------------
|
|
product_a = create_product('Product A', self.uom_unit.id, route_ids=[(6, 0, [route_manufacture, route_mto])])
|
|
product_c = create_product('Product C', self.uom_kg.id, route_ids=[])
|
|
product_b = create_product('Product B', self.uom_dozen.id, route_ids=[(6, 0, [route_manufacture, route_mto])])
|
|
product_d = create_product('Product D', self.uom_unit.id, route_ids=[(6, 0, [route_manufacture, route_mto])])
|
|
|
|
# ------------------------------------------------------------------------------------------
|
|
# Bill of materials for product A, B, D.
|
|
# ------------------------------------------------------------------------------------------
|
|
|
|
# Bill of materials for Product A.
|
|
bom_a = create_bom(product_a.product_tmpl_id.id, 2, self.uom_dozen.id, 'normal')
|
|
create_bom_lines(bom_a.id, product_b.id, 3, self.uom_unit.id, 'make_to_order')
|
|
create_bom_lines(bom_a.id, product_c.id, 300.5, self.uom_gm.id, 'make_to_stock')
|
|
create_bom_lines(bom_a.id, product_d.id, 4, self.uom_unit.id, 'make_to_order')
|
|
|
|
# Bill of materials for Product B.
|
|
bom_b = create_bom(product_b.product_tmpl_id.id, 1, self.uom_unit.id, 'phantom')
|
|
create_bom_lines(bom_b.id, product_c.id, 0.400, self.uom_kg.id, 'make_to_stock')
|
|
|
|
# Bill of materials for Product D.
|
|
bom_d = create_bom(product_d.product_tmpl_id.id, 1, self.uom_unit.id, 'normal')
|
|
create_bom_lines(bom_d.id, product_c.id, 1, self.uom_kg.id, 'make_to_stock')
|
|
|
|
# ----------------------------------------
|
|
# Create sales order of 10 Dozen product A.
|
|
# ----------------------------------------
|
|
|
|
order = self.SaleOrder.create({
|
|
'partner_id': self.partner_agrolite.id,
|
|
'partner_invoice_id': self.partner_agrolite.id,
|
|
'partner_shipping_id': self.partner_agrolite.id,
|
|
'date_order': datetime.today(),
|
|
'pricelist_id': self.env.ref('product.list0').id,
|
|
})
|
|
self.SaleOrderLine.create({
|
|
'name': product_a.name,
|
|
'order_id': order.id,
|
|
'product_id': product_a.id,
|
|
'product_uom_qty': 10,
|
|
'product_uom': self.uom_dozen.id
|
|
})
|
|
self.assertTrue(order, "Sales order not created.")
|
|
order.action_confirm()
|
|
|
|
# ===============================================================================
|
|
# Sales order of 10 Dozen product A should create production order
|
|
# like ..
|
|
# ===============================================================================
|
|
# Product A 10 Dozen.
|
|
# Product C 6 kg
|
|
# As product B phantom in bom A, product A will consume product C
|
|
# ================================================================
|
|
# For 1 unit product B it will consume 400 gm
|
|
# then for 15 unit (Product B 3 unit per 2 Dozen product A)
|
|
# product B it will consume [ 6 kg ] product C)
|
|
# Product A will consume 6 kg product C.
|
|
#
|
|
# [15 * 400 gm ( 6 kg product C)] = 6 kg product C
|
|
#
|
|
# Product C 1502.5 gm.
|
|
# [
|
|
# For 2 Dozen product A will consume 300.5 gm product C
|
|
# then for 10 Dozen product A will consume 1502.5 gm product C.
|
|
# ]
|
|
#
|
|
# product D 20 Unit.
|
|
# [
|
|
# For 2 dozen product A will consume 4 unit product D
|
|
# then for 10 Dozen product A will consume 20 unit of product D.
|
|
# ]
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# <><><><><><><><><><><><><><><><><><><><>
|
|
# Check manufacturing order for product A.
|
|
# <><><><><><><><><><><><><><><><><><><><>
|
|
|
|
# Check quantity, unit of measure and state of manufacturing order.
|
|
# -----------------------------------------------------------------
|
|
self.env['procurement.group'].run_scheduler()
|
|
mnf_product_a = self.env['mrp.production'].search([('product_id', '=', product_a.id)])
|
|
|
|
self.assertTrue(mnf_product_a, 'Manufacturing order not created.')
|
|
self.assertEqual(mnf_product_a.product_qty, 120, 'Wrong product quantity in manufacturing order.')
|
|
self.assertEqual(mnf_product_a.product_uom_id.id, self.uom_unit.id, 'Wrong unit of measure in manufacturing order.')
|
|
self.assertEqual(mnf_product_a.state, 'confirmed', 'Manufacturing order should be confirmed.')
|
|
|
|
# ------------------------------------------------------------------------------------------
|
|
# Check 'To consume line' for production order of product A.
|
|
# ------------------------------------------------------------------------------------------
|
|
|
|
# Check 'To consume line' with product c and uom kg.
|
|
# -------------------------------------------------
|
|
|
|
moves = self.StockMove.search([
|
|
('raw_material_production_id', '=', mnf_product_a.id),
|
|
('product_id', '=', product_c.id),
|
|
('product_uom', '=', self.uom_kg.id)])
|
|
|
|
# Check total consume line with product c and uom kg.
|
|
self.assertEqual(len(moves), 1, 'Production move lines are not generated proper.')
|
|
list_qty = {move.product_uom_qty for move in moves}
|
|
self.assertEqual(list_qty, {6.0}, "Wrong product quantity in 'To consume line' of manufacturing order.")
|
|
# Check state of consume line with product c and uom kg.
|
|
for move in moves:
|
|
self.assertEqual(move.state, 'confirmed', "Wrong state in 'To consume line' of manufacturing order.")
|
|
|
|
# Check 'To consume line' with product c and uom gm.
|
|
# ---------------------------------------------------
|
|
|
|
move = self.StockMove.search([
|
|
('raw_material_production_id', '=', mnf_product_a.id),
|
|
('product_id', '=', product_c.id),
|
|
('product_uom', '=', self.uom_gm.id)])
|
|
|
|
# Check total consume line of product c with gm.
|
|
self.assertEqual(len(move), 1, 'Production move lines are not generated proper.')
|
|
# Check quantity should be with 1502.5 ( 2 Dozen product A consume 300.5 gm then 10 Dozen (300.5 * (10/2)).
|
|
self.assertEqual(move.product_uom_qty, 1502.5, "Wrong product quantity in 'To consume line' of manufacturing order.")
|
|
# Check state of consume line with product c with and uom gm.
|
|
self.assertEqual(move.state, 'confirmed', "Wrong state in 'To consume line' of manufacturing order.")
|
|
|
|
# Check 'To consume line' with product D.
|
|
# ---------------------------------------
|
|
|
|
move = self.StockMove.search([
|
|
('raw_material_production_id', '=', mnf_product_a.id),
|
|
('product_id', '=', product_d.id)])
|
|
|
|
# Check total consume line with product D.
|
|
self.assertEqual(len(move), 1, 'Production lines are not generated proper.')
|
|
|
|
# <><><><><><><><><><><><><><><><><><><><><><>
|
|
# Manufacturing order for product D (20 unit).
|
|
# <><><><><><><><><><><><><><><><><><><><><><>
|
|
|
|
# FP Todo: find a better way to look for the production order
|
|
mnf_product_d = self.MrpProduction.search([('product_id', '=', product_d.id), ('move_dest_ids.group_id', '=', order.procurement_group_id.id)], order='id desc', limit=1)
|
|
# Check state of production order D.
|
|
self.assertEqual(mnf_product_d.state, 'confirmed', 'Manufacturing order should be confirmed.')
|
|
|
|
# Check 'To consume line' state, quantity, uom of production order (product D).
|
|
# -----------------------------------------------------------------------------
|
|
|
|
move = self.StockMove.search([('raw_material_production_id', '=', mnf_product_d.id), ('product_id', '=', product_c.id)])
|
|
self.assertEqual(move.product_uom_qty, 20, "Wrong product quantity in 'To consume line' of manufacturing order.")
|
|
self.assertEqual(move.product_uom.id, self.uom_kg.id, "Wrong unit of measure in 'To consume line' of manufacturing order.")
|
|
self.assertEqual(move.state, 'confirmed', "Wrong state in 'To consume line' of manufacturing order.")
|
|
|
|
# -------------------------------
|
|
# Create inventory for product c.
|
|
# -------------------------------
|
|
# Need 20 kg product c to produce 20 unit product D.
|
|
# --------------------------------------------------
|
|
|
|
inventory = self.Inventory.create({
|
|
'name': 'Inventory Product KG',
|
|
'product_id': product_c.id,
|
|
'filter': 'product'})
|
|
|
|
inventory.action_start()
|
|
self.assertFalse(inventory.line_ids, "Inventory line should not created.")
|
|
self.InventoryLine.create({
|
|
'inventory_id': inventory.id,
|
|
'product_id': product_c.id,
|
|
'product_uom_id': self.uom_kg.id,
|
|
'product_qty': 20,
|
|
'location_id': self.stock_location.id})
|
|
inventory.action_done()
|
|
|
|
# --------------------------------------------------
|
|
# Assign product c to manufacturing order of product D.
|
|
# --------------------------------------------------
|
|
|
|
mnf_product_d.action_assign()
|
|
self.assertEqual(mnf_product_d.availability, 'assigned', 'Availability should be assigned')
|
|
self.assertEqual(move.state, 'assigned', "Wrong state in 'To consume line' of manufacturing order.")
|
|
|
|
# ------------------
|
|
# produce product D.
|
|
# ------------------
|
|
|
|
produce_d = self.ProductProduce.with_context({'active_ids': [mnf_product_d.id], 'active_id': mnf_product_d.id}).create({
|
|
'product_qty': 20})
|
|
# produce_d.on_change_qty()
|
|
produce_d.do_produce()
|
|
mnf_product_d.post_inventory()
|
|
|
|
# Check state of manufacturing order.
|
|
self.assertEqual(mnf_product_d.state, 'progress', 'Manufacturing order should still be in progress state.')
|
|
# Check available quantity of product D.
|
|
self.assertEqual(product_d.qty_available, 20, 'Wrong quantity available of product D.')
|
|
|
|
# -----------------------------------------------------------------
|
|
# Check product D assigned or not to production order of product A.
|
|
# -----------------------------------------------------------------
|
|
|
|
self.assertEqual(mnf_product_a.state, 'confirmed', 'Manufacturing order should be confirmed.')
|
|
move = self.StockMove.search([('raw_material_production_id', '=', mnf_product_a.id), ('product_id', '=', product_d.id)])
|
|
self.assertEqual(move.state, 'assigned', "Wrong state in 'To consume line' of manufacturing order.")
|
|
|
|
# Create inventory for product C.
|
|
# ------------------------------
|
|
# Need product C ( 20 kg + 6 kg + 1502.5 gm = 27.5025 kg)
|
|
# -------------------------------------------------------
|
|
inventory = self.Inventory.create({
|
|
'name': 'Inventory Product C KG',
|
|
'product_id': product_c.id,
|
|
'filter': 'product'})
|
|
|
|
inventory.action_start()
|
|
self.assertFalse(inventory.line_ids, "Inventory line should not created.")
|
|
self.InventoryLine.create({
|
|
'inventory_id': inventory.id,
|
|
'product_id': product_c.id,
|
|
'product_uom_id': self.uom_kg.id,
|
|
'product_qty': 27.5025,
|
|
'location_id': self.stock_location.id})
|
|
inventory.action_done()
|
|
|
|
# Assign product to manufacturing order of product A.
|
|
# ---------------------------------------------------
|
|
|
|
mnf_product_a.action_assign()
|
|
self.assertEqual(mnf_product_a.availability, 'assigned', 'Manufacturing order inventory state should be available.')
|
|
moves = self.StockMove.search([('raw_material_production_id', '=', mnf_product_a.id), ('product_id', '=', product_c.id)])
|
|
|
|
# Check product c move line state.
|
|
for move in moves:
|
|
self.assertEqual(move.state, 'assigned', "Wrong state in 'To consume line' of manufacturing order.")
|
|
|
|
# Produce product A.
|
|
# ------------------
|
|
produce_a = self.ProductProduce.with_context(
|
|
# {'active_ids': [mnf_product_a.id], 'active_id': mnf_product_a.id}).create({'mode': 'consume_produce', 'product_qty': mnf_product_a.product_qty})
|
|
# produce_a.on_change_qty()
|
|
{'active_ids': [mnf_product_a.id], 'active_id': mnf_product_a.id}).create({})
|
|
produce_a.do_produce()
|
|
mnf_product_a.post_inventory()
|
|
|
|
# Check state of manufacturing order product A.
|
|
self.assertEqual(mnf_product_a.state, 'progress', 'Manufacturing order should still be in the progress state.')
|
|
# Check product A avaialble quantity should be 120.
|
|
self.assertEqual(product_a.qty_available, 120, 'Wrong quantity available of product A.')
|
|
|
|
def test_01_sale_mrp_delivery_kit(self):
|
|
""" Test delivered quantity on SO based on delivered quantity in pickings."""
|
|
# intial so
|
|
self.partner = self.env.ref('base.res_partner_1')
|
|
self.product = self.env.ref('mrp.product_product_build_kit')
|
|
self.product.invoice_policy = 'delivery'
|
|
# Remove the MTO route as purchase is not installed and since the procurement removal the exception is directly raised
|
|
self.product.write({'route_ids': [(6, 0, [self.warehouse.manufacture_pull_id.route_id.id])]})
|
|
so_vals = {
|
|
'partner_id': self.partner.id,
|
|
'partner_invoice_id': self.partner.id,
|
|
'partner_shipping_id': self.partner.id,
|
|
'order_line': [(0, 0, {'name': self.product.name, 'product_id': self.product.id, 'product_uom_qty': 5, 'product_uom': self.product.uom_id.id, 'price_unit': self.product.list_price})],
|
|
'pricelist_id': self.env.ref('product.list0').id,
|
|
}
|
|
self.so = self.SaleOrder.create(so_vals)
|
|
|
|
# confirm our standard so, check the picking
|
|
self.so.action_confirm()
|
|
self.assertTrue(self.so.picking_ids, 'Sale MRP: no picking created for "invoice on delivery" stockable products')
|
|
|
|
# invoice in on delivery, nothing should be invoiced
|
|
with self.assertRaises(UserError):
|
|
self.so.action_invoice_create()
|
|
self.assertEqual(self.so.invoice_status, 'no', 'Sale MRP: so invoice_status should be "nothing to invoice" after invoicing')
|
|
|
|
# deliver partially (1 of each instead of 5), check the so's invoice_status and delivered quantities
|
|
pick = self.so.picking_ids
|
|
pick.force_assign()
|
|
pick.move_lines.write({'quantity_done': 1})
|
|
wiz_act = pick.button_validate()
|
|
wiz = self.env[wiz_act['res_model']].browse(wiz_act['res_id'])
|
|
wiz.process()
|
|
self.assertEqual(self.so.invoice_status, 'no', 'Sale MRP: so invoice_status should be "no" after partial delivery of a kit')
|
|
del_qty = sum(sol.qty_delivered for sol in self.so.order_line)
|
|
self.assertEqual(del_qty, 0.0, 'Sale MRP: delivered quantity should be zero after partial delivery of a kit')
|
|
# deliver remaining products, check the so's invoice_status and delivered quantities
|
|
self.assertEqual(len(self.so.picking_ids), 2, 'Sale MRP: number of pickings should be 2')
|
|
pick_2 = self.so.picking_ids[0]
|
|
pick_2.force_assign()
|
|
pick_2.move_lines.write({'quantity_done': 4})
|
|
pick_2.button_validate()
|
|
|
|
del_qty = sum(sol.qty_delivered for sol in self.so.order_line)
|
|
self.assertEqual(del_qty, 5.0, 'Sale MRP: delivered quantity should be 5.0 after complete delivery of a kit')
|
|
self.assertEqual(self.so.invoice_status, 'to invoice', 'Sale MRP: so invoice_status should be "to invoice" after complete delivery of a kit')
|