def test_pricelist_application(self):
""" Test different prices are correctly applied based on dates """
support_product = self.env.ref('product.product_product_2')
support_product.list_price = 100
partner = self.res_partner_model.create(dict(name="George"))
christmas_pricelist = self.env['product.pricelist'].create({
'name':
'Christmas pricelist',
'item_ids': [(0, 0, {
'date_start': "2017-12-01",
'date_end': "2017-12-24",
'compute_price': 'percentage',
'base': 'list_price',
'percent_price': 20,
'applied_on': '3_global',
'name': 'Pre-Christmas discount'
}),
(0, 0, {
'date_start': "2017-12-25",
'date_end': "2017-12-31",
'compute_price': 'percentage',
'base': 'list_price',
'percent_price': 50,
'applied_on': '3_global',
'name': 'Post-Christmas super-discount'
})]
})
# Create the SO with pricelist based on date
order_form = Form(
self.env['sale.order'].with_context(tracking_disable=True))
order_form.partner_id = partner
order_form.date_order = '2017-12-20'
order_form.pricelist_id = christmas_pricelist
with order_form.order_line.new() as line:
line.product_id = support_product
so = order_form.save()
# Check the unit price and subtotal of SO line
self.assertEqual(so.order_line[0].price_unit, 80,
"First date pricelist rule not applied")
self.assertEquals(
so.order_line[0].price_subtotal,
so.order_line[0].price_unit * so.order_line[0].product_uom_qty,
'Total of SO line should be a multiplication of unit price and ordered quantity'
)
# Change order date of the SO and check the unit price and subtotal of SO line
with Form(so) as order:
order.date_order = '2017-12-30'
with order.order_line.edit(0) as line:
line.product_id = support_product
self.assertEqual(so.order_line[0].price_unit, 50,
"Second date pricelist rule not applied")
self.assertEquals(
so.order_line[0].price_subtotal,
so.order_line[0].price_unit * so.order_line[0].product_uom_qty,
'Total of SO line should be a multiplication of unit price and ordered quantity'
)
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
p_f.standard_price = 70.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()
# 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('swerp.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_00_product_company_level_delays(self):
""" In order to check schedule date, set product's Manufacturing Lead Time
and Customer Lead Time and also set company's Manufacturing Lead Time
and Sales Safety Days."""
company = self.env.ref('base.main_company')
# Update company with Manufacturing Lead Time and Sales Safety Days
company.write({'manufacturing_lead': 3.0, 'security_lead': 3.0})
# Create sale order of product_1
order_form = Form(self.env['sale.order'])
order_form.partner_id = self.partner_1
with order_form.order_line.new() as line:
line.product_id = self.product_1
line.product_uom_qty = 10
order = order_form.save()
# Confirm sale order
order.action_confirm()
# Check manufacturing order created or not
manufacturing_order = self.env['mrp.production'].search([
('product_id', '=', self.product_1.id),
('move_dest_ids', 'in', order.picking_ids[0].move_lines.ids)
])
self.assertTrue(manufacturing_order,
'Manufacturing order should be created.')
# Check schedule date of picking
out_date = fields.Datetime.from_string(order.date_order) + timedelta(
days=self.product_1.sale_delay) - timedelta(
days=company.security_lead)
min_date = fields.Datetime.from_string(
order.picking_ids[0].scheduled_date)
self.assertAlmostEqual(
min_date,
out_date,
delta=timedelta(seconds=1),
msg=
'Schedule date of picking should be equal to: Order date + Customer Lead Time - Sales Safety Days.'
)
# Check schedule date of manufacturing order
mo_date = out_date - timedelta(
days=self.product_1.produce_delay) - timedelta(
days=company.manufacturing_lead)
date_planned_start = fields.Datetime.from_string(
manufacturing_order.date_planned_start)
self.assertAlmostEqual(
date_planned_start,
mo_date,
delta=timedelta(seconds=1),
msg=
"Schedule date of manufacturing order should be equal to: Schedule date of picking - product's Manufacturing Lead Time - company's Manufacturing Lead Time."
)
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 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 test_onchange_product_id(self):
uom_id = self.product_uom_model.search([('name', '=', 'Unit(s)')])[0]
pricelist = self.pricelist_model.search([('name', '=',
'Public Pricelist')])[0]
partner_id = self.res_partner_model.create(dict(name="George"))
tax_include_id = self.tax_model.create(
dict(name="Include tax",
amount='21.00',
price_include=True,
type_tax_use='sale'))
tax_exclude_id = self.tax_model.create(
dict(name="Exclude tax", amount='0.00', type_tax_use='sale'))
product_tmpl_id = self.product_tmpl_model.create(
dict(name="Voiture",
list_price=121,
taxes_id=[(6, 0, [tax_include_id.id])]))
product_id = self.product_model.create(
dict(product_tmpl_id=product_tmpl_id.id))
fp_id = self.fiscal_position_model.create(
dict(name="fiscal position", sequence=1))
fp_tax_id = self.fiscal_position_tax_model.create(
dict(position_id=fp_id.id,
tax_src_id=tax_include_id.id,
tax_dest_id=tax_exclude_id.id))
# Create the SO with one SO line and apply a pricelist and fiscal position on it
order_form = Form(
self.env['sale.order'].with_context(tracking_disable=True))
order_form.partner_id = partner_id
order_form.pricelist_id = pricelist
order_form.fiscal_position_id = fp_id
with order_form.order_line.new() as line:
line.name = product_id.name
line.product_id = product_id
line.product_uom_qty = 1.0
line.product_uom = uom_id
sale_order = order_form.save()
# Check the unit price of SO line
self.assertEquals(100, sale_order.order_line[0].price_unit,
"The included tax must be subtracted to the price")
def create_account_invoice(self,
invoice_type,
partner,
product,
quantity=0.0,
price_unit=0.0):
""" Create an invoice as in a view by triggering its onchange methods"""
invoice_form = Form(
self.env['account.invoice'].with_context(type=invoice_type))
invoice_form.partner_id = partner
with invoice_form.invoice_line_ids.new() as line:
line.product_id = product
line.quantity = quantity
line.price_unit = price_unit
invoice = invoice_form.save()
invoice.action_invoice_open()
return invoice
def test_00_procurement_exception(self):
# I create a product with no supplier define for it.
product_form = Form(self.env['product.product'])
product_form.name = 'product with no seller'
product_form.lst_price = 20.00
product_form.standard_price = 15.00
product_form.categ_id = self.env.ref('product.product_category_1')
product_with_no_seller = product_form.save()
# I create a sales order with this product with route dropship.
so_form = Form(self.env['sale.order'])
so_form.partner_id = self.env.ref('base.res_partner_2')
so_form.partner_invoice_id = self.env.ref('base.res_partner_address_3')
so_form.partner_shipping_id = self.env.ref('base.res_partner_address_3')
so_form.payment_term_id = self.env.ref('account.account_payment_term')
with so_form.order_line.new() as line:
line.product_id = product_with_no_seller
line.product_uom_qty = 1
line.route_id = self.env.ref('stock_dropshipping.route_drop_shipping')
sale_order_route_dropship01 = so_form.save()
# I confirm the sales order, but it will raise an error
with self.assertRaises(Exception):
sale_order_route_dropship01.action_confirm()
# I set the at least one supplier on the product.
with Form(product_with_no_seller) as f:
with f.seller_ids.new() as seller:
seller.delay = 1
seller.name = self.env.ref('base.res_partner_2')
seller.min_qty = 2.0
# I confirm the sales order, no error this time
sale_order_route_dropship01.action_confirm()
# I check a purchase quotation was created.
purchase = self.env['purchase.order.line'].search([
('sale_line_id', '=', sale_order_route_dropship01.order_line.ids[0])]).order_id
self.assertTrue(purchase, 'No Purchase Quotation is created')
def test_00_account_voucher_flow(self):
""" Create Account Voucher for Customer and Vendor """
self._load('account', 'test', 'account_minimal_test.xml')
# User-groups and References
partner_id = self.env.ref('base.res_partner_12')
cash_journal_id = self.env.ref('account_voucher.cash_journal')
sales_journal_id = self.env.ref('account_voucher.sales_journal')
account_receivable_id = self.env.ref('account_voucher.a_recv')
# Create a Account Voucher User
voucher_user = self.env['res.users'].create({
'name': 'Voucher Accountant',
'login': '******',
'email': '*****@*****.**',
'company_id': self.env.ref('base.main_company').id,
'groups_id': [(6, 0, [
self.ref('base.group_partner_manager'),
self.ref('account.group_account_user'),
self.ref('account.group_account_invoice'),
])]
})
Voucher = self.env['account.voucher'].sudo(voucher_user)
# Create Customer Voucher
c = Form(Voucher.with_context(default_voucher_type="sale", voucher_type="sale"),
view='account_voucher.view_sale_receipt_form')
c.partner_id = partner_id
c.journal_id = sales_journal_id
with c.line_ids.new() as line:
line.name = "Voucher for Axelor"
line.account_id = account_receivable_id
line.price_unit = 1000.0
account_voucher_customer = c.save()
# Check Customer Voucher status.
self.assertEquals(account_voucher_customer.state, 'draft', 'Initially customer voucher should be in the "Draft" state')
# Validate Customer voucher
account_voucher_customer.proforma_voucher()
# Check for Journal Entry of customer voucher
self.assertTrue(account_voucher_customer.move_id, 'No journal entry created !.')
# Find related account move line for Customer Voucher.
customer_voucher_move = account_voucher_customer.move_id
# Check state of Account move line.
self.assertEquals(customer_voucher_move.state, 'posted', 'Account move state is incorrect.')
# Check partner of Account move line.
self.assertEquals(customer_voucher_move.partner_id, partner_id, 'Partner is incorrect on account move.')
# Check journal in Account move line.
self.assertEquals(customer_voucher_move.journal_id, sales_journal_id, 'Journal is incorrect on account move.')
# Check amount in Account move line.
self.assertEquals(customer_voucher_move.amount, 1000.0, 'Amount is incorrect in account move.')
# Create Vendor Voucher
v = Form(Voucher.with_context(default_voucher_type="purchase", voucher_type="purchase"))
v.partner_id = partner_id
v.journal_id = cash_journal_id
with v.line_ids.new() as line:
line.name = "Voucher Axelor"
line.account_id = account_receivable_id
line.price_unit = 1000.0
account_voucher_vendor = v.save()
# Check Vendor Voucher status.
self.assertEquals(account_voucher_vendor.state, 'draft', 'Initially vendor voucher should be in the "Draft" state')
# Validate Vendor voucher
account_voucher_vendor.proforma_voucher()
# Check for Journal Entry of vendor voucher
self.assertTrue(account_voucher_vendor.move_id, 'No journal entry created !.')
# Find related account move line for Vendor Voucher.
vendor_voucher_move = account_voucher_vendor.move_id
# Check state of Account move line.
self.assertEquals(vendor_voucher_move.state, 'posted', 'Account move state is incorrect.')
# Check partner of Account move line.
self.assertEquals(vendor_voucher_move.partner_id, partner_id, 'Partner is incorrect on account move.')
# Check journal in Account move line.
self.assertEquals(vendor_voucher_move.journal_id, cash_journal_id, 'Journal is incorrect on account move.')
# Check amount in Account move line.
self.assertEquals(vendor_voucher_move.amount, 1000.0, 'Amount is incorrect in acccount move.')
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.standard_price = 70.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.valuation = 'real_time'
# product_form.cost_method = 'fifo'
product_form.property_stock_account_input = self.env.ref(
'stock_dropshipping.o_expense')
product_form.property_stock_account_output = self.env.ref(
'stock_dropshipping.o_income')
product_lifo_icecream = product_form.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.value, -1400.0,
'Stock move value should have been 1400 euro')
def test_00_dropship(self):
# Create a vendor
supplier_dropship = self.env['res.partner'].create(
{'name': 'Vendor of Dropshipping test'})
# Create new product without any routes
drop_shop_product = self.env['product.product'].create({
'name':
"Pen drive",
'type':
"product",
'categ_id':
self.env.ref('product.product_category_1').id,
'lst_price':
100.0,
'standard_price':
0.0,
'uom_id':
self.env.ref('uom.product_uom_unit').id,
'uom_po_id':
self.env.ref('uom.product_uom_unit').id,
'seller_ids': [(0, 0, {
'delay': 1,
'name': supplier_dropship.id,
'min_qty': 2.0
})]
})
# Create a sales order with a line of 200 PCE incoming shipment, with route_id drop shipping
so_form = Form(self.env['sale.order'])
so_form.partner_id = self.env.ref('base.res_partner_2')
so_form.payment_term_id = self.env.ref('account.account_payment_term')
with mute_logger('swerp.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 = drop_shop_product
line.product_uom_qty = 200
line.price_unit = 1.00
line.route_id = self.env.ref(
'stock_dropshipping.route_drop_shipping')
sale_order_drp_shpng = so_form.save()
# Confirm sales order
sale_order_drp_shpng.action_confirm()
# Check the sales order created a procurement group which has a procurement of 200 pieces
self.assertTrue(sale_order_drp_shpng.procurement_group_id,
'SO should have procurement group')
# Check a quotation was created to a certain vendor and confirm so it becomes a confirmed purchase order
purchase = self.env['purchase.order'].search([('partner_id', '=',
supplier_dropship.id)])
self.assertTrue(purchase,
"an RFQ should have been created by the scheduler")
purchase.button_confirm()
self.assertEquals(purchase.state, 'purchase',
'Purchase order should be in the approved state')
self.assertEquals(len(purchase.ids), 1, 'There should be one picking')
# Send the 200 pieces
purchase.picking_ids.move_lines.quantity_done = purchase.picking_ids.move_lines.product_qty
purchase.picking_ids.button_validate()
# Check one move line was created in Customers location with 200 pieces
move_line = self.env['stock.move.line'].search([
('location_dest_id', '=',
self.env.ref('stock.stock_location_customers').id),
('product_id', '=', drop_shop_product.id)
])
self.assertEquals(len(move_line.ids), 1,
'There should be exactly one move line')
def test_01_product_route_level_delays(self):
""" In order to check schedule dates, set product's Manufacturing Lead Time
and Customer Lead Time and also set warehouse route's delay."""
# Update warehouse_1 with Outgoing Shippings pick + pack + ship
self.warehouse_1.write({'delivery_steps': 'pick_pack_ship'})
# Set delay on pull rule
for pull_rule in self.warehouse_1.delivery_route_id.rule_ids:
pull_rule.write({'delay': 2})
# Create sale order of product_1
order_form = Form(self.env['sale.order'])
order_form.partner_id = self.partner_1
order_form.warehouse_id = self.warehouse_1
with order_form.order_line.new() as line:
line.product_id = self.product_1
line.product_uom_qty = 6
order = order_form.save()
# Confirm sale order
order.action_confirm()
# Run scheduler
self.env['procurement.group'].run_scheduler()
# Check manufacturing order created or not
manufacturing_order = self.env['mrp.production'].search([
('product_id', '=', self.product_1.id)
])
self.assertTrue(manufacturing_order,
'Manufacturing order should be created.')
# Check the picking crated or not
self.assertTrue(order.picking_ids, "Pickings should be created.")
# Check schedule date of ship type picking
out = order.picking_ids.filtered(
lambda r: r.picking_type_id == self.warehouse_1.out_type_id)
out_min_date = fields.Datetime.from_string(out.scheduled_date)
out_date = fields.Datetime.from_string(order.date_order) + timedelta(
days=self.product_1.sale_delay) - timedelta(
days=out.move_lines[0].rule_id.delay)
self.assertAlmostEqual(
out_min_date,
out_date,
delta=timedelta(seconds=10),
msg=
'Schedule date of ship type picking should be equal to: order date + Customer Lead Time - pull rule delay.'
)
# Check schedule date of pack type picking
pack = order.picking_ids.filtered(
lambda r: r.picking_type_id == self.warehouse_1.pack_type_id)
pack_min_date = fields.Datetime.from_string(pack.scheduled_date)
pack_date = out_date - timedelta(days=pack.move_lines[0].rule_id.delay)
self.assertAlmostEqual(
pack_min_date,
pack_date,
delta=timedelta(seconds=10),
msg=
'Schedule date of pack type picking should be equal to: Schedule date of ship type picking - pull rule delay.'
)
# Check schedule date of pick type picking
pick = order.picking_ids.filtered(
lambda r: r.picking_type_id == self.warehouse_1.pick_type_id)
pick_min_date = fields.Datetime.from_string(pick.scheduled_date)
self.assertAlmostEqual(
pick_min_date,
pack_date,
delta=timedelta(seconds=10),
msg=
'Schedule date of pick type picking should be equal to: Schedule date of pack type picking.'
)
# Check schedule date of manufacturing order
mo_date = pack_date - timedelta(days=self.product_1.produce_delay)
date_planned_start = fields.Datetime.from_string(
manufacturing_order.date_planned_start)
self.assertAlmostEqual(
date_planned_start,
mo_date,
delta=timedelta(seconds=10),
msg=
"Schedule date of manufacturing order should be equal to: Schedule date of pack type picking - product's Manufacturing Lead Time."
)
