def _dropship_product1(self):
# enable the dropship and MTO route on the product
dropshipping_route = self.env.ref('stock_dropshipping.route_drop_shipping')
mto_route = self.env.ref('stock.route_warehouse0_mto')
self.product1.write({'route_ids': [(6, 0, [dropshipping_route.id, mto_route.id])]})
# add a vendor
vendor1 = self.env['res.partner'].create({'name': 'vendor1'})
seller1 = self.env['product.supplierinfo'].create({
'name': vendor1.id,
'price': 8,
})
self.product1.write({'seller_ids': [(6, 0, [seller1.id])]})
# sell one unit of this product
customer1 = self.env['res.partner'].create({'name': 'customer1'})
self.sale_order1 = self.env['sale.order'].create({
'partner_id': customer1.id,
'partner_invoice_id': customer1.id,
'partner_shipping_id': customer1.id,
'order_line': [(0, 0, {
'name': self.product1.name,
'product_id': self.product1.id,
'product_uom_qty': 1,
'product_uom': self.product1.uom_id.id,
'price_unit': 12,
})],
'pricelist_id': self.env.ref('product.list0').id,
'picking_policy': 'direct',
})
self.sale_order1.action_confirm()
# confirm the purchase order
self.purchase_order1 = self.env['purchase.order'].search([('group_id', '=', self.sale_order1.procurement_group_id.id)])
self.purchase_order1.button_confirm()
# validate the dropshipping picking
self.assertEqual(len(self.sale_order1.picking_ids), 1)
#self.assertEqual(self.sale_order1.picking_ids.move_lines._is_dropshipped(), True)
wizard = self.sale_order1.picking_ids.button_validate()
immediate_transfer = self.env[wizard['res_model']].browse(wizard['res_id'])
immediate_transfer.process()
self.assertEqual(self.sale_order1.picking_ids.state, 'done')
# create the vendor bill
move_form = Form(self.env['account.move'].with_context(default_type='in_invoice'))
move_form.partner_id = vendor1
move_form.purchase_id = self.purchase_order1
self.vendor_bill1 = move_form.save()
self.vendor_bill1.post()
# create the customer invoice
self.customer_invoice1 = self.sale_order1._create_invoices()
self.customer_invoice1.post()
all_amls = self.vendor_bill1.line_ids + self.customer_invoice1.line_ids
if self.sale_order1.picking_ids.move_lines.account_move_ids:
all_amls |= self.sale_order1.picking_ids.move_lines.account_move_ids.line_ids
return all_amls
def test_invoice_after_lc(self):
self.env.company.anglo_saxon_accounting = True
self.product1.product_tmpl_id.categ_id.property_cost_method = 'fifo'
self.product1.product_tmpl_id.categ_id.property_valuation = 'real_time'
self.product1.product_tmpl_id.invoice_policy = 'delivery'
self.price_diff_account = self.env['account.account'].create({
'name': 'price diff account',
'code': 'price diff account',
'user_type_id': self.env.ref('account.data_account_type_current_assets').id,
})
self.product1.property_account_creditor_price_difference = self.price_diff_account
# Create PO
po_form = Form(self.env['purchase.order'])
po_form.partner_id = self.env['res.partner'].create({'name': 'vendor'})
with po_form.order_line.new() as po_line:
po_line.product_id = self.product1
po_line.product_qty = 1
po_line.price_unit = 455.0
order = po_form.save()
order.button_confirm()
# Receive the goods
receipt = order.picking_ids[0]
receipt.move_lines.quantity_done = 1
receipt.button_validate()
# Check SVL and AML
svl = self.env['stock.valuation.layer'].search([('stock_move_id', '=', receipt.move_lines.id)])
self.assertAlmostEqual(svl.value, 455)
aml = self.env['account.move.line'].search([('account_id', '=', self.stock_valuation_account.id)])
self.assertAlmostEqual(aml.debit, 455)
# Create and validate LC
lc = self.env['stock.landed.cost'].create(dict(
picking_ids=[(6, 0, [receipt.id])],
account_journal_id=self.stock_journal.id,
cost_lines=[
(0, 0, {
'name': 'equal split',
'split_method': 'equal',
'price_unit': 99,
'product_id': self.productlc1.id,
}),
],
))
lc.compute_landed_cost()
lc.button_validate()
# Check LC, SVL and AML
self.assertAlmostEqual(lc.valuation_adjustment_lines.final_cost, 554)
svl = self.env['stock.valuation.layer'].search([('stock_move_id', '=', receipt.move_lines.id)], order='id desc', limit=1)
self.assertAlmostEqual(svl.value, 99)
aml = self.env['account.move.line'].search([('account_id', '=', self.stock_valuation_account.id)], order='id desc', limit=1)
self.assertAlmostEqual(aml.debit, 99)
# Create an invoice with the same price
move_form = Form(self.env['account.move'].with_context(default_type='in_invoice'))
move_form.partner_id = order.partner_id
move_form.purchase_id = order
move = move_form.save()
move.post()
# Check nothing was posted in the price difference account
price_diff_aml = self.env['account.move.line'].search([('account_id','=', self.price_diff_account.id), ('move_id', '=', move.id)])
self.assertEquals(len(price_diff_aml), 0, "No line should have been generated in the price difference account.")
def test_02_po_return(self):
"""
Test a PO with a product on Incoming shipment. Validate the PO, then do a return
of the picking with Refund.
"""
# Draft purchase order created
self.po = self.env['purchase.order'].create(self.po_vals)
self.assertTrue(self.po, 'Purchase: no purchase order created')
self.assertEqual(self.po.order_line.mapped('qty_received'), [0.0, 0.0],
'Purchase: no product should be received"')
self.assertEqual(self.po.order_line.mapped('qty_invoiced'), [0.0, 0.0],
'Purchase: no product should be invoiced"')
self.po.button_confirm()
self.assertEqual(self.po.state, 'purchase',
'Purchase: PO state should be "Purchase"')
self.assertEqual(
self.po.invoice_status, 'to invoice',
'Purchase: PO invoice_status should be "Waiting Invoices"')
# Confirm the purchase order
self.po.button_confirm()
self.assertEqual(self.po.state, 'purchase',
'Purchase: PO state should be "Purchase')
self.assertEqual(self.po.picking_count, 1,
'Purchase: one picking should be created"')
self.picking = self.po.picking_ids[0]
self.picking.move_line_ids.write({'qty_done': 5.0})
self.picking.button_validate()
self.assertEqual(self.po.order_line.mapped('qty_received'), [5.0, 5.0],
'Purchase: all products should be received"')
#After Receiving all products create vendor bill.
move_form = Form(
self.env['account.move'].with_context(default_type='in_invoice'))
move_form.partner_id = self.partner_id
move_form.purchase_id = self.po
self.invoice = move_form.save()
self.invoice.post()
self.assertEqual(self.po.order_line.mapped('qty_invoiced'), [5.0, 5.0],
'Purchase: all products should be invoiced"')
# Check quantity received
received_qty = sum(pol.qty_received for pol in self.po.order_line)
self.assertEqual(
received_qty, 10.0,
'Purchase: Received quantity should be 10.0 instead of %s after validating incoming shipment'
% received_qty)
# Create return picking
pick = self.po.picking_ids
stock_return_picking_form = Form(
self.env['stock.return.picking'].with_context(
active_ids=pick.ids,
active_id=pick.ids[0],
active_model='stock.picking'))
return_wiz = stock_return_picking_form.save()
return_wiz.product_return_moves.write({
'quantity': 2.0,
'to_refund': True
}) # Return only 2
res = return_wiz.create_returns()
return_pick = self.env['stock.picking'].browse(res['res_id'])
# Validate picking
return_pick.move_line_ids.write({'qty_done': 2})
return_pick.button_validate()
# Check Received quantity
self.assertEqual(
self.po.order_line[0].qty_received, 3.0,
'Purchase: delivered quantity should be 3.0 instead of "%s" after picking return'
% self.po.order_line[0].qty_received)
#Create vendor bill for refund qty
move_form = Form(
self.env['account.move'].with_context(default_type='in_refund'))
move_form.partner_id = self.partner_id
move_form.purchase_id = self.po
self.invoice = move_form.save()
move_form = Form(self.invoice)
with move_form.invoice_line_ids.edit(0) as line_form:
line_form.quantity = 2.0
with move_form.invoice_line_ids.edit(1) as line_form:
line_form.quantity = 2.0
self.invoice = move_form.save()
self.invoice.post()
self.assertEqual(self.po.order_line.mapped('qty_invoiced'), [3.0, 3.0],
'Purchase: Billed quantity should be 3.0')
def test_00_purchase_order_flow(self):
# Ensure product_id_2 doesn't have res_partner_1 as supplier
if self.partner_id in self.product_id_2.seller_ids.mapped('name'):
id_to_remove = self.product_id_2.seller_ids.filtered(
lambda r: r.name == self.partner_id
).ids[0] if self.product_id_2.seller_ids.filtered(
lambda r: r.name == self.partner_id) else False
if id_to_remove:
self.product_id_2.write({
'seller_ids': [(2, id_to_remove, False)],
})
self.assertFalse(
self.product_id_2.seller_ids.filtered(
lambda r: r.name == self.partner_id),
'Purchase: the partner should not be in the list of the product suppliers'
)
self.po = self.PurchaseOrder.create(self.po_vals)
self.assertTrue(self.po, 'Purchase: no purchase order created')
self.assertEqual(
self.po.invoice_status, 'no',
'Purchase: PO invoice_status should be "Not purchased"')
self.assertEqual(self.po.order_line.mapped('qty_received'), [0.0, 0.0],
'Purchase: no product should be received"')
self.assertEqual(self.po.order_line.mapped('qty_invoiced'), [0.0, 0.0],
'Purchase: no product should be invoiced"')
self.po.button_confirm()
self.assertEqual(self.po.state, 'purchase',
'Purchase: PO state should be "Purchase"')
self.assertEqual(
self.po.invoice_status, 'to invoice',
'Purchase: PO invoice_status should be "Waiting Invoices"')
self.assertTrue(
self.product_id_2.seller_ids.filtered(
lambda r: r.name == self.partner_id),
'Purchase: the partner should be in the list of the product suppliers'
)
seller = self.product_id_2._select_seller(
partner_id=self.partner_id,
quantity=2.0,
date=self.po.date_planned,
uom_id=self.product_id_2.uom_po_id)
price_unit = seller.price if seller else 0.0
if price_unit and seller and self.po.currency_id and seller.currency_id != self.po.currency_id:
price_unit = seller.currency_id._convert(price_unit,
self.po.currency_id,
self.po.company_id,
self.po.date_order)
self.assertEqual(
price_unit, 250.0,
'Purchase: the price of the product for the supplier should be 250.0.'
)
self.assertEqual(self.po.picking_count, 1,
'Purchase: one picking should be created"')
self.picking = self.po.picking_ids[0]
self.picking.move_line_ids.write({'qty_done': 5.0})
self.picking.button_validate()
self.assertEqual(self.po.order_line.mapped('qty_received'), [5.0, 5.0],
'Purchase: all products should be received"')
move_form = Form(
self.env['account.move'].with_context(default_type='in_invoice'))
move_form.partner_id = self.partner_id
move_form.purchase_id = self.po
self.invoice = move_form.save()
self.assertEqual(self.po.order_line.mapped('qty_invoiced'), [5.0, 5.0],
'Purchase: all products should be invoiced"')
def test_00_purchase_order_report(self):
uom_dozen = self.env.ref('uom.product_uom_dozen')
eur_currency = self.env.ref('base.EUR')
self.company_id.currency_id = self.env.ref('base.USD').id
self.env['res.currency.rate'].search([]).unlink()
self.env['res.currency.rate'].create({
'name': datetime.today(),
'rate': 2.0,
'currency_id': eur_currency.id,
})
po = self.env['purchase.order'].create({
'partner_id':
self.partner_id.id,
'currency_id':
eur_currency.id,
'order_line': [
(0, 0, {
'name': self.product1.name,
'product_id': self.product1.id,
'product_qty': 1.0,
'product_uom': uom_dozen.id,
'price_unit': 100.0,
'date_planned': datetime.today(),
}),
(0, 0, {
'name': self.product2.name,
'product_id': self.product2.id,
'product_qty': 1.0,
'product_uom': uom_dozen.id,
'price_unit': 200.0,
'date_planned': datetime.today(),
}),
],
})
po.button_confirm()
f = Form(
self.env['account.move'].with_context(default_type='in_invoice'))
f.partner_id = po.partner_id
f.purchase_id = po
invoice = f.save()
invoice.post()
po.flush()
res_product1 = self.PurchaseReport.search([('order_id', '=', po.id),
('product_id', '=',
self.product1.id)])
# check that report will convert dozen to unit or not
self.assertEquals(res_product1.qty_ordered, 12.0,
'UoM conversion is not working')
# report should show in company currency (amount/rate) = (100/2)
self.assertEquals(res_product1.price_total, 50.0,
'Currency conversion is not working')
res_product2 = self.PurchaseReport.search([('order_id', '=', po.id),
('product_id', '=',
self.product2.id)])
# Check that repost should show 6 unit of product
self.assertEquals(res_product2.qty_ordered, 12.0,
'UoM conversion is not working')
# report should show in company currency (amount/rate) = (200/2)
self.assertEquals(res_product2.price_total, 100.0,
'Currency conversion is not working')