def test_flow_5(self):
""" Check that the correct BoM is chosen accordingly to the partner
"""
# We create a second partner of type subcontractor
main_partner_2 = self.env['res.partner'].create({'name': 'main_partner'})
subcontractor_partner2 = self.env['res.partner'].create({
'name': 'subcontractor_partner',
'parent_id': main_partner_2.id,
'company_id': self.env.ref('base.main_company').id
})
# We create a different BoM for the same product
comp3 = self.env['product.product'].create({
'name': 'Component1',
'type': 'product',
'categ_id': self.env.ref('product.product_category_all').id,
})
bom_form = Form(self.env['mrp.bom'])
bom_form.type = 'subcontract'
bom_form.product_tmpl_id = self.finished.product_tmpl_id
with bom_form.bom_line_ids.new() as bom_line:
bom_line.product_id = self.comp1
bom_line.product_qty = 1
with bom_form.bom_line_ids.new() as bom_line:
bom_line.product_id = comp3
bom_line.product_qty = 1
bom2 = bom_form.save()
# We assign the second BoM to the new partner
self.bom.write({'subcontractor_ids': [(4, self.subcontractor_partner1.id, None)]})
bom2.write({'subcontractor_ids': [(4, subcontractor_partner2.id, None)]})
# Create a receipt picking from the subcontractor1
picking_form = Form(self.env['stock.picking'])
picking_form.picking_type_id = self.env.ref('stock.picking_type_in')
picking_form.partner_id = self.subcontractor_partner1
with picking_form.move_ids_without_package.new() as move:
move.product_id = self.finished
move.product_uom_qty = 1
picking_receipt1 = picking_form.save()
picking_receipt1.action_confirm()
# Create a receipt picking from the subcontractor2
picking_form = Form(self.env['stock.picking'])
picking_form.picking_type_id = self.env.ref('stock.picking_type_in')
picking_form.partner_id = subcontractor_partner2
with picking_form.move_ids_without_package.new() as move:
move.product_id = self.finished
move.product_uom_qty = 1
picking_receipt2 = picking_form.save()
picking_receipt2.action_confirm()
mo_pick1 = picking_receipt1.move_lines.mapped('move_orig_ids.production_id')
mo_pick2 = picking_receipt2.move_lines.mapped('move_orig_ids.production_id')
self.assertEquals(len(mo_pick1), 1)
self.assertEquals(len(mo_pick2), 1)
self.assertEquals(mo_pick1.bom_id, self.bom)
self.assertEquals(mo_pick2.bom_id, bom2)
def test_reordering_rule(self):
"""
- Receive products in 2 steps
- The product has a reordering rule
- On the po generated, the source document should be the name of the reordering rule
"""
warehouse_1 = self.env['stock.warehouse'].search(
[('company_id', '=', self.env.user.id)], limit=1)
warehouse_1.write({'reception_steps': 'two_steps'})
# Create a supplier
partner = self.env['res.partner'].create({'name': 'Smith'})
# create product and set the vendor
product_form = Form(self.env['product.product'])
product_form.name = 'Product A'
product_form.type = 'product'
with product_form.seller_ids.new() as seller:
seller.name = partner
product_form.route_ids.add(
self.env.ref('purchase_stock.route_warehouse0_buy'))
product_01 = product_form.save()
# create reordering rule
orderpoint_form = Form(self.env['stock.warehouse.orderpoint'])
orderpoint_form.warehouse_id = warehouse_1
orderpoint_form.location_id = warehouse_1.lot_stock_id
orderpoint_form.product_id = product_01
orderpoint_form.product_min_qty = 0.000
orderpoint_form.product_max_qty = 0.000
order_point = orderpoint_form.save()
# Create Delivery Order of 10 product
picking_form = Form(self.env['stock.picking'])
picking_form.partner_id = partner
picking_form.picking_type_id = self.env.ref('stock.picking_type_out')
with picking_form.move_ids_without_package.new() as move:
move.product_id = product_01
move.product_uom_qty = 10.0
customer_picking = picking_form.save()
# picking confirm
customer_picking.action_confirm()
# Run scheduler
self.env['procurement.group'].run_scheduler()
# Check purchase order created or not
purchase_order = self.env['purchase.order'].search([('partner_id', '=',
partner.id)])
self.assertTrue(purchase_order, 'No purchase order created.')
# On the po generated, the source document should be the name of the reordering rule
self.assertEqual(
order_point.name, purchase_order.origin,
'Source document on purchase order should be the name of the reordering rule.'
)
def test_flow_6(self):
""" Extra quantity on the move.
"""
# We create a second partner of type subcontractor
main_partner_2 = self.env['res.partner'].create({'name': 'main_partner'})
subcontractor_partner2 = self.env['res.partner'].create({
'name': 'subcontractor_partner',
'parent_id': main_partner_2.id,
'company_id': self.env.ref('base.main_company').id,
})
self.env.cache.invalidate()
# We create a different BoM for the same product
comp3 = self.env['product.product'].create({
'name': 'Component3',
'type': 'product',
'categ_id': self.env.ref('product.product_category_all').id,
})
bom_form = Form(self.env['mrp.bom'])
bom_form.type = 'subcontract'
bom_form.product_tmpl_id = self.finished.product_tmpl_id
with bom_form.bom_line_ids.new() as bom_line:
bom_line.product_id = self.comp1
bom_line.product_qty = 1
with bom_form.bom_line_ids.new() as bom_line:
bom_line.product_id = comp3
bom_line.product_qty = 2
bom2 = bom_form.save()
# We assign the second BoM to the new partner
self.bom.write({'subcontractor_ids': [(4, self.subcontractor_partner1.id, None)]})
bom2.write({'subcontractor_ids': [(4, subcontractor_partner2.id, None)]})
# Create a receipt picking from the subcontractor1
picking_form = Form(self.env['stock.picking'])
picking_form.picking_type_id = self.env.ref('stock.picking_type_in')
picking_form.partner_id = subcontractor_partner2
with picking_form.move_ids_without_package.new() as move:
move.product_id = self.finished
move.product_uom_qty = 1
picking_receipt = picking_form.save()
picking_receipt.action_confirm()
picking_receipt.move_lines.quantity_done = 3.0
picking_receipt.action_done()
mo = picking_receipt._get_subcontracted_productions()
move_comp1 = mo.move_raw_ids.filtered(lambda m: m.product_id == self.comp1)
move_comp3 = mo.move_raw_ids.filtered(lambda m: m.product_id == comp3)
self.assertEqual(sum(move_comp1.mapped('product_uom_qty')), 3.0)
self.assertEqual(sum(move_comp3.mapped('product_uom_qty')), 6.0)
self.assertEqual(sum(move_comp1.mapped('quantity_done')), 3.0)
self.assertEqual(sum(move_comp3.mapped('quantity_done')), 6.0)
move_finished = mo.move_finished_ids
self.assertEqual(sum(move_finished.mapped('product_uom_qty')), 3.0)
self.assertEqual(sum(move_finished.mapped('quantity_done')), 3.0)
def setUp(self):
super(TestMultistepManufacturingWarehouse, self).setUp()
# Create warehouse
self.customer_location = self.env['ir.model.data'].xmlid_to_res_id('stock.stock_location_customers')
warehouse_form = Form(self.env['stock.warehouse'])
warehouse_form.name = 'Test Warehouse'
warehouse_form.code = 'TWH'
self.warehouse = warehouse_form.save()
self.uom_unit = self.env.ref('uom.product_uom_unit')
# Create manufactured product
product_form = Form(self.env['product.product'])
product_form.name = 'Stick'
product_form.uom_id = self.uom_unit
product_form.uom_po_id = self.uom_unit
product_form.type = 'product'
product_form.route_ids.clear()
product_form.route_ids.add(self.warehouse.manufacture_pull_id.route_id)
product_form.route_ids.add(self.warehouse.mto_pull_id.route_id)
self.finished_product = product_form.save()
# Create raw product for manufactured product
product_form = Form(self.env['product.product'])
product_form.name = 'Raw Stick'
product_form.type = 'product'
product_form.uom_id = self.uom_unit
product_form.uom_po_id = self.uom_unit
self.raw_product = product_form.save()
# Create bom for manufactured product
bom_product_form = Form(self.env['mrp.bom'])
bom_product_form.product_id = self.finished_product
bom_product_form.product_tmpl_id = self.finished_product.product_tmpl_id
bom_product_form.product_qty = 1.0
bom_product_form.type = 'normal'
with bom_product_form.bom_line_ids.new() as bom_line:
bom_line.product_id = self.raw_product
bom_line.product_qty = 2.0
self.bom = bom_product_form.save()
def setUp(self):
super(TestMultistepManufacturing, self).setUp()
self.MrpProduction = self.env['mrp.production']
# Create warehouse
warehouse_form = Form(self.env['stock.warehouse'])
warehouse_form.name = 'Test'
warehouse_form.code = 'Test'
self.warehouse = warehouse_form.save()
self.uom_unit = self.env.ref('uom.product_uom_unit')
# Create manufactured product
product_form = Form(self.env['product.product'])
product_form.name = 'Stick'
product_form.uom_id = self.uom_unit
product_form.uom_po_id = self.uom_unit
product_form.route_ids.clear()
product_form.route_ids.add(self.warehouse.manufacture_pull_id.route_id)
product_form.route_ids.add(self.warehouse.mto_pull_id.route_id)
self.product_manu = product_form.save()
# Create raw product for manufactured product
product_form = Form(self.env['product.product'])
product_form.name = 'Raw Stick'
product_form.uom_id = self.uom_unit
product_form.uom_po_id = self.uom_unit
self.product_raw = product_form.save()
# Create bom for manufactured product
bom_product_form = Form(self.env['mrp.bom'])
bom_product_form.product_id = self.product_manu
bom_product_form.product_tmpl_id = self.product_manu.product_tmpl_id
bom_product_form.product_qty = 1.0
bom_product_form.type = 'normal'
with bom_product_form.bom_line_ids.new() as bom_line:
bom_line.product_id = self.product_raw
bom_line.product_qty = 2.0
self.bom_prod_manu = bom_product_form.save()
# Create sale order
sale_form = Form(self.env['sale.order'])
sale_form.partner_id = self.env.ref('base.res_partner_1')
sale_form.picking_policy = 'direct'
sale_form.warehouse_id = self.warehouse
with sale_form.order_line.new() as line:
line.name = self.product_manu.name
line.product_id = self.product_manu
line.product_uom_qty = 1.0
line.product_uom = self.uom_unit
line.price_unit = 10.0
self.sale_order = sale_form.save()
def setUp(self):
super(TestSubcontractingTracking, self).setUp()
# 1: Create a subcontracting partner
main_company_1 = self.env['res.partner'].create({'name': 'main_partner'})
self.subcontractor_partner1 = self.env['res.partner'].create({
'name': 'Subcontractor 1',
'parent_id': main_company_1.id,
'company_id': self.env.ref('base.main_company').id
})
# 2. Create a BOM of subcontracting type
# 2.1. Comp1 has tracking by lot
self.comp1_sn = self.env['product.product'].create({
'name': 'Component1',
'type': 'product',
'categ_id': self.env.ref('product.product_category_all').id,
'tracking': 'serial'
})
self.comp2 = self.env['product.product'].create({
'name': 'Component2',
'type': 'product',
'categ_id': self.env.ref('product.product_category_all').id,
})
# 2.2. Finished prodcut has tracking by serial number
self.finished_lot = self.env['product.product'].create({
'name': 'finished',
'type': 'product',
'categ_id': self.env.ref('product.product_category_all').id,
'tracking': 'lot'
})
bom_form = Form(self.env['mrp.bom'])
bom_form.type = 'subcontract'
bom_form.subcontractor_ids.add(self.subcontractor_partner1)
bom_form.product_tmpl_id = self.finished_lot.product_tmpl_id
with bom_form.bom_line_ids.new() as bom_line:
bom_line.product_id = self.comp1_sn
bom_line.product_qty = 1
with bom_form.bom_line_ids.new() as bom_line:
bom_line.product_id = self.comp2
bom_line.product_qty = 1
self.bom_tracked = bom_form.save()
def setUp(self):
super(TestBom, self).setUp()
self.Product = self.env['product.product']
self.Bom = self.env['mrp.bom']
self.Routing = self.env['mrp.routing']
self.operation = self.env['mrp.routing.workcenter']
# Products.
self.dining_table = self._create_product('Dining Table', 1000)
self.table_head = self._create_product('Table Head', 300)
self.screw = self._create_product('Screw', 10)
self.leg = self._create_product('Leg', 25)
self.glass = self._create_product('Glass', 100)
# Unit of Measure.
self.unit = self.env.ref("uom.product_uom_unit")
self.dozen = self.env.ref("uom.product_uom_dozen")
# Bills Of Materials.
# -------------------------------------------------------------------------------
# Cost of BoM (Dining Table 1 Unit)
# Component Cost = Table Head 1 Unit * 300 = 300 (468.75 from it's components)
# Screw 5 Unit * 10 = 50
# Leg 4 Unit * 25 = 100
# Glass 1 Unit * 100 = 100
# Total = 550 [718.75 if components of Table Head considered] (for 1 Unit)
# -------------------------------------------------------------------------------
bom_form = Form(self.Bom)
bom_form.product_id = self.dining_table
bom_form.product_tmpl_id = self.dining_table.product_tmpl_id
bom_form.product_qty = 1.0
bom_form.product_uom_id = self.unit
bom_form.type = 'normal'
with bom_form.bom_line_ids.new() as line:
line.product_id = self.table_head
line.product_qty = 1
with bom_form.bom_line_ids.new() as line:
line.product_id = self.screw
line.product_qty = 5
with bom_form.bom_line_ids.new() as line:
line.product_id = self.leg
line.product_qty = 4
with bom_form.bom_line_ids.new() as line:
line.product_id = self.glass
line.product_qty = 1
self.bom_1 = bom_form.save()
# Table Head's components.
self.plywood_sheet = self._create_product('Plywood Sheet', 200)
self.bolt = self._create_product('Bolt', 10)
self.colour = self._create_product('Colour', 100)
self.corner_slide = self._create_product('Corner Slide', 25)
# -----------------------------------------------------------------
# Cost of BoM (Table Head 1 Dozen)
# Component Cost = Plywood Sheet 12 Unit * 200 = 2400
# Bolt 60 Unit * 10 = 600
# Colour 12 Unit * 100 = 1200
# Corner Slide 57 Unit * 25 = 1425
# Total = 5625
# 1 Unit price (5625/12) = 468.75
# -----------------------------------------------------------------
bom_form2 = Form(self.Bom)
bom_form2.product_id = self.table_head
bom_form2.product_tmpl_id = self.table_head.product_tmpl_id
bom_form2.product_qty = 1.0
bom_form2.product_uom_id = self.dozen
bom_form2.type = 'phantom'
with bom_form2.bom_line_ids.new() as line:
line.product_id = self.plywood_sheet
line.product_qty = 12
with bom_form2.bom_line_ids.new() as line:
line.product_id = self.bolt
line.product_qty = 60
with bom_form2.bom_line_ids.new() as line:
line.product_id = self.colour
line.product_qty = 12
with bom_form2.bom_line_ids.new() as line:
line.product_id = self.corner_slide
line.product_qty = 57
self.bom_2 = bom_form2.save()
def test_00_crossdock(self):
# Create a supplier
supplier_crossdock = self.env['res.partner'].create(
{'name': "Crossdocking supplier"})
# I first create a warehouse with pick-pack-ship and reception in 2 steps
wh_f = Form(self.env['stock.warehouse'])
wh_f.name = 'WareHouse PickPackShip'
wh_f.code = 'whpps'
wh_f.reception_steps = 'two_steps'
wh_f.delivery_steps = 'pick_pack_ship'
wh_pps = wh_f.save()
# Check that cross-dock route is active
self.assertTrue(
wh_pps.crossdock_route_id.active,
"Crossdock route should be active when reception_steps is not in 'single_step'"
)
p_f = Form(self.env['product.template'])
p_f.name = 'PCE'
p_f.type = 'product'
p_f.categ_id = self.env.ref('product.product_category_1')
p_f.list_price = 100.0
with p_f.seller_ids.new() as seller:
seller.name = supplier_crossdock
p_f.route_ids.add(wh_pps.crossdock_route_id)
cross_shop_product = p_f.save()
std_price_wiz = Form(
self.env['stock.change.standard.price'].with_context(
active_id=p_f.id, active_model='product.template'))
std_price_wiz.new_price = 70.0
std_price_wiz.save()
# Create a sales order with a line of 100 PCE incoming shipment with route_id crossdock shipping
so_form = Form(self.env['sale.order'])
so_form.partner_id = self.env.ref('base.res_partner_4')
so_form.warehouse_id = wh_pps
with mute_logger('harpiya.tests.common.onchange'):
# otherwise complains that there's not enough inventory and
# apparently that's normal according to @jco and @sle
with so_form.order_line.new() as line:
line.product_id = cross_shop_product.product_variant_ids
line.product_uom_qty = 100.0
sale_order_crossdock = so_form.save()
# Confirm sales order
sale_order_crossdock.action_confirm()
# Run the scheduler
self.env['procurement.group'].run_scheduler()
# Check a quotation was created for the created supplier and confirm it
po = self.env['purchase.order'].search([('partner_id', '=',
supplier_crossdock.id),
('state', '=', 'draft')])
self.assertTrue(po, "an RFQ should have been created by the scheduler")
po.button_confirm()
def test_lifoprice(self):
self._load('account', 'test', 'account_minimal_test.xml')
self._load('stock_account', 'test', 'stock_valuation_account.xml')
# Set product category removal strategy as LIFO
product_category_001 = self.env['product.category'].create({
'name':
'Lifo Category',
'removal_strategy_id':
self.env.ref('stock.removal_lifo').id,
'property_valuation':
'real_time',
'property_cost_method':
'fifo',
})
# Set a product as using lifo price
product_form = Form(self.env['product.product'])
product_form.default_code = 'LIFO'
product_form.name = 'LIFO Ice Cream'
product_form.type = 'product'
product_form.categ_id = product_category_001
product_form.lst_price = 100.0
product_form.uom_id = self.env.ref('uom.product_uom_kgm')
product_form.uom_po_id = self.env.ref('uom.product_uom_kgm')
# these are not available (visible) in either product or variant
# for views, apparently from the UI you can only set the product
# category (or hand-assign the property_* version which seems...)
# product_form.categ_id.valuation = 'real_time'
# product_form.categ_id.property_cost_method = 'fifo'
product_form.categ_id.property_stock_account_input_categ_id = self.env.ref(
'stock_dropshipping.o_expense')
product_form.categ_id.property_stock_account_output_categ_id = self.env.ref(
'stock_dropshipping.o_income')
product_lifo_icecream = product_form.save()
std_price_wiz = Form(
self.env['stock.change.standard.price'].with_context(
active_id=product_lifo_icecream.id,
active_model='product.product'))
std_price_wiz.new_price = 70.0
std_price_wiz.save()
# I create a draft Purchase Order for first in move for 10 pieces at 60 euro
order_form = Form(self.env['purchase.order'])
order_form.partner_id = self.env.ref('base.res_partner_3')
with order_form.order_line.new() as line:
line.product_id = product_lifo_icecream
line.product_qty = 10.0
line.price_unit = 60.0
purchase_order_lifo1 = order_form.save()
# I create a draft Purchase Order for second shipment for 30 pieces at 80 euro
order2_form = Form(self.env['purchase.order'])
order2_form.partner_id = self.env.ref('base.res_partner_3')
with order2_form.order_line.new() as line:
line.product_id = product_lifo_icecream
line.product_qty = 30.0
line.price_unit = 80.0
purchase_order_lifo2 = order2_form.save()
# I confirm the first purchase order
purchase_order_lifo1.button_confirm()
# I check the "Approved" status of purchase order 1
self.assertEqual(purchase_order_lifo1.state, 'purchase')
# Process the receipt of purchase order 1
purchase_order_lifo1.picking_ids[
0].move_lines.quantity_done = purchase_order_lifo1.picking_ids[
0].move_lines.product_qty
purchase_order_lifo1.picking_ids[0].button_validate()
# I confirm the second purchase order
purchase_order_lifo2.button_confirm()
# Process the receipt of purchase order 2
purchase_order_lifo2.picking_ids[
0].move_lines.quantity_done = purchase_order_lifo2.picking_ids[
0].move_lines.product_qty
purchase_order_lifo2.picking_ids[0].button_validate()
# Let us send some goods
out_form = Form(self.env['stock.picking'])
out_form.picking_type_id = self.env.ref('stock.picking_type_out')
out_form.immediate_transfer = True
with out_form.move_ids_without_package.new() as move:
move.product_id = product_lifo_icecream
move.quantity_done = 20.0
move.date_expected = fields.Datetime.now()
outgoing_lifo_shipment = out_form.save()
# I assign this outgoing shipment
outgoing_lifo_shipment.action_assign()
# Process the delivery of the outgoing shipment
outgoing_lifo_shipment.button_validate()
# Check if the move value correctly reflects the fifo costing method
self.assertEqual(
outgoing_lifo_shipment.move_lines.stock_valuation_layer_ids.value,
-1400.0, 'Stock move value should have been 1400 euro')